The Zephyr Project Steps into the Spotlight at ELC + OpenIoT Summit

By | Blog, News

Last month, The Zephyr Project participated in The Linux Foundation’s Embedded Linux Conference + OpenIoT Summit North America in Portland, Oregon. Around 730 embedded and IoT technologists from 360 companies and 31 countries around the globe attended the event to collaborate with experts on a wide range of topics of embedded Linux and industrial IoT issues. This was an increase from last year, making this an important industry event for embedded and IoT developers with 12 keynotes and some 90 breakout sessions. In fact, 75% of attendees have already said they are planning on attending next year.

The Zephyr Project had a strong presence at the show. Jonathan Corbet, Author, Kernel Developer and Executive Editor of, mentioned Zephyr OS during his keynote for ELC. He mentioned how more developers are using Zephyr RTOS because of its small lightweight permissively licensing system and how open source projects like this one is the future of technology. You can watch the video of Jonathan’s keynote here.

Jonathan Corbet on stage during his keynote


The Zephyr Project, which was a Bronze sponsor for the show, had a booth in the technical and demo showcase. Featured demos included ones from Open Source Foundries, which showcased the LWM2M Device Management, LWM2M on AT&T LTE, which demonstrated the latest Zephyr code and LWM2M working over AT&T’s LTE network and Bluetooth Mesh in action on BBC micro:bit boards.

Demos at the Zephyr booth


Each day of the conference, the showcase hall was packed with attendees who wanted to learn about the latest projects and products, view hands-on demos and interact with other community members. 98% of attendees survey said they visited sponsor booths.

Zephyr members and experts on the first day of the show


Additionally, around 20 Zephyr technical experts attended the event from companies including Intel, Linaro, Nordic Semiconductor, Synopsys and Open Source Foundries, to present sessions related to Zephyr development and collaborate with other projects. Please see below for a few of the Zephyr sessions and links to the presentations:

Zephyr LTS Release: What to expect and why are we doing this

Anas Nashif, a Software Architect for Intel’s Open Source Technology Centre, presented a session that discussed the features of Zephyr LTS, such as stable APIs and the goal of taking a subset of the released project code through various certification activities, and next steps. The presentation can be found here.  

Zephyr and MCUBoot as Foundations for Secure IOT Products

Marti Bolivar, a Senior Engineer for Open Source Foundries, gave a talk about Zephyr and MCUBoot as Foundations for Secure IoT Products. This talk describes a concrete, open source IoT application based on Zephyr, MCUBoot, and LWM2M, as well as the developer tooling and security model underlying it. It focused on the practical application of these tools, rather than an abstract discussion of the components themselves. The presentation is available for review here.

Bluetooth Mesh

Johan Hedberg, a Senior Software Engineer for Intel, showcased how Bluetooth Mesh works with Zephyr OS and Linux. The presentation gave an introduction to Bluetooth Mesh, covering how it works and what kind of features it provides, as well as an overview of how it is supported in Zephyr OS and Linux and how to create new wireless solutions with them. See the presentation here.

Building IPv6 Mesh Network with Zephyr OS

Ravi Kumar Veeramally, a Software Engineer for Intel, gave a presentation about building IPv6 mesh network with Zephyr OS. This presentation detailed how to make use of Zephyr networking to utilize multiple interfaces (Ethernet and 802.15.4) and form a mesh network and control leaf nodes in the network. An 802.15.4 interface forms an RPL mesh network and Ethernet interface provides a web interface that shows and controls the mesh network leaf nodes. The web interface also displays the topology of the mesh network. Technologies involved here are Ethernet and 802.15.4, 6lowpan, IPv4/6, RPL, TCP, UDP, HTTP, Websocket and CoAP. See the presentation here.

Zephyr™ Now Supports OMA LwM2M protocol! What Can It Do For Me?

Michael Scott, an Embedded Software Engineer for Open Source Foundries, offered an interactive discussion about how Zephyr OS now supports OMA LwM2M Protocol and what that means for developers. He shared how the library has evolved from the 1.9 release through what’s available in the master branch of Zephyr today (to be released as 1.11) as well as broke down typical hardware configurations and instructions for testing the Zephyr LwM2M client via QEMU and connecting to a LwM2M server. See the presentation here.

