GSoCIdeas: Difference between revisions

From GNU Radio
Jump to navigation Jump to search
mNo edit summary
(Add another 2025 project - easy and small-medium)
 
(50 intermediate revisions by 14 users not shown)
Line 1: Line 1:
= Summer of Code 2019: Project ideas list =
Note- also check out [[Grant Ideas]] for additional ideas that are more suited towards grant money than GSoC.


This is the list of project ideas for the summer of code 2019 within GNU Radio.<br />
 
== Summer of Code 2025: Project ideas list ==
 
This is the list of project ideas for the summer of code 2025 within GNU Radio.<br />
Remember that these are '''ideas''' and are merely meant as an inspiration for you to write your own proposal.
Remember that these are '''ideas''' and are merely meant as an inspiration for you to write your own proposal.


Students who do not find a fit among these projects are encouraged to engage with us and suggest new ones. The [http://gnuradio.org/redmine/projects/gnuradio/wiki/MailingLists GNU Radio discussion mailing list] is the best place to contact all of us. Please do not contact us off-list for the sake of discussing the summer of code, unless you're contacting a mentor listed here to get feedback on a proposal.
Students who do not find a fit among these projects are encouraged to engage with us and suggest new ones. The [[MailingLists|GNU Radio discussion mailing list]] is the best place to contact all of us. Please do not contact us off-list for the sake of discussing the summer of code, unless you're contacting a mentor listed here to get feedback on a proposal.


Reviewing the [https://developers.google.com/open-source/gsoc/faq Google GSoC FAQ] page for a broader understanding of project, mentor, and student responsibilities is recommended.
Reviewing the [https://developers.google.com/open-source/gsoc/faq Google GSoC FAQ] page for a broader understanding of project, mentor, and student responsibilities is recommended.
Line 19: Line 22:
* Both OOTs and in-tree improvements are welcome
* Both OOTs and in-tree improvements are welcome


== Ideas ==
=== FM Broadcast Radio application ===


=== Hardware in the Loop: Cycle-accurate Verilog Design Simulation Integration ===
GNU Radio has built-in capabilities to receive, decode and play FM broadcast radio stations. With additional projects https://github.com/bastibl/gr-rds we are able to decode RDS data alongside.
The project does not (yet) have a fully fledged demo application which would allow potential users and beginners to see how to build a production-grade application (almost). The goal for this project
is to build an application which works plug&play with many SDRs and automatically scans (all) potential FM broadcast frequencies, gives a channel list and allows users to tune/select a radio station they would like to listen to.


Hardware accelerators are necessary or at least desirable in many SDR systems.
Therefore one part of the project is to focus on a polished user experience in the frontend application. Since this should be a good demo the other part of the project should focus on developing a well-functioning flowgraph with
the existing signal processing blocks and potentially also porting gr-rds to a newer GNU Radio and/or integrating it in the GNU Radio source tree. This flowgraph should then be started/halted on demand of the frontend application.
Potentially multiple streams could be recorded at the same time or decoded and some of the signal processing signals can be shown in a debug view so potential beginners and users can perform introspection on the application.


A typical development workflow for FPGA-accelerated DSP system looks like this:


* Write down the system specification, formulate the algorithm mathematically
'''Prerequisites'''
* Implement the algorithm in Matlab, Python to make a Proof of Concept
* Programming skills in Python
* Write extensive test cases to make sure you've got everything right
* Interest in designing a functional and polished graphical user interface
* Iterate.
* Preferred: Familiarity with basic signal processing libraries in Python (e.g., SciPy).
* Implement the same algorithm in a HDL, e.g. Verilog, and synthesize
* Interest working with real radio signals
* Write extensive (System)Verilog test benches, which mostly duplicate code from the software test cases in a less friendly development environment
* Run the test benches in simulation and the FPGA to prove functionality
* Iterate.


However, with [https://www.veripool.org/wiki/verilator Verilator], there's a relatively mature tool to turn Verilog modules into compilable C++ code that offers a cycle-accurate simulator of the module.
'''Expected Outcome'''
* Fully fledged FM broadcast receiver application with integrated RDS and spectrum scanning
* A clean example application which shows how the signal processing can be combined well with a GUI


The goal would be to use integrate verilator into the GNU Radio in a way that allows for rapid prototyping of small, well-defined Verilog modules; the idea is that you can, in the end, just drop your Verilog code file name in a GNU Radio block, and behind the scenes, the C++ code is generated, necessary "adapters" from native (GNU Radio) data types to simulated signals are added, and all is then executed at flow graph run time to process digital signals from within a flow graph.
'''Project Length'''
* Small (100 hours) – Medium (200 hours)


==== Prerequisites ====
'''Difficulty''''
* Easy


* workable C++ proficiency
'''Mentor(s)'''
* basic idea of FPGA development
* Andrej Rode
* Ability to read and write "hello world" verilog modules


==== Outcome ====
=== 5G Cell Scanner ===


* Adapter code to call Verilator-generated Code of modules with fixed interface from within a GNU Radio block's work routine
Cell scanning by passively observing the RF environment using an SDR and decoding received signals based on the waveforms defined in the 2G/3G/4G/5G standards is a well-established approach for assessing cellular connectivity in the surrounding environment. While multiple cell scanners are publicly available, they often employ opaque signal processing methods and frequently cease analysis prematurely, failing to provide detailed information about the cells. This includes not decoding the Master Information Block (MIB) and the System Information Block (SIB1) to extract cell properties and signal quality metrics.
* Integration of verilator into either build infrastructure or runtime infrastructure (might require further dependencies, e.g. llvm)
Our objective is to develop a high-quality cell scanner using GNU Radio in a transparent way that delivers the most information possible (depending on the cells’ signal levels) in a trustable manner. The general procedure will be based on the initial synchronization and cell identification process on the user-equipment side of 5G (see further reads).
* Examples and software test cases for fundamental blocks, e.g. a FIFO and a integer squarer
Depending on the student’s experience, we can also go a step further and parallelize the cell scanning process by observing multiple frequency bands simultaneously by applying channelization and parallel processing techniques to the signal.


==== Mentor ====
'''Prerequisites'''
* Proficiency with GNU Radio.
* Basic programming skills in Python.
* Preferred: Familiarity with basic signal processing libraries in Python (e.g., SciPy).
* Preferred: General understanding of the 5G waveform and experience with 5G processing libraries in Python.


Marcus Müller
'''Expected Outcome'''
* Development of an Out-Of-Tree (OOT) module or flowgraphs capable of interacting with SDR input streams and automatically generating detailed visualizations of cell search results.
* Capability to export results as a function of time and SDR location to enable the creation of coverage maps.


'''Further Reads'''
* https://de.mathworks.com/help/5g/ug/nr-cell-search-and-mib-and-sib1-recovery.html
* https://de.mathworks.com/help/5g/gs/synchronization-signal-blocks-and-bursts.html


=== Qt5 GUI Integrations ===
'''Project Length'''
* Small (100 hours) – Medium (200 hours)


Idea: Wrap the Qt GUI sinks to appear in QtCreator, including the GUI aspects of their parameterization
'''Difficulty''''
* Medium


==== Prerequisites ====
'''Mentor(s)'''
* Michael Petry
* Andrej Rode


* C++, Python proficiency
* Qt experienced


==== Outcome ====
=== Expanding the GNU Radio 4.0 Block Set ===


* Qt GUI Sinks usable as widgets in QtCreator (not necessarily already showing an "empty" GUI, just placeholders)
GNU Radio 4.0 has reached a stage where real signal processing applications can achieve performance improvements over GNU Radio 3.x. To maximize its adoption, we aim to expand the set of available blocks, making it easier for the community to build applications with readily available components.  The goal of this project is to migrate existing GR 3.x blocks (e.g. gr-digital, gr-analog, gr-audio ...) into GR 4.0.  A good list of blocks in GR3 that should be ports has been maintained here:  [https://github.com/fair-acc/gnuradio4/issues/161]
* Possible to import generate Qt GUI description file (UIC) into GRC
* Interface to map placeholders from GUI design to Qt GUI sinks in Flow graph
* Integration of that into GRC-generated Python code


==== Mentor ====
'''Prerequisites'''


Marcus Müller & Sebastian "GRC-Man" Koslowski
* Knowledge of modern C++
* Signal processing understanding


=== Block header parsing tool ===
'''Outcome'''


Rough ideas:
* GR4 OOT module with a substantial number of blocks
* Python-based tool
* Each block should have CI tests and an example flowgraph
* Can extract info from block headers (and maybe, if it has to, also from the .cc file)
* Document the process so that other block developers can be guided
** Analyse factory signature ("make function"), analyze getters/setters
** Analyse I/O signature


Utilities:
* Auto-generate YAML files for GRC (would require another tool, also part of this project)
* Facilitate inclusion of GNU Radio with other tools/frameworks


There is some code in gr_modtool which does this, which can be reused and
'''Project length'''
extended.


===== Prerequisites =====
Long (350 hours)


* Strong knowledge of Python, including Py3k idiosyncrasies
'''Difficulty'''
* Some text parsing experience
* Some understanding of GNU Radio block structure


===== Outcome =====
Medium


* A tool, written in Python, merged into the GNU Radio source tree, which can turn a block definition into some kind of abstract representation (the design which of is also part of this project)
'''Mentor(s)'''
* Another tool, which takes the abstract representation, and produces YAML files for GRC.
* An API into calling this which can be used by other tools (external to GNU Radio).
* Make gr_modtool use this tool instead of its builtin code.


===== Mentor(s) =====
John Sallay, Josh Morman


Martin Braun, Nicolas Cuervo


=== GRC: View-Only Mode (Secure) ===
=== Graphical interoperability between CyberEther and GNU Radio ===


When a flowgraph from an untrusted source is opened if GRC, arbitrary Python code can be executed. This poses a potential security risk. Storing the all evaluated values of all parameters within a flow graph (.grc) file would allow us to open such flow graphs without compromising security. No code would be have to executed to draw the flow graph and block parameters can be viewed safely. Only if the flow graph is modified the user would have to choose to trust the flow graph thus enabling normal eval operations.
The [https://github.com/luigifcruz/CyberEther CyberEther] project comes with some neat graphical sinks that would be great to have access to in GNU Radio. This project entails creating a new CyberEther GUI workflow much like the [https://github.com/gnuradio/gr-bokehgui gr-bokehgui] project, such that users can create flowgraphs with CyberEther sinks. This would allow the user to visualize GNU Radio data streams in one of the high-performance CyberEther plots (lineplot, waterfall, spectrogram, etc).


===== Prerequisites =====
'''Prerequisites'''


GRC is implemented using Python. So, Python should be known pretty well.
* Knowledge of C++ and some Python
* Familiarity with graphical APIs (OpenGL, Vulkan, Metal)
* Basic Qt understanding


===== Outcome =====
'''Outcome'''


Safely view other people's flowgraphs without putting your PC at risk.
* OOT module with CyberEther sinks
* Support for both GNU Radio main branch and 3.10?


===== Mentor(s) =====
'''Project length'''


Sebastian Koslowski
Long (350 hours)


'''Difficulty'''


=== Extending and Updating gr-radar ===
Medium


gr-radar (https://github.com/kit-cel/gr-radar/) was a great and successful GSoC project that provided a few methods of radar in GNU Radio. This module is heavily used by academics, researchers, cybersecurity folks, and hobbyists. This project would work to improve upon the concepts already in there as well as add more radar techniques.
'''Mentor(s)'''


There are uncountable methods and techniques that could be added to this project, such as:
Luigi Cruz, Håkon Vågsether


* SAR / InSAR methods
=== GPU Accelerated Signal Processing Blocks ===
* Better passive radar support
* Speed camera applications
* Multi-antenna radar techniques


===== Prerequisites =====
GPUs offer incredible capability for accelerating a number of signal processing routines when the calculations can be done in parallel.  Also, GNU Radio 3.10 brought in a "custom buffers" feature which provides support generally for accelerator devices by allowing blocks to have direct access to device memory, finally making accelerator processing feasible through a flowgraph (see [https://fosdem.org/2022/schedule/event/radio_gr3_10/ FOSDEM 2022 Presentation].


Signal processing and some radar basics are required. Code is written in C++ with some Python on the side, so the student must be able to handle these languages at the least.
One piece that is missing for GNU Radio is a library of blocks that accelerate common DSP routines.  There are several interesting libraries of GPU accelerated signal processing - primarily using CUDA because of its accessible programming paradigm and the ubiquity of NVIDIA hardware:


===== Outcome =====
* [https://github.com/NVIDIA/MatX Matx]
* [https://github.com/rapidsai/cusignal cuSignal] (Python signal processing)
* [https://github.com/gnuradio/cusp CUSP]


Based on the student's interest, a subset of the radar techniques listed above (or others) are chosen as milestones for this project. All code must be merged back into gr-radar by the end of the summer.
Integration of any of this functionality, along with additional kernels for signal processing would need to be predicated on using [https://github.com/gnuradio/gr-cuda gr-cuda] custom buffers, and expanding this module as needed


===== Mentor(s) =====
This project can be broken into several subprojects:


Stefan Wunsch, Martin Braun
* Create gr-matx OOT
** Add Matx Custom Buffer Type (after gr-cuda)
** Create blocks wrapping Matx operations
* Expand gr-cuda
** Additional custom buffer types - pinned, unified
** Create python custom buffers allowing zero copy into python blocks
* Create gr-cuSignal
** Wrap cuSignal functionality (dependent on python zero copy)
* Replicate existing GR blocks as CUDA accelerated (things not in cuSignal or Matx)
** Target for extensions to Matx, cuSignal, or CUSP (within our control)
** FIR Filters
** Polyphase Resampler
** Signal Source
** Moving Average
** Polyphase Clock Sync
** Stream Operators
** ...


'''Prerequisites'''


* Knowledge of C++ and Python.
* Familiarity with CUDA programming


=== QT Widgets Improvements ===


The gr-qtgui in-tree component provides some QT widgets for signal visualization. This component needs some improvement to become more useful.<br />
'''Outcome'''
This project is cleanly divided into several sub-projects:


* Add new widgets
Depends on chosen subprojects (see above).
** Compass display (e.g. for direction-finding applications)
** MPEG display (e.g. for video demod output)
** Matrix sink (e.g. for radar Doppler/range plane visualization, or 2D-equalizer taps visualization)


* Improve current widgets
'''Project length'''
** Better code structure to make the current widgets more manageable, extensible and remove code duplication between widgets
** More Control Panels on other widgets (follow lead on the frequency sink)
** Improve UI, make more intuitive, more power to mouse users
** Set trigger point with mouse


* Integration / Support for QT Creator
350 hours
** QML design
** Allow to build full GUI applications from, say, GRC


===== Prerequisites =====
'''Difficulty'''


Familiarity with QT is essential. Widgets are written in C+'', so some C''+ knowledge is also required. Python skills are highly useful.
Medium


===== Mentor(s) =====
'''Mentor(s)'''


Tim O'Shea
Josh Morman, Andrej Rode


=== Android ===
=== GRC and GR 4.0 ===


One effort of the past years was to improve Android support for GNU Radio. We're getting to a point where we've figured out '''how''' to do it, so the next step is to make it more accessible to users and developers.
Development of GR 4.0 is progressing quickly. In the current runtime prototype a plugin architecture is used to properly register blocks with the runtime.  
This allows a more dynamic construction of flowgraphs and introspection into the blocks. But this means the current way of assembling a flowgraph by generating a Python or C++
file needs updates.  


The Android ecosystem is an entirely different beast from the rest of GNU Radio. To make writing Android/GR apps easy, the following needs to happen (and shall be part of this project):
The idea is to port and change necessary parts of GRC (Qt development version) to use the block registry in the new GNU Radio runtime https://github.com/gnuradio/gnuradio4/ and assemble some of the example flowgraphs defined in GRC files and make them run.
The design for this is not finalized and therefore you will have freedom to propose your ideas.


* Improve support for development environment
'''Prerequisites'''
** Create Dockers for easy start of development
* Visualization classes for PSD, spectrogram and oscilloscope
** Easy reuse in other apps, like the gr-qtgui widgets, but for Android SDKs
* Interactivity concepts
** Gestures and config for radio params (e.g., freq, gain, bandwidth)
** Create an example FM receiver app that allows easy channel selection etc. through motions and gestures


===== Prerequisites =====
* Good Knowledge of C++ and Python
* Experience with inter-language bindings (not necessarily C++ & Python) is useful
* Basic Qt understanding


* Some Android experience
'''Outcome'''
* Enjoy writing GUI widgets
* C++/Java experience


===== Mentor(s) =====
* Prototype integration of GRC with the new plugin architecture of GR 4.0


Ben Hilburn
'''Project length'''


=== Filter Design Tool Enhancements ===
Long (350 hours)


GNU Radio provides many tools to design and use digital filters. Using these tools requires both some expertise in these areas as well as an understanding of the performance on the given platform. One example is the selection between FIR (convolution-based) and FFT (fast convolution-based) filters for different resampling rates. Another example is doing stages of filter decomposition when doing large down-sampling. Included in this is the polyphase filterbanks, which again are provided as primitive blocks that need tweaking to work.
'''Difficulty'''


This project is to improve our uses of these tools and blocks to make it more obvious to the users as well as automate some of the decisions for optimally using them. Some pointers:
Challenging


* When used in GRC, we want to save the results of the tool in a local file or for use in actual blocks.
'''Mentor(s)'''
* It still currently runs on PyQWT, which is obsolete and needs to be updated to QT4/QT5
** See https://github.com/trondeau/gnuradio/tree/filter/design_tool_newgui
* Add more support for filter design concepts and other filters.
** Cascaded filters
** Better support for creating PFB filters


===== Prerequisites =====
Andrej Rode, Josh Morman


Strong DSP background required. Python and QT knowledge highly useful (at least one of those is a must).


===== Mentor(s) =====


Marcus Leech


=== Implement SigMF functionality for GNU Radio ===


SigMF is the "Signal Metadata Format" that was defined during the 2017 DARPA Hackfest in Brussels. Its purpose is to annotate raw binary dumps of signals with metadata, thus giving meaning to a raw mass of samples.<br />
SigMF is specified and has a minimal reference implementation here: https://github.com/gnuradio/sigmf


GNU Radio needs its own implementation of SigMF that ties into the block structure. The following things need to be written:
=== Revitalize in-tree and out-of-tree (OOT) modules ===


* Source and Sink blocks for SigMF (similar to the current metadata blocks)
A lot has changed since version 3.7, and GNU Radio has made great technical strides the last few years. However, some OOT modules haven't been updated to support the latest versions of GNU Radio, and these modules currently require the user to install an older version of the framework. This is unfortunate, and lowers the useability of GNU Radio as a whole. Some of these modules have been superseded by others, but might still have some blocks or flowgraphs that are useful, and these could be updated and moved in-tree. Some in-tree modules are also in need of attention, like gr-wavelet, which does not have any examples.
* Converters for files generated with the current metadata file formats
* Static analysis tools using SigMF


===== Prerequisites =====
'''Prerequisites'''


Basic understanding of how to write GNU Radio blocks is required. Also, the student needs to explain that she or he has understood the concepts of SigMF, although SigMF is a very simple, JSON-based file format.<br />
* Knowledge of C++, Python and DSP.
Depending on the precise path that the student and the mentor define, experience in GUI development would also be useful.


===== Outcome =====
'''Outcome'''


The source and sink blocks are by the far the most important outcomes of this project. We estimate it would take about a third of the active coding time to implement those, and have them merged around the midterms.<br />
* More example code, tests and flowgraphs for various in-tree modules
This leaves plenty of time for further development. The next most important task are the converters, so existing metadata files will continue to be useful. After that, the student should define own tasks based on their interests. A very relevant problem is the ability to effectively visualize metadata in combination with signals.
* Porting various OOT modules to support recent versions of GNU Radio
* Possibly blocks/flowgraphs from old OOT modules moved in-tree


===== Mentor(s) =====
'''Project length'''


Bastian Bloessl
Small (90 hours) - Medium (175 hours)


=== Statistical Toolbox for GRC ===
'''Difficulty'''


A statistical toolbox for GRC would enable GUI-based statistical analysis. Currently, such analysis can be done by writing an independent program (e.g., with Scipy), but there is no actual integration with GNU Radio. By developing the statistical toolbox, we provide blocks for probability distribution fitting, hypothesis testing, extracting statistical parameters for one-dimensional as well as multi-dimensional data. This would significantly expand GNU Radio users' ability to perform datascience analysis and modeling on signal data.
Easy - Medium


===== Prerequisites =====
'''Mentor(s)'''


Understanding of existing GNU Radio tools (e.g., GRC), GNU Radio Out-of-Tree Modules, and statistics / datascience modeling.
Andrej Rode, Håkon Vågsether


===== Outcome =====


An OOT module that provides statistical analysis capabilities for GNU Radio.
=== CI for maintenance branches and select OOT modules ===


===== Mentor(s) =====
It would be useful to have nightly builds for GNU Radio's maintenance branches (3.8, 3.9, 3.10) and some select OOTs.


Ben Hilburn
'''Prerequisites'''


=== Standardized High Throughput FEC Codes ===
* Experience with Docker?
* ?


Channel coding is essential to modern communications. Also, it is computationally very heavy. As of now, there exist implementations in GNU Radio which are too slow to be integrated into high throughput applications. GNU Radio would benefit from integration of standardized decoders for Turbo and LDPC codes. These codes would only support a certain subset of the whole code class but would be well optimized.
'''Outcome'''


* Automated PPAs, Snaps, Flatpak apps


===== Prerequisites =====
'''Project length'''


Understanding of ''gr-fec'' API. Knowledge on channel coding. Understanding of C++.
175 hours


===== Outcome =====
'''Difficulty'''


Standardized Codes, e.g. LTE Turbo Codes, 5G Polar Codes, 5G LDPC Codes, CCITT Convolutional Codes etc. are available in ''gr-fec''. The prefered goal is to find a highly optimized implementation and integrate these into GNU Radio.
Easy


===== Mentor(s) =====
'''Mentor(s)'''


Johannes Demel
Håkon Vågsether, ?


== Application process ==
== Old Ideas ==


* Students interested in participating, read the [[GSoCStudentInfo|student instructions]] and the [[GSoCManifest|rules of conduct]].
Feel free to browse [https://wiki.gnuradio.org/index.php?title=OldGSoCIdeas old ideas] from previous years for inspiration.
* Please introduce yourself on the [https://lists.gnu.org/mailman/listinfo/discuss-gnuradio GNU Radio mailing list]
* Fill in the formal application for GNU Radio
* Pick some items from the list above or feel free to suggest another piece of work relevant to this theme. Give us a detailed, week-by-week plan for completing the task over the summer.

Latest revision as of 20:31, 27 February 2025

Note- also check out Grant Ideas for additional ideas that are more suited towards grant money than GSoC.


Summer of Code 2025: Project ideas list

This is the list of project ideas for the summer of code 2025 within GNU Radio.
Remember that these are ideas and are merely meant as an inspiration for you to write your own proposal.

Students who do not find a fit among these projects are encouraged to engage with us and suggest new ones. The GNU Radio discussion mailing list is the best place to contact all of us. Please do not contact us off-list for the sake of discussing the summer of code, unless you're contacting a mentor listed here to get feedback on a proposal.

Reviewing the Google GSoC FAQ page for a broader understanding of project, mentor, and student responsibilities is recommended.

If you need a USRP or other radio hardware to complete the project, we will be able to arrange something.

Please add ideas to this list (you may cannibalize old ideas, of course!).

Guidelines for good projects (when suggesting projects, please consider these):

  • Clearly defined scope, with a main target that can be done in 3 months
  • Clear benefits for the GNU Radio project
  • Not specific to a certain hardware. No specific embedded devices, either, please.
  • Both OOTs and in-tree improvements are welcome

FM Broadcast Radio application

GNU Radio has built-in capabilities to receive, decode and play FM broadcast radio stations. With additional projects https://github.com/bastibl/gr-rds we are able to decode RDS data alongside. The project does not (yet) have a fully fledged demo application which would allow potential users and beginners to see how to build a production-grade application (almost). The goal for this project is to build an application which works plug&play with many SDRs and automatically scans (all) potential FM broadcast frequencies, gives a channel list and allows users to tune/select a radio station they would like to listen to.

Therefore one part of the project is to focus on a polished user experience in the frontend application. Since this should be a good demo the other part of the project should focus on developing a well-functioning flowgraph with the existing signal processing blocks and potentially also porting gr-rds to a newer GNU Radio and/or integrating it in the GNU Radio source tree. This flowgraph should then be started/halted on demand of the frontend application. Potentially multiple streams could be recorded at the same time or decoded and some of the signal processing signals can be shown in a debug view so potential beginners and users can perform introspection on the application.


Prerequisites

  • Programming skills in Python
  • Interest in designing a functional and polished graphical user interface
  • Preferred: Familiarity with basic signal processing libraries in Python (e.g., SciPy).
  • Interest working with real radio signals

Expected Outcome

  • Fully fledged FM broadcast receiver application with integrated RDS and spectrum scanning
  • A clean example application which shows how the signal processing can be combined well with a GUI

Project Length

  • Small (100 hours) – Medium (200 hours)

Difficulty'

  • Easy

Mentor(s)

  • Andrej Rode

5G Cell Scanner

Cell scanning by passively observing the RF environment using an SDR and decoding received signals based on the waveforms defined in the 2G/3G/4G/5G standards is a well-established approach for assessing cellular connectivity in the surrounding environment. While multiple cell scanners are publicly available, they often employ opaque signal processing methods and frequently cease analysis prematurely, failing to provide detailed information about the cells. This includes not decoding the Master Information Block (MIB) and the System Information Block (SIB1) to extract cell properties and signal quality metrics. Our objective is to develop a high-quality cell scanner using GNU Radio in a transparent way that delivers the most information possible (depending on the cells’ signal levels) in a trustable manner. The general procedure will be based on the initial synchronization and cell identification process on the user-equipment side of 5G (see further reads). Depending on the student’s experience, we can also go a step further and parallelize the cell scanning process by observing multiple frequency bands simultaneously by applying channelization and parallel processing techniques to the signal.

Prerequisites

  • Proficiency with GNU Radio.
  • Basic programming skills in Python.
  • Preferred: Familiarity with basic signal processing libraries in Python (e.g., SciPy).
  • Preferred: General understanding of the 5G waveform and experience with 5G processing libraries in Python.

Expected Outcome

  • Development of an Out-Of-Tree (OOT) module or flowgraphs capable of interacting with SDR input streams and automatically generating detailed visualizations of cell search results.
  • Capability to export results as a function of time and SDR location to enable the creation of coverage maps.

Further Reads

Project Length

  • Small (100 hours) – Medium (200 hours)

Difficulty'

  • Medium

Mentor(s)

  • Michael Petry
  • Andrej Rode


Expanding the GNU Radio 4.0 Block Set

GNU Radio 4.0 has reached a stage where real signal processing applications can achieve performance improvements over GNU Radio 3.x. To maximize its adoption, we aim to expand the set of available blocks, making it easier for the community to build applications with readily available components. The goal of this project is to migrate existing GR 3.x blocks (e.g. gr-digital, gr-analog, gr-audio ...) into GR 4.0. A good list of blocks in GR3 that should be ports has been maintained here: [1]

Prerequisites

  • Knowledge of modern C++
  • Signal processing understanding

Outcome

  • GR4 OOT module with a substantial number of blocks
  • Each block should have CI tests and an example flowgraph
  • Document the process so that other block developers can be guided


Project length

Long (350 hours)

Difficulty

Medium

Mentor(s)

John Sallay, Josh Morman


Graphical interoperability between CyberEther and GNU Radio

The CyberEther project comes with some neat graphical sinks that would be great to have access to in GNU Radio. This project entails creating a new CyberEther GUI workflow much like the gr-bokehgui project, such that users can create flowgraphs with CyberEther sinks. This would allow the user to visualize GNU Radio data streams in one of the high-performance CyberEther plots (lineplot, waterfall, spectrogram, etc).

Prerequisites

  • Knowledge of C++ and some Python
  • Familiarity with graphical APIs (OpenGL, Vulkan, Metal)
  • Basic Qt understanding

Outcome

  • OOT module with CyberEther sinks
  • Support for both GNU Radio main branch and 3.10?

Project length

Long (350 hours)

Difficulty

Medium

Mentor(s)

Luigi Cruz, Håkon Vågsether

GPU Accelerated Signal Processing Blocks

GPUs offer incredible capability for accelerating a number of signal processing routines when the calculations can be done in parallel. Also, GNU Radio 3.10 brought in a "custom buffers" feature which provides support generally for accelerator devices by allowing blocks to have direct access to device memory, finally making accelerator processing feasible through a flowgraph (see FOSDEM 2022 Presentation.

One piece that is missing for GNU Radio is a library of blocks that accelerate common DSP routines. There are several interesting libraries of GPU accelerated signal processing - primarily using CUDA because of its accessible programming paradigm and the ubiquity of NVIDIA hardware:

Integration of any of this functionality, along with additional kernels for signal processing would need to be predicated on using gr-cuda custom buffers, and expanding this module as needed

This project can be broken into several subprojects:

  • Create gr-matx OOT
    • Add Matx Custom Buffer Type (after gr-cuda)
    • Create blocks wrapping Matx operations
  • Expand gr-cuda
    • Additional custom buffer types - pinned, unified
    • Create python custom buffers allowing zero copy into python blocks
  • Create gr-cuSignal
    • Wrap cuSignal functionality (dependent on python zero copy)
  • Replicate existing GR blocks as CUDA accelerated (things not in cuSignal or Matx)
    • Target for extensions to Matx, cuSignal, or CUSP (within our control)
    • FIR Filters
    • Polyphase Resampler
    • Signal Source
    • Moving Average
    • Polyphase Clock Sync
    • Stream Operators
    • ...

Prerequisites

  • Knowledge of C++ and Python.
  • Familiarity with CUDA programming


Outcome

Depends on chosen subprojects (see above).

Project length

350 hours

Difficulty

Medium

Mentor(s)

Josh Morman, Andrej Rode

GRC and GR 4.0

Development of GR 4.0 is progressing quickly. In the current runtime prototype a plugin architecture is used to properly register blocks with the runtime. This allows a more dynamic construction of flowgraphs and introspection into the blocks. But this means the current way of assembling a flowgraph by generating a Python or C++ file needs updates.

The idea is to port and change necessary parts of GRC (Qt development version) to use the block registry in the new GNU Radio runtime https://github.com/gnuradio/gnuradio4/ and assemble some of the example flowgraphs defined in GRC files and make them run. The design for this is not finalized and therefore you will have freedom to propose your ideas.

Prerequisites

  • Good Knowledge of C++ and Python
  • Experience with inter-language bindings (not necessarily C++ & Python) is useful
  • Basic Qt understanding

Outcome

  • Prototype integration of GRC with the new plugin architecture of GR 4.0

Project length

Long (350 hours)

Difficulty

Challenging

Mentor(s)

Andrej Rode, Josh Morman




Revitalize in-tree and out-of-tree (OOT) modules

A lot has changed since version 3.7, and GNU Radio has made great technical strides the last few years. However, some OOT modules haven't been updated to support the latest versions of GNU Radio, and these modules currently require the user to install an older version of the framework. This is unfortunate, and lowers the useability of GNU Radio as a whole. Some of these modules have been superseded by others, but might still have some blocks or flowgraphs that are useful, and these could be updated and moved in-tree. Some in-tree modules are also in need of attention, like gr-wavelet, which does not have any examples.

Prerequisites

  • Knowledge of C++, Python and DSP.

Outcome

  • More example code, tests and flowgraphs for various in-tree modules
  • Porting various OOT modules to support recent versions of GNU Radio
  • Possibly blocks/flowgraphs from old OOT modules moved in-tree

Project length

Small (90 hours) - Medium (175 hours)

Difficulty

Easy - Medium

Mentor(s)

Andrej Rode, Håkon Vågsether


CI for maintenance branches and select OOT modules

It would be useful to have nightly builds for GNU Radio's maintenance branches (3.8, 3.9, 3.10) and some select OOTs.

Prerequisites

  • Experience with Docker?
  • ?

Outcome

  • Automated PPAs, Snaps, Flatpak apps

Project length

175 hours

Difficulty

Easy

Mentor(s)

Håkon Vågsether, ?

Old Ideas

Feel free to browse old ideas from previous years for inspiration.

Retrieved from "https://wiki.gnuradio.org/index.php?title=GSoCIdeas&oldid=14663"