FOSDEM 2023 schedule - Open-source Embedded, Mobile, IoT, Arm, RISC-V, etc... projects

After two years of taking place exclusively online, FOSDEM 2023 is back in Brussels, Belgium with thousands expected to attend the 2023 version of the “Free and Open Source Developers’ European Meeting” both onsite and online.

FOSDEM 2023 will take place on February 4-5 with 776 speakers, 762 events, and 63 tracks. As usual, I’ve made my own little virtual schedule below mostly with sessions from the Embedded, Mobile and Automotive devroom, but also other devrooms including “Open Media”, “FOSS Educational Programming Languages devroom”, “RISC-V”, and others.

FOSDEM Day 1 – Saturday February 4, 2023

10:30 – 10:55 – GStreamer State of the Union 2023 by Olivier Crête

GStreamer is a popular multimedia framework making it possible to create a large variety of applications dealing with audio and video. Since the last FOSDEM, it has received a lot of new features: its RTP & WebRTC stack has greatly improved, Rust has become a first-class language, a high-level transcoding API was added, and much more. I will go over those major improvements and explain who they can be most useful for. Finally, I will look at the next releases.

This talks targets everyone who cares about Free and Open Source multimedia on embedded systems. GStreamer is the standard multimedia framework, not only on the Linux desktop, but most importantly, in embedded Linux systems.

11:00 – 11:25 – Matter and Thread as Connectivity Solution for Embedded by Stefan Schmidt

Matter is the new kid in town when it comes to IoT protocols and the Matter specification, together with an open-source SDK, got just released in October 2022. As Matter is based on IPv6 it can run over a different number of connectivity solutions. From the start, it supports Ethernet, Wi-Fi, and Thread. The latter is a low-power wireless protocol used for a few years already but without too much traction. With Matter support, this might change in 2023 and forward. With border router support in popular devices like Apple Homepod and TV, Google Nest, and Wi-Fi or Eero access points the needed technology infrastructure will become available in normal households.

This talk will look at the technology in Thread and Matter and its open-source implementations. Topics include the mesh capabilities of Thread, the border router, and service discovery.

11:30 – 11:55 – Developing Bluetooth Mesh networks with Rust by Dejan Bosanac

Bluetooth mesh networks enable the creation of large-scale device networks and can be very useful for a variety of IoT use cases. As the state of open-source tools around it needed some love, it was an ideal candidate for developing Rust stack to help developers use it in their solutions. In this session, you’ll learn about Rust tools available to develop embedded firmware, Linux gateways, and cloud applications for Bluetooth mesh solutions.

We’ll cover asynchronous embedded Rust with “Embassy” and “Drogue device” projects for writing firmware and how to use them for mesh applications. Next, we’ll explore the state of the mesh on Linux with “Bluez” and “Bluer” projects. We’ll see how to use Rust and containers to develop mesh gateways. Finally, we’ll describe the final piece needed to build end-to-end solutions, “Drogue IoT cloud”. With this, we laid down the architecture and tools needed to build usable mesh applications. The session participants will get a good overview of the whole stack needed to build mesh IoT applications. They learn the benefits of Rust for building this kind of software and find good starting points to get going with their projects.

12:00 – 12:25 – 5 errors when building embedded systems by Marta Rybczynska

Building embedded systems is complex, especially if they will last. This talk will be a collection of (funny!) cases and stories of errors made in different projects. Examples cover a wide range of situations, for example, not using git at all (or poorly), or optimizing too early. Marta will also show best practices to follow instead and how to convince customers and coworkers actually to follow those practices.
The talk applies to an intermediate audience, but experts could also find a suggestion or two.

12:30 – 12:55 – Dual presentation: FFmpeg 6 and VLC.js by Jean-Baptiste Kempf

This is a double talk about “What’s in the new release of FFmpeg 6.0”, and a “demonstration of VLC running inside Webbrowsers using Wasm”. As FFmpeg 6.0 is approaching, what’s new in it, what are the major and minor changes, and why you should care about future work on FFmpeg. After that, a demonstration of VLC and its dependencies compiled to the web-browser using wasm, and using Webcodecs to decode the video.

13:10 – 13:30 – Ubuntu Core: a technical overview by Valentin David

Ubuntu Core is a different kind of Linux. It offers image-based updates and secure boot with disk encryption. This presentation is a technical explanation of how this is achieved. We will focus on what makes Ubuntu Core different from other distributions.

