Accidental Struggle by Example of Ringbuffers

When you ask: Why is everything so complicated? - Most likely because of accidental complexity taking a big bite of your time.

It's often hard to recognize in large code bases. In this talk we will analyse the story of an innocent ring buffer for embedded systems. You will learn how to recognize and fight feature creep and accidental complexity.

Embedded Device Exploitation 101: An Introduction to Firmware Hacking

Embedded devices are widely used and can be exploited by attackers due to vulnerabilities in their firmware. In this talk, we will cover classic software vulnerabilities that are commonly found in firmware, such as buffer overflows, format string vulnerabilities, and integer overflows. We will also explore various methods for finding vulnerabilities in firmware, including reverse engineering, fuzzing, and code analysis.

To illustrate firmware exploitation, we will examine two case studies, one using a basic stack buffer overflow with shellcode and a variant using Return-Oriented Programming (ROP). We will then discuss various defenses that can be used to protect against firmware exploits, such as stack canaries, XN (Execute Never) Memory, and Control Flow Integrity (CFI). We will also discuss how the embedded environment may influence the choice and function of defensive measures.


Modern CMake for reusable, portable and testable embedded projects

In Embedded Projects often IDE's provided by the chip vendors are used for Software Development. These IDE's often come with code generators for device drivers and are intended to help the developers to start projects fast. But they are not suitable for projects with external dependencies or for reusable software components. CMake can help you manage your SW dependencies and use the software for multiple target microprocessors, platforms or compilers. Using different compilers helps you assure that the software is standard compliant. Using different toolchain files will enable you to compile the code or project for different microprocessor.

I would like to show you the way we tackle our dependencies and how we reuse our components on different microprocessors.

Open Loop Testing - The missing Link to embedded testing?

The current state of firmware testing is too complicated. Huge resources are spent on system tests that discover little bugs. For embedded firmware the correct interaction with microcontroller periphery (GPIO, CAN, ...) is essential. Drivers are programmed to utilize this periphery. Open loop tests offer the possibility to test these drivers in detail. Embedded platforms are based on drivers. Therefore a process to test drivers is critical to reliable platforms. Open loop is a term used in control theory. Control theory aims to influence a process so that a given state is reached. Closed loop controllers continuously measure the output. The process is then influenced based on the difference between desired and actual state. Open loop controllers are not dependent on the output and influence the process in a blind way. This simplifies the design and use enormously. Embedded systems are typically tested in a way that resembles closed loop controllers. Open loop principles can simplify the complexity so that tests are compact and readable. This talk will present the current state of embedded systems testing. It will explain how this relates to closed loop systems. Then an alternative approach is developed that is based on open loop principles. 


Using both cores of Raspberry Pi Pico with C++OS

Last year Detlef Vollmann presented C++OS, an operating system targeting small MCUs based on the C++ Standard API. But it was all mostly theoretical and very few things actually worked. This year there will be more fun: C++OS now supports both cores of the RP2040, the processor of Raspberry Pi Pico. While the RP2040 features two Cortex M0+ cores, as an implementation of the Armv6-M architecture it's not really meant for symmetric multi-processing (SMP), so std::thread is not appropriate for using these two cores (though it could be make work). But with coroutines in C++20 and std::execution (probably in C++26) there are other standard mechanisms in C++ to utilize multiple cores. And for the fun this presentation will show a network loudspeaker based on the Raspberry Pi Pico W.


Getting rid of "it works on my machine"

In the embedded world, there are a multitude of vendors, each providing their own flavour of toolchain, code-generation tools and more. It is really difficult to get all the developers (and hopefully your CI) to stick to the exact same version. Sometimes the download links don’t work anymore, sometimes the software doesn’t like having parallel installs, or sometimes the links silently change to a “minor” version that still breaks things.

Using docker, we can handle the complexity once per project (or even re-use the results from another project) and guarantee that the environments always work and are somewhat reproducible. No more "it works on my machine"

Here I give a quick demonstration of the setup we have landed on.

The foundation of embedded DRAM Memory

DRAM Memory is the major performance, energy and reliability bottleneck of all data-intensive workloads, e.g., graph processing, machine learning using large data sets, data analytics, databases, genome analysis. Many specific accelerators for these applications are being created and many of them make use of embedded DRAM. eDRAM is dynamic random-access memory (DRAM) integrated on the same die or multi-chip module of an application-specific integrated circuit (ASIC) or microprocessor. This talk provides a comprehensive introduction to Embedded DRAM (eDRAM), and a clear understanding of the latencies and Bottlenecks in embedded DRAM./p>

Molding VS Code into a care-free development environment to develop with Zephyr RTOS

Developing for the next generation of devices at our company enabled us to use a lot of new technologies. One of the biggest sweeping changes to our stack has been the use of Zephyr RTOS for our embedded projects. Working in a team where most of the developers were inexperienced with Zephyr, yet also wishing to keep the mentality that anyone can work on any given topic, we as a team decided to strive for a working setup that is as care-free to set up and use for anyone.

Join me on this field report describing the essence of our development setup, ranging from Docker to CMake presets, getting custom setup steps for Zephyr seamlessly integrated, handling remote debugging and integrating unit tests as well as other helpful tools.

How Artificial Intelligence is Changing the Face of Computing and Development

