Embedded Systems Course

Lesson 1 • Development Toolchain Overview

Introduces cross-compilers, linkers, debuggers, and flash programmers. Learners configure a basic toolchain to build and run their first program.

Lesson 2 • Core Hardware Components

Surveys microcontrollers, processors, memory types, and peripherals. Provides the hardware vocabulary needed for all subsequent chapters.

Lesson 3 • Embedded System Constraints and Trade-offs

Analyses power, memory, latency, and cost constraints that shape design decisions. Frames the engineering trade-offs revisited throughout the course.

Lesson 4 • Defining Embedded Systems

Contrasts embedded systems with desktop computing using real-world examples. Anchors the chapter by establishing scope and design philosophy.

Lesson 1 • State Machines and Control Flow

Implements finite state machines using enums and switch statements for event-driven firmware. Provides a scalable alternative to nested conditionals.

Lesson 2 • Volatile, Const, and Restrict Qualifiers

Explains compiler optimisation interactions with hardware-mapped variables. Learners apply qualifiers correctly to prevent subtle concurrency and optimisation bugs.

Lesson 3 • Pointers and Memory Management

Covers pointer arithmetic, function pointers, and static memory allocation strategies. Avoids dynamic allocation pitfalls in safety-critical firmware.

Lesson 4 • Fixed-Width Types and Bit Manipulation

Uses stdint.h types and bitwise operators to write portable register-level code. Eliminates type-size ambiguity common in embedded bugs.

Lesson 1 • Interrupts and Exception Handling

Covers interrupt vectors, priority levels, and ISR design rules. Learners replace polling loops with interrupt-driven I/O for efficiency.

Lesson 2 • CPU Architecture Essentials

Covers pipeline stages, instruction sets, and register files of common embedded cores. Connects architecture knowledge to writing efficient low-level code.

Lesson 3 • Memory Architecture and Mapping

Explains memory-mapped I/O, address spaces, and stack vs. heap allocation. Prepares learners to read datasheets and write correct peripheral access code.

Lesson 4 • Analog Interfaces: ADC and DAC

Explains ADC sampling, resolution, reference voltages, and DAC output. Learners read sensor voltages and generate analogue signals under software control.

Lesson 5 • GPIO and Digital I/O Control

Teaches register-level GPIO configuration for input, output, and alternate functions. Learners implement LED control and button debouncing exercises.

Lesson 1 • UART Serial Communication

Configures baud rate, framing, and flow control for UART links. Learners implement a command-line interface over a serial terminal.

Lesson 2 • Protocol Selection and Debugging

Guides protocol choice based on speed, distance, node count, and cost. Learners use logic analysers and oscilloscopes to decode and debug bus traffic.

Lesson 3 • CAN Bus Fundamentals

Introduces CAN frame structure, arbitration, error detection, and bus circuit topology. Prepares learners for automotive and industrial protocol work.

Lesson 4 • I2C Bus Protocol

Explains I2C addressing, ACK/NACK, clock stretching, and multi-master arbitration. Learners read sensor data from I2C devices using register maps.

Lesson 1 • Task Creation and Management

Creates, suspends, resumes, and deletes tasks using RTOS APIs. Learners build a multi-task application with independent sensor and display tasks.

Lesson 2 • RTOS Concepts and Scheduling

Defines tasks, schedulers, preemption, and context switching. Contrasts RTOS-based design with bare-metal super-loop approaches.

Lesson 3 • RTOS Timers and Power Management

Configures software timers and tickless idle modes to reduce power consumption. Integrates RTOS timing with hardware low-power states.

Lesson 4 • Inter-Task Communication

Uses queues, mailboxes, and event flags to pass data between tasks safely. Eliminates global variable sharing that causes race conditions.

Lesson 1 • Peripheral Power Optimisation

Enables and disables peripherals on demand to eliminate idle current. Applies duty-cycling to sensors, radios, and displays.

Lesson 2 • Sleep and Low-Power Modes

Configures sleep, deep sleep, and standby modes with appropriate wake-up sources. Learners measure power savings at each mode transition.

Lesson 3 • Clock and Voltage Scaling

Reduces active power by lowering CPU frequency and supply voltage dynamically. Learners implement DVFS policies tied to workload demand.

Lesson 4 • Power Consumption Fundamentals

Breaks down dynamic, static, and peripheral power components. Establishes a measurement baseline before optimisation begins.

Lesson 1 • Embedded Threat Landscape

Catalogues physical, firmware, and network attack vectors targeting embedded devices. Motivates security investment with real-world breach case studies.

Lesson 2 • Secure Communication Channels

Configures TLS and DTLS on embedded stacks for authenticated, encrypted links. Manages certificates and session keys within memory constraints.

Lesson 3 • Secure Boot and Firmware Integrity

Implements a chain of trust from ROM bootloader through application firmware. Learners sign firmware images and verify signatures at boot time.

Lesson 4 • Secure Firmware Update (OTA)

Designs a fail-safe over-the-air update pipeline with rollback protection. Learners implement a dual-bank flash update scheme with signature checks.

Lesson 1 • Debugging Techniques and Tools

Uses JTAG/SWD debuggers, trace buffers, and printf-style logging to isolate faults. Builds systematic fault-finding skills applicable to any embedded platform.

Lesson 2 • Deployment and Field Update Strategies

Plans production flashing, field diagnostics, and OTA update rollout for deployed devices. Addresses fleet management and version tracking at scale.

Lesson 3 • Static Analysis and Code Quality

Runs static analysers and enforces coding standards to prevent defects before runtime. Integrates quality gates into the build pipeline.

Lesson 4 • Hardware-in-the-Loop Testing

Connects real hardware to automated test scripts to validate timing and peripheral behaviour. Catches integration bugs that unit tests cannot detect.