Semester Lab Track
Mission: From User to Builder — Master Embedded Linux from Application to Platform
Start with a bare Raspberry Pi. First, get fluent with Linux basics, then build a complete temperature-sensor-to-OLED path (user space first, kernel driver next). After that, move to graphics stacks and application pipelines. Then, peel back deeper platform layers: boot flow, custom Linux images, and real-time performance. End with a self-booting, tear-free, RT-measured IMU display — and the data to prove it works.
The Journey
┌──────────────────────────────────────────────────────────────────────────────┐
│ │
│ FOUNDATION DRIVERS+GRAPHICS PLATFORM INTEGRATION │
│ Labs 1-3 Labs 4-7 Labs 8-9 Labs 10-12 │
│ │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │ SSH │ ──► │ Drivers │ ──► │ Boot │ ──► │ Measure │ │
│ │ Explore │ │ OLED FB │ │ Reliab.│ │ Build │ │
│ │ Sensor │ │ SDL2 │ │ Update │ │ Ship │ │
│ │ │ │ Doom/Qt │ │ │ │ │ │
│ └──────────┘ └──────────┘ └──────────┘ └──────────┘ │
│ │
│ "Use Linux" "Build drivers "Understand the "Make it real" │
│ and apps" platform" │
│ │
└──────────────────────────────────────────────────────────────────────────────┘
Session Format
| Session | Duration | Structure |
|---|---|---|
| Theory | 2 × 45 min | Block 1: concept + live demo (45 min) — Block 2: interactive exercise (45 min) |
| Lab | 3 × 45 min | Recap + demo (15 min) — Guided work (90 min) — Challenge + wrap-up (30 min) |
Theory sessions use a problem-first format: each session opens with a concrete question, delivers the minimal lecture needed, then spends the second block on a hands-on exercise, group design task, or live analysis. Labs follow the tutorials, with buffer time for exploration and challenges.
Prerequisite Overlay
If students already have a Linux/driver prerequisite, the same weeks apply with shifted emphasis.
Slides marked ⏩ Review are covered in ~1 minute each (students have seen the concept).
Freed time is filled with embedded depth.
| Week | What to condense (review) | What to add (depth) |
|---|---|---|
| 1 (T1) | UNIX history, OS basics, market share, MCU vs MPU | Cross-compilation, power management, reliability preview, ecosystem overview |
| 2 (T2) | FHS, permissions, shell tools, process basics | Device file ecosystem, udev, systemd service design, strace, RT scheduling preview, musl vs glibc |
| 3 (T3) | DT motivation, basic overlay syntax | I2C/SPI bus waveforms, pin multiplexing, clock tree — the "why" behind device tree properties |
| 4 (T4) | MCP9808 Python read, overlay benefits | Driver lifecycle (probe/deferred probe), interrupts in drivers, DMA basics |
| 8 (T8) | No changes — boot flow is new for most students | — |
| 10 (T10) | No changes — RT is entirely new | Cache effects, CPU isolation, hardware counters, DVFS |
| All others | No changes | — |
Semester Plan (14 Weeks)
| Week | Phase | Theory (2×45 min) | Lab (3×45 min) | Milestone |
|---|---|---|---|---|
| 1 | Foundation | T1: What Is Embedded Linux? | L1: Hello, Embedded Linux | Pi responds, SSH workflow works |
| 2 | Foundation | T2: How Linux Works | L2: Exploring Linux | System report script works |
| 3 | Foundation | T3: Hardware Interfaces & DT Primer | L3: I2C Sensor + OLED Path | Temp readout works in terminal + OLED |
| 4 | Drivers+Graphics | T4: Kernel Drivers & Device Tree | L4: Kernel Drivers & OLED FB | MCP9808 in sysfs + OLED FB + Pong running |
| 5 | Drivers+Graphics | T5: Graphics Stack | L5: Graphics Foundations | Framebuffer/DRM output + DSI display working |
| 6 | Drivers+Graphics | T6: Graphics Applications & Profiling | L6: SDL2 Applications | SDL2 cube + level display responding to tilt |
| 7 | Drivers+Graphics | T7: Architecture & Integration | L7: Full-Stack Integration | Doom + Qt launcher + camera pipeline working |
| 8 | Platform | T8: Boot Flow & Architectures | L8: How Linux Boots | Annotated boot timeline |
| 9 | Platform | T9: Reliability, Updates & Security | L9: Data Logging & Reliability | Data logger survives power loss + overlayfs |
| 10 | Integration | T10: Real-Time Systems | L10: Real-Time Measurement | RT kernel installed + jitter table |
| 11 | Integration | T11: Build Your Own Linux | L11: Build Your Own Linux | Custom Buildroot image boots |
| 12 | Delivery | Synthesis & Review | L12: Demo Day | Presentation + live demo |
| 13-14 | — | Exam period | — | — |
Note
The sequence groups drivers and graphics together (weeks 3–7) so students build the full sensor→driver→display path before moving to platform topics. Reliability and boot flow are pushed later when students have working applications to protect and optimize.
Project Milestones
| Lab | Checkpoint | What to Submit |
|---|---|---|
| 3 | Sensor/display bring-up complete | Screenshot: MCP9808 userspace readout + OLED temperature |
| 4 | Kernel driver working | Screenshot: MCP9808 sysfs + dmesg probe log + OLED FB + Pong |
| 6 | Graphics applications working | Photo/video of SDL2 level display responding to tilt |
| 7 | Full integration | Doom + Qt launcher running, camera pipeline, architecture diagram |
| 9 | Reliability layer complete | Data logger with overlayfs + systemd service + recovery notes |
| 10 | RT measurement complete | Jitter comparison table (standard vs RT kernel) |
| 11 | Custom image boots | Boot time comparison: stock vs minimal vs SDL2 |
| 12 | Final demo | Presentation + live demo + measurement report |
Lab Details
Lab 1: Hello, Embedded Linux
Problem: You have a Raspberry Pi running Linux. How is this different from your laptop? From a microcontroller?
| Tutorial | Time |
|---|---|
| SSH Login | 15 min |
Quick look: htop, lsmod, /dev, systemctl, journalctl |
45 min |
| Baseline checks: network, storage, package status, board ID | 30 min |
| Optional prep: enable I2C (if time remains) | 30 min |
Deliverable: Linux baseline checklist + notes comparing Linux to bare-metal MCU.
Lab 2: Exploring Linux
Problem: 80 processes, 200 device files, permission denied. You learned the theory — now explore the real system.
| Tutorial | Time |
|---|---|
| Exploring Linux — Sections 1-4 | 60 min |
| Exploring Linux — Sections 5-6 + Challenge | 45 min |
Extension: Shell Scripting for Embedded Linux (60 min) — students who finish early or want to deepen their scripting skills can work through this tutorial, which applies Theory 2 Section 10.
Extension: ELF and Program Execution (45 min) — inspect ELF binaries, trace program loading with strace, compare static vs dynamic linking. Applies Theory 2 Sections 1.1–1.2.
Deliverable: All 6 checkpoint tables filled in + system report script (system_report.sh).
Tip
This lab directly applies Theory 2. Students should have their Theory 2 notes open and fill in the MCU vs Linux comparison table at the end.
Lab 3: I2C Sensor + OLED Path
Problem: Before advanced graphics, can you build a reliable sensor-to-display path end-to-end?
| Tutorial | Time |
|---|---|
| Enable I2C | 30 min |
| OLED Display | 30 min |
| MCP9808 Kernel Driver — setup + read path preview | 45 min |
| Compare user-space read vs kernel/sysfs read | 30 min |
Deliverable: Temperature value shown in terminal and on OLED + block diagram of the data path.
Lab 4: Kernel Drivers & OLED FB
Problem: The temperature sensor works from Python already. Why write 500 lines of C? And can you turn a tiny OLED into a Linux framebuffer?
| Tutorial | Time |
|---|---|
| MCP9808 Kernel Driver | 60 min |
| OLED FB Driver | 45 min |
| Pong on Framebuffer | 30 min |
Extension: LDD BUSE (120 min) — SPI LED matrix framebuffer driver with manual CS timing and hrtimer-based refresh. Demonstrates fbdev registration, real-time constraints in display drivers, and SPI with GPIO chip-select.
Extension: Debugging Practices (60 min) — GDB, remote debugging with gdbserver, and kernel logging deep-dive. Natural fit here as the first session involving driver debugging and dmesg interpretation.
Deliverable: MCP9808 in sysfs + OLED FB working + Pong running on OLED.
Tip
This lab pairs directly with Theory 4 (Kernel Drivers & DT). Students should have their Theory 4 notes open. The OLED display from Lab 3 becomes a kernel framebuffer device — same hardware, different abstraction layer.
Lab 5: Graphics Foundations
Problem: The OLED framebuffer was 128×64. Now scale up to a real display — how do pixels get from memory to an 800×480 screen?
| Tutorial | Time |
|---|---|
| Framebuffer Basics | 20 min |
| DRM/KMS Test Pattern | 20 min |
| Display Applications | 30 min |
| BMI160 SPI Kernel Driver | 30 min |
Extension: DSI Display (30 min) — connect a 5" DSI panel, verify DRM/KMS output, test touch input. Only a few DSI displays are available — HDMI is the default.
Extension: SPI TFT Display (45 min) — connect a 3.5" Waveshare SPI display, draw to /dev/fb1, measure SPI bandwidth limits, and compare CPU-driven rendering with HDMI GPU scan-out.
Deliverable: HDMI/DSI test pattern + BMI160 SPI driver loaded + display app running.
Tip
The BMI160 driver is started here so students have IMU data ready for the SDL2 level display in Lab 6. If time is tight, the SPI driver can carry over to Lab 6.
Lab 6: SDL2 Applications
Problem: You have drivers for the IMU and a working display. Build interactive graphics applications.
| Tutorial | Time |
|---|---|
| Linux Input Events | 45 min |
| SDL2 Rotating Cube | 45 min |
| SDL2 Touch Paint | 30 min |
| Level Display: SDL2 + DRM/KMS | 45 min |
Extension: IMU Controller Input (45 min) — map BMI160 tilt to the rotating cube with sensor fusion, measure sensor-to-display latency. I2S Audio Visualizer (90 min) — capture audio from an I2S microphone, display waveform/spectrum/spectrogram, optionally estimate sound direction with GCC-PHAT.
Extension: SDL2 Dashboard (60 min) — multi-gauge dashboard reading sensor data, comparing SDL2 rendering approaches. SDL2 UI Patterns (45 min) — build overlays, touch buttons, and draggable sliders for embedded displays.
Deliverable: SDL2 cube rendering + level display responding to IMU tilt.
Tip
This is where drivers meet graphics. The IMU data from Lab 5's BMI160 driver feeds directly into the level display. Students see the full path: SPI bus → kernel driver → sysfs → user-space app → GPU → display.
Lab 7: Full-Stack Integration
Problem: You have sensors, drivers, displays, and SDL2 apps. Now build a complete product-like system.
| Tutorial | Time |
|---|---|
| Doom on Raspberry Pi | 45 min |
| Qt App Launcher | 45 min |
| Camera Pipeline | 30 min |
Extension: Qt + EGLFS Dashboard (75 min) — build the same dashboard with Qt, compare binary size, RAM usage, and startup time vs SDL2.
Extension: Ball Detection (60 min) — OpenCV pipeline for tracking, camera→display latency measurement. Acoustic Keystroke Recognition (90 min) — use the I2S microphone to recognize typed keys via ML classification.
Extension: Kiosk Service (30 min) — systemd service for auto-launching the Qt launcher on boot with proper display handoff.
Deliverable: Doom running from Qt launcher + camera pipeline + architecture diagram showing all components.
Tip
This is the fun week. The Qt launcher ties together everything: it launches Doom, SDL2 demos, and shows system info. Students see a polished product that uses every layer they've built: drivers, graphics, systemd services, DRM master handoff.
Lab 8: How Linux Boots
Problem: Boot takes 35 seconds. An MCU starts in 50 ms. Where does the time go?
| Tutorial | Time |
|---|---|
| Boot Timing Lab | 45 min |
Deep dive: annotate dmesg, compare to MCU boot |
30 min |
| Optimize: disable services, measure improvement | 30 min |
Deliverable: Annotated boot timeline SVG + before/after improvement table.
Lab 9: Data Logging & Reliability
Problem: Your display apps and drivers work on the bench. What happens when the power goes out? When the SD card fills up?
| Tutorial | Time |
|---|---|
| Processes and IPC in C | 45 min |
| Data Logger Appliance | 45 min |
| Threads and Synchronization | 45 min |
Extension: Security Audit and Hardening (45 min) — threat-model the data logger, apply hardening practices from Theory 9.
Extension: Shell Scripting for Embedded Linux (60 min) — continuous logging, trap cleanup, log analysis, systemd timers.
Deliverable: Data logger running as systemd service with overlayfs + fork/pipe/signal programs.
Tip
Students now have real applications to protect. The overlayfs and watchdog patterns from Theory 9 directly apply to keeping the Qt launcher and sensor pipeline running through power cycles.
Lab 10: Real-Time Measurement
Problem: Your level display "feels smooth" but how do you prove it? And can you make it provably better?
| Tutorial | Time |
|---|---|
| Audio Pipeline Latency | 60 min |
| PREEMPT_RT Latency | 45 min |
| Jitter Measurement and RT Comparison | 45 min |
| Run all 4 test conditions, collect CSVs, generate plots | 30 min |
Deliverable: RT kernel installed + completed jitter comparison table + histogram plots.
| Metric | Standard | Standard + Load | RT | RT + Load |
|---|---|---|---|---|
| Sensor dt max (us) | ||||
| Frame dt max (ms) | ||||
| Dropped frames | ||||
| Input latency 99th (ms) |
Extension: MCU Real-Time Controller (90 min) — offload the control loop to a Pico 2 W, compare three RT approaches (standard Linux, PREEMPT_RT, external MCU).
Extension: 1D Ball Balancing (90 min) — servo + VL53L0X PID control loop, physical demonstration of why real-time matters.
Extension: 2D Plate Balancing (120 min) — 2-axis servo + camera PID, full pipeline latency measurement.
Tip
Students already have the level display and SDL2 apps from Labs 6-7. Now they measure the same applications under different kernel configurations. The before/after comparison makes RT tangible.
Lab 11: Build Your Own Linux
Problem: Stock Raspberry Pi OS: 4 GB image, 120 processes at idle, 35-second boot. Your appliance needs 5 processes and boots in 5 seconds.
| Tutorial | Time |
|---|---|
| Buildroot: Minimal Linux | 60 min |
| Buildroot: SDL2 + SPI Image | 50 min |
| Verify: boot time, SDL2, SPI, Python all working | 20 min |
Extension: IIO Buffered Capture (60 min) + Custom IIO Driver (90 min) — use the mainline IIO driver for buffered capture with DMA, then write a custom IIO driver for unsupported hardware.
Extension: SPI DMA Optimization (45 min) — optimize the BMI160 driver with DMA transfers, measure CPU impact.
Extension: Profile your own project: perf record + strace -c (see Performance Profiling) (20 min).
Deliverable: Custom image with SDL2 + SPI + Python + boot time comparison (stock vs minimal vs SDL2).
Note
Start the minimal build early — it compiles for 30-90 minutes. While it builds, begin configuring the SDL2 + SPI additions. This is a tight session; ensure students have read Theory 11 beforehand and have their Pi connected.
Lab 12: Demo Day
Problem: Show what you built. Prove it works with data.
| Activity | Time |
|---|---|
| Prepare demo station (15 min) | 15 min |
| Presentations (8 min × teams) | 80 min |
| Live demos + Q&A | 30 min |
| Course synthesis discussion | 10 min |
Deliverable: 5-minute presentation covering architecture, measurements, and one thing you would change.
Tip
Before Demo Day, students should read Software Architecture for Embedded Linux — it covers how to structure a multi-component project (process patterns, IPC, error handling, state machines) and provides the vocabulary for the architecture section of their presentation.
Theory Session Details
Each 90-minute theory session is split into two blocks. Block 1 introduces concepts; Block 2 is an interactive exercise.
Theory 1
What Is Embedded Linux? — When do you need an OS on your embedded device?
| Block | Content | Format |
|---|---|---|
| 1 (45 min) | Linux under constraints: memory, boot time, real-time. When to choose Linux vs RTOS vs bare-metal. | Lecture + live demo: htop on Pi vs laptop |
| 2 (45 min) | Group exercise: 4 product specs (smart thermostat, drone, PLC, medical monitor). Each team picks Linux, RTOS, or bare-metal and defends the choice. | Think-pair-share → class debate |
Theory: What Is Embedded Linux?
Theory 2
How Linux Works — 80 processes, 200 device files, permission denied. What is all this?
| Block | Content | Format |
|---|---|---|
| 1 (45 min) | Processes, program execution (fork/exec, ELF loading), IPC (pipes, signals, shared memory), threads vs processes, filesystem hierarchy, /dev /sys /proc, permissions, kernel vs user space, shell tools, scheduling basics, MMU and virtual memory. Debugging overview: three layers, GDB, QEMU, JTAG awareness. | Lecture + live htop, ls /dev, cat /proc/cpuinfo, pstree, readelf -h, strace -e execve, kill -l |
| 2 (45 min) | Preview of Lab 2: students SSH in and start the Exploring Linux tutorial — investigate processes, filesystem, permissions, and scheduling on their Pi. Fill in comparison table. | Hands-on exploration |
Theory: How Linux Works
Theory 3
Hardware Interfaces & DT Primer — How does Linux discover and talk to hardware?
| Block | Content | Format |
|---|---|---|
| 1 (45 min) | I2C/SPI bus protocols, Device Tree motivation and basic syntax, overlays, pin multiplexing. | Lecture + read dtc -I fs /proc/device-tree together |
| 2 (45 min) | Hands-on: find the I2C node in the device tree, modify a property, enable an overlay. | Live demo + guided exercise |
Theory: Device Tree
Theory 4
Kernel Drivers & Device Tree — Three programs need this sensor simultaneously — now what?
| Block | Content | Format |
|---|---|---|
| 1 (45 min) | Kernel vs user space, /dev, sysfs, ioctl. Driver lifecycle: probe, match, deferred probe. Walk through MCP9808 (I2C chardev), SSD1306 OLED (I2C fbdev), BUSE LED matrix (SPI fbdev with real-time refresh). | Lecture + code walkthrough |
| 2 (45 min) | Live: read MCP9808 from Python (user space), then from sysfs (kernel). Discuss trade-offs. "Why 500 lines of C for something Python does in 10?" | Live demo → class discussion |
Theory: Drivers
Theory 5
Graphics Stack — How do pixels get from memory to a physical display?
| Block | Content | Format |
|---|---|---|
| 1 (45 min) | Display hardware, scan-out, framebuffer, DRM/KMS, compositor. Connection from OLED FB (Lab 4) to full GPU pipeline. | Lecture + live fbset, /dev/fb0 demo |
| 2 (45 min) | Predict and test: "What happens if you write pixels faster than the display refreshes?" Write a simple framebuffer flood, observe tearing, explain why. | Live coding + observation |
Theory: Graphics Stack in Embedded Linux
Theory 6
Graphics Applications & Profiling — The display works but stutters under load. Why?
| Block | Content | Format |
|---|---|---|
| 1 (45 min) | SDL2 architecture, OpenGL ES 2.0 on embedded, VSync, page flipping, double buffering, sensor-to-pixel pipeline. | Lecture + pipeline diagram walkthrough |
| 2 (45 min) | RT kernel impact, CPU core partitioning, DMA. Live: demonstrate tearing vs VSync, measure frame times. Students predict: "Which change helps more — better code or better kernel?" | Live demo + prediction exercise |
Theory: Real-Time Graphics and Display Pipelines
Theory 7
Architecture & Integration — Draw the whole system. Where does data flow? Where can it fail?
| Block | Content | Format |
|---|---|---|
| 1 (45 min) | Full-stack system view: hardware → kernel → user space → display. Data flow, layers, failure domains. DRM master handoff, systemd service design, multi-process architecture. | Lecture + architecture diagram |
| 2 (45 min) | Teams draw the complete architecture of their sensor→driver→display system: all components, data flow, latency at each stage. Peer review another team's diagram. | Whiteboard exercise → peer review |
Theory: Software Architecture for Embedded Linux
Theory 8
Boot Flow & Architectures — Why does a Pi boot in 35 seconds but an STM32 in 50 ms?
| Block | Content | Format |
|---|---|---|
| 1 (45 min) | Boot stages, dmesg walkthrough, systemd-analyze live demo. | Lecture + live terminal |
| 2 (45 min) | MCU vs SoC vs PC boot comparison. Each team gets a platform (STM32, Pi 4, STM32MP1, PC) and draws its boot flow on the whiteboard. Compare results. | Group whiteboard exercise |
Theory: Boot Flow & Architectures
Theory 9
Reliability, Updates & Security — The power goes out during an update. Your device is on the public internet. What happens?
| Block | Content | Format |
|---|---|---|
| 1 (45 min) | Storage types (eMMC, SD, NOR/NAND), filesystems (ext4, F2FS, SquashFS), write endurance, read-only rootfs, overlayfs, A/B updates, watchdogs. | Lecture + overlayfs demo |
| 2 (45 min) | Security: attack surfaces, CVE case studies, hardening checklist. Failure mode exercise: teams design a recovery strategy for power loss, SD corruption, runaway process. | Case study + group design |
Theory: Reliability, Updates, and Watchdogs + IoT, Networking, and Security
Theory 10
Real-Time Systems — Your sensor reads at 200 Hz but sometimes takes 50 ms. Can Linux do real-time?
| Block | Content | Format |
|---|---|---|
| 1 (45 min) | Hard vs soft RT, PREEMPT_RT deep dive (threaded interrupts, sleeping spinlocks, priority inheritance). When RT is not enough: external MCU, heterogeneous SoC. | Lecture + cyclictest live demo |
| 2 (45 min) | RT control loop design: latency budget exercise. Students design a 500 Hz controller, allocate time budgets, choose PREEMPT_RT vs MCU. Test under stress-ng, report 99.9th percentile. |
Group design + live measurement |
Theory: Real-Time Systems Design
Theory 11
Build Your Own Linux — 4 GB image for 5 processes. Is that engineering?
| Block | Content | Format |
|---|---|---|
| 1 (45 min) | Why custom images: boot time, security, reproducibility. Buildroot pipeline. Buildroot vs Yocto comparison. | Lecture + Buildroot menuconfig demo |
| 2 (45 min) | Design exercise: door access control system. Teams list 3 packages for the image, 3 tools for development only, and one measurable success criterion. Present and critique. | Group design → peer review |
Theory: Why Build Your Own Linux?
Synthesis (Week 12)
Course Review — What did you actually learn?
| Block | Content | Format |
|---|---|---|
| 1 (45 min) | Key decisions and trade-offs: user-space vs kernel, fbdev vs DRM/KMS, stock vs custom image, standard vs RT kernel. Review measurement results across teams. | Interactive review |
| 2 (45 min) | Presentation prep: structure, what to show, how to present measurements. Practice in pairs with peer feedback. | Practice presentations |
Grading Suggestion
| Component | Weight | Details |
|---|---|---|
| Lab checkpoints (6) | 40% | Milestones at Labs 4, 6, 7, 9, 10, 11 with architecture and integration evidence |
| Lab journal | 20% | Brief notes per lab: what worked, what broke, which trade-off was chosen, why |
| Final demo | 25% | Live presentation + measurement report |
| Theory participation | 15% | Engagement in interactive exercises and trade-off discussions |
Adapting to Fewer Weeks
If holidays reduce available sessions below 12:
| Drop to | What to cut | Impact |
|---|---|---|
| 11 labs | Merge L10 + L11 (RT measurement + Buildroot in one session, skip DMA optimization) | Less time for custom images, but core RT measurements survive |
| 10 labs | Also skip L8 (boot timing — cover briefly in L11 Buildroot intro) | Lose boot analysis depth, gain a buffer week |
| 9 labs | Also condense L6 + L7 (SDL2 apps + integration in one session, skip camera) | Lose camera pipeline, but the driver→graphics arc remains |
Warning
Below 9 lab sessions, the project arc breaks down. Consider dropping the BUSE driver track entirely and focusing only on the IMU Level Display path.
Compressed Format (3 Sessions)
When the full 14-week semester is not available, the course can be delivered in 3 sessions of 4×45 minutes (12 blocks total). Each session mixes theory and lab so students apply concepts immediately.
Session 1 — "From User to System Engineer" (4×45 min)
| Block | Type | Content | Covers |
|---|---|---|---|
| 1 | Theory | What Is Embedded Linux — OS vs RTOS vs bare-metal, when to use Linux, the layered stack | T1 (condensed) |
| 2 | Theory | How Linux Works — processes, "everything is a file", permissions, systemd, kernel vs user space | T2 (condensed) |
| 3 | Lab | SSH + Explore — connect to Pi, htop, filesystem tour, write system-report script | L1 + L2 |
| 4 | Lab | I2C Sensor + OLED — enable I2C, read MCP9808, show temperature on OLED | L3 parts |
Session 2 — "Building the Platform" (4×45 min)
| Block | Type | Content | Covers |
|---|---|---|---|
| 1 | Theory | Boot Flow + Device Tree — boot stages, DTS overlays, driver matching, common failure modes | T4–5 + T6–7 (condensed) |
| 2 | Lab | Kernel Driver — MCP9808 I2C driver with device tree overlay, sysfs interface | L7 |
| 3 | Theory | Build Your Own Linux — why custom images, Buildroot pipeline, toolchain, Buildroot vs Yocto | T9 (condensed) |
| 4 | Lab | Buildroot — build minimal image, boot on Pi, compare boot time and image size vs stock | L9 |
Session 3 — "Real-Time, Reliability, Demo" (4×45 min)
| Block | Type | Content | Covers |
|---|---|---|---|
| 1 | Theory | Real-Time + Graphics — PREEMPT_RT, tearing, DRM/KMS, latency budgets, cyclictest | T8 + T11 (condensed) |
| 2 | Theory | Security + Reliability — overlayfs, watchdog, A/B updates, threat model basics | T10 + T12 (condensed) |
| 3 | Lab | Level Display — SDL2 + IMU visualization, cyclictest measurement under load | L10 (condensed) |
| 4 | Lab | Integration + Mini Demo — combine sensor + display + measurement, 5 min per student | L12 (condensed) |
Self-Study (Assign as Homework)
| Topic | Material | Why Skip in Class |
|---|---|---|
| Graphics stack details | Theory 3 slides + framebuffer tutorial | Students can read the three levels (fbdev/DRM/Wayland) at home; Session 3 covers the essential tearing/vsync part |
| Architecture + History | Theory 13 slides | Capstone review — valuable but not essential for compressed format |
| Bash scripting | bash-scripting.md tutorial |
Useful skill but supplementary — C system programming is the priority |
| Processes and IPC | processes-and-ipc.md tutorial |
Covered in Session 1 Lab block; self-study if class time is tight |
| Threads and Synchronization | threads-and-synchronization.md tutorial |
Covered in Session 1 Lab block; self-study if class time is tight |
| Data logger | data-logger-appliance.md tutorial |
Good practice but skippable in compressed format |
| ELF format | elf-and-program-execution.md |
Deep dive, better as optional reading |
Note
The compressed format sacrifices depth for coverage. Students who want to go further should work through the self-study materials and the full tutorial set at their own pace.
What Students Walk Away With
By Lab 12, every student has:
- Produced and defended architecture decisions at subsystem boundaries
- Implemented an end-to-end vertical slice from sensor to visible output
- Built a resilient data logger with overlayfs and systemd on stock Linux
- Created interactive display applications and a camera processing pipeline
- Written two kernel drivers (I2C + SPI) with device tree overlays
- Built a custom Linux image from source (Buildroot)
- Validated recovery behavior for selected failure scenarios
- Measured and compared standard vs RT kernel jitter with real data
- Built a tear-free real-time display application (SDL2 + DRM/KMS)
- Optimized a peripheral with DMA and measured the CPU impact
- Presented their system with quantitative evidence — not just "it works"