Yocto Project training

Yocto Project

This course provides all the information needed to manage a project with Yocto Project and Openembedded. You will learn to generate an embedded BSP for Linux and develop embedded applications.

Yocto Project Participant

Koan has been contributing to the Yocto Project since its creation and is a Yocto Project Participant


  • Duration: 2 consecutive days (from 9:00 to 18:00)
  • Type: ~ 50% presentations, ~ 50% practical exercises
  • Slides language and material provided: English
  • Oral presentation language: Italian or English
  • Number of participants: maximum 10 people

Equipment required

Each participant must have a Laptop on which a Virtual Machine provided by the teacher at the beginning of the course will be installed. All the necessary material is provided by Koan except the PC. Therefore participants must have their own laptop with:

  • Laptop PC with at least 4 GB of RAM and 40 GB of free disk space.
  • Virtual Box installed (downloadable from here).
  • We will work with Lubuntu Desktop 18.04 (64 bit). (We don’t support other distributions, because we can’t test all possible versions).
  • Internet connection (direct or through the company proxy).
  • For security reasons it is necessary that each participant backup their computer before the course.

Hardware used

The practical exercises will be run on a BeagleBone Black with a Cortex ARM CPU provided on loan during the course.

beagleBone Black training

All exercises will be applicable to any other type of board supported by Linux.


To get the best results from this course it is advisable to know the following topics:

  • Knowledge of embedded Linux as described in our embedded Linux training
  • Basic knowledge of the command line shell
  • Programming knowledge C
  • Experience with Embedded GNU / Linux (kernel, user space, root file system, tools)
  • Practice of Unix or GNU / Linux commands
  • Cross-compilers
  • Linux kernel
  • u-boot bootloader

Course structure

  • __ Day 1 – Morning __
  • Introduction
  • History of the project
  • Layers
  • Overview of an embedded Linux system architecture
  • Methods to build a root filesystem image
  • Usefulness of build systems
  • Organization of the project source tree
  • Building a root filesystem image using the Yocto Project
  • Organization of the build output
  • Flashing and installing the system image
  • Downloading the Poky reference build system
  • Building a system image
  • Flashing and booting the image on the BeagleBone
  • __ Day2 – Afternoon __
  • Configuring the build system
  • Customizing the package selection
  • Writing a minimal recipe
  • Adding dependencies
  • Development workflow with bitbake
  • Extending and overriding recipes
  • Adding steps to the build process
  • Configuring the BeagleBone to boot over NFS
  • Learn how to use the PREFERRED_PROVIDER mechanism
  • Writing a recipe for nInvaders
  • Adding nInvaders to the final image
  • __ Day 2 – Morning __
  • Learn about classes
  • Analysis of examples
  • Logging
  • Debugging dependencies
  • What layers are
  • Where to find layers
  • Creating a layer
  • Extending an existing BSP
  • Adding a new machine
  • Bootloaders
  • Linux and the linux-yocto recipe
  • Adding a custom image type
  • Extending a recipe to add configuration files
  • Using ROOTFS_POSTPROCESS_COMMAND to modify the final rootfs
  • Studying package dependencies
  • Learn how to write a layer
  • Add the layer to the build
  • Move nInvaders to the new layer
  • __ Day 2 – Afternoon __
  • Adding nInvaders to the custom image
  • Play nInvaders
  • Writing an image recipe
  • Adding users/groups
  • Adding custom configuration
  • Writing and using package groups recipes
  • Writing a custom image recipe
  • Understanding the purpose of an SDK
  • for the application developer
  • Building an SDK for the custom image
  • Using the Yocto Project SDK

Prossimi Corsi Yocto Project

No Events
No Events

Prossimi Corsi

No Events
No Events