Yocto Project training – ONLINE

Yocto Project is one of our most popular online courses because you can learn everything you need to know in only three afternoons and start using it to create recipes and custom layers.

This course gives you all the knowledge you need to manage a Yocto Project and Openembedded project.

You’ll discover how to create an embedded BSP for Linux and create embedded programmes.

Learn to build and manage embedded Linux systems with the Yocto Project and OpenEmbedded.
If you want to not waste time performing time-consuming tasks during the course, this intensive course is perfect for you.
In order to save time, some sections are shortened or skipped, such as downloading the packages and the long initial compilation, depending on the needs and interests of the participants.

Register for Yocto training

Details

  • Duration: 3 consecutive afternoons (from 14:00 to 18:00 CET)
  • Type: ~ 50% presentations, ~ 50% practical exercises
  • Slides language and material provided: English
  • Oral presentation language: Italian or English
  • Number of participants: maximum 12 people
  • Price: 360,00 Euro + VAT
  • Registration available using this training subscription form

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 by the teacher on a BeagleBone Black with a Cortex ARM CPU during the course.

while the practical exercises will be carried out with Yocto Project using a Qemu ARM virtual hardware

hanks to the portability of Linux and Yocto Project, all the exercises performed will be applicable to any other type of card. For example:

  • NXP – i.MX6, i.MX7, i.MX8
  • ST Microelectronics – STM32
  • Intel – x86
  • NVIDIA –  Jetson NANO, Xavier NX

Prerequisites

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 ONLINE

  • __ Afternoon 1 – Yocto Project __
  • Introduction
  • Openembedded and Yocto Project history
  • 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
  • Configuring the build system
  • What layers are
  • Where to find layers
  • Creating a layer
  • Customizing the package selection
  • Development workflow with bitbake
  • Writing a minimal recipe
  • Learn how to use the PREFERRED_PROVIDER mechanism
  • Writing a recipe for nInvaders
  • Adding nInvaders to the final image
  • __ Afternoon 2 – Yocto Project __
  • Manage dependencies in the recipe
  • Extending and overriding recipes
  • Adding steps to the build process
  • Learn about classes
  • Analysis of examples
  • Logging
  • Debugging dependencies
  • Extending an existing BSP
  • Adding a new machine
  • 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
  • __ Afternoon 3 – Yocto Project __
  • Adding nInvaders to a custom image
  • 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
  • devtool
  • Using devtool

Yocto Project and all related marks and logos are registered trademarks of The Linux Foundation. This website is not, in any way, endorsed by the Yocto Project or The Linux Foundation.

Scroll to Top