Operating Systems

The Android operating system, developped by Google and based on the Linux kernel, is used more and more frequently not only on smartphones but also for dedicated embedded devices, notably in the "Machine to Machine" market.

ac6-training  proposes trainings on the porting of the operating system on your board and its tailoring to your specific needs, as well as creating embedded applications running on the Android system.

With ac6 training, you’ll learn Embedded Linux for industrial and IoT devices—from boot to user space. We walk you through the full path: U-Boot/TF-A → Linux kernel → device tree → root filesystem, cross-compiling for Arm, RISC-V, and x86, and bringing new boards to life quickly and repeatably.

Our lineup matches real project needs: Embedded Linux, Embedded Linux using Yocto, Yocto Project Development, Yocto Project Expert, Comprehensive Yocto Usage, Linux User-Mode Programming, and Linux Drivers. Together, these tracks take you from application basics to BSP creation, driver work, and production workflows.

Hands-on labs cover kernel configuration, device-tree editing, driver scaffolding, systemd and BusyBox, debugging with gdb/strace/perf/ftrace, networking, security (SELinux/AppArmor, dm-verity), real-time options (PREEMPT_RT), and OTA updates with SWUpdate. We also work with vendor BSPs like OpenSTLinux for STM32MP. You finish with reproducible builds, clean logs, and a deployment-ready checklist.

A real-time operating system does not make an application faster. It makes its behaviour predictable. That distinction decides the architecture of an embedded project, and it is often settled too late.

On a microcontroller, a main loop is enough as long as the work stays short and the deadlines stay wide. As soon as a long task has to coexist with a response due in a few milliseconds, something has to arbitrate. An RTOS provides that arbitration: preemptive priority scheduling, synchronisation primitives, time management. In exchange it brings its own traps, priority inversion, stack overflows, critical sections held too long, which rarely show up in development and almost always in production.

Choosing a kernel

Three kernels cover most of the embedded world, and they answer different questions.

FreeRTOS is a kernel. A few thousand lines, a scheduler, queues, semaphores. It drops into an existing project without overturning anything, and its memory footprint stays in the tens of kilobytes. It is the natural choice when the hardware is well understood and the need is multitasking, nothing more.

Zephyr is a complete environment: kernel, drivers, networking stack, hardware description through Devicetree, configuration through Kconfig, multi-repository handling through West. The learning curve is longer, but moving from one board to another stops being a project of its own. It is the choice that imposes itself when a product has to live for years across several targets.

ThreadX, now open source as Eclipse ThreadX, sits in between: a compact, certifiable kernel with networking and file stacks alongside it. It shows up mostly where certification weighs on the decision.

Our courses

FreeRTOS Real Time Programming (RT3), three days, starts at the kernel: scheduling, queues, semaphores, mutexes, and above all the design mistakes that produce intermittent lockups.

Zephyr RTOS Programming (RT5), five days, covers the whole ecosystem, from the build system and West to Devicetree and Kconfig configuration, up to writing drivers.

Real Time Programming with Eclipse ThreadX (RT6), three days, applies the same principles to the ThreadX kernel, formerly Azure RTOS.

West, MCUXpresso SDK and Kconfig (RTW), two days, covers multi-repository project handling with West and the structure of the NXP MCUXpresso SDK.

STM32 + FreeRTOS + LwIP (STG), five days, takes on the complete case: an STM32, a real-time kernel and a TCP/IP stack that have to share the processor without starving one another.

Cortex-M4 Texas Instruments Implementation and Ti-RTOS (TI3) covers the TI platform and its own kernel.

Internet of Things on Microcontrollers (IOT1), three days, addresses the particular case of very low power devices, where scheduling is judged in microamps as much as in milliseconds.

Hands-on work is a large part of every session. On site it runs on real boards. Remotely, depending on the course, on remotely accessible hardware or on the simulation tools we develop, which lets you work on a target you do not physically have. A scheduler is only understood by watching what it does to a loaded system.

What is Zephyr?

Zephyr is an open-source RTOS specifically designed for embedded systems and IoT. Drawing on the strengths of Linux and tailored for microcontrollers, it enables you to write portable applications across multiple vendor platforms thanks to its build system, Kconfig, and devicetree.

Many built-in drivers speed up development by providing support for a wide range of peripherals out of the box. With Zephyr, developers can focus on building applications without worrying about porting or rewriting low-level code.

Our Zephyr training courses help you master the ecosystem—covering the device tree, the device driver model, and everything that sets Zephyr apart from other real-time operating systems.

L'écriture de drivers (ou pilotes de périphériques) est une activité très importante, et souvent critique, en environnement embarqué.

Nous proposons des cours adaptés aux spécificités du développement de drivers en environnement embarqué, avec des exercices utilisant, chaque fois que nécessaire, des environnement de développement croisés et des cartes cibles industrielles.