GNU Radio is a framework to implement software-defined radio applications on standard PC hardware, embedded systems (from handheld spectrum analyzers to Raspberry Pis) to servers. This talk will take the surprise out of how to implement a very simple transmitter and a matching receiver application, where to go from there, how to improve upon existing designs, and address common pitfalls.

The audience will be introduced to the flowgraph as a means of describing a signal processing application, to core GNU Radio concepts, important design patterns, and how they interact with common communications engineering approaches. As a prerequisite for following the talk, you should be familiar with the basics of signals. An understanding of complex baseband and IQ signals will enhance the value of the talk to the reader, but is not strictly necessary.

To (optionally) replicate the examples shown, a computer running a recent version of Windows, Linux, or Mac OS on which the user is able to install software is required.

This guide was created with the help of AI, based on the presentation's transcript. Its goal is to give you useful context and background so you can get the most out of the session.

What this presentation is about and why it matters

This talk demonstrates how to build simple transmitters and receivers using GNU Radio — a widely used open-source framework for software-defined radio (SDR). Rather than focusing on one protocol or a single device, the presentation shows the practical workflow: constructing a flowgraph in the GNU Radio Companion (GRC), running it, inspecting signals with visual blocks, and iterating until the system works. Marcus Müller uses an audio-based FSK example so you can reproduce ideas without radio hardware or regulatory complications.

Why this matters: modern communications engineering increasingly relies on software for prototyping, teaching, and production. GNU Radio lets engineers and students move from mathematical ideas to over-the-air experiments (or, as in the demo, to audible simulations) quickly. The talk gives a practical bridge between DSP concepts you already know (filters, sampling, modulation) and their implementation on real platforms, including how GNU Radio handles buffers, threading, and block execution.

Who will benefit the most from this presentation

• Students and instructors of digital communications who want a hands-on tool for demonstrations.
• Engineers and hobbyists who want to prototype modulation, framing, or simple transceivers without immediately writing C++ or FPGA code.
• Anyone curious about SDR toolchains, GNU Radio internals (flowgraphs, runtime behavior), and how to extend the system with Python blocks.

What you need to know

To get the most from the talk you should be familiar with a few basic concepts from signals and communications:

• Sampling and sample rate: continuous-time signals are represented by discrete samples. The audio demo uses a sample rate like 48000 samples/s. When you design symbol timing you will often compute samples-per-symbol as samples per symbol = sample_rate / symbol_rate, written as $\displaystyle \text{samples/symbol} = \frac{\text{sample\_rate}}{\text{symbol\_rate}}$.
• Complex baseband and IQ signals: many radio blocks operate in complex baseband where a complex sample encodes orthogonal I/Q components. This allows symmetric positive/negative frequency representation around DC. When you must send a real-valued audio signal, the talk shows frequency shifting (multiplying with an NCO) and discarding the imaginary part.
• Basic modulation (FSK): frequency-shift keying maps symbols to different frequencies. The demo uses a frequency modulator block and repeats input symbols for stable tones.
• Decibels to linear gain: GUI sliders may show dB values. To convert to linear amplitude use $\text{linear} = 10^{\text{gain\_dB}/20}$. (The talk uses Python expressions like 10**(gain/20) in block parameters.)
• GNU Radio architecture basics: flowgraphs are graphs of blocks that the GRC generates into Python (or C++) programs. Blocks run under a runtime scheduler, communicate via zero-copy ring buffers, and are typically threaded. Expect variable work sizes: your custom block's work() function must handle arbitrary numbers of input items.

Glossary

• GNU Radio: an open-source toolkit for building SDRs — signal processing blocks, interfaces, and runtime.
• GRC (GNU Radio Companion): the graphical flowgraph editor that generates runnable Python code representing a block graph.
• Flowgraph: a graph of connected processing blocks (sources, sinks, filters, etc.) representing the signal path.
• Block: a modular processing element (e.g., filter, modulator, sink) with defined input/output signatures.
• Complex baseband / IQ: representation of RF signals with in-phase (I) and quadrature (Q) components as complex samples.
• Sample rate: number of samples per second used by a block or hardware interface.
• Symbol rate: rate at which modulation symbols are sent; used to compute samples per symbol.
• FSK (Frequency Shift Keying): modulation that encodes symbols as different frequencies.
• NCO (Numerically Controlled Oscillator): a digital oscillator used to shift frequency/phase of a signal.
• Sync_block: a GNU Radio block type where output count equals input count — simplifies work() implementation.
• Ring buffer: circular memory structure used by the GNU Radio runtime to provide zero-copy streaming between blocks.

Final notes — why watch

Marcus's talk is practical and approachable: he builds an end-to-end example live, points out common pitfalls (data types, saturation, sampling choices), and explains how GNU Radio glues DSP components together. If you want a compact, realistic look at how DSP theory becomes working software (and how to start writing your own blocks in Python), this presentation is a very efficient way to learn. Expect hands-on tips, a clear explanation of runtime behavior, and pointers to expand beyond the demo — all delivered in a friendly, example-driven style.