Arm Cortex-M4 Bare-Metal Development With Stm32F411

Learn how to write Bare-metal code on the STM32F411 to bring up and configure the microcontroller for various tasks

What you'll learn

Understand the ARM Cortex-M4 Core on the STM32F411 Discovery Board, Datasheets and Reference Manuals

Learn Embedded C for 32 bit controllers. Different methods for Register and Memory Access, Bitwise operations, Inline Assembly

Learn the Interrupt Subsystem for both Non Floating and Floating Point modes. Set up the Exception Vector Table, Set up the Systick and EXTI interrupts

Learn ELF object file format, Linker Symbol Relocation and Resolution, Linker variables, VMA and LMA. Write Linker Script files.

Understand the Clock subsystem, learn about PLL operation, bare-metal configuration of clock tree and PLL without configuration tool

Learn about the I/O subsystem, circuitry of the I/O pins. Learn different pin modes like open drain, push pull, alternate functions and internal pull ups

Understand the startup process, setup the interrupt vector table.

Learn how to write the reset handler, set up the data, stack and .bss sections

Requirements

Basic microcontroller knowledge is necessary, at least knowledge of any 8 bit controller, better still if you are aware of a 16 bit architecture

Intermediate knowledge of C programming and basic pointer and data structure concepts are necessary. Knowledge of embedded C not necessary at all as necessary embedded C will be tackled in the course itself

Description

A deep dive into the ARM Cortex M4 architecture with the STM32F411 Discovery board with the GNU ARM Cross Toolchain. Understanding the programmers model, IDE (Integrated Development Environment). Detailed discussions, In depth  study of Datasheets and Reference Manuals, Demos and Case Studies on Memory access and its pitfalls (Different methods like Macros with offsets and Structures), Compilation and Linking process, Input/Output Subsystem, Interrupts (Both non-floating and floating point) and Clock Tree Configuration with in depth discussion on PLL circuitry and operation. Slideshows, Code Walkthroughs, Whiteboard and Debug Sessions are an integral part of the course.  There are certain topics in Embedded Systems especially for advanced microcontrollers which pose unique challenges The process of manipulating the memory directly on a microcontroller either through macros or through structure pointersPointers for embedded systems. Though looking similar to their workstation counterparts, there are subtle differences which could mess up the application if not carefully handledIn embedded firmware development since application efficiency, determinism, power efficiency, memory size, writing efficient C programs and keeping track of the assembly code compiled from C/C++ are of paramount importance.The Interrupt Handling Process is complicated and the stack frames created, vary between implementations like Floating point and Non Floating point Stacking and Unstacking. Interrupt preemption is a complicated feature and needs to be handled with care. The process of Linking and Make is grossly misunderstood as well. The topics of object files, relocation, symbol resolution pose an unique challenge and consolidated information on these in one place in a book of on the internet are scarce. Object File Formats are a grey area as well which causes much distress when the process of linking is to be understood. The different tables in the object file like the Symbol Table, Relocation Table are difficult to comprehend without proper guidance. Input/Output pin configuration also pose challenges if the electricals and circuitry of the pins are not understood well. There are multiple configuration in which each pin of a microcontroller can operate like open drain, push-pull, high impedance etc. The Clock Tree for a high end microcontroller is quite complex as well. Multiple clock sources feeding clocks to different subsystems make the initial learning curve quite steep. Over and above that the high frequency clocks are driven by PLLs which are complex circuits themselves and need a good deal of understanding when configuring them. The processor startup could be tricky especially the part where the memory is set up after every reset. The understanding of .text, .data, .bss sections and setting them up properly during boot up is tricky.In this course I strive to address all of the challenges above with theory, diagrams, animation and code. There are plenty of demos to explain difficult to understand concepts. I have cleared all concepts through extensive debugging sessions on the IDE while inspecting the different subsystems of the controller in real time. I have taken the following steps to address the challengesApproached memory access and operations in different ways like Macros and Structures. I have built up the concepts gradually until I arrived at the final form of the expressions. I have shown examples of misaligned accessing of memory through structures and their mitigation. Bitwise operations have been dealt with in real time on the debugger.For understanding the Linking process, I created code examples and first manually compile each source file and look into the ELF object files, the symbol tables and relocation tables along with the disassembly is explained. Once the files were compiled into a single object file by the linker, the symbol resolution and code and symbol relocation are clearly explained by looking into the final object file. The linker script file is explained in detail with diagrams of before and after initialisation diagrams of memory.An extensive debug session of the startup process explaining how the processor sets up memory, in real time. The reset handler is explained and demonstrated. The process of initialising the .data section in the RAM and setting up the .bss section and stack is demonstrated.    The Make process is explained using multiple makefiles each with slightly increasing complexity in each until the final 'cryptic' makefile is written and fully understood. The dependency graph is explained and many possible error scenarios are discussed on make so as to explain how make tackles Makefiles. It's a decently exhaustive treatment of Make which will facilitate developers to write makefles for deeply embedded systems. Interrupt Handling is demonstrated in detail along with theory. Demonstration and Theory of Interrupt Handling, preemption for both non-floating and floating point configuration. Concepts like lazy stacking explained explained and demonstrated on the debugger. The Clock Tree is explained in detail. PLL calculations for setting frequency. Theory of PLL operation with explanation of different PLL sub systems with illustrations and timing diagrams. Demonstration of initialisation of all registers in the clock tree subsystem on the debugger along with explanation. I/O circuitry and then configuring the I/O pins. All pin modes explained like push-pull, open drain, analog and alternate functions. 

