Getting Started with BSP (Board Support Package) and Embedded C

Lesson 1 • First Bare-Metal Program

Writes and flashes a minimal C program without an OS or library. Demonstrates the complete build-flash-debug cycle on real hardware.

Lesson 2 • Reading Hardware Documentation

Teaches systematic navigation of datasheets and reference manuals. Directly supports register-level programming in later chapters.

Lesson 3 • Toolchain and Development Environment Setup

Installs and configures a cross-compiler, debugger, and build system. Students produce a working build environment before writing any code.

Lesson 4 • What a BSP Is and Does

Defines BSP scope: startup code, drivers, and HAL layers. Connects BSP responsibilities to hardware bring-up tasks.

Lesson 1 • Fixed-Width Types and Data Representation

Introduces stdint.h types and their hardware significance. Prevents size-assumption bugs that cause silent failures on target hardware.

Lesson 2 • Pointers and Memory Access Patterns

Covers pointer arithmetic, function pointers, and memory-mapped I/O access. Directly enables register manipulation in subsequent chapters.

Lesson 3 • Preprocessor and Compiler Directives

Covers macros, conditional compilation, and compiler attributes. Enables portable, hardware-specific code selection across BSP targets.

Lesson 4 • Bit Manipulation Techniques

Teaches masking, setting, clearing, and toggling individual bits. These operations are the primary mechanism for configuring hardware registers.

Lesson 1 • Linker Script Syntax and Sections

Explains MEMORY, SECTIONS, and symbol definitions in GNU LD scripts. Students place .text, .data, and .bss in correct regions.

Lesson 2 • Stack and Heap Configuration

Configures stack size, heap boundaries, and overflow detection. Prevents the most common runtime memory failures in embedded systems.

Lesson 3 • Microcontroller Memory Map

Maps Flash, SRAM, and peripheral regions to physical addresses. Provides the spatial model required for linker script authoring.

Lesson 4 • Startup Code and C Runtime Init

Implements the startup sequence that copies .data and zeros .bss before main. Connects linker symbols to startup assembly and C code.

Lesson 1 • Debouncing and Edge Detection

Implements software debouncing and configures edge-triggered interrupts. Produces reliable button-press detection as a practical exercise.

Lesson 2 • GPIO Register Architecture

Covers direction, output, input, and alternate-function registers. Establishes the register-level model applied to all peripheral drivers.

Lesson 3 • Clock Enabling and Peripheral Reset

Explains why peripherals must be clock-enabled before register access. Prevents the silent lockup caused by accessing ungated peripherals.

Lesson 4 • Writing Interrupt Service Routines

Implements ISRs with correct naming, minimal latency, and safe flag clearing. Introduces shared-data hazards between ISR and main context.

Lesson 1 • Timer Hardware Architecture

Explains prescaler, auto-reload register, and counter modes. Provides the conceptual model for all timer-based features.

Lesson 2 • Input Capture and Frequency Measurement

Uses input capture to measure pulse width and signal frequency. Demonstrates bidirectional use of the same timer peripheral.

Lesson 3 • PWM Signal Generation

Configures output compare channels for PWM with adjustable duty cycle. Enables motor control and LED dimming as practical applications.

Lesson 4 • Watchdog Timers and System Safety

Configures independent and windowed watchdog timers for fault recovery. Introduces the concept of system liveness monitoring in BSP design.

Lesson 1 • UART Driver Implementation

Configures baud rate, frame format, and transmit/receive registers. Builds a polled UART driver as the baseline for interrupt-driven upgrades.

Lesson 2 • SPI Driver Implementation

Configures SPI clock polarity, phase, and chip-select control. Implements full-duplex transfers to an external sensor or memory device.

Lesson 3 • Interrupt-Driven UART with Ring Buffers

Upgrades the polled driver to use TX/RX interrupts and circular buffers. Eliminates CPU blocking during serial transfers.

Lesson 4 • I2C Driver Implementation

Implements I2C start, address, data, and stop sequences at the register level. Handles ACK/NACK and bus arbitration errors correctly.

Lesson 1 • BSP Layering and API Design

Defines the HAL, driver, and application layers with clear interface contracts. Enables driver reuse across hardware variants without modifying application code.

Lesson 2 • Driver Initialization and Lifecycle

Implements init, deinit, and power-state transitions for each driver. Ensures deterministic startup and clean shutdown in the BSP.

Lesson 3 • Configuration and Board Header Files

Centralizes pin assignments, clock frequencies, and feature flags in board headers. Isolates hardware differences to a single file per target board.

Lesson 4 • Porting the BSP to a New Target

Walks through the steps to port an existing BSP to a different microcontroller. Validates the abstraction design by exercising hardware-specific seams.

Lesson 1 • Continuous Integration for Firmware

Automates build, static analysis, and unit tests in a CI pipeline. Ensures BSP quality gates run on every code change without manual effort.

Lesson 2 • Fault Handling and Error Recovery

Implements hard fault handlers that capture stack frames and fault status. Enables post-mortem analysis of crashes in deployed firmware.

Lesson 3 • Unit Testing Embedded C Code

Applies host-based unit testing frameworks to BSP driver logic. Separates hardware-dependent code from testable pure logic.

Lesson 4 • JTAG and SWD Debugging Techniques

Uses a hardware debugger to set breakpoints, inspect registers, and step through ISRs. Builds confidence in live hardware debugging workflows.