Mastering Embedded 'Systems programming' on ARM Cortex-M4

Important Note: Please go through the 'Requirements' section before taking up this course. This course is for professionals already working on Embedded Systems and for experienced hobbyists and enthusiasts only.

Description

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