Overview

Section 1: CortexM4_Basics

Lecture 1 A few words on embedded systems and ARM Cortex M4 introduction

Lecture 2 Cortex-M4 Features

Lecture 3 Processor Architecture, Bus Matrix and Memory Map

Lecture 4 STM32F411xC/xE Datasheet Walkthrough, Cortex-M4 Registers and Memory Map

Lecture 5 Program Execution and Pipeline Details

Lecture 6 STM32F411 Discovery Board Datasheet Walkthrough

Lecture 7 Toolchain installation on Windows

Lecture 8 Toolchain installation on Linux

Lecture 9 Connect the Discovery board for the first time

Lecture 10 Getting started with the STM32 CUBEIDE for the first time

Lecture 11 Embedded C Code for Download

Lecture 12 Embedded C, Part 1 - Address Pointer Basics and Memory Access Macros

Lecture 13 Embedded C, Part 2 - Demo on Address Pointers with Macros

Lecture 14 Embedded C, Part 3 - Accessing Memory through structures and Demo

Lecture 15 Embedded C, Part 4 - Bitwise Operators and Pointer Arithmetic

Lecture 16 Embedded C, Part 5 - Demo on Bitwise Operators and Pointer Arithmetic

Lecture 17 Embedded C, Part 6 - Inline Assembly

Lecture 18 Embedded C, Part 7 - Demo on Inline Assembly

Lecture 19 Embedded C, Part 8 - Header file creation heuristics and CMSIS memory map header

Section 2: Linker and Make Mechanism

Lecture 20 Necessary code for Linker and Make

Lecture 21 Introduction to Linker and Make

Lecture 22 ELF file format

Lecture 23 ELF Object Code

Lecture 24 Linker Relocation

Lecture 25 Symbol Table and Symbol and Segment Relocation

Lecture 26 Linker Control Scripts, VMA and LMA

Lecture 27 Make Basics and Makefiles

Lecture 28 Putting it all together

Lecture 29 Demo on Make

Lecture 30 Startup and Reset handler on the STM32F11

Lecture 31 Cortex-M4 Startup Demo on the STM32F11

Section 3: General-purpose I/Os (GPIO)

Lecture 32 Necessary Code for GPIO

Lecture 33 I/O Circuitry and Electricals

Lecture 34 I/O Pin Configuration and Registers Overview

Lecture 35 I/O Pin Configuration Demo

Section 4: Interrupt and Exception Handling on Cortex-M4

Lecture 36 Necessary Code on Exception Handling

Lecture 37 Exception Handling Basics

Lecture 38 Basics of Interrupt Behaviour and Introduction to Exception Vector Table

Lecture 39 The SCB Exception Control and NVIC Registers Walkthrough

Lecture 40 Interrupt Priority Management

Lecture 41 Advanced Interrupt Behaviour

Lecture 42 Interrupt Entry and Exit Sequence

Lecture 43 Systick Interrupt Theory

Lecture 44 SysTick Demo Part 1

Lecture 45 Systick Demo Part 2

Lecture 46 Interrupt stacking for Non-Floating point mode

Lecture 47 Demo on Interrupt Unstacking

Lecture 48 Demo on Stacking for Floating Point Enabled Mode

Lecture 49 External Interrupts Theory

Lecture 50 Demo on External Interrupts Part 1

Lecture 51 Demo on External Interrupts Part 2

Lecture 52 Demo on Interrupt Preemption

Lecture 53 Reset Handler Theory

Section 5: STM32F411 Clock Tree Configuration and PLL setting

Lecture 54 Necessary Code on Clock Tree Configuration

Lecture 55 Introduction to the Clock Tree, PLL Basics and Register Walkthrough

Lecture 56 PLL Internal Circuitry and Operation

Lecture 57 Clock Tree Walkthrough and PLL Configuration

Lecture 58 Demo on Clock Tree Configuration and PLL Configuration

Computer Science, Electrical and Electronics Undergraduates and Fresh Graduates looking for a career in Embedded Systems,Working professionals looking to upgrade to a ARM Cortex-M4 STM32F4 controller from 8 bit or 16 bit counterparts,Hobbyists and Enthusiasts interested in Bare-metal programming on the STM32F4 Microcontroller