Retrofitting Zephyr Memory Protection

Andrew Boie, a Senior Software Engineer for Intel, shared a presentation about how to retrofit memory protection in the Zephyr OS. This talk presented the work performed to retrofit memory protection in the Zephyr kernel, discussing the constraints, design decisions (affecting portability, security, and performance), its current state, and the next steps. He discussed details on a novel method of tracking and validating kernel objects, techniques for defining system calls with a minimal amount of boilerplate code, details on our APIs for managing memory permissions, and implications of the recently unveiled Meltdown and Spectre bugs and their implications for Zephyr. See the presentation here.

Flexible IoT Solutions using Zephyr and JavaScript

Brian Jones, a Software Engineer for Intel, offered a look at how flexible IoT solutions use Zephyr RTOS and JavaScript. He details the core concepts, use cases, and demos to illustrate how it all works. The presentation is available for review here.

Photos from a few of the Zephyr sessions


Overall, the Zephyr Project was well represented at ELC OpenIoT Summit. If you missed it, you can catch Zephyr at the next conference. Zephyr will be at LinuxCon China, which is co-located with ContainerCon China and CloudOpen China on June 25-27 at the China National Convention Center in Beijing. See below list of topics Zephyr will be presenting:

Retrofitting Memory Protection in the Zephyr OS – Wayne Ren, Synopsys

On Monday, June 25, Wayne Ren, a Senior Software at Synopsys, is doing a talk about Retrofitting Memory Protection in the Zephyr OS. Click here to add it to your schedule.

Introduction to the Zephyr Project – Ryan Qian, NXP & Kate Stewart, The Linux Foundation

On Tuesday, June 26, Kate Stewart, Senior Director of Strategic Programs for The Linux Foundation, and Ryan Qian, a software Engineer at NXP, will provide an Introduction to the Zephyr Project. Click here to add it to your schedule.

Stay tuned for more and come see us at LinuxCon China!

Let the party begin: Zephyr OS 1.11 is here!

By | Blog, News

Today, the Zephyr Project is happy to announce a new release of the Zephyr Open Source RTOS for embedded devices, version 1.11.

The breakneck pace of development has not stopped, and this new release introduces multiple features and enhancements that take Zephyr closer to its goal: to be the RTOS of choice in the embedded industry for companies and makers alike.

Among the headline features in this release, we are proud to introduce a native Microsoft Windows development environment. While many Zephyr users develop on UNIX-like platforms like GNU/Linux and macOS, we are fully aware that a lot of embedded developers rely on and trust Microsoft Windows as their operating system of choice. As a result, we have been building up support for it over the last few releases leading to this present one, which is the first to be completely buildable on Microsoft’s popular platform. Instead of relying on emulation layers to ensure maximum performance and seamless interaction with other native development tools, we rely on the power of the CMake build system and the Python scripting language to deliver a build system that is scalable, future-proof and completely cross-platform.

Additionally, this release introduces a new connectivity technology originally designed by Google and Nest, the Thread protocol. This has been a longstanding requested feature, and we have integrated the popular OpenThread implementation into Zephyr, allowing users to seamlessly interact with Thread networks using the already familiar Zephyr networking APIs and reusing the existing 802.15.4 drivers available.

A few high-profile features have percolated from “big”, full-blown operating systems into Zephyr in this version: Symmetric Multi Processing (also known as SMP) is now available for the Tensilica Xtensa architecture, allowing the kernel to run on more than one CPU core concurrently. In the same line, the already existing support for thread-level memory protection, previously available only on the x86 architecture, now can be enabled on the Arm and ARC architectures.

Additionally, IEEE POSIX support for the PS352 (Realtime Controller Product Standard) profile is nearing completion, with the majority of the APIs now covered. Zephyr does not intend to overlap in features and functionality with GNU/Linux, but these additions help transition existing codebases to embedded microcontrollers.

