Trainings

Embedded Linux Principles and Practices – Building an Embedded Linux System

This training provides a comprehensive overview of an embedded Linux system and each of its core components: the bootloader (U-Boot/SPL), the Linux kernel, the C library, and the root filesystem. Attendees will learn how to set up a cross-compilation environment, configure and build each component, and assemble a minimal but functional embedded Linux system. The course covers the full boot chain — from first-stage bootloader through kernel initialization to userspace — and is validated on real hardware as well as QEMU.

Duration: 4 days  |  Level: Beginner to Intermediate

Embedded Linux Development with the Yocto Project and OpenEmbedded

This hands-on class teaches attendees how to leverage the Yocto Project and OpenEmbedded to build production-grade embedded Linux systems. Topics include creating custom layers, writing and extending recipes, integrating a BSP, managing package feeds, and optimizing image size and boot time. By the end of the session, attendees will be able to ship a fully customized Yocto-based BSP, enabling end users to focus on application-level development with real added value.

Duration: 4 days  |  Level: Intermediate

Introduction to Linux Kernel Development

This training focuses on Linux kernel internals and progressively guides attendees into kernel-space development through hands-on exercises. Topics include kernel configuration and build system (Kbuild/Kconfig), kernel modules, memory management, process scheduling, interrupt handling, concurrency and locking primitives, and the device model. Attendees will develop their first kernel modules and gain the foundations needed to write production-quality device drivers.

Duration: 4 days  |  Level: Intermediate

Embedded Linux Systems Architecture

This session provides a detailed, end-to-end view of every element constituting an embedded Linux system — their specificity, trade-offs, and existing alternatives. Drawing on extensive project experience across industrial and automotive domains, this training helps system architects make informed design decisions, from bootloader selection and secure boot chains (TF-A, OP-TEE) to graphics stacks, multimedia frameworks, and update strategies (RAUC, SWUpdate).

Duration: 3 days  |  Level: Intermediate to Advanced

Linux Device Driver Development

This in-depth training takes attendees through the full spectrum of Linux device driver development. Starting with the platform device model and device tree, it progresses through character drivers, I2C/SPI client drivers, interrupt handling, DMA, the clock and reset frameworks, and bus-level drivers (USB, PCI/PCIe). Advanced topics include the regmap API, power management (runtime PM and system sleep), and integration with kernel subsystems such as IIO, input, and GPIO. Extensive hands-on exercises ensure mastery of each topic.

Duration: 5 days  |  Level: Intermediate to Advanced

Embedded Linux and Kernel Debugging

When things go wrong, efficient debugging is what separates days of frustration from hours of productive problem-solving. This class covers the full debugging toolkit available to embedded Linux engineers: printk and dynamic debug, KGDB/KDB, ftrace and trace-cmd, perf, eBPF, crash dump analysis (kdump/crash), user-space debugging (GDB, strace, ltrace, Valgrind), and debugging device tree and driver probe failures. Attendees will practice each technique on realistic bug scenarios.

Duration: 3 days  |  Level: Intermediate to Advanced

Linux Power Management for Embedded Systems

Power consumption is critical in battery-powered and thermally constrained embedded systems. This training covers both system sleep states (suspend-to-RAM, suspend-to-idle, hibernation) and the runtime PM framework, along with the underlying building blocks: clock gating, voltage/frequency scaling (CPUFreq, devfreq), regulator framework, and wakeup sources. Attendees will learn how to instrument power consumption, identify bottlenecks, and implement power-aware device drivers and system policies.

Duration: 2 days  |  Level: Intermediate to Advanced

Embedded Linux Multimedia – Audio, Video, and Graphics

This training covers the Linux multimedia stack from kernel to user space. On the audio side, attendees discover the ALSA/ASoC framework, codec and platform drivers, and machine-level audio routing. The video section covers V4L2, the Media Controller API, and camera pipeline configuration. Graphics topics include DRM/KMS, framebuffer legacy, and user-space integration with Wayland/Weston. Labs are conducted on real SoC platforms with audio codecs and display interfaces.

Duration: 3 days  |  Level: Intermediate to Advanced

Embedded Linux Networking and Connectivity

This class covers networking from the embedded Linux perspective: Ethernet drivers (including MAC and MDIO/PHY layers, stmmac/MACB), network device model and NAPI, TCP/IP stack tuning, hardware offloading (checksum, TSO), and industrial protocols. Attendees will also explore wireless connectivity (Wi-Fi, Bluetooth/BLE) and learn to bring up, configure, and debug network interfaces on embedded targets using tools such as ethtool, ip, and tcpdump.

Duration: 2 days  |  Level: Intermediate

