Embedded Bootloader Development from Ground Up™

Learn how a bootloader loads and initializes the main application, enables firmware updates over the air or via wired connections, and provides recovery and security benefits across two firmware slots.

Enable the Cortex-M4F floating point unit via the CPACR, granting full access to CP ten and CP eleven, and implement a reusable FPU driver for bare-metal projects.

Develop a UART driver by identifying USART peripherals, enabling APB1 clock access, configuring PA2 and PA3 as alternate function AF7 for USART2, and analyzing the documentation.

Develop a debug uart init that configures gpio pin for alternate function, enables uart clock, sets baud rate and transfer direction, and enables the module with a transmit function.

Configure uart init by enabling GPIO A clock, setting PA2 to alternate function mode AF7, enabling USART2 on APB1, computing baud rate 115200, and enabling transmitter.

Develop the uart write function to transmit a character by waiting for the txe flag in the status register, then writing to the data register and retarget printf.

Test the UART driver by initializing it, sending a hello from stm32, and viewing the serial output on a PC using real time at 115200 baud.

Develop a robust system timebase by configuring the Cortex-M4 systick timer on STM32, enabling precise delays and timing via the systick control and status register and clock source selection.

Define symbolic names for the systick control bits and implement time base init by loading a timer for one second at 16 mhz, clearing current value, enabling interrupt and systick.

Develop a system timebase by implementing a systick interrupt driven tick counter, a get_tick function, and a delay routine with atomic access and a tick frequency macro.

Develop and test the system timebase with a precise delay and time init, verifying a one-second interval output. Prepare modular drivers and a board support package for the nuclear board.

Create a STM32F4 nuclear board BSP by implementing GPIO drivers for PA5 led and PC13 button, including led init, led on, led off, and get_btn_state.

Enable gpio clocks in ahb1enr for gpio a and c, configure pa5 as output, and drive it high via odr; set up for button input in the next lesson.

Enable clock access to GPIO C and configure PC13 as input, then implement the push button driver to read the active-low pin and return one when pressed and zero otherwise.

Test and verify the board support package by initializing the LED and turning it on. Then read a push button state using the GPIO input/output drivers on the stm32 board.

Explain the embedded build process that converts high level source code into executable binary images, detailing preprocessing, compiling, assembling, linking, and locating for ELF and relocatable files.

Learn the five-stage embedded build process, from preprocessor directives and header inputs through compiler, assembler, and linker, to relocation and the final elf or bin executable.

Explore the STM32 memory model, including flash and SRAM, the linker script, and startup code, covering vector table, reset handler, and VMA versus LMA.

Explore how the linker script merges object files, resolves symbols, and maps sections like text and data to memory. Learn about relocation, vma, lma, and keep directives in linking.

Analyze a linker script and memory layout, showing code placement in flash, data in ram, and how boot pins alias memory to flash, ram, or system memory.

Set up a workspace and practice creating and placing sections in a linker script, including custom ram block and custom flash block, to manage memory in embedded bootloader projects.

Define a new custom memory inside the flash region, set its size, and place a custom section into that memory using the linker script.

Learn to store functions in a custom section using a section attribute and symbolic name, place code in flash or RAM, and verify with a LED toggle and millisecond delay.

Create a bootloader that manages multiple firmware in flash and branches to the application based on conditions, using a function pointer to jump to the default application after MSP initialization.

Learn to build a bootloader that jumps to a second application at a fixed flash address, relocate the vector table, and verify the application exists in memory.

Diagnose bootloader and application startup using the core stack, fix the vector table offset from 0x800 to 0x8, and explore a common memory area for shared functions.

Demonstrates creating a common APIs region in memory via the linker script, and exposing a function-pointer based interface for bootloader and user application integration.

Share common APIs between bootloader and application by placing functions in a shared memory region, accessed via function pointers, enabling unified time base and uart handling.

Develop a bootloader-driven system with multiple applications selectable via UART commands after reset, and enable UART receive in interrupt mode for firmware selection and flashing.

design a multi-slot bootloader system with memory demarcations for bootloader, default app, and factory app; initialize hardware, check a button, and use interrupt-driven messaging to select the appropriate application.

Develop a multi-slot bootloader system by implementing hardware initialization, button-based selection, a bootloader menu, and jump-to-application logic with address-based targets.

Define app addresses and create a uart-driven switch to select the factory or default bootloader app. Explore enum-based selection, debugging prints, and the next steps to implement applications.

Learn to implement a multi-slot bootloader system by configuring default, app one, and factory apps with vector table and linker script updates to steer execution.