Ubuntu Core is based on “snaps” which are read-only squashfs images with signed metadata. Everything on the system is a snap. This includes applications and the kernel. Snaps run in a lightweight container-like environment with AppArmor confinement and are isolated from each other and can only communicate via well-defined security boundaries (“interfaces”).

Then the main system is composed of a kernel snap, a bootloader snap, a base (rootfs) snap, and a snapd daemon snap. This granularity is useful to handle IoT hardware since much of the hardware needs custom kernels or bootloaders. Here a new initrd was developed and is presented in the talk. Some hurdles (like how to deal with /etc in a read-only image world) are also presented.

13:30 – 13:55 – Green software engineering by Arne Tarara

Desktop and server software at the present moment in time is very rarely developed with its energy consumption as a major consideration. However, in a world with limited resources, this becomes a growing concern, especially as developers cannot cater to this need since the appropriate tools are currently lacking.

The Green Metrics Tool is an open-source framework that allows for measuring, comparing, and optimizing the energy consumption of arbitrary software. The goal is to empower both software engineers and users to make educated decisions about libraries, code snippets, and software in order to save energy and thus carbon emissions.

Any application will be containerized and then analyzed by its logical parts. The open-source tool measures classical performance metrics as well as energy-related metrics like wattage, temperature, and cooling efficiency to understand what part of the software is responsible for which part of the energy consumption.

Through the concept of usage scenarios, we create an interface for developers to test/develop against. In the end, this makes complex software products comparable to each other and thus enables developers to select libraries based on their functionality-energy-profile (for instance messages per Watt or similar).

We present the roadmap for this tool over the next year, which will result in a public and open database of energy information for arbitrary hardware setups, code blocks. and libraries and a green standard library / green code completion.

14:00 – 14:50 – Advanced Camera Support on Allwinner SoCs with Mainline Linux by Paul Kocialkowski

This talk will present how support for an advanced camera use case was integrated into the mainline Linux kernel, using the Media and V4L2 APIs. It involves supporting a sensor using the raw Bayer RGB format, transmission over the MIPI CSI-2 bus as well as support for the Image Signal Processor (ISP) found on Allwinner platforms. A specific focus will be set on this ISP, with details about the features it implements as well as the internal and userspace APIs that are used to support it.

Capturing pixels with a camera involves a number of steps, from the ADC reading the photosites in the image sensor to the final pixel values that are ready for encoding/display, with various processing and transmission taking place along the way. While simple cases put most of the heavy lifting on the image sensor’s side (through its embedded processor) and use a simple parallel bus for transmission, advanced cases require more work to be done outside of the sensor. In addition, modern high-speed transmission buses also bring in more complexity.

15:00 – 15:25 – U-Boot as PSCI provider on ARM64 by

OS kernel on embedded ARM64 systems requires a PSCI (Power State Coordination Interface) to bring CPU cores up/down, suspend/resume/reset/power off. U-Boot bootloader provides a PSCI interface and this talk explains it.

The talk consists of five parts:

How the PSCI interface works
Where and how OS kernel calls it
How and in which hooks on the bootloader side do those calls land
How those hooks in U-Boot provide the functionality required by the OS
An example of U-Boot configured to provide a PSCI interface on a contemporary SoC.

The benefit of using the U-Boot PSCI interface over other PSCI interface providers is twofold. First, it allows for utilizing the full potential of U-Boot, and especially the SPL preloader, which can then boot OS kernel directly and quickly. Second, removing one software component from the boot stack reduces the Software BoM.

15:30 – 15:55 – Barebox, the bootloader for Linux kernel developers by Marco Felsch

Embedded doesn’t mean we can’t have nice things. As Linux kernel developers we have grown accustomed to the comfort afforded to us by Kconfig, device trees, the device-driver model, multi-platform kernel images, the kernel having sane defaults and virtual filesystems giving us shell-level access to debug and introspect the system.

Why can’t we have this in the boot environment? We can and you’ll see how, welcome to barebox. What began as a rejected patchset for adding Kconfig to U-Boot has now been a full-fledged bootloader in its own right for 13 years. barebox is powering millions of devices around the world.

In his talk, Marco will give a brief overview of barebox from a kernel developer’s point of view and show how easy it is to add support for new NXP i.MX8M board. The attendees will see barebox in action and learn how to leverage the VFS for hardware bring-up, kernel debugging, and booting the system in production.

