Difference between revisions of "GSoCIdeas"

From GNU Radio
Jump to: navigation, search
(Mentor(s))
(Modify SigMF idea)
 
(33 intermediate revisions by 9 users not shown)
Line 1: Line 1:
= Summer of Code 2017: Project idea list =
+
== Summer of Code 2020: Project ideas list ==
  
This is the list of project ideas for the summer of code 2017 within GNU Radio.<br />
+
This is the list of project ideas for the summer of code 2020 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 19:
 
* Both OOTs and in-tree improvements are welcome
 
* Both OOTs and in-tree improvements are welcome
  
==== gr-modtool overhaul ====
 
  
gr-modtool is one of the most important tools within GNU Radio, as it makes the creation of community modules much more accessible. However, it is in dire need of an overhaul, as its early codebase even predates the 3.7 API change. In its current state, gr-modtool is a fairly static chunk of code: The 'add' functionality in particular is a long string of if-then-else style static rules, which are then procedurally executed into a string of templates or file operations. A more functional style, with a less static rule set, would do the wonders to that good old tool.
 
  
Rewriting modtool in its entirety is task that is most likely way to large for a single GSoC. However, there's a lot of subtasks, so this can be broken up. When applying to this task, students should indicate which part of modtool they would like to work on. Even so, it is unlikely that more then one student will be able to work on this without too much destructive interference.
+
=== GRC: Build-in sub flowgraphs ===
  
The following items can be improved for modtool, in order of priority:
+
GNU Radio has the hierarchical blocks to build reuseable sub flowgraphs. These hier_blocks can be designed in GRC, however, they have to be compiled to code and GRC bindings, before they can be used in other GRC files. While this is great for reuseablity across flowgraphs, it is quite cumbersome when the main use is to structure a single (larger) flowgraph. The goal of this project is to ease this use-case by embedding sub flowgraphs directly in the main GRC file. Instead of creating bindings and code and then parsing them back again, this process shall be done in-place to allow quickly editing sub flowgraphs on-the-fly. 
  
* Rewrite as a plugin architecture. Currently, only GNU Radio OOTs and in-tree components can be extended. There's no reason modtool can't work for VOLK and RFNoC (thereby obsoleting rfnocmodtool).
+
'''Prerequisites'''
* Find and eliminate pockets of non-Py3k compatibility.
 
* Python API. modtool is currently only usable as a command-line program.
 
* An actual UI to improve usability.
 
  
===== Prerequisites =====
+
* GRC is written in Python which is (almost) all you need to know for this project.
  
Creating a better modtool requires strong knowledge of Python, including Py3k idiosyncrasies, functional design principles, template generation. Also, this task requires some knowledge of the existing modtool.
+
'''Outcome'''
  
===== Outcome =====
+
* A vastly improved workflow for structuring flowgraphs
  
The outcome depends on the subtasks selected by the student, but in an ideal case, the plugin architecture would be in place and would allow other projects to implement their own plugins. Documentation for this project would also be highly valuable.
+
'''Mentor(s)'''
  
===== Mentor(s) =====
+
* Sebastian Koslowski
  
Martin Braun
 
  
==== GRC: View-Only Mode (Secure) ====
 
  
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.
+
=== Qt5 GUI Integrations ===
 +
 
 +
Idea: Wrap the Qt GUI sinks to appear in QtCreator, including the GUI aspects of their parameterization
 +
 
 +
'''Prerequisites'''
 +
 
 +
* C++, Python proficiency
 +
* Qt experienced
  
===== Prerequisites =====
+
'''Outcome'''
  
GRC is implemented using Python. So, Python should be known pretty well.
+
* Qt GUI Sinks usable as widgets in QtCreator (not necessarily already showing an "empty" GUI, just placeholders)
 +
* 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
  
===== Outcome =====
+
'''Mentor(s)'''
  
Safely view other people's flowgraphs without putting your PC at risk.
+
* Marcus Müller & Sebastian "GRC-Man" Koslowski
  
===== Mentor(s) =====
 
  
Sebastian Koslowski
 
  
==== DTV User Front-End ====
+
=== GRC: View-Only Mode (Secure) ===
  
