Embedded C Programming with Arm Cortex-M Video Course

I believe that the Arm Community could be interested in the "Embedded C Programming Course with Arm Cortex-M" video course, which I've been teaching for over a year on YouTube. The playlist for this course is available below.

Embedded Systems Programming Playlist on YouTube

Embedded Systems Programming Course on YouTube

The course starts from the beginning and is structured as a series of short, focused, hands-on lessons that teach you how to program Arm Cortex-M microcontrollers in C.

My goal is not just to teach C–other courses do it already quite well. But there are virtually no courses that would step down to the machine level and show you exactly what happens inside the Arm processor. This deeper understanding will allow you to use both the Arm processor and the C language more efficiently and with greater confidence. You will gain understanding not just what for your program does, but also how the C statements translate to machine instructions and how fast the processor can execute them.

What I believe is special about this "Modern Embedded Programming" course is that it shows exactly what happens inside an Arm Cortex-M microcontroller. Specifically, I use the IDE and the various views in the debugger, such as disassembly, registers, memory, variables, call stack, etc. to explain exactly what's happening and also what can go wrong. For example, in the lesson about functions and the stack, I show an example of a stack overflow. (Have you ever seen how an Arm CPU "executes" it's own interrupt table?) In the lesson about stdint.h and mixing integers in expressions I show examples of non-portable code and how it changes behavior between 32-Arm and 16-bit MSP430. In the last lesson about structures I show how Cortex-M3/M4 can handle misaligned data while Cortex-M0 can't, and so on.

Here is the list of the lessons released so far:

  • Lesson 0 ( 9:17): Getting Started  
  • Lesson 1 (17:06): Counting
  • Lesson 2 (11:00): Flow of Control
  • Lesson 3 (12:23): Variables and Pointers
  • Lesson 4 (16:45): Blinking the LED
  • Lesson 5 (14:30): Preprocessor and volatile
  • Lesson 6 (17:06): Bit-wise operators in C
  • Lesson 7 (15:22): Arrays and Pointer Arithmetic
  • Lesson 8 (17:06): Functions and the Stack
  • Lesson 9 (19:08): Modules, Recursion, AAPCS
  • Lesson 10 (27:42): Stack Overflow and Other Pitfalls of Functions
  • Lesson 11 (28:34): <stdint.h>, Endianness, Mixing Types in Expressions
  • Lesson 12 (32:11): Structures and CMSIS

I’d love to hear your comments about the course. Is there anything that you would like to see in the upcoming lessons? Do you see anything that you would teach differently? Or perhaps you have ideas for teaching specific subjects? Please share…

Watch more lessons

Anonymous
  • Thanks for providing these valuable resources. These videos are very helpful.

  • Since the last post the following two lessons have been added to the course:

    In Lesson 15 "Startup Code Part-3" you initialize the custom vector table. You also develop fault-handler code and test it. Finally, you add all interrupt handlers and learn how to alias them such that you can override only the ones that you actually use.

    In Lesson 0x10 "Interrupts Part-1" you get a gentle introduction to the subject of interrupts. In this lesson you will learn what interrupts are, and how they work.

    In Lesson 17 "Interrupts Part-2" you delve deeper into interrupts. You will see how interrupts work in the MSP430 processor, which will help you to understand how Arm Cortex-M differs from other processors. Specifically, you will see exactly how an interrupt service routine is entered and how it returns.

  • I'm glad to hear that you find the Video Course informative.

    I am going to add new lessons, although I have to admit that I have underestimated the time required to produce such videos.

    On the other hand, only now the course is getting really interesting, because we are finally ready to tackle subjects like: interrupts, race conditions, context switch, and RTOS. So stay tuned!


    --Miro

  • Hi Dr. Miro Samek,

    I am learning very well from your embedded course. It would be helpful to me and others also if you could please add course for Interrupts and pointers to function in details. After the course 15 it has been almost 3 months but no new course been published. Since waiting too long astray from learning path. So please publish new lesson at your earliest. Thanks

    Abdul Sattar

    KHU South Korea

  • Since the last post the following two lessons have been added to the course:

    In Lesson 13 you will learn about the standard startup code that gets linked with your application from the IAR library. You will see how the startup code initializes the various data sections and you will see these sections in the linker map file. Finally, you'll go back all the way to the beginning of the reset sequence, where you will encounter the vector table.

    In Lesson 14 you will learn how to replace the default vector table from the IAR library with your own. To achieve this, you first need to understand the embedded software build process. You will look inside the object files (ELF format) to see what "relocatable code" really means. You will also see how the linker resolves the cross-module references and how the rules are different for objects included directly and object libraries.