16:00 – 16:25 – Building FPGA Bitstreams with Open-Source Tools by Michael Tretter

Yosys and nextpnr made FPGA development very attractive for developers that prefer to use open-source tools over proprietary vendor tools. Affordable and well-documented boards with ECP5 FPGAs lowered the entry threshold for hobbyists even further.

Michael will show how to use LiteX to use these tools to build soft-core RISC-V SoCs that are capable of running Linux and combine them with use-case-specific cores to custom FPGA bitstreams.
LiteX provides a framework to build FPGA SoCs including a few examples of SoCs that are capable of running Linux. However, to fully leverage the capabilities of FPGAs, one would not only reproduce existing designs but also implement use-case-specific cores and add them to the FPGA bitstream.

Michael will give an update on Steffen’s and his experiences with using the open-source FPGA tools to build FPGA bitstreams. In recent years, they presented how to build the LiteX example SoCs, run Linux on them, and how to make the systems reproducible by using Yocto. This talk will focus on how to add custom cores that are written in Verilog and Migen to the SoC to implement use-case-specific features.

16:30 – 16:55 – AI Discussion by Karen Sandler

All are welcome for a facilitated group conversation about the impact of AI on software freedom legal and policy issues. We will be looking to cover issues related to ethics and licensing and shape the conversation around the participation of attendees in the room.

17:05 – 17:15 – Bluetooth state in PipeWire and WirePlumber by Frédéric Danis

Over the last two years, Bluetooth support has seen significant improvements in PipeWire and WirePlumber. In this talk, we’ll take a closer look at these changes, including the recently added initial support for next-generation Bluetooth LE Audio, and discuss future plans.

This talk targets everyone who cares about Bluetooth Audio support in Linux, not only for the Linux desktop but also for embedded Linux projects.

17:15 – 17:25 – Exploring a Swedish Smart Home hub by Hannah Kiekens

Exploring the hardware and software of an Ikea Dirigera Zigbee hub. State of the open-source software used. Is Ikea committed to open source? API description.

17:30 – 17:55 – The PolyVent FLOSS Ventilator, a Free-libre Respiration Ecosystem by Robert Read

The PolyVent is a fully free-libre open mechanical ventilator educational platform for teaching and research. It is part of a proposed and partially implemented complete free ecosystem of medical devices for respiration called Freespireco. It runs VentOS free software which can drive any ventilator and uses a “super loop” Arduino framework deployed with PlatformIO. These projects represent a burgeoning open-source medical device movement.

Our hope is that in the next decade, a complete ecosystem of cooperating medical devices, components, data standards, and software, will make safe, reliable, reasonably priced respiratory care available to all people in all nations.

18:00 – 18:25 – VoLTE for FOSS by Marius Gripsgard

Marius has been playing around with VoLTE with Qualcomm & Mediatek devices. He has got to the point of being able to make and receive calls and send and receive SMSs on Ubuntu Touch-ported devices. It is still very hacky. Without any knowledge of the modem stack, it seemed impossibly difficult but now we are getting some insights into how it works it is possible to see how the binary blobs are doing stuff. The way forward was to run Android and capture all the calls made to the drivers. Sailfish have some of it working so their solution provided tools too.

The fixes so far are very specific, every proprietary system has its own unique way of doing things. It is a horrible standard and no carrier even follows the standard. The modem is a black box with no outputs. To be honest, when it works, we don’t know why it works. It works perfectly well though. He would like to share his results, to discuss with the wider community how we can rolls this out to get more devices supported.

18:30 – 18:55 – Reverse engineering a solar roof datalogger by Paolo Bonzini

What happens when you buy a solar roof, and you find out that the logging component has a Raspberry Pi MAC address? Perhaps nothing at the beginning, but sooner or later you’ll have to scratch that itch and teach yourself some reverse engineering.

Back in 2018, my family installed a solar roof at home. It came with a nice component to log and visualize your production and consumption statistics, and I was pretty surprised to see that its MAC address started with B8:27:EB, the OUI of the Raspberry Pi Foundation. During the 2021 Christmas holidays, I finally decided to look into the device, a fun experience covering Modbus, radare2, and even PCB reverse engineering; in this presentation, I will explain what I learned and how I replaced the vendor software with a custom Python program and Home Assistant.

FOSDEM Day 2 – Sunday, February 5, 2023