GNU Radio includes gr-dtv, which allows the decoding of ATSC TV signals and various other Digital Video Broadcast standards. From a DSP/decoding perspective, it's an impressive GNU Radio module. The issue is that it lacks any sort of user front-end and is difficult to use.
+
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.
  
A well-designed UI for gr-dtv would be a great addition to GNU Radio. It would nicely demonstrate how GNU Radio can be used to create real-world applications. It could also include the following features:
+
'''Prerequisites'''
  
* Automatic selection of frequencies based on location
+
* GRC is implemented using Python. So, Python should be known pretty well.
* Integration with web services, such as TV program indicators
 
* Load IQ files
 
* Record-to-file
 
  
===== Prerequisites =====
+
'''Outcome'''
  
Since gr-dtv already includes the bulk of the DSP/decoding part, this would be primarily GUI development. The programming language may be chosen by the student, although Python is probably the most viable candidate. Experience in GUI development is a strong requirement, though.
+
* Safely view other people's flowgraphs without putting your PC at risk.
  
===== Outcome =====
+
'''Mentor(s)'''
  
The result of this project should be a simple, click-to-launch app that immediately allows watching DTV, assuming the availability of some SDR hardware. The fact that a GNU Radio flowgraph is running in the background should be nicely hidden away.
+
* Sebastian Koslowski
  
===== Mentor(s) =====
 
  
Johnathan Corgan
 
  
==== Extending and Updating gr-radar ====
+
=== Extending and Updating gr-radar ===
  
 
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.
 
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.
Line 94: Line 90:
 
* Multi-antenna radar techniques
 
* Multi-antenna radar techniques
  
===== Prerequisites =====
+
'''Prerequisites'''
 
 
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.
 
  
===== Outcome =====
+
* 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.
  
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.
+
'''Outcome'''
  
===== Mentor(s) =====
+
* 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.
  
Stefan Wunsch, Martin Braun
+
'''Mentor(s)'''
  
==== GNU Radio Companion Extensions: Output C++ Code ====
+
* Stefan Wunsch, Martin Braun
  
GRC currently only outputs Python code, which is convenient for a number of reasons of usability and dynamic development. Some people prefer to work in, build, and release compiled binaries. Our Android work in GNU Radio requires C+''-based flowgraphs compiled into a static library. Being able to tell GRC to output a C''+ project with the actual .cc/.cpp code and the Makefile structure to build both dynamic linked and static linked apps would be a great addition to GNU Radio in general.
 
  
===== Prerequisites =====
 
  
The generated code is C++, and GRC uses Python for the generation, so these two languages should be known to a decent level. Basic understanding of how GNU Radio and GRC is also required, but may be obtained in the ramp-up phase.
+
=== QT Widgets Improvements ===
 
 
===== Outcome =====
 
 
 
Add a feature to GRC that will allow to select the output language. Port some blocks to include XML bindings for C++ and use those to test generation of buildable source packages and binaries.
 
 
 
===== Mentor(s) =====
 
 
 
Sebastian Koslowski, Felix Wunsch
 
 
 
==== 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 />
 
The gr-qtgui in-tree component provides some QT widgets for signal visualization. This component needs some improvement to become more useful.<br />
Line 142: Line 126:
 
** Allow to build full GUI applications from, say, GRC
 
** Allow to build full GUI applications from, say, GRC
  
===== Prerequisites =====
+
'''Prerequisites'''
  
Familiarity with QT is essential. Widgets are written in C+'', so some C''+ knowledge is also required. Python skills are highly useful.
+
* Familiarity with QT is essential.
 +
* Widgets are written in C+'', so some C''+ knowledge is also required.
 +
* Python skills are highly useful.
  
===== Mentor(s) =====
+
'''Mentor(s)'''
  
 
Tim O'Shea
 
Tim O'Shea
  
==== Android ====
+
 
 +
 
 +
=== Standardized High Throughput FEC Codes ===
 +
 
 +
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.
 +
 
 +
'''Prerequisites'''
 +
 
 +
* Understanding of ''gr-fec'' API. Knowledge on channel coding. Understanding of C++.
 +
 
 +
'''Outcome'''
 +
 
 +
* Standardized Codes, e.g. LTE Turbo Codes, 5G Polar Codes, 5G LDPC Codes, CCITT Convolutional Codes etc. are available in ''gr-fec''.
 +
