Teach on Udemy

Turn what you know into an opportunity and reach millions around the world.

Learn More

Your cart is empty.

Keep shopping

Mastering Zephyr RTOS with DeviceTree and Board Bring Up

Name: Mastering Zephyr RTOS with DeviceTree and Board Bring Up
Rating: 4.6 (49 reviews)

Complete workflow: toolchain setup, DeviceTree from scratch, custom board porting, and real world applications on STM32

Bestseller

Hot & New

Created byFastBit Embedded Brain Academy, Fastbit Embedded Technologies, Kiran Nayak

Last updated 6/2026

English

What you'll learn

Write DeviceTree from scratch for any custom board, not just copy from existing samples
Port a custom board into Zephyr with the complete board porting workflow
Build real Zephyr applications using interrupts, threads, workqueues, and message queues on custom hardware
Debug common DeviceTree and build issues using a repeatable step by step process
Set up the complete Zephyr workspace and toolchain on Windows, Ubuntu, and MacOS
Understand how a Zephyr application is organized, how the build system works, and how all the pieces connect
Configure your Zephyr project using prj.conf, menuconfig, and Kconfig the practical way
Use DeviceTree macros and GPIO APIs to control hardware pins from your Zephyr application
Configure UART console output for stdout logs and test your application on real hardware
Use application overlays to customize DeviceTree without modifying the base DTS files
Implement interrupts and button handling using ISR, DeviceTree nodes, and GPIO callbacks
Create and manage threads in Zephyr
Flash and test your Zephyr application on a real custom board
Add custom properties to standard DeviceTree nodes and access them from your application code
Set up and use AI-assisted coding with Claude Code for embedded projects

Course content

9 sections • 98 lectures • 10h 50m total length

Why Zephyr?3:25
Zephyr RTOS setup [Windows]6:51
Set up the Zephyr RTOS development environment on Windows by installing dependencies (CMake, Ninja, Python, Device Tree Compiler) with winget, verifying versions, and preparing for a hello world emulator.
Zephyr RTOS setup [Ubuntu]4:50
Zephyr RTOS setup [MacOS]5:26
Set up the Zephyr RTOS development environment on macOS by installing Homebrew and dependencies (cmake, python, device tree compiler), cloning Zephyr ecosystem, and building a Hello World on the emulator.
Setting up Python virtual environment5:03
Installing West3:45
Important Note: Zephyr Installation Version0:27
Clone Zephyr using West and install Python build tools5:48
Installing Zephyr Python requirements via pip5:23
Installing the Zephyr SDK4:08
Course repository0:24

Application development in Zephyr: introduction4:40
Learn to develop Zephyr applications from scratch, covering device trees, overlays, and kconfig, then set up a minimal project, west workflow, and board flash and debugging.
Creating an application in Zephyr2:54
Understanding the important files in a Zephyr application7:32
Understanding the important files in a Zephyr application (continued)4:27
prj.conf file and configuration items: menuconfig and .config explained9:45
Configure your Zephyr app with prj.conf or project.conf to override kconfig options and enable the GPIO subsystem; use menuconfig and the .config file to edit and validate settings.
Application specific Kconfig file6:05

Key DeviceTree files and types3:56
Writing DeviceTree from scratch for your board7:18
Creating a minimal DTS file layout8:25
Updating DTS file includes1:23
Understanding DeviceTree nodes9:34
Understanding DeviceTree properties: 'reg' property and its significance12:12
Describe the reg standard property in device trees, showing how reg encodes base address and size in 32-bit cells, with address cells and size cells guiding i2c bus mappings.
Using the 'compatible' property3:53
How to select compatible strings and DT binding document9:04
Select exact compatible strings using binding documents to link devices with drivers in Zephyr, and consult yaml bindings for required properties to apply them during board bring up.
Compatible strings in a driver3:48
About root level 'compatible' property1:46
'phandle' property in DeviceTree12:16
'phandles' property in DeviceTree12:21
Learn the p-handles property in device tree as a list of node references with no per-entry arguments or commas, used to configure pins for i2c and usart via pin control.
'phandle-array' type14:09
Understanding specifier space of the 'phandle-array' type9:04