09:05 – 09:25 – Linux Kernel Functional Testing by Rémi Duraffort

The Linux Kernel Functional Testing (LKFT) project is aiming at improving the quality of the Linux kernel by performing functional testing on Arm hardware. LKFT has built over 1 million kernel per year other the last two years and ran 140 million tests on both emulation (qemu) and hardware devices.

In this talk, I will present the current architecture that is able to build and test millions of kernels with a really small team of engineers and at a reasonable cost.

09:30 – 09:55 – Pulse-Width-Modulation (PWM) is easy, isn’t it? by Uwe Kleine-König

There is a surprising variance in the way different hardware implements such a “simple” concept as a PWM. After a brief introduction about what a PWM actually is and the common use cases, the talk demonstrates the challenges of the PWM framework by presenting a few different hardware implementations and showing how the kernel’s PWM API covers the whole zoo of PWM implementations.

The talk concludes with an outlook on plans to further develop the API to be able to cover more use cases. The audience learns the general concept of PWMs, the corner cases in their usage and driver design, and how to avoid the common pitfalls often pointed out to authors of new PWM drivers during the review process.

10:20 – 11:00 – Porting RISC-V to GNU Guix by Efraim Flashner

GNU Guix is a from-source distribution with binary substitutes available. It is also a functional package manager, meaning that all the inputs are hashed and the build results are placed in their own destination folder. Guix also does its best to minimize bootstrap seeds, instead relying on a few cross-compiled bootstrap binaries used to build all other packages on the system. This provides some interesting bootstrap issues, especially for newer architectures, as we need to recreate the bootstrap path as it may have existed years ago in order to support programming languages. Some languages, like node.js or OCaml, need to have support backported only a few versions. Others like Java need more than a decade. Rust needed to use an alternate implementation of rustc to be bootstrapped and Haskell currently isn’t on the roadmap.

11:00 – 11:40 – Linux on RISC-V, Status and progress of RISC-V support in Gentoo Linux and other Linux distributions by Jakov Smoli

RISC-V support across Linux distributions has significantly improved over the past few years. Thanks to this, developers and users are able to set up Linux environments easily on RISC-V platforms. Major desktop environments (e.g. KDE, Gnome) and applications have gained RISC-V support, enabling users to have a full desktop experience on RISC-V. This talk will give an overview of readiness and future work for RISC-V on Gentoo Linux and other Linux distributions.

11:40 – 11:55 – FOSSbot: An open-source and open-design educational robot by Iraklis Varlamis and Christos Chronis

FOSSbot is a 3D-printed educational robot that uses open software, open design, and electronics, and can be employed in all levels of education. FOSSBot has been developed collaboratively by Harokopio University of Athens and the Greek Free and Open Source Software (GFOSS) community. The use of FOSSBOT in education will be supported by collaborative seminars for all teachers of all specialties and levels based on public educational materials.&t;/p>

The hardware is based on a Raspberry Pi Zero that controls everything and a set of electronics comprising: – Sensors: Ultrasonic distance sensor, Battery Sensor, Accelerometer, Gyroscope, Odometers, IR Receiver, Line detection sensors, Light Sensors – Interaction Features: Speaker and Front RGB LED – General Features: Brick-compatible surface, Hole in the front for attaching a marker/pencil, a special pulling loop, rechargeable batteries.

The software of FOSSbot is based on a modular stack that allows the implementation the various programming functions, orchestrates everything through the UI, and controls the hardware in an easy way through a software library that plays the role of the FOSSBot operating system. This stack includes Google Blockly, Python Jupyter, Python Flask which hosts FOSSBot’s UI, the core FOSSBot library written in Python which controls the bot’s hardware, and finally the manual operation it offers to users through a user interface, i.e. a way to control the robot without any programming knowledge.

All the plastic parts, except the wheels, are printable on a 3D printer and the total printing time does not exceed 36 hours.

More information and source files can be found on GitHub and in a research paper.

11:40 – 12:20 – How to add an GCC built-in to the RISC-V compiler by Nandni Jamnadas

Many low-level features of architectures are implemented in GCC as builtin functions. Builtin functions look superficially like any C function, but are in fact intrinsic to the compiler and represented as patterns to be matched in the machine description. Builtin functions are often used to access a unique functionality of individual machine instructions. Being integrated within the compiler, they are more efficient than using simple inline assembly code. For RISC-V, they offer an excellent way to expose the functionality of instruction set extensions to the C/C++ programmer.

