Training

We train

You are here:

Home
Training

Embedded GNU/Linux System Architecture (EGLiSA)

This 3-days (or 4-days) training class uses hands-on exercises combined with instruction to illustrate the concepts of embedded GNU/Linux. It is designed to bring you quickly up to speed. We describe the philosophy, concepts and commands necessary to make effective use of GNU/Linux through a combination of theory and on-the-job training. Don’t reinvent the wheel, but learn from our experience and take home a working knowledge of GNU/Linux and the ability to use it effectively in your own embedded development project.

The standard course will take 3 days, but it can be extended with an additional day with other topics that can be selected and customized by the participants.

Agenda

Day 1: Development Environment & Basic System Setup

History

Unix
Free Software
Linux

Shell

How to master the commandline
Editing files
Man-Pages
Filesystem Hierarchy
Links
Globs & Expansion
Piping & Redirection
Environment
Unix Permission Model

Development Environment

Toolchain
TFTP
NFS
Serial Console

Base System Assembly 1

Building U-Boot
Introduction to U-Boot
U-Boot Commandline
Building Linux
Boot-Sequence
Device-Trees

Day 2: Root Filesystem & Application Development

Base System Assembly 2

Root Filesystem Overview
Flash Storage
UBI

Unix Philosophy & Linux Architecture

Unix Philosophy
Files & File Descriptors

Application Development 1

Processes
Unix Patterns
IPC
Licensing
Updating

Day 3: Debugging, Profiling, Realtime

Application Development 2

Debugging
Profiling

Realtime

Overview
Approaches / Solutions

Next courses

The Yocto Project - An Overview (3 days)

You already use GNU/Linux for your projects and have probably heard about the Yocto Project (YP), but did not dare to have a closer look into it, or had difficulties using it. You don’t know whether and how your daily work flow can be accommodated in the YP and generally find the YP rather complicated. Why do we need all this since up to now everything was (supposedly) much easier? After the training you should be able to decide whether you need the YP or not. The workshop is aimed at software-, development-, system engineers, testers, administrators, engineers and other parties interested in the YP, with a solid knowledge of Embedded GNU/Linux

The specific contents of each training course is negotiated with the participants prior to the course. We try to consider their specific needs and wishes whenever possible.

Agenda

Introduction

This three day training combines theory with hands-on exercises in order to introduce the Yocto Project (YP). It answers frequently asked questions like:

Is it really necessary to use another version of the toolchain/libraries/packages for each and every GNU/Linux project and an top of that to follow a different work-flow?
Can you ensure that the development environment is identical for all developers/suppliers and that you can still produce identical builds like today in 10+ years from now?
Can the YP help find out under what software licenses the packages you use are licensed?

… and much more

Hands-on sessions are performed on target hardware. After the training the students will be able to download a docker image with Ubuntu 18.x and all dependencies pre-installed plus the examples in order to work with the course material in their own labs. Please note that this is not an introductory course to Embedded GNU/Linux. You should already know how Embedded GNU/Linux works and maybe you even configured/built the Linux kernel for some of your projects.

Who should attend?

You already use GNU/Linux for your projects and have probably heard about the Yocto Project, but did not dare to have a closer look into it, or had difficulties using it. You don’t know whether and how your daily workflow can be accommodated in the YP and generally find the YP rather complicated. Why do we need all this since up to know everything was (supposedly) much easier? After the training you should be able to decide whether you need the YP or not. The workshop is aimed at software engineers who are involved with system design, development, integration or quality insurance and anybody else interested in OpenEmbedded or the Yocto Project. You should have a solid knowledge of Embedded GNU/Linux.

Requirements

Experience with Software development under Linux
Familiarity with a Unix-based operating system
Familiarity with C/C++ toolchains
Familiarity with git

All the training material is English, but the presentation of it can be in English or in German, as you wish.

The work- and reference books typically stay with the students after the training.

Course Outline

Day 1:

Introduction into OpenEmbedded/Yocto Project
- Goal: Learn what OpenEmbedded/Yocto Project (OE/YP) is and what it is not
  Gain history and Background information
  Know where to find documentation1s and help
  Learn how to get in contact with the developers
Getting started with OpenEmbedded/Yocto Project (highly practical)
- Goal: Gain basic but practical insight by getting your feet wet
Introduction into BitBake
- Goal: Understand the build-system which OE/YP is build on
  Study the BitBake syntax
  See how the BitBake build process works
  Learn how to write your own recipes and configuration files

Day 2:

Introduction into OpenEmbedded/Yocto Project
- Goal: Understand which features OE/YP provides
  Get familiar with the task pipeline
  Learn to write new recipes or customize recipes provided by OE/YP
  Study how to generate custom images and what SDK means
  Learn to work with the tools provided by OE/YP (wic, test frameworks, …)

Day 3:

Build your own BSP
- Goal: Basic understanding of creating and maintaining a custom BSP in OE/YP
  Learn how to create your own machine configuration
  Get familiar with integrating U-Boot
  Understand how to integrate your custom kernel
  Learn how to boot your new kernel and image on real hardware

Next Courses

21.11.2023 – 23.11.2023

Embedded Multimedia (3 days)

Multimedia is a challenging topic – frequently needed and key feature for user acceptance of many devices, there is still very few information available about the internal workings, optimal configuration, etc. – not to mention that things like graphics drivers are treated as a top secret, with very little information available about porting or debugging, especially for Open Source code.

This training class includes all tons of information which cannot be found elsewhere. To follow this class, you should have routine knowledge about working with Embedded GNU/Linux systems. Ideally you should have been working with multimedia devices (cameras, GPUs, audio devices) before and know the standard tools like v4l2-ctl, yavta, aplay/arecord/alsaloop, gstreamer, ffmpeg…

Agenda

Who should attend?

You already use GNU/Linux for your projects and need to perform some challenging multimedia tasks, like high-end graphical output on systems with restricted resources and limited hardware capabilities, complex handling of sensors and cameras, or embedded GPUs which have don;t have optimal Open Source support yet.

The class is aimed at software and system engineers interested in the gory and ugly details of multimedia support in Linux with a solid knowledge of Embedded GNU/Linux and multimedia applications.

Requirements

Experience with Software development under Linux
Familiarity with a Unix-based operating system
Familiarity with Linux multimedia tools

All the training material and the presentation is in English.

The work- and reference books typically stay with the students after the training.

Course Outline

Day 1 – Video input pipeline:
- Hardware
  - Historical context, media hardware evolution
  - Video input pipeline — Sensor, Bus, DMA, Memory
  - Pixel formats, ordering, colorspaces, timings
  - Video input bus types and properties
- Kernel
  - V4L2 subsystem overview
  - Driver interface
  - Trivial driver example
  - V4L2 subdevices, media controller, OF graph
  - Userspace interface, IOCTLs
- Userspace
  - The other side of kernel interface
  - Pipeline configuration, streaming modes
  - Example of interaction with V4L2 devices
  - Buffer handling and zero copy operations
- Tooling
  - V4l-utils, yavta
  - Introuction to gstreamer
  - Performance evaluation and profiling
  - Examples
Day 2 – Video output pipeline:
- Hardware
  - Video output pipeline — Memory, DMA, Encoder, Bridge, Connector, Panel
  - Pixel formats, colorspaces, timings
  - Video output bus types and properties
- Kernel
  - DRM subsystem overview
  - Acronyms explained — DRM, KMS, GEM, TTM, DDX, PRIME, DMABUFs
  - Pipeline — Planes, CRTCs, Bridges, Panels, Encoders, Connectors
  - Driver interface
  - Atomic pipeline operations
  - Trivial scanout, bridge, panel driver example
- Userspace
  - DRM device look up and configuration
  - Buffer management, zero copy buffer passing, DMABUFs
  - Example of interaction with DRM devices
  - Buffer sharing with V4L2 devices