Understanding LED blinking in Zephyr (App to driver layer)9:52
Adding an LED node to the DTS file5:48
Zephyr board directory setup: Part 19:15
Zephyr board directory setup: Part 2 (board Kconfig)5:44
Create a board-specific kconfig file in the Zephyr board directory to select the SoC. Use the board.yml name, avoid defining any type, and understand config and select behavior in menuconfig.
Zephyr board directory setup: Part 3 (board defconfig)6:01
Use a board defconfig to set minimal defaults, enable gpio and the uart console, and leave leds and sensors to applications; rely on prj.conf overrides and device tree for bindings.
Build flow of zephyr application9:36
Follow the west-driven zephyr build flow from toolchain and board setup through device tree pre-processing to generate zephyr.dts and c headers, not a dtb, then kconfig processing and final elf.
Building and configuring the Zephyr application3:24
Set up the board directory with board.yml, the device tree file, and dev config; build the Blinky sample with west, then explore menu config and fix dts qualifiers.
Fixing DTS related issues11:10
Manual Flash and SRAM configuration7:33
Flash and RAM address setup: best practices1:36
About 'choosen' node5:20
Flashing and testing the Blinky application on the custom board5:36

Introduction2:35
Basic setup11:12
Configuring button and interrupt13:17
Configure a button in Zephyr RTOS with device tree and board bring up, implement gpio callback and interrupt, and post button isr events to queues for consumer threads.
Adding button node in DT6:10
Button ISR implementation9:25
Create a button event structure and a Zephyr message queue to transfer ISR button events to a consumer thread, toggle the LED, and schedule a blink on the work queue.
Message queues and queues8:35
Creating threads in zephyr5:57
Thread handler implementation8:40
About Workqueues4:57
Using workqueues7:58
Workqueue handler9:25
Summary and build8:58
Demonstrate wiring the LEDFlash module in Zephyr RTOS from button ISR to a thread, using a message queue and work queue to toggle the LED in 250 ms bursts.

Introduction3:03
Game development plan explanation4:58
Basic project setup2:49
Set up a new Zephyr project from templates, clean the build. Create a minimal codebase with game.c, lcd.c, input.c, and util.c for a state-machine driven display with sensor input.
About AI assisted coding4:04
Claude Code installation and basic setup6:28
Adding Claude Code to VS code1:41
About slash commands and project initialization8:55
Creating specification document spec.md7:03
Reading Schematic and user manual to extract key information using AI3:58
Use AI to read the board schematic and manual pdfs, update spec.md hardware details with sections for microcontroller, motion sensor, and lcd/touch components, and flag missing pin data for verification.
Updating project features , gameplan and requirements in spec.md9:05
Updating spec.md with device orientation details8:04
Summary so far2:14
Adding Kconfig items related to LCD orientation4:44
Verifying LCD orientation Kconfig items in menuconfig2:38
Generate code for the source files and create the device tree overlay, then build with west, and verify lcd orientation kconfig items in menuconfig, configuring display geometry and orientation.
Display bringup plan with checkpoints7:38
Implementing chekpoint 1 : DT nodes and smoke test for display4:56
Understanding &spi1 device tree node11:32
Understanding MIPI DBI controller and Display DT nodes16:36
Display testing with smoke test code3:59
Fixing colour issue8:05
Display testing with different orientation6:36
Implementing and testing game startup/splash screen2:41
Implementing and testing game play screen4:27
About slow display rendering1:20
Generating plan to increase display rendering speed6:19
Configuring PLL and RCC through Device Tree nodes to boost the system clock11:04
Next : Implementing Game end screen and full game sequence0:37
Gameplay introduction1:47
Implementing ball movement3:41
Designing common input interface4:01
paddle control using tilt5:07
Making paddle movement responsive4:22

Requirements

Basic 'C' programming knowledge.
Basic understanding of microcontrollers.
No prior Zephyr experience needed. We start from zero

Description

### Learn Zephyr RTOS from the ground up with a clear, structured foundation path ###