The Internet emerged in the 1960s in the USA with the Arpanet and later with the Internet. Tim Berners-Lee created the World Wide Web in the late 1980s to solve the problem of storing information on different computers. Subsequently, mobile devices opened a new era of computing. With remote computing power for mobile devices, cloud computing became popular again on the desktop as well. Artificial neural networks (AI) experienced a boom thanks to this power. ChatGPT is an example of an AI-driven human-machine interaction. It came about that high school and college students started using it to solve their assignments. The use of conversational services and AI in programming has raised concerns about job loss, but human interaction is still needed for complicated tasks and soft skills like empathy. Human interaction will become even more important in the future.

Towards a safer C++

C++ is one of the most widely used programming languages, In this talk I will explore how a future C++ might be much safer by a combination of different techniques. Some of the ideas can be applied today and they exist in several coding guidelines. Some others will require modifications, extensions or restrictions in the C++ language and the standard library.

High-Performance Message Dispatch in C++

Last year Luke presented the CIB framework developed by Intel at emBO++ 2022. Watch this talk to learn how the CIB framework is used to enable low-latency, high performance message dispatch in embedded systems. Luke will quickly recap the basics of CIB, the message handler service, and provide details on message dispatch performance achieved and how it is done. This topic covers template metaprogramming techniques, clean design principles, hashing and binary search algorithms, and declarative programming styles.

Embedded C and C++: A Security Perspective

For decades, C was the primary language for development on embedded systems and is still the language of choice in many new projects. However, even with these decades of knowledge and myriads of highly skilled developers, basic security vulnerabilities are still commonly found. Even worse, their root causes mostly boil down to the same recurring issues like buffer overflows or insecure handling of user input. One reason that such issues still show up is that the C language does not provide straightforward mechanisms to guard a developer against accidental mistakes. To make things worse, unlike functional bugs, security issues can often not be found by established testing methods.

In this lightning talk, we will explore C++ from a security perspective and see how many of the recurring security problems in embedded C projects can be systematically avoided using C++ language features.

RISC-V tracing. What is different?

The RISC-V foundation is about to ratify the "N-Trace specification based on the Nexus standard. In this talk we will take a look at the new specification, its components and how it compares to the Arm variant.

Open source C/C++ embedded toolchains using LLVM

Open-source tools based on LLVM, such as clang and lld, have traditionally focused on rich software platforms. There is much less usage of open-source C/C++ toolchains for embedded software development, with GNU toolchains being dominant. This can be explained by a number of factors: assembling an embedded toolchain is complicated, interface differences from GNU as well as code-size and performance gaps. There are efforts in the LLVM community to improve the suitability for embedded software development. This presentation will cover some of the gaps and what we are trying to do to fill them. Specifically:

  • Hosted versus embedded toolchains.
  • Why do we want to use LLVM for an embedded toolchain?
  • What components make up an embedded toolchain, and which of these can be supplied by the LLVM project.
  • A comparison of a LLVM based toolchain against an equivalent GNU toolchain.
  • Work that is being done in the community to improve embedded development.


Low Code/No Code Design Paradigm for Multi-OS Cockpits

Developing a cohesive experience for an integrated cockpit brings a host of challenges to the most skilled of design teams. Each display requires its own software. Clusters require RTOS, state tool, functional safety software and graphics tool. IVI requires connected OS, like Android, graphics tool, RTOS and state tool.

Each team involved is working in a different language – Java, C, C++ – and must manage behavior specifications and requirements for UX, safety and system. They must port their output to the same embedded chip on different sides of a hypervisor. Additionally, engineers are in short supply. Design teams rely on other team members to contribute to delivery of their automotive cockpit.

With a model-based development process and automatic code generation, development teams can meet delivery schedules and bring winning cockpit HMIs to market. Low-code/No-code GUI development environments empower automotive development teams to succeed.

Using Embedded Real-time Operating Systems with C++

Nowadays applications in modern embedded systems are more complex. Therefore an RTOS is often used as a foundation for the application. Developers have the demand to use C++ instead of C to develop the RTOS application. Using RTOS API with C++ can be challenging. This session demonstrates how to develop C++ RTOS applications.

Lessons Learned for Reusable Firmware

MCUs get more and more powerful and get more responsibilities in a system. Each device from our company contains one or more MCUs, which needs to be maintained for at least 10 years after the release. To keep the development and maintenance costs small it is necessary to reuse as much software as possible. In my talk I want to provide you the lessons I learned for writing reusable, hardware and operating system independent software. This contains hints about the hard- and middleware abstraction and also how to structure the business logic that it can be reused without changes between different firmware projects.

Next generation zonal architectures in cars

This talk discusses our new approach to the zonal architectures in cars, showcasing how Automotive Ethernet enables the next generation of zonal controllers. Discussing safety and non-safety relevant signals processed by zonal controllers, we will show how Automotive Ethernet is becoming the pre-dominant standard in E/E architectures using technologies such as TSN, PTP and AVB. As a quick outlook to the future of automotive networks we will finally take a look at the new evolving technology of 10Base-T1S covering the last mile.

More LEDs

MicroPython is a valid alternative to compiled langues when speed of modification is more important than speed of the running application. The talk demonstrates the use of MicroPython on a number of target chips, and using various ways to make the best of their limited resources. But foremost, it shows various ways to blink large numbers of LEDs, because more LEDs is obviously better.