* The preferred goal is to find a highly optimized implementation and integrate these into GNU Radio.
 +
 
 +
'''Mentor(s)'''
 +
 
 +
* Johannes Demel
 +
 
 +
 
 +
 
 +
=== Android ===
  
 
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.
 
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.
Line 161: Line 168:
 
** Easy reuse in other apps, like the gr-qtgui widgets, but for Android SDKs
 
** Easy reuse in other apps, like the gr-qtgui widgets, but for Android SDKs
 
* Interactivity concepts
 
* Interactivity concepts
** Gestures and config for radio params (e.g., freq, gain, bandwidth)
+
** Gestures and config for radio parameters (e.g., freq, gain, bandwidth)
 
** Create an example FM receiver app that allows easy channel selection etc. through motions and gestures
 
** Create an example FM receiver app that allows easy channel selection etc. through motions and gestures
  
===== Prerequisites =====
+
You can find a summary of the work that has been done on this (years ago) here: [[Android]]
 +
 
 +
'''Prerequisites'''
  
 
* Some Android experience
 
* Some Android experience
Line 170: Line 179:
 
* C++/Java experience
 
* C++/Java experience
  
===== Mentor(s) =====
+
'''Mentor(s)'''
 +
 
 +
* Bastian Bloessl
  
Ben Hilburn
+
=== Runtime Benchmarks ===
  
==== Filter Design Tool Enhancements ====
+
To facilitate development of a more modern GNU Radio runtime and scheduler, we need a tool to measure its performance (in terms of delay and throughput).
 +
This data is required to compare alternate approaches and to become aware of performance regressions early in the process.
 +
 
 +
