Embedded Linux training
Our maximum popular `combo` on-line path due to the fact in only 5 afternoons you may examine the whole lot you want to start to move bring together the Linux Kernel for an ARM card and use Yocto Project to generate recipes and custom layers.
Basic path aimed toward novices with a minimal information of Linux, it gives the facts had to configure and move-bring together the u-boot Bootloader and the Kernel.
This path additionally gives the facts had to configure and use Yocto Project (and Openembedded), git and bitbake via way of means of developing an embeddded Linux distribution from scratch. Management of recipes in overlays with custom layers.
Learn to construct and control embedded Linux structures with the Yocto Project and OpenEmbedded.
If you need to now no longer waste time acting time-ingesting obligations in the course of the path, this in depth path is ideal for you.
In order to shop time, a few sections are shortened or skipped, including downloading the applications and the lengthy preliminary compilation, relying at the desires and hobbies of the participants.
The course, aimed at developers who need to quickly learn the Linux development environment.
- Understanding the Linux Kernel
- Understanding the Device Tree
- Compiling the Kernel
- Development with the Yocto Project project
- Laboratory practice on ARM board (physical and QemuARM)
- Writing and extension of Yocto Project recipes
- Creation of new Yocto Project layers
- Integrate your card into a BSP
- Creation of personalized Yocto Project images
- Remote debugging of applications
At the end of this course, you will be ready to use the Yocto Project to develop your embedded Linux system and compiled cross applications.
- Duration: 5 consecutive afternoons (Monday-Friday 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: 590,00 Euro + VAT
- Registration available using this training subscription form
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.
The practical exercises will be run by the teacher on a real board with an ARM CPU during the course.
The board used depends on the course you are attending.
Verify this detail in the page dedicated to the specific training course you are going to attend.
Thanks 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
During the online course some of the practical exercises will be carried out with Yocto Project using a Qemu ARM virtual hardware. In this way you can directly experiment the development workflow on your Linux Virtual Machine (provided by the trainer).
To get the best results from this course it is advisable to know the following topics:
- Basic Linux knowledge
- Basic knowledge of the command line shell
- Knowledge of the C language
Course structure ONLINE
- __ Afternoon 1 – Linux embedded __
- Introduction to embedded linux
- Advantages of using linux
- Systems running linux
- Typical embedded hardware
- System architecture
- Linux filesystem
- Virtual filesystems procfs and sysfs
- Understanding the development process
- __ Afternoon 2 – Linux embedded __
- Booting the kernel using TFTP and NFS
- DEMO – Flash a Linux image on the microSD card
- DEMO – Booting the target board using TFTP and NFS
- Learn Linux kernel sources structure
- Cross compilation toolchains
- Cross-compiling the kernel for the target board
- Linux kernel configuration
- Kernel boot parameters
- Native and cross-compilation generated files
- DEMO – Cross compile a customized kernel
- DEMO – Run a modified Linux image on your target board
- CPU pin muxing
- Device Tree (examples for TI AM335x, NXP iMX6)
- __ Afternoon 3 – Yocto Project __
- 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 4 – Yocto Project __
- Manage dependencies in the recipe
- Extending and overriding recipes
- Adding steps to the build process
- Learn about classes
- Analysis of examples
- 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 5 – – 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
- Using devtool