Embedded Software Course

Lesson 1 • Embedded Software Characteristics

Identifies properties unique to embedded software: determinism, bare-metal execution, and tight coupling to hardware. Frames constraints that shape all later design choices.

Lesson 2 • Core Hardware Components

Surveys microcontrollers, processors, memory types, and peripherals. Connects hardware capabilities to software design decisions.

Lesson 3 • Development Toolchain Overview

Introduces cross-compilers, linkers, debuggers, and flash programmers. Students understand how source code becomes executable firmware on a target device.

Lesson 4 • Setting Up a Development Environment

Guides students through installing and configuring a complete toolchain and IDE. Produces a working build-and-flash workflow before writing application code.

Lesson 1 • Pointers and Memory Access

Explains pointer arithmetic, volatile qualifiers, and memory-mapped register access. Directly enables hardware register manipulation covered in later chapters.

Lesson 2 • Embedded C Coding Standards

Introduces industry coding guidelines for safety-critical firmware, including naming conventions and restricted language features. Prepares students for professional code reviews.

Lesson 3 • Data Types and Memory Layout

Covers fixed-width integer types, struct packing, and alignment rules. Ensures students control memory layout precisely on any target architecture.

Lesson 4 • Preprocessor and Compiler Directives

Covers macros, conditional compilation, and inline functions for portable firmware. Students learn to write hardware-abstraction headers used across projects.

Lesson 1 • UART Serial Communication

Covers baud rate calculation, frame format, and transmit/receive register access. Students implement a polling-based UART driver used for debugging throughout the course.

Lesson 2 • ADC and DAC Fundamentals

Explains analog-to-digital conversion resolution, sampling rate, and reference voltage selection. Students read sensor data and understand signal conditioning requirements.

Lesson 3 • Timers and PWM Generation

Configures hardware timers for periodic events, input capture, and PWM output. Timer knowledge is prerequisite for real-time scheduling and motor control topics.

Lesson 4 • GPIO Configuration and Control

Explains input/output modes, pull resistors, and drive strength settings. GPIO is the simplest peripheral and anchors all subsequent driver development.

Lesson 1 • Writing Interrupt Service Routines

Covers ISR naming conventions, minimal execution time, and flag clearing sequences. Students write GPIO and timer ISRs that integrate with the drivers from Chapter 3.

Lesson 2 • Interrupt-Driven UART Driver

Refactors the polling UART driver from Chapter 3 into a fully interrupt-driven design. Demonstrates measurable CPU utilization improvement through a practical exercise.

Lesson 3 • DMA-Assisted Data Transfers

Introduces direct memory access controllers to offload bulk transfers from the CPU. Students configure DMA for UART and ADC, reducing interrupt overhead significantly.

Lesson 4 • Sharing Data Between ISRs and Tasks

Addresses volatile variables, atomic access, and ring buffers for ISR-to-main communication. Prevents data corruption bugs common in interrupt-driven designs.

Lesson 1 • Static vs. Dynamic Allocation

Compares static allocation with malloc/free, highlighting fragmentation and non-determinism risks. Guides students toward allocation strategies appropriate for safety-critical firmware.

Lesson 2 • Reducing Code and Data Footprint

Applies compiler flags, link-time optimization, and data compression to shrink firmware size. Essential for devices with limited flash capacity.

Lesson 3 • Embedded Memory Architecture

Maps flash, SRAM, stack, heap, and linker sections to physical memory regions. Provides the mental model needed to interpret linker scripts and map files.

Lesson 4 • Memory Protection Units

Configures MPU regions to enforce access permissions and catch null pointer dereferences at runtime. Adds a hardware safety net to firmware running without an OS.

Lesson 1 • RTOS Concepts and Kernel Services

Introduces tasks, scheduler types, context switching, and kernel objects. Establishes the RTOS vocabulary and mental model before any API usage.

Lesson 2 • Timers, Idle Hook, and Power Management

Uses software timers and the idle hook to implement periodic actions and low-power sleep modes. Connects RTOS scheduling to system power consumption goals.

Lesson 3 • Inter-Task Communication with Queues

Implements message queues for passing data between tasks and ISRs safely. Replaces the ring buffer patterns from Chapter 4 with RTOS-managed queues.

Lesson 4 • Deadline Analysis and Schedulability

Applies rate-monotonic analysis and worst-case execution time estimation to verify that all tasks meet their deadlines. Provides a formal method for validating RTOS designs.

Lesson 5 • Task Creation and Management

Covers task creation, priority assignment, stack sizing, and deletion. Students convert the bare-metal firmware from earlier chapters into a multitask application.

Lesson 1 • Ethernet and TCP/IP on Microcontrollers

Configures an Ethernet MAC/PHY and integrates a lightweight TCP/IP stack. Students implement a simple HTTP server to demonstrate networked embedded devices.

Lesson 2 • Modbus Protocol Implementation

Explains Modbus RTU framing, function codes, and register mapping over UART. Students build a slave device that responds to master read and write requests.

Lesson 3 • Wireless Protocols Overview

Surveys Bluetooth Low Energy, Wi-Fi, and sub-GHz radio options for embedded connectivity. Students evaluate protocol trade-offs for power, range, and data rate requirements.

Lesson 4 • USB Device Fundamentals

Introduces USB enumeration, descriptors, and CDC class for virtual serial communication. Students configure a USB CDC device using a middleware stack.

Lesson 1 • Integration and System-Level Testing

Designs integration tests that verify peripheral drivers, protocol stacks, and RTOS tasks together. Validates the complete firmware image against system requirements.

Lesson 2 • Instrumentation and Tracing

Applies printf logging, SWO trace, and logic analyzers to observe runtime behavior non-intrusively. Complements breakpoint debugging for timing-sensitive issues.

Lesson 3 • Static Analysis and Linting

Runs static analysis tools to detect undefined behavior, unreachable code, and MISRA violations automatically. Integrates analysis into the build pipeline for continuous feedback.

Lesson 4 • Hardware Debugging Techniques

Uses JTAG/SWD debuggers, breakpoints, watchpoints, and register inspection to diagnose firmware faults. Builds essential skills for all subsequent debugging tasks.