The embedded industry is shifting. Zephyr RTOS, backed by the Linux Foundation, is rapidly becoming the default choice for production IoT and embedded products. Nordic, NXP, Intel, STMicroelectronics, and dozens of other companies are building their ecosystems around it. No other RTOS brings together a unified build system, DeviceTree based hardware abstraction, and a porting workflow that works across MCU vendors in a single codebase. If you are an embedded engineer and you do not know Zephyr yet, you are falling behind.

This course turns you into the engineer who can take any Zephyr supported MCU, write DeviceTree for it from scratch, port it as a custom board, and build real applications on top of it. Not by copying from samples or following a pre-configured dev kit tutorial. By understanding the complete workflow from the ground up.

Here is what you will be able to do by the end of this course:

- Set up the complete Zephyr workspace and toolchain on Windows, Ubuntu, and MacOS

- Build and run your first Zephyr applications on QEMU and on real hardware

- Configure your Zephyr project using prj.conf, menuconfig, and Kconfig

- Write DeviceTree from scratch for a custom board and understand every node and property

- Port your own board into Zephyr with the full board directory and configuration setup

- Build real applications using interrupts, threads, and workqueues on your custom hardware

- Debug common DeviceTree and build issues with a repeatable step by step process

Zephyr is not just another RTOS. It is where the industry is heading. Companies building IoT products, wearables, industrial controllers, and connected devices are choosing Zephyr because it gives them one codebase that works across multiple chip vendors. The engineer who can bring up a custom board in Zephyr and write DeviceTree is the one who gets the interesting projects, the better roles, and the trust of the team. That skill set is rare right now. This course builds it.

Most Zephyr resources out there show you how to run samples on a supported dev kit. That is the easy part, and you can do it by reading the documentation. This course teaches you the skills that actually matter at work: writing DeviceTree from scratch, creating your own board files, and debugging the problems that show up when you step off the beaten path. Very few Zephyr courses go this deep into DeviceTree and board porting. This one does.

This course is built for:

- Embedded engineers who want to use Zephyr on their own custom hardware

- Engineers who tried Zephyr before but got stuck at DeviceTree or board porting

- Firmware developers, students and hobbyists moving from bare metal or FreeRTOS to Zephyr

Note on using AI assisted coding in this course

In the final project, we use AI-assisted coding to build a real embedded application. We deliberately save this for last. First, you build the foundation. You understand how Zephyr works. You can debug issues on your own. Only then do we bring in AI tools to show you how they can speed up your workflow when you actually know what you are doing. Understand first, accelerate later.

By the end of this course, you will not just know Zephyr. You will be the engineer who can take a bare board, bring it up in Zephyr, and build real applications on it. If that is the engineer you want to become, enroll now. Let us get started.

Hardware Requirement (for hands on practice)

This course uses the Fastbit STM32 Nano board, based on the STM32F303 microcontroller.
You can also follow along using any STM32 or Zephyr supported development board you already have.
If you want to use the exact board used by the instructor, you can explore the Fastbit STM32 Nano board and follow along one to one

Who this course is for:

Embedded engineers who want to use Zephyr on their own custom hardware
Engineers who tried Zephyr but got stuck at DeviceTree or board porting
Firmware developers moving from bare metal or FreeRTOS to Zephyr
Students and hobbyists

Mastering Zephyr RTOS with DeviceTree and Board Bring Up

What you'll learn

Explore related topics

Course content

Zephyr workspace and toolchain setup11 lectures • 46min

Build and run your first Zephyr application2 lectures • 25min

Zephyr application structure and configuration basics6 lectures • 35min

Zephyr application 001 LED Blinky on a custom board3 lectures • 25min

Writing DeviceTree from scratch for a custom board14 lectures • 1hr 49min

Zephyr Blinky on a custom board: board porting and bring up12 lectures • 1hr 21min

Zephyr application 001: Writing the Blinky application for a custom board6 lectures • 58min

Zephyr application 002 : Interrupt driven LED burst with workqueue12 lectures • 1hr 37min

Zephyr application 003 : Tilt based brick breaker game with AI assisted coding32 lectures • 2hr 55min

Requirements

Description

Who this course is for: