Embedded Systems Course

Lesson 1 • What Is an Embedded System

Defines embedded systems by contrasting them with general-purpose computers. Anchors the chapter by establishing the design constraints that drive all subsequent topics.

Lesson 2 • Development Toolchain Overview

Covers compilers, linkers, debuggers, and IDEs used in embedded development. Prepares students to set up a working environment before writing code.

Lesson 3 • Embedded System Design Process

Outlines requirements analysis, architecture selection, and iterative prototyping. Frames the engineering workflow students will follow throughout the course.

Lesson 4 • Core Hardware Components

Surveys microcontrollers, processors, memory types, and peripherals. Provides the hardware vocabulary needed to understand software-hardware interaction.

Lesson 1 • CPU Core and Instruction Set

Examines pipeline stages, registers, and assembly instruction categories. Grounds students in how the CPU executes code before moving to C-level programming.

Lesson 2 • Interrupt System and NVIC

Explains interrupt vectors, priority levels, and the nested vector interrupt controller. Students implement interrupt-driven I/O to replace inefficient polling loops.

Lesson 3 • GPIO and Digital I/O Control

Teaches pin configuration, direction registers, and output drive modes. Students write their first register-level code to toggle LEDs and read buttons.

Lesson 4 • Timers and PWM Generation

Covers timer counter modes, prescalers, and pulse-width modulation output. Students generate precise timing signals and variable-duty-cycle waveforms.

Lesson 1 • State Machines in Firmware

Models system behaviour as finite state machines implemented in C. Students structure complex control logic for readability and testability.

Lesson 2 • Code Optimization Strategies

Addresses compiler optimization flags, inlining, and loop unrolling. Students balance execution speed against code size for constrained targets.

Lesson 3 • Data Types and Memory Efficiency

Covers fixed-width integer types, struct packing, and alignment rules. Students choose data types that minimise RAM and flash consumption.

Lesson 4 • Pointers and Memory Management

Teaches pointer arithmetic, function pointers, and static memory allocation. Students avoid dynamic allocation pitfalls common in embedded contexts.

Lesson 1 • UART and Serial Communication

Covers baud rate, framing, and flow control for asynchronous serial links. Students implement UART drivers and use serial output for debugging.

Lesson 2 • I2C Protocol and Bus Management

Details start/stop conditions, addressing, and clock stretching. Students handle multi-master arbitration and diagnose common bus faults.

Lesson 3 • SPI Protocol and Driver Design

Explains clock polarity, phase modes, and chip-select management. Students write a full-duplex SPI driver and interface a sensor or display.

Lesson 4 • USB and Higher-Level Protocols

Surveys USB device classes, descriptors, and enumeration. Students integrate a USB stack to expose a virtual COM port or HID device.

Lesson 1 • RTOS Fundamentals and Scheduling

Defines tasks, schedulers, and preemption in a real-time context. Students compare scheduling algorithms and predict worst-case response times.

Lesson 2 • Timing Services and Soft Timers

Explains tick resolution, software timers, and deadline management. Students implement periodic and one-shot timers without blocking tasks.

Lesson 3 • Memory Management in an RTOS

Addresses stack sizing, heap allocators, and memory protection units. Students configure per-task stacks and detect overflow at runtime.

Lesson 4 • Task Synchronisation Primitives

Covers semaphores, mutexes, and event flags for safe inter-task coordination. Students eliminate race conditions in shared-resource scenarios.

Lesson 1 • ADC Configuration and Sampling

Covers resolution, reference voltage, sampling rate, and trigger modes. Students configure an ADC to acquire sensor data with minimal noise.

Lesson 2 • Signal Conditioning and Filtering

Introduces anti-aliasing filters, amplification, and impedance matching. Students design front-end circuits that prepare signals for accurate digitisation.

Lesson 3 • Sensor Fusion Fundamentals

Combines data from multiple sensors using complementary and Kalman filters. Students produce stable orientation or position estimates from noisy inputs.

Lesson 4 • Digital Filtering Techniques

Implements moving average, IIR, and FIR filters in fixed-point arithmetic. Students reduce noise in sampled data without floating-point overhead.

Lesson 1 • Power Consumption Analysis

Measures dynamic and static current draw across operating modes. Students build a power budget that guides hardware and firmware design decisions.

Lesson 2 • Low-Power Firmware Patterns

Applies event-driven architecture and tickless idle to minimise active time. Students refactor polling-based code into interrupt-driven, sleep-friendly designs.

Lesson 3 • MCU Sleep Modes and Wake Sources

Details sleep, deep-sleep, and standby modes with their wake-up latencies. Students select the deepest safe sleep mode for each application scenario.

Lesson 4 • Clock Gating and Peripheral Shutdown

Teaches selective clock disabling and peripheral power-down sequences. Students reduce idle current by shutting down unused hardware blocks.

Lesson 1 • System-Level Validation and Regression

Designs integration tests, hardware-in-the-loop setups, and regression suites. Students confirm that the full system meets functional and timing requirements.

Lesson 2 • Unit Testing for Embedded Code

Introduces host-based unit testing frameworks and hardware abstraction for testability. Students write tests that run on a PC before deploying to target hardware.

Lesson 3 • Fault Analysis and Defensive Coding

Addresses hard faults, stack overflows, and watchdog timer recovery. Students add assertions and error handlers that make failures visible and recoverable.

Lesson 4 • Debugging Tools and Techniques

Covers JTAG, SWD, breakpoints, and watchpoints for live debugging. Students halt execution and inspect registers to diagnose firmware faults.