Sometimes developers do not want to go through the “modify, build, program” cycle in order to iterate quicker on a new piece of code that they might be working on. The new “native POSIX” board allows Zephyr to be compiled as a native Linux application, and debug it using the vast array of tools available to Linux application developers. This not only helps when coding and debugging new features, but it can also be used to profile and examine in detail execution paths and memory usage. It essentially turns embedded software development into desktop application development, and is a nice complement to our already existing QEMU emulation support.

Finally, one of the most requested features has made its way into the project: over-the-air device firmware upgrades (OTA DFU) using Bluetooth Low Energy.  The integration of a new framework to support this (MCUmgr) alongside the familiar MCUboot bootloader allows Zephyr images to be sent and programmed over a BLE connection, as well as adding a management layer that is able to access the filesystem and retrieve kernel statistics remotely.

We invite you to download Zephyr 1.11 today and try out all the exciting new features along with many others (initial Armv8-M support, a new lightweight storage layer, additional boards supported) that would be too long to list here. Your feedback is extremely welcome in our path to make Zephyr better than ever.

Download the Zephyr 1.11 here:

A sincere thank you to all those in the community who contributed. This release would not have been possible without your contributions!

Additional Zephyr resources:

Zephyr Project to Demonstrate IoT Innovation at Embedded World

By | Blog

Next week, The Zephyr™ Project will be joining some 1,000 exhibitors at Embedded World in Nurnberg, Germany. The event, which is slated to take place from February 27 to March 1, offers the embedded community the opportunity to obtain information about new products and innovations, enter into an exchange and to maintain and develop valuable contacts.

Project members include Intel, Linaro, NXP, Synopsys, Nordic Semiconductor, DeviceTone,, Texas Instruments, Oticon and more. Many of these members will be at Hall 4: Booth 4-680 and will offer interactive IoT device demos powered by the Zephyr RTOS, which supports multiple hardware architectures and is built with security in mind.

The Zephyr Project supports more than 82 boards, with additional hardware support being added regularly, making it widely applicable to both industrial and commercial IoT devices that demand the power of a real-time operating system.

Visitors of the Zephyr booth can expect to see numerous functional prototype devices using the Zephyr kernel, including a functional Bluetooth Mesh network, a low energy Bluetooth controller, and an OpenThread demo.

Additional details about the interactive demos are below:

  • The World’s first Bluetooth 5.0 qualified, open source low energy Bluetooth Controller that features open source code from Application to Radio, a BlueZ Bluetooth Host stack, a Zephyr kernel, low energy link layer, OS Host Controller Interface, the Nordic Semiconductor nRF52, and the Arm Cortex M4F + Bluetooth 5 and Radio SoC. This demo will take a closer look at the different layers that make up a full BLE protocol stack helps explain this capability.
  • Bluetooth Mesh in action on BBC micro:bit boards available since Zephyr OS v1.9  showcases the many-to-many BLE communication, how every node can be a relay and the user interface.
  • A functional Bluetooth Mesh Network with Lightweight Machine to Machine Device Management that will showcase the Cloud Device Management System using Linux-based IoT gateways and Zephyr-based IoT devices for real-world project prototypes and smart objects.
  • A demonstration of OpenThread integration, benefits from the Zephyr infrastructure and how it works with Nordic nRF52840 and OpenThread 6loWPAN Thread Stack. The flow of IP traffic is handled seamlessly by both the Zephyr native IP stack and OpenThread: 802.15.4 traffic received by radio driver is forwarded to the OpenThread stack, where it is processed by the 802.15.4 MAC, 6loWPAN and IPv6 layers implemented in OpenThread.

Additionally, ZephyrOS will also be on display in the Avnet Silica booth, located in Hall 1: booth 1-370, in a drink ordering application. The demo uses Zephyr’s BlueTooth Mesh Implementation on BBC Microbit boards. Attendees can order a choice of drinks such as Espresso, coffee, Cappuccino and water using the Microbit. The order is transmitted through the mesh to the host where a Tcl/Tk application will display the order to the baristas. There will be a setup of 7 demo pods – each gets a BBC Microbit and the drink orders are delivered right to the pod.

Nordic Semiconductor, located at at booth at Hall 4A: 110, will also have a few new demos that feature ZephyrOS.

