Course ELIN100
Getting Started with Embedded Linux
Getting Started with Embedded Linux
Duration: 5 Days
Intended Audience
Attendees should be embedded systems developers with some experience of C programming and some experience of working with Linux or Unix at the command line. The course should provide a good understanding of what Linux can and cannot do, its strengths as well as its limitations.
Course Overview
This is a very intensive course which aims to provide beginners to embedded linux with sufficient understanding to be able to start developing and maintaining applications for embedded linux based systems, to build linux kernels for their target systems, to work with cross development environments and be able to configure a kernel on a target board for working with such environments. The course will also sand demonstrate how to write simple device drivers and how to write user applications to drive basic hardware such as buttons, LEDs, simple motors as well as I2C and SPI devices.
At the Linux user level the course covers key topics essential to understanding Linux such as logging on, Linux file systems, TCP/IP networking, user accounts and security, the Linux boot process, terminals and serial ports, and basic shell programming.
Each attendee will be given a full ARM 9 based embedded system (Tin Can Tools' Hammer Development Kit) that they will be able to take away with them so as that they can continue developing skills learned on the course. This kit includes a JTAG probe that can be used on other embedded targets as well. Details of the kit can be found on the Tin Can Tools web site, and kits and associated Tin Can Tools products are available in the UK via Robotiq.
Course Benefits
Getting started with embedded Linux is a daunting task. There are so many things to learn all at once. This includes such things as finding your way around linux, understanding the intricacies of the GNU compiler, make files and the GNU debugger. Then there is the need to master the art of cross-compilation and downloading code to the targer. In addition it is necessary to understand how to configure and build linux kernels and load then onto the target device. In addition, since Linux is a multi-tasking operating system there is the need to understand multi-tasking and multi-threading. It will not be possible to cover all of these topics exhaustively. Rather the approach will be to provide basic knowledge and a sound understanding of the underlying principles to lay the foundations for further discovery and learning.
You'll learn fundamentals such as user accounts, Unix permissions and access control. You'll gain confidence in finding your way around Linux system installations using standard Linux commands.
You'll become familiar with the vi editor and be able to use it proficiently to create and modify files. You'll learn, the principles of how Linux boots, both on PCs (GRUB, LILO) and on embedded systems (U-Boot).
You'll get a good introduction to working with the shell and with the standard Unix tools and utilities (including the BusyBox toolset on the ARM 9 target system). You'll also learn how to set up and configure disk based, in memory, and flash file systems.
You'll gain the skills needed to configure ethernet and serial communications ports and TCP/IP networking. And you'll learn how to use package managers (both RPM and APT) to install software.
You will also be introduced to Posix API programming and be shown how to write applications that will make use of terminal and file i/o, create and manage tasks and threads, memory mapping and how it can be used to drive memory mapped hardware from user applications.
The Linux device driver model will be explained and techniques for writing kernel loadable modules will be introduced. You will also be shown how to configure and build Linux kernels
As well as building applications running on the PC, you will be shown how to use QEMU to set up and install Linux on "emulated targets" and run applications on these targets. You will, of course, also learn how to install Linux kernels on your embedded ARM 9 target, and how to use JTAG to debug applications on it.
Course Contents
Introduction
- Logging on to Linux
- Linux as a multi-user, multi-tasking operating system
- Accessing the command line (terminal and desktop)
- Accessing and using manual pages
Working with the command line and the shell
- Introduction to command shells
- Understanding command syntax
- Executing commands at the command line
- Common command line tasks
- Piping and redirection
- Managing user accounts
- Performing RPM and APT package related operations
Managing directories and files
- Understanding the filesystem hierarchy standard (FHS)
- Changing directories and listing directory contents
- Creating, viewing and appending files
- Copying and moving files and directories
- Creating directories
- Deleting files and directories
- Finding files on linux
- Managing file permissions and ownership
Basic use of the vi text editor
Understanding and viewing processes
- Viewing processes from the command line
- Understanding the runlevel concept
- Multiuser processes, multitasking and multi-threading
Managing the network configuration
- Basic network configuration
- Overview of the network-related command-line tools
Managing user access and security
- Basic Linux user security features
- Managing Linux users and groups
- Managing and securing the linux user environment
- Securing files and directories with permissions
Setting up a linux file system
- An overview of the various types of Linux filesystems
- Overview of configuring linux filesystem partitions
- Overview of configuring and managing a linux file system
- Backing up and restoring a file system
- Working with Flash File Systems
Understanding System initialisation
- Overview of bootloaders and the Linux boot process
- Overview of run levels and system settings
- Overview of startup shell scripts and services
Connecting a system to the network
- Network components and architecture
- Configuring a network connection
- Configuring and managing routes
- Testing a network interface
- Enabling network services
Basic POSIX API Programming
- Terminal and File I/O
- Creating task and threads
- Working with pipes
- Introduction to memory mapping
- Overview of inter-process communication mechanisms and patterns
Understanding the Kernel Architecture
- Overview of the kernel architecture
- Interrupt handling
- Memory mapping
- Block, character and network devices
- Basic anatomy of a device driver
- How system calls work
- Loadable modules
Cross Compilation - Kernel and Application Building for Remote Targets
- The kernel configuration and build process explained
- Installing a kernel on a remote target
- Compiling and downloading applications to a remote target
- Block, character and network devices
- Introduction to JTAG and its uses
- Introduction to QEMU and its use to emulate other targets and embedded linux systems running on such targets
Driving hardware on the embedded target
- Detecting button presses
- Flashing LEDs
- Working with SD/MMC card file systems
- Pulse Width Modulation for power and basic motor control
- Measuring temperature using an I2C based temperature sensor