I’m happy to be back at Paderborn University as Substitute Professor of the Computer Networks group.
I’ll be mainly responsible for teaching the Systems Software and Systems Programming lecture, including exercises and labs, which is a mandatory module in the Computer Science Bachelor curriculum.
Looking forward to this new experience.
Together with Lars Baumgärtner, I co-organized a workshop on Next Generation Wireless Edge Networks, which is part of a workshop series, organized in the context of our Collaborative Research Center MAKI.
I’m thankful for the awesome speakers that joined us and the interesting discussions at the event.
We also had quite some fun at the demo session :-)
I’ll be giving a tutorial on FutureSDR at NetSys 2023, which will take place between 4 – 8 September 2023 at the Hasso-Plattner-Institut in Potsdam, Germany.
NetSys, the conference on Networked Systems, is organized by the special interest group Communication and Distributed Systems (KUVS), which is anchored both in the German Computer Science society (Gesellschaft für Informatik (GI)) and in the Information Technology society (Informationstechnische Gesellschaft im VDE (ITG)).
I’m happy to receive the Ulrich L. Rohde Award for outstanding contributions in the field of Software Defined Radio for my work on FutureSDR.
The award was handed-over at the Software Defined Radio Academy, presented by IARU R1 President Sylvain Azarian and the DARC.
I released my Rust SDR experiments as a project that I call FutureSDR and prepared a video to introduce its main features.
The code is available on GitHub.
I was happy to give a tutorial about Programming Software Defined Radios with GNU Radio at ACM WiSec 2021.
This was a lot of fun to prepare but also a good excuse to spent a lot of money and get some more professional A/V equipment :-)
I also uploaded the IQ file that was recorded in the session and the GNU Radio module.
Our subproject of the Collaborative Research Center MAKI got funded :-)
It’s the first time I can hire a PhD student. So I’m looking for motivated candidates, who want to build fancy SDR prototypes and explore new concepts for SDR runtimes.
If you’re interested, drop me an email.
Josh Morman and I gave an update on our current efforts to build a new more modular runtime for GNU Radio that comes with pluggable schedulers and native support for accelerators.
If you’re interested in the topic
This is the second post on FutureSDR, an experimental async SDR runtime, implemented in Rust.
While the previous post gave a high-level overview of the core concepts, this and the following posts will be about more specific topics.
Since I just finished integration of AXI DMA custom buffers for FPGA acceleration, we’ll discuss this.
The goal of the post is threefold:
- Show that the custom buffers API, presented in the previous post, can easily be generalized to different types of accelerators.
- Show that FutureSDR can integrate the various interfaces and mechanisms to communicate between the FPGA and the CPU.
- Provide a complete walk-through of a minimal example that demonstrates how FPGAs can be integrated into SDR applications. (I didn’t find anything on the this topic and hope that this shows the big picture and helps to get started.)
The actual example is simple. We’ll use the FPGA to add 123 to an 32-bit integer.
The data will be DMA’ed to the FPGA, which will stream the integers through the adder and copy the data back to CPU memory.
It’s only slightly more interesting than a loopback example, but the actual FPGA implementation is, of course, not the point.
There are drop-in replacements for FIR filters, FFTs, and similar DSP cores.
I only have a Xilinx ZCU106 board with a Zynq UltraScale+ MPSoC.
But the example doesn’t use any fancy features and should work on any Zynq platform.
In the last year, I’ve been thinking about how GNU Radio and SDR runtimes in general could improve.
I had some ideas in mind that I wanted to test with quick prototypes.
But C++ and rapid prototyping don’t really go together, so I looked into Rust and created a minimalistic SDR runtime from scratch.
Even though I’m still very bad at Rust, it was a lot of fun to implement.
One of the core ideas for the runtime was to experiment with async programming, which Rust supports through
Hence the name FutureSDR.
(Other languages might call similar constructs promises or co-routines.)
The runtime uses futures and it is a future, in the sense that it’s a placeholder for something that is not ready yet :-)
FutureSDR is minimalistic and has far less features than GNU Radio.
But, at the same time, it’s only ~5100 lines of code and served me well to quickly test ideas.
I, furthermore, just implemented basic accelerator support and finally have the feeling that the current base design makes some sense.
Overall, I think it might have reached a state where it might be useful to experiment with SDR runtimes.
So this post gives a bit of an overview and introduces the main ideas.
In follow-up posts, I want to go in more detail on specific features and have an associated git commit introducing this feature.
Note that the code examples might not compile exactly as-is (e.g. I leave some irrelevant function parameters out).
Also there is, at the moment, no proper error handling (i.e.,
unwrap() all over the place).