Whether you visit member booths or the Zephyr booth, experts will be on-site to discuss the advantages of the project and readily explain how open source derived RTOS solutions will come to power the ever growing ecosystem of IoT devices.

Stay tuned for more from Embedded World!

Using Renode to run real multi-node Zephyr setups without physical hardware

By | Blog

Written by Michael Gielda, Zephyr Project Community Member and Business Development and Board Member for Antmicro

If you’re working with multi-node Internet of Things (IoT) systems, you probably have experienced problems related to testing, security, interoperability, reuse, lifecycle management, and code quality involved in building real-life networks.

To address these problems, new tools and workflows are needed that allow developers to collaborate around code more effectively. These tools and workflows must increase the test coverage and understanding of the software and protocols running on the devices that form the backbone of our homes, offices, factories, and cities, both now and in the future.

The open source Renode framework from Antmicro, which started a collaboration with the Zephyr project in 2017, is aimed at doing exactly that: Renode lets you simulate complex wireless (and wired) setups running real binaries so that you can do testing, continuous integration, and debugging to an extent that wasn’t possible before.

Sound promising? We hope it does. And it’s not as complex as it sounds. In this blog note, we’ll explain how Renode can help you in your daily development without forcing you to rewrite your software or abandon your familiar toolset.

Renode can simulate physical hardware systems – including the CPU, peripherals, sensors, environment, and wireless medium between nodes. Just develop your IoT software, including software based on the Zephyr RTOS (real-time operating system) using your familiar processes, and then use Renode to debug and test it in various circumstances. The tests includes protocols and applications that span multiple nodes. You can run them in a joint virtual environment with full determinism and control over the execution parameters.

For example, at the 2017 Embedded Linux Conference (ELC) Europe, the Renode and Zephyr teams jointly showcased a fairly complex simulated wireless setup. With nodes based on two architectures (x86 and ARM) and running two different RTOSes (Zephyr and Contiki), the demo showed how easy it is to perform interoperability testing with Renode.

