I/Q Constellation Diagrams in GNU Radio

Your First GNU Radio Flowgraph

GNU Radio is a free and open-source software development toolkit that provides signal processing blocks to implement software radios. Its companion application, GNU Radio Companion (GRC), offers a graphical interface for building these signal processing "flowgraphs" by connecting blocks. The basic paradigm is to connect a source block (which generates a signal or data), through one or more processing blocks (which manipulate the signal), to a sink block (which consumes or displays the signal).

We will now build a simple flowgraph to generate and visualize a QPSK signal. The GNU Radio Wiki provides an excellent tutorial that walks through this process. We will follow its logic closely.

Building the QPSK Transmitter in GRC

Now, let's translate the concepts from the reading into a working flowgraph. Launch GNU Radio Companion on your computer. You will see a blank canvas with an Options and a Variable block by default. On the right, there is a library of available blocks.

Follow these steps to build the transmitter:

1. Options Block: Double-click the Options block. Ensure the ID is top_block and Generate Options is set to QT GUI. This tells GRC to create a graphical application we can interact with.

2. Variables: For good practice, we'll define key parameters as variables.

   • samp_rate: Set this to 32k. This is our simulation's sample rate.
   • sps (samples per symbol): Set this to 4. Each symbol will be represented by 4 samples.
   • excess_bw (excess bandwidth): Set this to 0.35. This is the roll-off factor for our RRC pulse-shaping filter.

3. Random Source: Find the Random Source block (under Waveform Generators) and drag it onto the canvas. This will generate the data we want to transmit. Leave its Output Type as Byte and set Maximum to 255.

4. Constellation Object: Find the Constellation Rect. Object (under Modulators) and add it. This block defines our modulation scheme.

   • Set its ID to qpsk.
   • Leave the Constellation Points and Symbol Map at their defaults, which define a Gray-coded QPSK constellation.

5. Constellation Modulator: Add a Constellation Modulator block (under Modulators). This performs the modulation.

   • Constellation: Set this to qpsk, the ID of the object you just created.
   • Samples/Symbol: Set this to our variable sps.
   • Excess BW: Set this to our variable excess_bw.

6. Throttle: Add a Throttle block (under Misc). In a simulation without hardware, this block is essential. It controls the flow of data to prevent your CPU from running at 100%. Set its Sample Rate to samp_rate.

7. QT GUI Constellation Sink: Finally, add a QT GUI Constellation Sink (under GUI Widgets). This is our visualizer. Leave its parameters at their defaults for now.

8. Connect the Blocks: Connect the blocks by clicking the output port of one block and the input port of the next:
   Random Source -> Constellation Modulator -> Throttle -> QT GUI Constellation Sink.

   Notice the colors of the ports: magenta for byte streams and blue for complex floating-point streams. GRC enforces type checking, a very useful feature.

Your flowgraph should look similar to the one in the tutorial (though that one includes receiver components we haven't added yet). Now, save the flowgraph and click the "Generate" button (gear icon) followed by the "Execute" button (play icon).

A window should appear showing the constellation diagram. You should see four distinct clusters of points at the corners, but also lines connecting them. These lines represent the trajectory of the I/Q samples during the transition from one symbol to the next, shaped by the RRC filter. They are not errors; they are an inherent part of the filtered signal's representation.

Introducing Channel Impairments

The plot you see is for a perfect, noiseless channel. This is not representative of any real communication system, especially not a satellite link. To simulate a more realistic scenario, we will add a Channel Model block. This block allows us to introduce common impairments like noise, frequency offsets, and timing drift.

The image below shows a flowgraph very similar to the one we will now build. It includes the Channel Model block placed after the modulator.

Let's modify your flowgraph:

1. Delete the connection between the Throttle block and the Constellation Sink.
2. Add a Channel Model block (under Channel Models).
3. Insert it between the Constellation Modulator and the Throttle block. The new chain is: Constellation Modulator -> Channel Model -> Throttle -> QT GUI Constellation Sink.
4. Double-click the Channel Model block. Let's examine its key parameters:
   • Noise Voltage: This controls the amount of Additive White Gaussian Noise (AWGN). A value of 0 is a noiseless channel. Start with a small value like 0.1.
   • Frequency Offset: This simulates the carrier frequency difference between transmitter and receiver. It is specified as a fraction of the sampling rate. A small value like 0.01 will cause the constellation to rotate.
   • Epsilon (Timing Offset): This simulates the sampling clock difference. Keep it at 1.0 for now.

Now, execute the flowgraph again.

• With Noise Voltage set to 0.1 (and others at zero), you will see the four points blur into "clouds." The higher the noise voltage, the larger and more diffuse these clouds become.
• Reset Noise Voltage to 0 and set Frequency Offset to 0.01. You will see the entire constellation diagram rotate continuously. This is what a receiver must correct for.

This simple exercise powerfully demonstrates why the receiver's job is so challenging. It doesn't receive clean points; it receives a noisy, rotating, and time-drifted cloud of samples and must recover the original symbols from it.

As an example of what a more complex, real-world signal looks like, the image below shows a GNU Radio simulation of the 32APSK constellation we studied in the last lesson. You can clearly see the three rings of points, but they are blurred into clouds by noise. You can also see additional BPSK pilot symbols (in yellow), which are used by the receiver to help correct for channel impairments.

Conclusion

In this lesson, you took your first practical steps with GNU Radio, bridging the gap between modulation theory and its implementation. You have learned how to construct a signal processing flowgraph from source, processing, and sink blocks to generate and visualize a digitally modulated signal.

Key takeaways include:

• A GNU Radio flowgraph processes data from a source, through processing blocks, to a sink.
• The Constellation Modulator block, paired with a Constellation Object, maps input data to complex I/Q symbols.
• The QT GUI Constellation Sink is an essential tool for visualizing the I/Q samples of a signal.
• The Channel Model block simulates real-world impairments like noise and frequency offset, which distort the ideal constellation points into rotating, noisy clouds.

You have now completed the foundational module of this course. You understand I/Q signals, are familiar with the key modulation schemes of DVB-S2, and have the basic skills to generate and visualize them in GNU Radio.

In the next module, we will begin our deep dive into the DVB-S2 standard itself. Our first lesson will describe the end-to-end DVB-S2 transmission chain, giving you a high-level map of the entire system before we start dissecting each component in detail.