The goal of the project is to provide a tool to benchmark the GNU Radio runtime. Since we are interested in the performance on many platforms and architectures, it should provide an option to submit performance data to our sever, allowing us to crowdsource data. (Similar to our [http://stats.gnuradio.org/ online stats] for SIMD performance.)
 +
 
 +
* Come up with interesting metrics and, if needed, implement blocks to extract them.
 +
* Come up with interesting flowgraph topologies that should be benchmarked.
 +
* Setup automated experiments that iterate over a given parameter space (repetitions, number of samples, size of the flowgraph).
 +
* Parse, evaluate, and visualize the data.
 +
* Add an option to upload the performance data to our web sever.
 +
 
 +
'''Prerequisites'''
 +
 
 +
* C++ programming
 +
* Data evaluation and visualization
 +
* Automation tools (like GNU Make to run benchmarks)
 +
 
 +
'''Mentor(s)'''
 +
 
 +
* Bastian Bloessl, Marcus Mueller
 +
 
 +
=== Filter Design Tool Enhancements ===
  
 
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.
 
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.
Line 181: Line 213:
  
 
* When used in GRC, we want to save the results of the tool in a local file or for use in actual blocks.
 
* When used in GRC, we want to save the results of the tool in a local file or for use in actual blocks.
* It still currently runs on PyQWT, which is obsolete and needs to be updated to QT4/QT5
+
* It still currently runs on PyQWT, which is obsolete and needs to be updated to Qt5
 
** See https://github.com/trondeau/gnuradio/tree/filter/design_tool_newgui
 
** See https://github.com/trondeau/gnuradio/tree/filter/design_tool_newgui
 
* Add more support for filter design concepts and other filters.
 
* Add more support for filter design concepts and other filters.
Line 187: Line 219:
 
** Better support for creating PFB filters
 
** Better support for creating PFB filters
  
===== Prerequisites =====
+
'''Prerequisites'''
  
Strong DSP background required. Python and QT knowledge highly useful (at least one of those is a must).
+
* Strong DSP background required.
 +
* Python and QT knowledge highly useful (at least one of those is a must).
  
===== Mentor(s) =====
+
'''Mentor(s)'''
  
Sebastian Müller, Marcus Leech
+
* Marcus Leech
  
==== A DAB/DAB+ transceiver app ====
 
  
gr-dab is an Out-Of-Tree (OOT) module that implements the PHY of the Digital Audio Broadcasting (DAB) standard. Right now, however, only basic information can be extracted from the broadcast and it's not possible to actually listen to the audio. This project aims at completing the implementation of the standard and creating a standard-compliant DAB/DAB+ receiver as well as a transmitter.
 
  
In addition to that, a GUI is to be designed and implemented to make this a full-fleshed application for DAB reception and transmission running on GNU Radio.
+
=== Implement SigMF functionality for the GNU Radio Ecosystem ===
  
===== Prerequisites =====
+
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
 +
There is an out-of-tree module providing SigMF functionality for GNU Radio as well: https://github.com/skysafe/gr-sigmf
  
A solid background in communications and DSP is strongly recommended as intensive work with the DAB technical standard documents will be required. Optimally, the student already has some knowledge about DAB or similar standards. The coding will be done in C++ (GNU Radio blocks) and Python (GUI), so these two languages are a requirement.
+
However, SigMF is not represented well in the GNU Radio tooling landscape. Therefore, a subset of tools can be extended by SigMF support. Incomplete lists of possible tools benefitting from SigMF support:
  
===== Outcome =====
+
* qgrx (https://github.com/csete/gqrx)
 +
* inspectrum (https://github.com/miek/inspectrum)
 +
* ...
  
The result of this project should be an extended gr-dab module that allows standard-compliant transmission and reception. Furthermore, a GUI is to be created to make it easy to use.
+
Any additional tools are welcome in a proposal.
  
===== Mentor(s) =====
+
'''Prerequisites'''
  
Felix Wunsch, Sebastian Koslowski, Bastian Bloessl, Johnathan Corgan
+
* Knowledge of the programming language of the covered tools.
 
+
* Hands-on experience with the respective tools.
==== Implement SigMF functionality for GNU Radio ====
+
* Familiarity with the SigMF specification.
 
 
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:
+
'''Outcome'''
  
* Source and Sink blocks for SigMF (similar to the current metadata blocks)
+
* The tools worked on have capability to load and save files in the SigMF format.
* Converters for files generated with the current metadata file formats
+
* Depending on the specific tool, SigMF meta data is displayed within the tool.
* Static analysis tools using SigMF
+
* The number of tools worked on needs to be determined by the student, depending on his/her experience.
  
===== Prerequisites =====
+
'''Mentor(s)'''
  
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 />
+
* Sebastian Müller, Andrej Rode
Depending on the precise path that the student and the mentor define, experience in GUI development would also be useful.
 
  
===== 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 />
 
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.
 
  
===== Mentor(s) =====
+
=== Statistical Toolbox for GRC ===
  
Bastian Bloessl, Sebastian Müller
+
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 data-science analysis and modeling on signal data.
  
==== A HTML-based GUI for GNU Radio applications ====
+
'''Prerequisites'''
  
Currently, GRC supports building GNU Radio GUI applications using QT widgets only. A set of HTML-based widgets along with a back-end server to handle sample streaming and control inputs would allow GNU Radio applications can be run remotely with monitoring and control accessible via a browser.
+
* Understanding of existing GNU Radio tools (e.g., GRC), GNU Radio Out-of-Tree Modules, and statistics / data-science modeling.
  
The idea is to support this in GRC by creating a new generate mode (analogous to QtGui) that adds the server and support to register GUI widgets:
+
'''Outcome'''
  
* For (graphical) output widgets, like number displays or plots, a set of blocks will be needed that handle streaming data to clients. The client-side code is added as part of the templates in the GRC bindings (again, analogous to QtGui).
+
* An OOT module that provides statistical analysis capabilities for GNU Radio.
* Input widgets would be represented by GRC variables (or message sources).
 
  
A suitable Web GUI framework will have to chosen. Instead of using a full-fleshed library, plotting tools like [https://www.continuum.io/content/painless-streaming-plots-bokeh Bokeh] or [https://plot.ly/python/streaming-tutorial/ Plotly] could be used. These handle data transport and may even already include most widgets we have in qtgui.
+
'''Mentor(s)'''
  
===== Prerequisites =====
+
* Ben Hilburn
  
* Python & C++ to handle the GNU Radio portion of this work.
 
* HTML/CSS/Javascript
 
  
===== Outcome =====
 
  
GRC-generated GNU Radio applications that can run remotely and be monitored/controlled with a web browser.
+
=== Digital Pre-Distortion ===
  
===== Mentors =====
+
Digital Pre-Distortion (DPD) is a technique allowing transmitters to compensate for non-linear responses in their hardware, most notably the power amplifier. This improves SNR and can allow more spectral and power efficient operation of a given set of hardware.
  
Sebastian Koslowski
+
DPD is widely used and is increasingly necessary as many multicarrier signals such as what are seen in DVB and LTE exhibit high peak to average power ratios (PAPRs). DPD implementations are not widely available in the open source community. This is a deficit that this project hopes to correct. Over the course of the project the student would implement standard DPD algorithms in to a GNU Radio out of tree module so that they can be available for use directly or as reference designs.
  
==== Statistical Toolbox for GRC ====
+
'''Prerequisites'''
  
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.
+
* Workable C++ proficiency, basic knowledge of radio systems, ideally familiarity with GNU Radio and/or Digital Pre-Distortion
  
===== Prerequisites =====
+
'''Outcome'''
  
Understanding of existing GNU Radio tools (e.g., GRC), GNU Radio Out-of-Tree Modules, and statistics / datascience modeling.
+
* Implement standard memory-less and memory based DPD algorithms
 +
* Implement the training algorithms for such DPD application algorithms.
 +
* Implement a GUI tool or testbench for viewing the AM-AM and AM-PM responses of an amplifier
  
===== Outcome =====
+
'''Mentor(s)'''
  
An OOT module that provides statistical analysis capabilities for GNU Radio.
+
* Derek Kozel
  
===== Mentor =====
 
  
Ben Hilburn
 
  
=== Application process ===
+
== Application process ==
  
* Students interested in participating, read the [[GSoCStudentInfo|student instructions]] and the [[GSoCManifest|rules of conduct]].
+
Students interested in participating, read the [[GSoCStudentInfo|student instructions]] and the [[GSoCManifest|rules of conduct]].
* To apply, please introduce yourself on both the [https://lists.gnu.org/mailman/listinfo/discuss-gnuradio GNU Radio mailing list]
+
* 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
 
* 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.
 
* 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 17:28, 1 February 2020

Summer of Code 2020: Project ideas list[edit]

This is the list of project ideas for the summer of code 2020 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


GRC: Build-in sub flowgraphs[edit]

GNU Radio has the hierarchical blocks to build reuseable sub flowgraphs. These hier_blocks can be designed in GRC, however, they have to be compiled to code and GRC bindings, before they can be used in other GRC files. While this is great for reuseablity across flowgraphs, it is quite cumbersome when the main use is to structure a single (larger) flowgraph. The goal of this project is to ease this use-case by embedding sub flowgraphs directly in the main GRC file. Instead of creating bindings and code and then parsing them back again, this process shall be done in-place to allow quickly editing sub flowgraphs on-the-fly.

Prerequisites

  • GRC is written in Python which is (almost) all you need to know for this project.

Outcome

  • A vastly improved workflow for structuring flowgraphs

Mentor(s)

  • Sebastian Koslowski


Qt5 GUI Integrations[edit]

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

Prerequisites

  • C++, Python proficiency
  • Qt experienced

Outcome

  • Qt GUI Sinks usable as widgets in QtCreator (not necessarily already showing an "empty" GUI, just placeholders)
  • 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(s)

  • Marcus Müller & Sebastian "GRC-Man" Koslowski


GRC: View-Only Mode (Secure)[edit]

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.

Prerequisites

  • GRC is implemented using Python. So, Python should be known pretty well.

Outcome

  • Safely view other people's flowgraphs without putting your PC at risk.

Mentor(s)

  • Sebastian Koslowski


Extending and Updating gr-radar[edit]

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.

There are uncountable methods and techniques that could be added to this project, such as:

  • SAR / InSAR methods
  • Better passive radar support
  • Speed camera applications
  • Multi-antenna radar techniques

Prerequisites

  • 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.

Outcome

  • 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.

Mentor(s)

  • Stefan Wunsch, Martin Braun


QT Widgets Improvements[edit]

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

  • Add new widgets
    • 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
    • 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
    • QML design
    • Allow to build full GUI applications from, say, GRC

Prerequisites

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

Mentor(s)

Tim O'Shea


Standardized High Throughput FEC Codes[edit]

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.

Prerequisites

  • Understanding of gr-fec API. Knowledge on channel coding. Understanding of C++.

Outcome

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

Mentor(s)

  • Johannes Demel


Android[edit]

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.

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):

  • Improve support for development environment
    • 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 parameters (e.g., freq, gain, bandwidth)
    • Create an example FM receiver app that allows easy channel selection etc. through motions and gestures

You can find a summary of the work that has been done on this (years ago) here: Android

Prerequisites

  • Some Android experience
  • Enjoy writing GUI widgets
  • C++/Java experience

Mentor(s)

  • Bastian Bloessl

Runtime Benchmarks[edit]

To facilitate development of a more modern GNU Radio runtime and scheduler, we need a tool to measure its performance (in terms of delay and throughput). This data is required to compare alternate approaches and to become aware of performance regressions early in the process.

The goal of the project is to provide a tool to benchmark the GNU Radio runtime. Since we are interested in the performance on many platforms and architectures, it should provide an option to submit performance data to our sever, allowing us to crowdsource data. (Similar to our online stats for SIMD performance.)

  • Come up with interesting metrics and, if needed, implement blocks to extract them.
  • Come up with interesting flowgraph topologies that should be benchmarked.
  • Setup automated experiments that iterate over a given parameter space (repetitions, number of samples, size of the flowgraph).
  • Parse, evaluate, and visualize the data.
  • Add an option to upload the performance data to our web sever.

Prerequisites

  • C++ programming
  • Data evaluation and visualization
  • Automation tools (like GNU Make to run benchmarks)

Mentor(s)

  • Bastian Bloessl, Marcus Mueller

Filter Design Tool Enhancements[edit]

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.

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:

  • When used in GRC, we want to save the results of the tool in a local file or for use in actual blocks.
  • It still currently runs on PyQWT, which is obsolete and needs to be updated to Qt5
  • Add more support for filter design concepts and other filters.
    • Cascaded filters
    • Better support for creating PFB filters

Prerequisites

  • 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 the GNU Radio Ecosystem[edit]

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.
SigMF is specified and has a minimal reference implementation here: https://github.com/gnuradio/sigmf There is an out-of-tree module providing SigMF functionality for GNU Radio as well: https://github.com/skysafe/gr-sigmf

However, SigMF is not represented well in the GNU Radio tooling landscape. Therefore, a subset of tools can be extended by SigMF support. Incomplete lists of possible tools benefitting from SigMF support:

Any additional tools are welcome in a proposal.

Prerequisites

  • Knowledge of the programming language of the covered tools.
  • Hands-on experience with the respective tools.
  • Familiarity with the SigMF specification.

Outcome

  • The tools worked on have capability to load and save files in the SigMF format.
  • Depending on the specific tool, SigMF meta data is displayed within the tool.
  • The number of tools worked on needs to be determined by the student, depending on his/her experience.

Mentor(s)

  • Sebastian Müller, Andrej Rode


Statistical Toolbox for GRC[edit]

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 data-science analysis and modeling on signal data.

Prerequisites

  • Understanding of existing GNU Radio tools (e.g., GRC), GNU Radio Out-of-Tree Modules, and statistics / data-science modeling.

Outcome

  • An OOT module that provides statistical analysis capabilities for GNU Radio.

Mentor(s)

  • Ben Hilburn


Digital Pre-Distortion[edit]

Digital Pre-Distortion (DPD) is a technique allowing transmitters to compensate for non-linear responses in their hardware, most notably the power amplifier. This improves SNR and can allow more spectral and power efficient operation of a given set of hardware.

DPD is widely used and is increasingly necessary as many multicarrier signals such as what are seen in DVB and LTE exhibit high peak to average power ratios (PAPRs). DPD implementations are not widely available in the open source community. This is a deficit that this project hopes to correct. Over the course of the project the student would implement standard DPD algorithms in to a GNU Radio out of tree module so that they can be available for use directly or as reference designs.

Prerequisites

  • Workable C++ proficiency, basic knowledge of radio systems, ideally familiarity with GNU Radio and/or Digital Pre-Distortion

Outcome

  • Implement standard memory-less and memory based DPD algorithms
  • Implement the training algorithms for such DPD application algorithms.
  • Implement a GUI tool or testbench for viewing the AM-AM and AM-PM responses of an amplifier

Mentor(s)

  • Derek Kozel


Application process[edit]

Students interested in participating, read the student instructions and the rules of conduct.

  • Please introduce yourself on the 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.