Due to its strong community support and portability, the Zephyr Real-Time Operating System (RTOS) is gaining increasing popularity in both academic and industrial environments. This paper discusses the integration of Zephyr RTOS into research projects with a particular focus on its application at the Chair of Information Technology for Transport Systems (ITVS) at TU Dresden. We highlight how Zephyr facilitates cutting-edge research in networked embedded systems and serves as a foundation for practical instruction in IoT and telematics. Additionally, we examine the educational benefits but also the technical challenges.
When talking about embedded devices there are usually two main approaches: classic bare-metal programming approaches and RTOS-based approaches. Easily someone would say that the baremetal approach provides direct control over hardware resulting in maximum efficiency in 1† These authors contributed equally.
sven.grunwald@tu-dresden.de(S. Grunwald); Kevin.Krebs@tu-dresden.de (K.Krebs)
© 2025 Copyright for this paper by its authors. Use permitted under Creative Commons License Attribution 4.0 International (CC BY 4.0). combination with minimal delay and a small memory footprint that is ideal for simple or high resource-world systems. Which may be correct, but this means an increase in the complexity of development, lack of portability and the absence of underlying multitasking is difficult to manage concurrent functions or scale the system. On the other hand, using an RTOS (real-time operating system) provides support for structured work management, hardware abstraction and multitasking that greatly simplifies development for complex systems and increases scalability and maintenance but there’s a certain learning curve and the need to understand some basic concepts in programming and RTOS-driven software development. Central to our teaching and research is the Zephyr RTOS. It plays an important role in enabling practical and innovative work with embedded systems since 2020 within the classroom as well as within research projects at the chair at TU-Dresden.
Zephyr’s modular architecture allows students and researchers to tailor the operating system to
specific project needs, gathering a deep understanding of embedded system design by selecting only
the necessary components and protocols [
This is becoming more and more important in a globally connected world and is underlining the
importance of cybersecurity in modern IoT systems [
At TU Dresden, we offer a variety of courses for both undergraduate and graduate students that use the Zephyr Real-Time Operating System (RTOS) to connect theory with hands-on practice. Our students come from many different fields including electrical engineering, computer science, aeronautics, rail transport and traffic telematics. This diversity brings some challenges but also great opportunities. Notably, almost none of the students have prior experience working with microcontroller boards and many lack a formal background in communications engineering. Yet, understanding connectivity technologies is becoming increasingly important across all areas of technology. To support this, we have developed a series of “crash courses” that run alongside our main lectures. These courses focus on key concepts in embedded systems, networking and wireless communications while giving students practical experience using Zephyr as a teaching tool. This approach helps ensure that all students, regardless of their background or previous hands-on experience gain the essential knowledge and skills needed to work effectively in today’s connected world.
Lectures at ITVS
Zephyr building blocks within lectures Traffic Sensor Technology
Digital Signal Processing
Traffic Telematics Networks Theory and Technology of Information Systems 7th semester 6th semester 6th semester 5th semester Audience
Research projects Electrical Engineering
Traffic Telematics Railway Systems and Public Transport
Air Transportation and Logistics
External peripherals e.g. sensors
CMSIS DSP / Algorithms Networking / Wireless connectivity Basic usage / RF-Basics antennas
Custom hardware e.g. nRF91 Custom traffic sciences related applications e.g. IQ-sampling Algorithmic / signal processing tasks
To provide a clearer picture of how these concepts are integrated into our curriculum, the
following section outlines some of the key lectures and their focus areas. Within lectures such as
Theory and Technology of Information Systems we are establishing a strong foundation by teaching
the fundamentals of radio frequency technology, antenna principles and propagation effects essential
wireless basics for students without a background in communications engineering [
Fundamentals in RF-technology, antenna principles and propagation effects The ISO/OSI layer model and practical networking, reinforced through hands-on work with protocols like MQTT / MQTT-SN, CoAP, UDP and TCP Introduction and application of modern IoT connectivity standards such as Thread, Matter, UWB preparing students to engage with real-world smart device ecosystems • •
Fundamentals in Cybersecurity and best-practices for data security in IoT applications and why it is necessary Core embedded systems topics e.g. power, constraints and memory management Design and implementation of sensor nodes and gateways for smart mobility and traffic telematics, effectively bridging theoretical concepts with industry-relevant topics By integrating Zephyr into the curriculum, we ensure that students from diverse academic backgrounds acquire the connectivity and embedded systems skills that are now fundamental across all modern engineering and technology fields. Leveraging Zephyr’s extensive library of sample applications and board support packages enables students to focus on high-level system design, debugging and application development fast. This approach accelerates the learning process but also mirrors best practices in industry where rapid prototyping and cross-disciplinary collaboration are the norm and kind of expected. All in all the curriculum is designed to make complex technical topics accessible and relevant to students from all engineering backgrounds ensuring that they acquire the essential skills needed to thrive in a world where connectivity is ubiquitous and foundational to innovation in every technical field. Through this holistic and application-oriented integration of Zephyr we empower our students to understand but also design and troubleshooting modern connected systems.
At TU Dresden a recent research project showcased how powerful Zephyr RTOS can be for realtime data acquisition in traffic monitoring. The team worked with a custom hardware platform based on the Nordic Semiconductors® nRF9160 cellular IoT module. Due to the modular software design and the available configuration tools the researchers were able to build a robust multi-layer network stack and integrate secure cloud connectivity via MQTT. The components of the setup are shown in figure 3. The protocol MQTT was chosen to ensure flexibility, scalability and loose coupling to have freedom in the mode of operation on both sides. The development of a live web dashboard for data visualization was part of the outcome as shown in figure 4. moved from theoretical models such as real-time scheduling and secure communication protocols into real-world implementation. The team could work “close to the metal” when needed, optimizing low-level peripherals (e.g. ADC) and power consumption, but also take advantage of abstractions for rapid development which is usually the case when dealing with research projects and tight timelines especially in a university context.
A clear illustration of Zephyr’s strengths emerged when the team needed to implement a custom low-power sleep mode that dynamically adjusted based on physical movement and incoming sensor data rates and network activity. Using Zephyr’s flexible power management APIs and real-time kernel features they could fine-tune the device’s energy consumption without sacrificing responsiveness. For instance, the system was able to wake instantly to process high-priority traffic events and then return to deep sleep ensuring to minimize power consumption. This was an essential requirement for cellular IoT deployments within the remote traffic monitoring context because the test carrier was quite sensitive to quiescent current. This level of control in combination with Zephyr’s support for seamless integration of custom analytics modules enabled the team to process and filter large volumes of sensor data locally e.g. sending only relevant information to the cloud. As a result they achieved both efficient energy usage and reduced the costs of the cellular data demonstrating how Zephyr empowers developers to create optimized and field-ready solutions.
Zephyr based connectivity system The outcomes of the project were not confined to research activities alone. They were systematically integrated into our teaching framework, facilitating the adoption of the Zephyr RTOS and nRF9160 platforms in our curriculum. Challenges encountered and solutions developed during the research phase were translated into new laboratory exercises and project modules that closely reflect real-world engineering scenarios. This approach provides students with concrete examples that bridge theoretical instruction and practical application, thereby demystifying complex embedded systems concepts through experiential learning. For instance, students engage directly with the same hardware and firmware utilized in our research allowing them to observe firsthand the implementation of advanced topics such as power management and secure IoT communication including the practical application of cryptographic techniques. Furthermore, students experiment with various cryptographic algorithms gaining insight into their impact on system resources such as memory utilization. This hands-on exposure equips students with the skills and understanding necessary to address contemporary challenges in embedded and connected systems. A more complex and therefore challenging task for the participants is setting up the Zephyr environment to work with network protocols like MQTT and MQTT-SN making sure everything runs well on low-power devices. One important assignment is to keep the system reliable even when things go wrong, like losing the network or server issues arise. Through this practical experience, students not only tackle the tough topics that come with modern RTOS development but also gain confidence to play around with advanced features like remote diagnostics and cloud data visualization (Figure 5). They learn to fix real problems, adapt to changing needs and understand why solid design matters. This hands-on approach gives them a deeper grasp of embedded systems and gets them ready to face challenges in the industry with practical skills and creative thinking. By engaging with industry-standard tools and development workflows students gain valuable skills that are directly transferable to professional settings. The integration of Zephyr and the nRF9160 platform into the curriculum has inspired many students to pursue their own projects and even take a closer look into open-source initiatives. Over time this work has also helped strengthen our partnerships with leading industry players like Nordic Semiconductor, ST Microelectronics, Memfault e.g. guest talks from an industry perspective. These collaborations have opened doors for students to work with cutting-edge hardware and software such as Nordic’s nRF Connect SDK, stateof-the-art hardware platforms like nRF53/54/91, Memfault’s advanced device monitoring tools and even STMicroelectronics™ MEMS sensors featuring machine learning core technology. Not only do students gain hands-on experience with the same technologies used by professionals but they also have opportunities to connect with industry mentors and build networks early. This is especially valuable in the Dresden region where the embedded sector is thriving. Through workshops, guest lectures and joint projects our students are exposed to real-world challenges and current industry practices further enhancing their readiness for the workforce. As more companies adopt Zephyr this practical exposure and industry engagement give our students a real advantage in their studies and as they launch their professional journeys. This synergy between academia and industry ensures that our graduates are well-prepared to contribute meaningfully to the rapidly evolving field of embedded systems.
The inclusion of Zephyr RTOS in our embedded systems class has been a driving force in advancing the adoption of teaching ideas in real-time and embedded software. The scalability of Zephyr's design, with the aid of a microkernel that is supported by many hardware platforms, is an environment relevant to the industry for students. Early engagement with Zephyr allows students to master essential RTOS design patterns, including preemptive multitasking, priority-based scheduling and inter-thread communication.
The adoption of Zephyr RTOS within embedded systems education has led to significant changes
in both instructional content and pedagogical methods. Curricula increasingly combine theoretical
lectures with practical laboratory sessions enabling comprehensive coverage of essential RTOS
principles including kernel initialization context switching, interrupt management and various
memory management techniques such as heap, stack and memory pool utilization. Laboratory-based
activities reinforce these foundational concepts by requiring participants to deploy Zephyr on
diverse hardware platforms modify device trees for hardware abstraction and interact with
subsystems such as file systems, network stacks and peripheral drivers. This emphasis on
experiential learning facilitates the transition from theoretical understanding to practical
competence. Application-oriented tasks such as the implementation of sensor fusion algorithms or
the development of Bluetooth Low Energy (BLE) solutions serve to bridge the divide between
academic instruction and industry practices. A central factor in this educational evolution is the
open-source nature of the Zephyr ecosystem. The collaborative environment fosters exploration of
kernel source code contributions to bug fixes and feature enhancements and active engagement with
a global developer community. Such exposure demystifies the software development process and
encourages the adoption of professional practices including code review, version control and
continuous integration. By shifting the focus toward application logic and overall system design
Zephyr’s abstraction mechanisms make it possible to engage with sophisticated subjects including
Bluetooth LE channel sounding without requiring exhaustive familiarity with low-level hardware
details we learned recently in a student thesis we supervised at the chair [
Although it has its advantages, Zephyr does have a non-negligible learning curve, particularly for users from bare-metal or proprietary embedded development backgrounds. Key hurdles to overcome are understanding Zephyr's build system (west and CMake), the Kconfig configuration language and adapting to the device tree hardware description paradigm. These are elegant concepts but can be mysterious to the uninitiated and require a shift in thinking from imperative register manipulation to declarative hardware configuration. To assist in mitigating these concerns, we are and continue to make the following best practices: • • • • • •
Begin with foundational Zephyr topics such as the basic application structure and build workflow before advancing to more complex features like multi-threading and interprocess communication Integrate comprehensive, hands-on tutorials that walk students through essential tasks such as configuring hardware with device tree overlays and customizing system behavior with Kconfig using practical examples Structure coursework so that each project builds upon the previous one, gradually introducing new Zephyr subsystems and concepts to reinforce learning and promote a sense of achievement Encourage teamwork through code reviews, group debugging sessions and peer-to-peer mentoring encouraging students to share insights and troubleshooting together Utilize regular check-ins, surveys and reflective exercises to identify learning bottlenecks and adapt instructional methods accordingly Empirical results collected in the form of pre- and post-course survey indicate a substantial rise in students' self-rated confidence and skill level in RTOS concepts after completing Zephyr-based modules. Performance indicators such as lab completion rates and project success rates also affirm these results.
One significant result of bringing Zephyr into the classroom is the shift it encourages in how students approach embedded systems. Instead of focusing on programming at the register level students begin to think in terms of system-level design and abstraction. In many traditional embedded systems courses the emphasis is placed on directly manipulating peripheral registers. While this method has educational value it does not always align with the way embedded software is developed in industry today especially when talking connected embedded systems. Zephyr changes this by providing device drivers and standardized application programming interfaces. This results in highly portable code that can run on a variety of architectures e.g. ARM Cortex-M or RISCV. This abstraction makes it easier for students to direct their efforts toward building systems that are scalable and easier to maintain. For example, instead of writing code that is specific to a particular vendor just to initialize the UART. Students can use Zephyr’s common interface for serial communication. This optimizes the development process and introduces important concepts such as platform independence as well as modularity and reuseable code. These are qualities that are highly valued in the current embedded systems job market. It is important to acknowledge that Zephyr’s abstraction does not always cover every possible use case with complete consistency. There are situations where applications need access to advanced or highly specialized hardware features and in these cases the generic interfaces may not provide all the necessary functionality. For example, Nordic Semiconductors® nRF devices using features like the programmable peripheral interconnect (PPI) for advanced analog-to-digital conversion often require developers to work directly with the vendor’s software development kit stepping outside of Zephyr’s abstraction. The same is true for the Raspberry Pi Pico where the basic analog-to-digital converter can be accessed through Zephyr but making use of advanced features such as direct memory access, round-robin sampling or detailed configuration options typically means turning to the Pico SDK or manipulating hardware registers directly. These examples illustrate a challenge in the design of portable system code. There is often a trade-off between generating code that’s portable across different hardware platforms and to be able to access the full range of features that a specific device offers. While Zephyr is designed to promote portability and modularity developers sometimes need to fall back on hardware-specific code to achieve the best performance or to use unique features. This reality highlights why it remains important for students to understand both the higher-level concepts of operating systems and the lower-level details of hardware programming especially when working on advanced or performancesensitive embedded applications. By explicitly addressing these limitations in the curriculum students gain a realistic understanding of both the strengths and boundaries of RTOS-based development. They learn not only to appreciate the benefits of system-level abstraction but also to recognize scenarios where direct hardware access remains essential for leveraging the full potential of modern microcontrollers.
The integration of Zephyr RTOS into our embedded systems courses has produced measurable improvements in student performance, confidence and project success. Oral surveys before and after implementation indicate that students' self-reported confidence in developing embedded applications increased significantly. From around 40% confidence initially to 75% upon completing Zephyr-based courses illustrating how hands-on exposure to a modular, industry-focused RTOS bridges the knowledge-practice gap. Project and laboratory success rates also consolidate this trend. Successful project submission went up from 65% in previous cohorts to 85% after Zephyr was integrated, with significant improvement in applications requiring lots of resources, including real-time processing of data and power management. Additionally, lab exercise debugging time for minor firmware issues decreased by approximately 50%, from 30 minutes average time to 15 minutes. This indicates that students rapidly gain debugging tool proficiency and system knowledge for less complex programming flaws. These gains are complemented by more instances of using optional advanced projects, such as building secure IoT communication modules or low-power sensor networks, which leverage Zephyr's on-board security libraries and power management APIs. In combination, these quantitative results demonstrate that Zephyr RTOS increases technical expertise and builds a deeper knowledge of system-level design principles critical to modern embedded development. In the future, longitudinal studies will attempt to measure how these initial successes impact students' transition into industry roles, with the hope that the experience and exposure accrued through Zephyr will mean greater employability and readiness for future needs within the field of embedded systems.
The most longstanding problem encountered is most likely debugging within the Zephyr platform. Tightly integrated but proprietary IDEs such as KEIL® uVision® and IAR Embedded Workbench®, for instance, offer a more straightforward setup process and experience. Since Zephyr relies on open-source and free tools like GDB, OpenOCD and SEGGER Ozone. This setup procedure can be intimidating for both students and instructors alike, especially for those new to embedded systems development. Moreover, the use of tools occasionally results in unpredictable behavior during debugging or programming sessions. Issues such as devices failing to program without a visible feedback or unexpected deadlocks at startup are not uncommon and can detract from the overall learning experience. To address these debugging challenges there is a need for better tooling and integrated development environments that simplify setup and troubleshooting. Developing or adopting Zephyr-specific IDEs with enhanced features such as real-time thread visualization and integrated peripheral monitoring could significantly improve the user experience. Obviously debugging multi-threaded, real-time programs introduces additional and challenging complications. Deadlocks, priority inversion and race conditions are intrinsically difficult to identify, as context switching and task scheduling events are not always obvious in the source code or easily traced using traditional debug tools. Current solutions are mainly for single-threaded static platforms and do not adequately deal with the dynamic behavior of RTOS-based applications. To address these challenges, we recommend the following from a teaching perspective: • • • •
Creation or adoption of a graphical interface supporting real-time thread visualization, event tracing and integrated peripheral monitoring Comprehensive instructional materials and video guides for setup and use of debugging tools emphasizing common challenges and advanced RTOS debugging methods Incorporation of advanced analysis solutions e.g. Percepio Tracealyzer® or SEGGER SystemView to provide accessible, real-time insight into thread execution, system events and resource usage in a more streamlined and easy to follow way Collection and analysis of data on debugging outcomes, resolution times and user feedback to continuously improve curriculum effectiveness
To further enhance the educational value of Zephyr in the classroom and contribute to the broader community the following initiatives could be useful: • • • •
Systematically gather and analyze quantitative and qualitative data on student performance and learning outcomes Contribute modular, open-source teaching materials including lab manuals, annotated code samples and debugging guides to the Zephyr documentation repository Establish stronger ties between academia and the Zephyr developer community by encouraging student / instructor participation in forums and open-source contributions as part of coursework Establish feedback loops with students and industry partners to ensure the curriculum remains aligned with evolving best practices and technological advancements
Integrating Zephyr RTOS into the curriculum and research activities at TU Dresden has
significantly modernized embedded systems education. Its modular design and community support
facilitate quick adaptation for diverse projects and foster practical skill development. Notably, even
students with limited prior experience in embedded systems have successfully engaged with Zephyr,
overcoming initial challenges to design and implement projects at bachelor’s and master’s levels.
This demonstrates Zephyr’s effectiveness in bridging the gap between theoretical knowledge and
real-world application. This demonstrates with the right guidance and resources the challenges of
adopting modern RTOS are surmountable. Nevertheless, our experience has highlighted several
opportunities for further improvement within our courses and labs. The initial learning curve
remains a significant challenge particularly for newcomers to embedded systems. To address this,
we plan to develop more structured onboarding materials e.g. beginner-friendly tutorials in
combination with step-by-step lab guides. Interactive workshops that clarify key concepts like
device trees, KConfig and Zephyr’s build system could also improve the learning experience.
Expanding the peer-to-peer learning and mentoring opportunities can also help students navigate
early hurdles more effectively. Moreover, keeping instructional materials and documentation up to
date is essential in a fast-moving ecosystem. A good example for managing different Zephyr and in
this case SDK versions is the Nordic Semiconductors® developer academy [
During the preparation of this manuscript, the authors employed DeepL to assist with sentence refinement and rephrasing. Following the use of this tool, the authors thoroughly reviewed and edited all content as required and assume full responsibility for the accuracy and integrity of the final publication.