- Tooling
  - libdrm test tooling
  - Modern protocols and servers, Wayland, Weston
  - Gstreamer video output
  - Framework integration, Qt5, browsers
- GPU
  - Architecture and operation of generic GPU
  - Standardized APIs, OpenGL, GLES, EGL, VK
  - Integration with the DRM subsystem
  - Mesa3d user space
  - Tracing and performance monitoring
Day 3 – Audio:
- Hardware
  - Audio hardware — Memory, DMA, ADC/DAC, DSP
  - Digital audio sampling and data formats
  - Audio bus types and their properties
- Kernel
  - ALSA subsystem overview
  - ALSA SoC framework
  - Cards and components, codecs, DAIs and machine glue code
  - Trivial card, codec, PCM component driver examples
- Userspace
  - ALSA device and proc interface
  - Device naming scheme
  - Alsa-lib library, plugin interface and tools
- Tooling
  - Pipewire and wireplumber
  - Interaction with Gstreamer

Next Courses

12.09.2023 – 14.09.2023

Workshop : SWUpdate (1 day)

The one-day Workshop will introduce you in the risky world of updating a unattended system.

Upgrading an embedded system is complex. In fact, updating an unattended device is very different from updating a standard PC. Security, power cut, resource constraints and many other aspects must be taken into account for both local and over-the-air (OTA) updates. The Workshop will explain these themes and how to design and implement an update system that is reliable and guarantees not to brick the device in field. The Workshop will focus on SWUpdate – a framework that can be customized to the project’s needs – and how to integrate the updater into the Yocto project.

Agenda

Introduction

The one-day Workshop will introduce you in the risky world of updating a unattended system.

Who should attend ?

System Architects, Software developers, managers who are planning an update system for their embedded product. They do no not need a deep knowledge into programming, but a basic know how in Linux / Yocto is an advantage.

All the training material is in English, but the presentation of it can be in English or in German, as you wish.

Workshop Outline

Why update ?
Problems with unattended update
Different update stategies
Risks when updating
OTA / Remote update
Which components should be updated ?
Update strategies
Security issue in an updater
The SWUpdate Framework
- Features
- Architecture
- Components in SWUpdate
- Configuration
- Creation of releases
- Security in SWUpdate
- The sw-description file
- The Handlers
- Bind to Backend (Hawkbit)
- how to match with own product
- Extensions : plugins in LUA
- Security in SWUpdate
- Interface with other components (GUI,..)
- Best use cases

Next Courses

This is on Demand Workshop – please contact DENX at info@denx.de for availability.

Workshop: tbot (1 day)

Developing / porting of U-Boot, Linux, and/or Yocto for a new hardware, or even updating an existing port to a newer version, can be a hard job. Testing if a new version still works at least as well as the previous one is even harder. And usually this is uninteresting, boring work.

This workshop shows how to install and use the tbot test tool for automatic build and runtime tests. The demonstrations use the well-known BeagleBoneBlack (BBB) board as target system.

Originating from a system that focussed on the tasks that developers have to perform routinely, like boring maintenance work in U-Boot and Linux, tbot has grown into an universal test tool that not only catches bugs, but also allows to automatize such boring routine tasks. If you find yourself doing similar things again and again, this workshop might show you how you can safe a lot of time and still improve the overall quality of your work.

Agenda

Introduction

This workshop shows how to install and use the tbot test tool for automatic build and runtime tests. The demonstrations use the well-known BeagleBoneBlack (BBB) board as target system.

Who should attend

Software developers interested in running all kinds of automatic procedures and tests, including complex ones where other CI tools give up (like automatic patch download, automated git bisecting etc.).

Course Outline

Introduction
Overview Testtools
tbot principles
tbot installation
tbot examples
tbot practicall session

Next Courses

This is on Demand Workshop – please contact DENX at info@denx.de for availability.