Mastering Embedded 'Systems programming' on ARM Cortex-M4

Description

Important Note: Please go through the 'Requirements' section before taking up this course.

Description

A deep dive into the ARM Cortex M4 architecture and Systems programming 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. 

I have kept the complete first chapter with preview enabled for you to learn some basic concepts of ARM Cortex-M4 microcontrollers

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 pointers

• Pointers for embedded systems. Though looking similar to their workstation counterparts, there are subtle differences which could mess up the application if not carefully handled

• In 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 unique challenges and consolidated information on these is 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 poses unique challenges.

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 challenges

• Approached 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. Once the files are 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 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 in C. The process of initialising the .data section in the RAM and setting up the .bss section and stack are demonstrated in exhaustive detail.   

• The Make process is explained using multiple Makefiles each with slightly increasing complexity in each, until the final 'cryptic' makefile is written and fully explained. The make 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 and preemption for both non-floating and floating point configuration. Concepts like lazy stacking are 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 such as the Voltage Controller Oscillator, Frequency Divider, Phase Frequency Detector, Low Pass Filter with illustrations, animations and timing diagrams. Demonstration of initialisation of registers in the clock tree subsystem on the debugger.

• I/O circuitry and then configuring the I/O pins. All pin modes explained like push-pull, open drain, analog and alternate functions. 

What You Will Learn!

• Understand the ARM Cortex-M4 Core on the STM32F411 Discovery Board. Datasheets and Reference Manuals walkthroughs
• Learn standalone use (no IDE involved) of the GNU ARM Embedded Toolchain
• Cube IDE (with Makefile Projects) and CUBE Programmer
• Basics of ARM GNU debugger (ARM GDB) commands with examples
• Embedded C for 32 bit controllers. Different methods for Register and Memory Access, Bitwise operations, Inline Assembly
• Learn how to use the CMSIS memory map header
• Deep dive into the Clock subsystem, learn about PLL operation, bare-metal configuration of clock tree and PLL, without using any configuration tool
• Understand the Interrupt mechanism in detail, through extensive demos. Understand Stack creation and Teardown, for both floating and non-floating point modes
• Interrupt preemption with examples run on the debugger
• Lots of supplementary information provided on topics like Lazy Stacking, double word padding, memory barrier instructions etc. with demos
• Learn how to set up the Exception Vector Table from the reference manual. Learn about the difference between exceptions and interrupts
• On startup, learn how to copy initialised variables from Flash to SRAM; set up stack and .bss memory areas, with examples, and live memory views while on debug
• Set up and configure the SysTick and EXTI interrupts
• Understand the ELF object file format. Look into object files to inspect the ELF format in detail, through objdump (for ARM) and readelf commands
• Deep dive into the Linker mechanism. Learn about Symbol Relocation and Resolution by investigating Symbol Tables, Relocation Tables and more
• Understand how Global Variables are handled by the compiler and Linker. Understand the properties of Linker Variables and how to use them
• VMA (Virtual Memory Address) and LMA (Load Memory Address). Understand how VMA and LMA are controlled through Linker Scripts
• Write Linker scripts for various memory configuration, deriving from the knowledge of the Linker mechanism
• Understand the Make mechanism through multiple examples with increasing complexity. Understand how Make dependency tree works
• Write moderately complex Makefiles
• Learn about the GPIO subsystem, circuitry of the I/O pins. Learn different pin modes like open drain, push pull, alternate functions and internal pull ups

Who Should Attend!

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

TAKE THIS COURSE