Linux is used ever more on embedded systems driven by increasingly complex devices and a greater requirement for connectivity and multimedia. This is a rapidly growing market. Working with Linux for embedded systems can be difficult, with a vast array of choices available for tools and software.
This Developing with Embedded Linux training provides the practical skills and knowledge required to work with Linux in this environment. Workshops comprise approximately 50% of class time, and are based around carefully designed exercises to reinforce and challenge the extent of learning.
The course mainly uses Linux open source tools with a discussion of some of the available commercial solutions where appropriate.
The course is offered as a face to face public or on-site class or as a Live-Online class. In the latter case the practical exercises are slightly different but the training material is identical.
Course description video
Course Overview Video
Who should attend?
This course is designed for anyone wishing to get started quickly on working with Linux for embedded systems.
Format
The format of Live ONLINE training from Doulos is focused on delivery of a single 6 hour intensive session per day. This includes live tuition and class interaction with the Doulos subject matter expert during the full scope of each session.
Labs are incorporated within the 6 hour sessions with the Doulos lab platform providing individual (private) tutor support at all times for each delegate. On occasion, labs may require time outside of the 6 hour session to complete. Additional lab material is available in some subjects for individuals to reinforce their understanding of the course content.
Hardware
A QEMU software solution is used which emulates real hardware and most of the labs are identical. The QEMU emulator can be booted and interacted with like a real hardware target using virtualized serial and ethernet connections.
What will you learn?
An understanding of the structure of an embedded Linux system and how to work with the component parts
Practical information about developing, analysing and debugging kernel and user space applications using a wide range of freely available Linux tools
How to configure embedded Linux on the target, including the filesystem and the booting process
Pre-requisites
Completion ofLinux Fundamentalstraining or equivalent basic knowledge of using Unix/Linux on the desktop
Experience of working with embedded systems (e.g. using RTOS or bare machine)
Some familiarity with C programming is useful
Course materials
Doulos course materials are renowned for being the most comprehensive and user friendly available. Their unique style, content and coverage has made them sought after resources in their own right. The materials include fully indexed class notes creating a complete reference manual.
Structure and Content
Introduction
Course Objectives
Linux Background
Open-Source Software
Licensing
Embedded Linux Distributions
Development platforms
Host to target communications
Console command and version control
Exercises:
Booting a standard image
Establishing target communications
Exploring the target filesystem
Working with the Linux Kernel
Scheduling, real-time and memory
Kernel configuration
Building and booting the kernel
Board support
Kernel modules
Exercises:
Configuring and building the kernel
Creating a kernel module
Debugging the Linux Kernel
Kernel logs & printk
JTAG
KGDB/KDB
Exercises:
Using kernel logs
Using KGDB/KDB to debug a kernel module
Building Applications
Compiling on the target
Cross-compiling
Static and shared libraries
Using a portable build system (e.g. Autotools)
Exercises:
Cross-compiling
Creating static and shared libraries
Configuring and compiling an Autotools application
Debugging Applications
Compiling for debugging
Target debugging
Cross debugging
Other user space tools
Debugging user space seg faults
Exercises:
Target debugging
Cross-debugging a seg fault
Generating and using core dumps
Linux Applications
How a Linux application can be structured
Managing processes and threads
Inter-process communications
Interfacing with the kernel
Exercises:
Simple IPC
Threads and processes
Configuring Filesystems
Filesystem contents
Init programs
BusyBox
Device management
Exercises:
Adding a daemon to init
Configuring and compiling BusyBox
Filesystem Locations
NFS
RAM filesystems
Block-based filesystems
Flash filesystems (JFFS2, UBIFS)
Exercises:
Creating an initramfs
Creating an early user space filesystem
Writing a UBIFS into flash
Configuring the Bootloader
The bootloader
Bootloader choices
Working with U-Boot
Porting U-Boot to a new board
Exercises:
Working with the U-Boot shell
Trace & Profile
Linux trace technology
SysProf
OProfile
FTrace
Perf
Other Tools
Use case examples
Exercises:
Investigating scp behaviour with trace & profile tools