Embedded Linux Hardware Interfacing

This session bridges the gap between hardware and software. Attendees learn how to interface a Linux system with external peripherals through I2C, SPI, UART, GPIO, PWM, and 1-Wire, both from kernel space (writing device drivers) and user space (sysfs, /dev, libgpiod, and the industrial I/O subsystem). The class also covers device tree overlays for runtime hardware description and the UIO framework for user-space driver development.

Duration: 3 days  |  Level: Beginner to Intermediate

OTA Updates for Embedded Linux – RAUC and Beyond

Deploying reliable over-the-air updates is essential for any connected embedded product. This training covers OTA update strategies (A/B, recovery, in-place), with a deep focus on the RAUC framework: bundle creation, slot configuration, update handlers, integration with U-Boot and GRUB, and secure update signing. Attendees will integrate a full RAUC-based update pipeline into a Yocto-built image, including rollback mechanisms and health-check scripting.

Duration: 2 days  |  Level: Intermediate

Secure Boot and Trusted Execution on Embedded Linux

Security starts at boot. This training covers the full secure boot chain: ROM boot, TF-A (Trusted Firmware-A), OP-TEE, U-Boot verified boot, and Linux kernel integrity (dm-verity, IMA/EVM). Attendees learn how to configure each stage for chain-of-trust verification, provision keys, and integrate secure boot into a Yocto-based build system. The class also covers hardware security modules (HSM) and platform-specific secure enclaves (TrustZone, CAAM, SE050).

Duration: 2 days  |  Level: Advanced

Zephyr RTOS Fundamentals – From Zero to Real-Time Application

This training provides a comprehensive introduction to the Zephyr RTOS. Starting from the project setup and west build system, it covers the kernel primitives: threads, scheduling, semaphores, mutexes, message queues, FIFOs, and timers. Attendees learn to write portable, real-time applications using Zephyr’s device model and devicetree-based hardware abstraction. Labs are performed on STM32-based boards (Nucleo) and include GPIO, UART, I2C, and SPI peripheral access, interrupt-driven and poll-based I/O, and shell/logging integration.

Duration: 4 days  |  Level: Beginner to Intermediate

Zephyr RTOS Connectivity – Bluetooth LE and Networking

This class focuses on wireless and network connectivity within Zephyr. The Bluetooth LE section covers the full stack: advertising, scanning, GATT services and characteristics, connection management, bonding, and security. The networking section covers Zephyr’s IP stack, socket API, MQTT, CoAP, and LwM2M integration. Attendees build complete connected applications — from BLE sensor nodes to MQTT-enabled IoT devices — on real hardware.

Duration: 3 days  |  Level: Intermediate

Zephyr RTOS – Bootloaders, OTA, and Production Readiness

Taking Zephyr from prototype to production requires robust update and boot mechanisms. This training covers MCUboot integration (signed images, swap/revert strategies, encrypted updates), DFU (Device Firmware Update) over USB and BLE, and production-oriented topics: power management, watchdog configuration, flash partitioning, and hardware security. Attendees will set up a complete secure boot and OTA pipeline on STM32 targets.

Duration: 2 days  |  Level: Intermediate to Advanced

Zephyr RTOS – Device Driver Development

This advanced class focuses on writing custom device drivers within Zephyr’s driver model. Topics include the devicetree bindings system, driver initialization macros, the device API structure, DMA integration, interrupt management, and PM (power management) hooks. Attendees will develop drivers for I2C/SPI sensors, UART peripherals, and custom hardware, following Zephyr upstream coding conventions and testing with Ztest and Twister.

Duration: 3 days  |  Level: Advanced

Cortex-M Development with Open Source Tools – STM32 and libopencm3

This training teaches bare-metal programming on ARM Cortex-M microcontrollers using an entirely open source toolchain. Using an STM32L476 Nucleo board and the libopencm3 library, attendees learn to configure clocks, GPIOs, timers, UART, I2C, SPI, ADC, and DMA without relying on vendor HALs or IDEs. The class also covers linker scripts, startup code, interrupt vector tables, debugging with GDB/OpenOCD, and integrating with a Makefile-based build flow.

Duration: 4 days  |  Level: Beginner to Intermediate

Containerization is increasingly used in embedded systems for application isolation, portability, and update management. This training covers Docker and OCI container basics, building minimal container images for embedded targets (Buildroot, Yocto), resource constraints with cgroups and namespaces, and orchestration on edge devices. The class also introduces hypervisors and lightweight virtualization approaches (KVM, Xen on ARM) relevant to mixed-criticality and multi-OS embedded deployments.

Duration: 2 days  |  Level: Intermediate