FM Receiver Application

User-friendly FM Broadcast Receiver with RDS and Spectrum Scanning built with GNU Radio

A complete software-defined radio solution developed during Google Summer of Code 2025 with GNU Radio. This application combines powerful signal processing capabilities with an intuitive PyQt5 interface for FM radio reception, RDS decoding, and automated station scanning.

Main application views: RDS reception, station management, and multi-recording interface

GSoC Verification

Google Summer of Code 2025 Verification Letter

Project Overview

Developed as part of Google Summer of Code 2025, this FM receiver application bridges the gap between GNU Radio’s powerful signal processing and everyday usability. The application automatically detects FM stations across the broadcast band, extracts Radio Data System (RDS) metadata, and enables simultaneous recording of multiple stations.

Key Features

Automated Station Detection The application implements sophisticated power spectral density analysis aligned to FM frequency raster (100kHz intervals) to automatically discover available stations across the 87.5-108.0 MHz band. Detection algorithms include pilot tone verification and threshold-based peak finding.

RDS Integration Real-time Radio Data System decoding displays station names, program information, and radiotext using the gr-rds module. The interface presents metadata in an intuitive panel with clear visual feedback.

Multi-Station Recording Record up to 3 FM stations simultaneously within SDR bandwidth constraints. The hierarchical GNU Radio block structure enables independent recording controls while maintaining efficient resource usage.

Debug Visualization Advanced debugging view includes RF band spectrum, waterfall display, audio visualization, and pilot tone detection. These tools help developers understand signal characteristics and troubleshoot reception issues.

Debug view showing RF spectrum analysis and waterfall visualization

Technical Implementation

The project demonstrates advanced integration of GNU Radio’s signal processing with modern Python GUI development:

Architecture

  • Modular separation of GUI (PyQt5), signal processing (GNU Radio), and utilities
  • Multi-threaded design prevents UI blocking during spectrum scanning
  • Custom embedded GNU Radio blocks for station detection and recording
  • Configuration management system with JSON persistence

Signal Processing

  • FM demodulation with stereo decoding
  • 19kHz pilot tone detection for station verification
  • Power spectral density analysis with frequency bin summation
  • Real-time FFT visualization with 1024-point transforms

SDR Integration

  • SoapySDR support for multiple hardware platforms
  • Automatic device detection and configuration
  • Resource-aware bandwidth constraint validation
  • Dynamic frequency tuning and sample rate control
RDS metadata extraction and 19kHz pilot tone verification

Development Journey

Over 13 weeks, the project evolved from basic FM reception to a full-featured SDR application:

Phase 1: Foundation (Weeks 1-4) Established project structure, designed UI mockups in Figma, implemented core FM reception flowgraphs, and integrated initial RDS support.

Phase 2: Detection (Weeks 5-6) Developed automated station scanning using normalized power spectral density, added debug visualization tools, and implemented pilot tone verification.

Phase 3: Polish (Weeks 7-10) Enhanced code quality with pylint and documentation, added recording functionality, created SDR configuration manager, and improved state management.

Phase 4: Advanced Features (Weeks 11-13) Implemented multiple simultaneous recording using hierarchical blocks, created comprehensive documentation with MkDocs, and migrated to modern SoapySDR blocks.

Technical Challenges

SDR Resource Contention GNU Radio flowgraphs cannot share SDR hardware access simultaneously. Solved by implementing selector blocks that switch between scan and play modes within a single flowgraph instance.

Station Detection Accuracy Simple peak detection failed without external amplification. Developed normalized power summation approach aligned to FM raster frequencies, achieving detection of 23+ stations without additional hardware.

GUI Threading Blocking spectrum scans froze the interface. Created QThread-based architecture with progress reporting to maintain responsive UI during long-running operations.

Impact & Learning

This project contributed a complete FM receiver application to the GNU Radio ecosystem while serving as an educational resource through comprehensive documentation and tutorials. The work demonstrates how to embed GNU Radio processing in custom Python applications, making SDR technology more accessible to end users.

Key technical skills developed include signal processing algorithm design, multi-threaded GUI programming, software architecture for modular systems, and technical documentation for open-source projects.

Resources

Code & Documentation

Technologies Used

  • GNU Radio 3.10+
  • Python 3.8+
  • PyQt5
  • SoapySDR
  • gr-rds module
  • MkDocs

This project was completed as part of Google Summer of Code 2025 with the GNU Radio organization. The application demonstrates a complete software-defined radio solution ready for end-user deployment and continued community development.