Online Training
Languages Programmable Logic Real-Time Systems Safety and security Linux

Calendar Details

Operating Systems
System Workbench Android Linux RTOS Drivers

Calendar Details

Programming
Methods Languages Safety and security Real-Time Internet Programmable Logic
Calendar Details

Processors
ARM Cores NXP ARM SoCs ST processors TI processors NXP Power CPUs

Calendar Details

Communication
Connectivity Network Storage



Calendar Details

Related Courses

ac6 >> ac6-training >> Online Training >> Real-Time Systems >> Zephyr Real Time Programming

oRT5 Zephyr Real Time Programming

Real-time programming applied to the Zephyr operating system

Objectives

Learn how to develop, configure, debug and trace Zephyr applications
Discover the real time multitasking concept
Understand Real Time constraints, like determinism, preemption or interrupts
Understand the Zephyr kernel Services
Learn communication and synchronization mechanisms
Interactions with processor architecture features
Understand Zephyr memory management and data structures
Understand User mode and kernel mode
Writing a device tree
Writing a complete driver

Course environment

Theoretical course

PDF course material (in English)
Course dispensed using the Teams video-conferencing system
The trainer to answer trainees’ questions during the training and provide technical and pedagogical assistance through the Teams video-conferencing system

Practical activities

Practical activities represent from 40% to 50% of course duration
The trainer has access to trainees’ Online PCs for technical and pedagogical assistance.
Example code, labs and solutions

Virtual Machine with System Workbench for STM32 with GNU ARM Eclipse QEMU
Emulated board STM32F4-Discovery

Prerequisites

Good C programming skills (see our oL2 - C Language for Embedded MCUs course)

Duration

Total: 30 hours
5 sessions, 6 hours each (excluding break time)
From 40% to 50% of training time is devoted to practical activities
Some Labs may be completed between sessions and are checked by the trainer on the next session

First Session

Real-Time Concepts

Base real time concepts
The Real Time constraints
Multi-task and real time
Tasks and Task Descriptors

Content of the task descriptor
List of task descriptors

Context Switch

Introduction to Zephyr

Zephyr Project
Zephyr Ecosystem
Why use Zephyr
Install and use Zephyr
Build and Configuration Systems

West
CMake
Kconfig and configuration overlay
Configuration tools: menuconfig and guiconfig

Zephyr Without Threads

Operation without Threads
GPIO
Random Number Generation
Utilities
Data Structures

Single-linked List
Double-linked List
Ring Buffers

Exercise:	Hello World from Zephyr, configure and blink LEDs using Zephyr
Exercise:	Manage Zephyr linked list and understand container_of macro

Scheduling

Task Scheduling and Preemption

Tick based or tickless scheduling

Scheduling systems and schedulability proof

Fixed priorities scheduling
RMA and EDF scheduling

Scheduling through Zephyr

Scheduling Algorithm
Cooperative Time Slicing
Preemptive Time Slicing

Second Session

Thread Management

Thread Control Block
Creating Threads
Threads Priorities
Thread States
Main and Idle Threads
Delays
Changing Thread Priority
Suspending Threads
Kernel Structures

Simple linked-list ready queue
Red/black tree ready queue
Traditional multi-queue ready queue

Thread Custom Data
Scheduling Traces

Runtime Statistics
User-Defined Tracing
Percepio Tracealyzer

Exercise:	Create and manage threads
Exercise:	Create periodic threads
Exercise:	Create config overlay for visual trace diagnostics using Tracealyzer

Memory Management in Zephyr

Memory Managers
Dynamic memory managers

K_heap
System heap
Memory Slabs
Memory Blocks

Heap Listeners
Stack Overflow detection
User Mode
Memory Domains

Exercise:	Understand dynamic memory allocation in Zephyr
Exercise:	Display threads information and detect stack overflow

Third Session

Resource Management

Mutual Exclusion
Critical Sections
Mutexes
Gatekeeper threads
Atomic
Lock-Free Data Structures
SpinLocks

Exercise:

Implement mutual exclusion between threads

Synchronization Primitives

Synchronization
Semaphores
The Readers/Writer Problem
Condition variables
Events and Event Groups
Polling

Exercise:	The producer-consumer problem, synchronize and avoid concurrent access problems
Exercise:	Understanding event bit group by synchronizing several threads

Fourth Session

Data Passing

Message Queues
Pipes
Queues

FIFOs
LIFOs

Mailboxes
Stacks

Exercise:

Create a print gatekeeper thread using message queue

Interrupt Management

Threads and Interrupts
Interrupts in zephyr
Interrupts on ARM Cortex-M
Handler thread
Queue within an ISR
Workqueue Threads
Power Management

Exercise:	Understand how to wait on multiple events and interrupt safe APIs
Exercise:	Understand how to pass data using Queues from an interrupt to a thread
Exercise:	Create and submit work items from interrupts to custom WorkQueue

Software Timers

Timers

Defining a Timer
Using a Timer Expiry Function

Timer types

One-shot timers
Auto-reload timers

Timer Commands

Exercise:

Understand the use of one-shot and auto-reload timers

Fifth Session

Modules

Why to use modules?
Module structure
Out-of-tree module
YAML files
Module CMakeLists.txt
How to add and use custom Kconfigs

Exercise:	Create a simple hello world module
Exercise:	Create a module that uses custom Kconfig options

Zephyr device driver model

Introduction to Device Drivers
Overview of the Zephyr device driver model
Standard Drivers
The struct device
Subsystems
API Extensions
Initialization Levels
Dependencies between device drivers
Define devices programmatically
Adding In-Tree Code to Zephyr Source Code

Exercise:	Create a driver that respects the Zephyr Device Driver Model and define devices
Exercise:	Writing in-tree drivers

Device Trees in Zephyr

Overview of Device Tree (DT) and its role in Zephyr
Device Tree VS Kconfig
Device Tree node structure
Device Tree bindings
Overlay and yaml files
APIs to access device tree properties
Write device drivers using device tree APIs
Device Tree in Zephyr VS Linux

Exercise:

Create a driver that uses custom device tree and Kconfig

Next Scheduled Open Courses

From 2 to 6 October 2023

Online EurAsia (9h-16h CET)

From 13 to 17 November 2023

Online USA (8am to 3pm Pacific)

This course was designed specifically to be provided online, by one of our skilled trainers.

Scheduled classes are confirmed as soon as there is two confirmed bookings.

A version tailored for face-to-face delivery is available under reference RT5 - Zephyr Real Time Programming

To book a training session or for more information, please contact us on info@ac6-training.com.

Registrations are accepted till one week before the start date for scheduled classes. For late registrations, please consult us.

You can also fill and send us the registration form

Last update of course schedule: 5 June 2023

Booking one of our trainings is subject to our General Terms of Sales

Login :
Password :

New user
Forgot password?