Embedded Linux and its Platforms

 Synopsis of lectures:

1. Introduction to embedded Linux, the structure and platforms of Linux (SoC, FPGA, etc.), SW execution model and memory management (virtual storage management and its consequences), possibilities and consequences of managing peripherals in Linux (user- and kernel-space).

2. Using the Shell. Basics of Linux programs, command line and configuration management. File system and its usage, including /proc, /sys, etc. file systems. Using a serial port (UART) in a programmed way.

3. Scheduler,  influencing the scheduler, real-time scheduling. Use of processes and threads and their consequences. Samples of event-driven programming (select, poll, epol). Basics of system startup and process management (systemd and its alternatives).

4. Mutual exclusion, communication and synchronization in Linux. Solutions for shared memory (between threads running in the context of a process). Mutex, readers-writer lock, user-space spinlock, conditional variable, and their use.

5. Inter-process communication (IPC) at low level and high level (DBUS). Event management, pipelines, shared memory between processes and its use, file locking, DBUS basics.

6. Subsystems suitable for managing embedded peripherals, a brief introduction to the Device Tree. GPIO management in Linux and the impact of programming models on performance. A/D and D/A management, I2C, SPI and CAN management in Linux, construction of related subsystems.

7. User-space drivers, USB management and TUN/TAP in user mode. Accessing memory-mapped peripherals in user mode, advantages and disadvantages.

8. Low-level (socket) and high-level (HTTP, etc.) network management, intermediate layers (Middleware).

9. Heterogeneous architecture support, task scheduling and communication with external HW accelerators (real-time cores, AI acceleration, OpenCV acceleration with example, etc).

10. Multimedia subsystem of Linux: Video for Linux (V4L2). Overview of multimedia frameworks: Gstreamer, FFmpeg.

11. SoC, concept, characteristic structure. Fixed function and programmable hardware units, their integration into the system. Construction of GPUs.

12. Programming model of heterogeneous systems: OpenCL and CUDA.

13. Characteristics of FPGA-based SoC devices (Intel, Lattice, Xilinx). Description of processor subsystem, programmable logic and other system elements. High-level description of FPGA-based accelerators: OpenCL and HLS.

Synopsis of exercises:

Exercise 1: Setup of the Development System

Exercise 2: Shell programming and command line management, serial port management with termio.

Exercise 3: Creating processes and threads, influencing schedule (RT and CPU affinity), process management with systemd

Exercise 4: Select and poll/epol based complex SW architectures

Exercise 5: Mutual exclusion and synchronization in shared memory, use of IPC solutions

Exercise 6: GPIO (with GPIO user-space library and mapped to memory) management in a user program, I2C and SPI management (writing a user-space's driver and using an existing kernel driver)

Exercise 7: User-space USB peripheral management (periphery implemented on MCU, with ready-made code and communication protocol specification)

Exercise 8: Socket programming, HTTP client programming (downloading information from a program from a server)

Exercise 9: Remoteproc and rpmsg in practice, on an OpenCV heterogeneous system chip (remoteproc and rpmsg at high-level)

Exercise 10: Using the V4L2 user space API.

Exercise 11: Using Gstreamer.

Exercise 12: OpenCL/CUDA basics: host code and simple kernel.

Exercise 13: OpenCL/CUDA: kernel programming.