The Embedded Systems Summit will run over three days, October 14–16, 2025 (Tuesday through Thursday), from 8:30 a.m. to 5:00 p.m. each day.
Day one will feature a hands-on Zephyr Bootcamp led by Jacob Beningo and Mohammed Billoo. Days two and three will be dedicated to the main program, offering a rich mix of talks and workshops.
All Sessions to be Scheduled Soon
You've gotten started with Zephyr RTOS. Maybe you've followed a tutorial or built a basic demo. But when it comes to building real-world, production-ready firmware, things get complicated—fast.
You’re not alone.
Most embedded developers struggle to move beyond simple examples into scalable, testable, maintainable systems. The complexity of modern workflows, device trees, overlays, CI/CD integration, and power management often creates more confusion than clarity.
That’s where the Zephyr RTOS Bootcamp comes in.
In this one-day immersive workshop, you’ll go hands-on to design and build a real production system using Zephyr RTOS.
Led by industry experts Jacob Beningo and Mohammed Billoo, this immersive workshop provides a proven roadmap to master Zephyr RTOS—from low-level board bring-up to modern, professional workflows. You’ll leave with practical experience, professional confidence, and the toolkit you need to build and ship production-grade firmware.
Who Should Attend
This course is designed for embedded developers with a basic understanding of RTOS concepts and some exposure to Zephyr, such as those who’ve completed the Nordic Zephyr Academy or similar training.
Your Guides
Jacob Beningo is an embedded systems consultant who has helped hundreds of companies modernize their firmware development. He specializes in RTOS design, DevOps workflows, and architecting systems that scale.
Mohammed Billoo is an embedded Linux and firmware expert who trains teams to navigate complex system design, testing, and hardware-software integration.
Together, they bring decades of real-world experience to help you go from “just tinkering” to building professional firmware.
Key Topics and Hands-On Labs
Development Environment Setup
Device Tree & Custom Boards
Interrupts & Low-Level Programming
Custom Drivers & HAL
Debugging & Testing
What to Bring
Zephyr is a complete, fully integrated, highly configurable and modular open-source RTOS for resource-constrained designs that is rising in popularity. However, debugging an embedded RTOS application can be both challenging and time consuming. Having quality tools to assist the debug effort can help tremendously. With SEGGER development tools that support Zephyr, developers can easily debug and analyze application software to get to market more quickly.
This session features demonstrations of the J-Link debug probe with Zephyr Thread Awareness using SEGGER Ozone, plus analysis and visualization with SEGGER SystemView.
Most embedded teams are under pressure to ship faster, but outdated tools, brittle architectures, and unscalable workflows often lead to missed deadlines, quality issues, and developer burnout.
In this fast-paced 2-hour session, you’ll learn how modern embedded teams deliver faster, smarter firmware without sacrificing reliability. We’ll explore practical strategies to streamline your build system, design scalable architectures, adopt DevOps workflows, improve test coverage, and integrate AI where it adds real value.
Along the way, you'll be introduced to a proven 7-step modernization framework you can immediately apply to improve your team’s velocity, quality, and confidence.
Whether you're working with bare-metal systems or RTOS-based platforms, this session will equip you with modern practices to deliver embedded software that scales with less friction and greater impact.
What You’ll Learn
Developing embedded software is hard. It gets even more “complicated” when requirements, hardware, schedule, or team composition change. Change, by definition, implies additional work—and the drama comes from how to complete that work without pushing the schedule or adding resources. Put another way, too many changes can put software on the critical path and the development team under a microscope. This session covers strategies for taming inevitable changes and keeping your software off the critical path.
Topics covered will include:
Embedded development environments are often brittle—tied to specific host setups, compiler versions, and SDKs. As teams grow or go remote, these inconsistencies cause environment drift, onboarding delays, and audit challenges. This session presents a technical blueprint for adopting containerized development environments to eliminate these issues.
We will demonstrate how to:
We will also explore techniques for:
Real-world use cases will highlight improved developer onboarding, reproducibility, and security posture across distributed teams.
It's well known that network-connected systems need to secure themselves against remote attackers. But what could a person do with a device if they could actually hold it in their hands? A lot, it turns out!
Join me in this workshop as we discuss the many ways an electronic device could become compromised by a knowledgeable person with physical access to a device.
Participants will then employ a technique called "voltage glitching" with a Chip Whisperer - Nano to unlock a secure system!
What if every component shipped with a clean JSON schema instead of a 4000-page PDF? Would HAL work still be “software,” or merely data flow? And can AI fit inside functional-safety development constraints without becoming a black box?
This talk revisits low-level development from first principles. We’ll show how data-stable hardware descriptions - uniform, machine-readable, and vendor-neutral - turn driver generation, verification, and even migration between MCUs or RTOSes into push-button tasks. The result is faster bring-up, fewer bugs, and supply-chain freedom, all while keeping deterministic guard-rails that satisfy safety standards.
While C has long been the dominant language in embedded systems development, modern C++ offers a rich set of features that can significantly improve code quality, robustness, and efficiency — all without sacrificing performance on resource-constrained devices.
This session introduces practical, real-world techniques for applying modern C++ to embedded systems. It is divided into three focused parts:
Whether you're new to C++ in embedded contexts or looking to deepen your expertise, this session will provide concrete tools and insights to level up your embedded development with modern C++.
This presentation will show how to combine Dan North’s Behavior Driven Development (BDD) with James Grenning’s Test-Driven Development (TDD) for embedded systems. Whether you work in a highly-specified regulated industry or off the back of a napkin, BDD helps build software verified to implement the desired behaviors.
The presentation will first introduce the techniques. Then it will introduce strategies for applying them in the presence of embedded system complexities, such as:
The goal is to produce lean, effective, maintainable embedded system software that meets the aspirations of Edsger Dijkstra’s 1972 ACM Turing Lecture:
“Those who want really reliable software will discover that they must find means of avoiding the majority of bugs to start with, and as a result the programming process will become cheaper. If you want more effective programmers, you will discover that they should not waste their time debugging, they should not introduce the bugs to start with.”
Most embedded verification strategies rely on deterministic methods: unit tests, integration checks, static analysis. These approaches are necessary, but they only validate anticipated behavior. They follow expected paths with known inputs. Those methods cannot prepare us for the moment unexpected data arrives. Entire classes of bugs sit just outside their reach, quietly waiting for the real world to trigger them.
Fuzzing closes that gap. It introduces malformed, random, or invalid inputs, forcing the system to react to scenarios no one thought to test. This method prepares an embedded system to face what it will do in the field. Faulty physical layers, unstable sensors, corrupted wireless packets, or even intentional attacks all feed real-world chaos into devices. Traditional test methods struggle to recreate that kind of noise at scale.
Despite its proven value in other domains, fuzzing remains uncommon in embedded workflows. Most teams either haven’t considered it, or have avoided it altogether afraid that costs outweigh the benefits. Applied correctly, fuzzing becomes a powerful extension of existing test strategies, especially in areas like protocol parsing, hardware interfaces, and edge behavior in state machines. The approach can work without reinventing infrastructure or placing an onerous burden on a development team.
In this talk, we’ll discuss different fuzzing approaches and how they can help you build more trustworthy devices.
Embedded development isn’t just about getting the firmware to run anymore. AI at the edge, growing security demands, and the push for open standards are changing the rules quickly. Teams that ignore these shifts are getting blindsided by missed deadlines, blocked features, and compliance headaches.
In this talk, we’ll break down how each of these forces is reshaping the work, why older habits make it worse, and what you can do to adapt without blowing up your process. You’ll leave with practical ways to cover your A.S.S. and keep your projects smart, safe, and ready to connect.
Let’s efficiently unit test and integration test our state machine monstrosities! The general approach works with multiple unit testing frameworks, but Google Test has some distinct advantages, so we’ll use that. We’ll laugh, we’ll cry, and in the end, we’ll achieve full hierarchical state transition and behavior coverage in an easy-to-maintain manner.
The general concept works with any type of state machine (hand written, code generated, C, C++, Python…).
Topics include:
We are arguably better equipped with software tools, processes, debuggers, and analyzers than ever before—so why are we still struggling?
The core problems remain the same: mixed expectations, poor communication, shifting priorities, and a lack of autonomy. What can we do today to improve outcomes for ourselves, our team, and our organization?
In this talk, I will share lessons learned from a significant project at the LEGO Group, where we successfully transitioned all PoweredUp motors and sensors from STM8 to STM32, on time and within budget.
The Rust programming language is experiencing rapid adoption across the software industry. In this talk, we'll explore the features that make Rust especially suitable for **hard-real-time embedded applications**. We'll see that Rust's unique approaches to memory management and asynchronous programming provide bare-metal Rust with nearly the same capabilities as a real-time operating system.
As a case study, I'll discuss the bare-metal Rust firmware for an STM32-based motor controller being developed by the Robotics and AI Institute. Our experience has been heavily influenced by Rust's approach to error handling, its package management system, and its interoperability with C and C++. We've found that Rust makes it much easier to write robust and well-architected firmware.
Rust is a relatively new language, and we'll touch on the benefits and challenges posed by its rapid pace of development. I'll summarize the major Rust embedded projects under active development, including Embassy, RTIC, Hubris, and several PACs and HALs. The talk will close with recommendations for developers considering the use of Rust in their own real-time hardware projects.