In this note, we’d like to focus on how a simple multi-node setup can be reproduced from the comfort of your chair. This short tutorial can act as a starting point for your development with Renode and Zephyr.

  1. Installing Renode
    The Renode framework is hosted on GitHub - You can use the README file to download and install it, but the easiest way to start is by downloading a binary release from The precompiled packages are provided as deb and rpm packages for Linux, a dmg package for macOS, and a zip archive for Windows.

  2. Starting Renode
    This tutorial uses the Renode command line interface, which is one of many ways to interact with Renode. After installation, run the renode command. Alternatively, look for the Renode.exe binary. Once Renode is started, you will see two windows: one for Renode’s smart logger (you can control what’s being logged) and one for the command line interface (CLI) called the Monitor.

    From this CLI window you can create and control the whole emulation environment.

  3. Scripts
    While you can type all commands interactively, it’s a good idea to group them into reusable Renode scripts, which typically have the .resc extension. The scripts can be used to load binaries, set starting conditions, prepare the environment, connect machines to the network, and other tasks.

    This tutorial uses scripts available in the Renode package named: scripts/many-nodes/quark-c1000-zephyr/demo.resc and scripts/many-nodes/quark-c1000-zephyr/quark_c1000.resc. For details on the scripts, please review the commented files in the Renode installation directory. (For Linux, opt/renode/scripts is the default.)

  4. Loading our setup
    The tutorial setup consists of two Intel Quark C1000 nodes with a TI CC2520 radio connected via SPI. The nodes run applications based on Zephyr demos, an echo_server and an echo_client, compiled as normal for the target hardware. (The provided scripts use precompiled binaries hosted online, but you can provide your own binaries by changing the relevant $BIN variable in the scripts.)

    In Renode, the nodes are assigned coordinates in a virtual 3D space. By manipulating the maximum range of the wireless medium or moving the nodes around, we can put them in or out of each other’s range, and form different topologies, building routing scenarios of various complexity. In this simple example, the nodes are within each other’s range and we won’t move them around or make them lose packets.

    To run a script, use the include command (or i, for short), with a path to the script to load, prepended with the @ sign, like this:

    include @scripts/many-nodes/quark-c1000-zephyr/demo.resc

    After the script is loaded, you will see two new terminal windows. These are UART windows opened for each machine.

    The emulation is now loaded, but not started. You can control it using start and pause and other commands that are described in the next section.

  5. Simple commands
    1. Start and pause
      To control whether the simulation is running, use start and pause.
    2. Machines
      In the provided scripts, we use the mach create command to create new machines. This switches the context in the Monitor. All subsequent commands are executed with regard to the current machine.

      To change the machine, use the mach set command. Use a number or the name of the machine, for example, mach set 1 or mach set servername.

      All machines can be listed with the mach command. To clear the current selection, use mach clear.

    3. Accessing peripherals
      All peripherals are accessible in the Monitor, with most of their methods and properties exposed to the user. To list all available peripherals, use the peripherals command.

    4. Peripheral methods and properties
      To access a peripheral, you have to provide its path. All peripherals are registered in sysbus, so use sysbus.uartB to access the second UART or to access the CC2520. The using sysbus command is used in most of the provided demos, allowing you to drop the sysbus. prefix. Typing a peripheral name gives you a list of available methods, fields, and properties. The list is automatically generated, and most of the accessible members are not designed for the end user. The list shows examples of correct Monitor syntax for each member type.

    5. Other commands
      To find information about built-in Monitor commands, type help and refer to the documentation. Running help prints out the help for the given command.

  6. Debugging and inspection
    Renode provides many ways to verify the behavior of your applications. Thanks to having full control over the environment, you can add logging, hooks on events, interactive code debugging, and more in a way that is completely transparent to the emulated application. Since this is a simple tutorial, only a few debugging options are listed below, however, many more are available.

    1. Function name logging
      When the application is stuck or misbehaves, it is a good idea to inspect the trace of function calls. To enable logging of function names in a selected machine, run cpu LogFunctionNames true (use false to disable it). Since the amount of logged data may be too overwhelming to be useful, you can filter the logged functions to the ones that begin with a specified prefix. For example cpu LogFunctionNames true “uart_ qm_” only logs functions that begin with either the uart_ or qm_ prefix.

    2. Logging of peripheral accesses
      If your driver does not behave correctly, it may be beneficial to investigate communication with the device it controls. To enable logging of each interaction between the CPU and the UART peripheral, run the sysbus LogPeripheralAccess uartB command. This feature is available only for peripherals registered directly on the system bus.

    3. Wireshark
      Network traffic analysis is a common task in every multi-node system. Since Wireshark is a tool of choice for programmers, Renode supports it for both Ethernet and wireless networks. There are multiple options for choosing which interfaces should be logged, but the easiest way to observe all packets in an IEEE 802.15.4 network is to run the emulation LogWirelessTraffic command.
      This command opens a new Wireshark window. If you close it, you can always reopen it by running host.wireshark-allWirelessTraffic Run.

    4. GDB (GNU Project Debugger)
      A popular tool for debugging, GDB can be used to analyze applications running in Renode. It uses the same remote protocol as OpenOCD, so it can be easily integrated with most GDB-based IDEs, such as Eclipse. To start a GDB stub in Renode, run cpu StartGDBServer 3333 (where 3333 is a sample port number) and connect from GDB by calling (gdb) target remote :3333. To start the emulation, you have to run both start in Renode and continue in GDB.
      You can use most of GDB’s regular features: breakpoints, watchpoints, stepping, reading/writing to variables, etc. You can also use the monitor command in GDB to send commands directly to the Renode CLI, to avoid switching between two console windows.

We hope that this short tutorial will help you get started with Zephyr and Renode, which has recently become one of Zephyr’s recommended developer tools:

In a future blog post we’ll continue this tutorial with details on more complex wireless setups – stay tuned!

RenodeTM is a software development framework from Antmicro, a technology company building software-driven IoT systems. If you need help with implementing your platforms and setups in Renode, adopting a Continuous Integration workflow inside your organization, integrating with your tools or building custom ones, or IoT system development services using the Renode methodology, please contact them at