Adding a builtin function to GCC is not that difficult, but neither is it completely trivial. In this talk, we will show you how to add builtin functions using examples from the OpenHW Group’s CV32E40Pv2 processor core.

12:20 – 13:00 – Bringing up the OpenHW Group RISC-V toolchains by Jeremy Bennett

The Open Hardware Group is a large industry/academic consortium developing a family of fully open-source, commercial-grade RISC-V cores, branded as CORE-V. These are supported by a full software ecosystem. In this talk, we will look at the challenges of developing a vendor-specific software ecosystem, how this ecosystem relates to the official upstream projects, and particularly the technical challenges in developing, maintaining, and upstreaming vendor specific software.

The upstream projects generally provide mechanisms to support vendor-specific variants, for example by use of the vendor field in the target triplet. Thus rather than the generic riscv32-unknown-elf-gcc compiler, we can have the riscv32-corev-elf-gcc compiler. However this requires modifications to the code to use this information to control when CORE-V-specific functionality is to be enabled, and this talk will explore these. In one specific case (vendor-specific relocations), we are waiting on standardization from the RISC-V psabi committee, but otherwise, this is all using well-proven existing technology.

The talk cannot cover the detail of every tool and operating system being developed, so will concentrate particularly on the CORE-V GCC toolchain. However, we will draw parallels with the work going on in CORE-V-specific simulators and in CORE-V-specific operating systems.

13:15 – 13:45 – prplMesh: open source Wi-Fi mesh by Frederik Van Bogaert

“Mesh” is the new hotness when it comes to Wi-Fi. Routers, extenders, and wireless range extenders all propose to work together to optimize your Wi-Fi experience. This is where prplMesh comes in. prplMesh is an open-source implementation of the Wi-Fi Easymesh standard. It helps organize your network by making onboarding easier, coordinate settings between devices, and steer devices to the correct access point.

In this presentation, I’ll go over some of the challenges of coordinating Wi-Fi devices, and how we use (and develop) open source and open standards to make Wi-Fi better for everyone.

14:05 – 14:35 – If it’s public money, make it public code! – How to effectively push for Free Software all over Europe by Johannes Näder and Lina Ceballos

Do you want to promote Free Software in public administrations? Then the campaign framework of “Public Money? Public Code!” is the right choice for you; no matter if you want to do it as an individual or as a group; if you have a small or large time budget; whether you are targeting the national level or your local administration.

In this talk, we will present some inspiring success stories from the campaign around Europe and invite you to follow their example. For this we will explain how the campaign framework can be used to push for the adoption of Free Software friendly policies in your area; be it your public administration, your library, your university, your city, your region, or your country.

15:00 – 16:30 – Panel discussion: SBOM content, usefulness, and caveats with Bradley M. Kuhn, Alexios Zavras, Anthony Harrison, Julian Coccia, and Paul Novarese

A panel discussion on different aspects of SBOMs (Software Bill of Materials). Audience participation is expected and encouraged!

17:00 – 17:50 – Open Source Software at NASA by Steve Crawford

Software has been a common thread across all of NASA’s major achievements from the Moon landing to the deepest images of our Universe. Today, NASA relies on, releases, and contributes to Open Source Software to advance its scientific missions. From powering our databases monitoring our planet and Sun to running in our missions on other planets, Open Source Software is critical to addressing NASA’s biggest challenges on climate change, exploring the solar system, and discovering life beyond Earth. The Ingenuity helicopter, exploring the surface of Mars, is guided by Open Source Software. The amazing images of the earliest galaxies from the James Webb Space Telescope were made possible by open-source software developed openly and contributed back to the community.

Now, NASA is taking the next steps to further broaden the impact of open source by applying it to the scientific process with its Open Source Science Initiative. NASA is directly supporting open-source scientific software through grants and contributions. To further advance scientific reproducibility and reuse, the scientific software underlying future scientific results will be made openly available, and unrestricted mission software will be developed openly to allow for community contributions.

You can check out the full schedule for FOSDEM 2023 by day, track, or devroom on the FOSDEM website, and as usual, it’s free to attend

Jean-Luc Aufranc (CNXSoft)

Jean-Luc started CNX Software in 2010 as a part-time endeavor, before quitting his job as a software engineering manager, and starting to write daily news, and reviews full time later in 2011.