An overview of what Embedded Systems is and what the basics one needs to know.

Dive into the details of what Firmware engineering means and what are the skills one should have.

Understand the meaning of what System is and what systems programming means in the context of Embedded systems software.

Reflecting on the early years, the personal background and the pressures that shaped the journey.

The internship journey at Intel - from the interview to working on real projects.

Other interview adventures and opportunities explored along the way.

A quick hands on tour of the C language and a demo to experience it's raw power.

How to think like a computer scientist when working in the C language.

Introduction to the RISC-V ISA and how the text gets converted to 0s and 1s.

How to write assembly programs using the RISC-V RV32I instructions.

Explore the C Keywords to understand the scope and powers of the language.

Exploring the branching instructions the C language provides by means of hands on experiments.

How to save data and group instructions together.

Using the concepts learned in the previous sections to implement an interactive program.

Understanding strings, arrays, pointers, and the relation/differences between them.

Project based on the concepts learned in the previous sections. Implement a program to generate digital audion.

Exploring ways in which we can define data types that C doesn't already provide.

Using the concepts from previous sections to implement a sensor management system.

Exploring and understanding the operators available in the C language and how to use them.

Understand and learn how to use the Bitwise operations for bit manipulation. More importantly, discover the insights and reasons to use such manipulations.

You’ll trade confusion for clarity in under an hour. Instead of dry definitions, you’ll lock in a single, vivid mental image that turns every pointer into something you can literally see on a whiteboard or sketch on a napkin. You’ll discover what a pointer truly is (spoiler: it’s not just “a variable holding an address”), why the Linux kernel, FreeRTOS, Zephyr, and every serious RTOS lean on them like oxygen, and the three everyday firmware disasters that disappear once pointers click. By the end, you’ll explain pointers to a five-year-old!

You’ll fire up a real dev environment in five minutes and start writing pointer code that compiles and runs on your laptop. You’ll declare your first pointer, watch the & operator spit out raw memory addresses, and use * to reach inside that address like a surgeon. By the time you finish, the difference between a pointer variable and the memory it guards will feel as natural as breathing, and you’ll never again mix up “value” versus “address” in your sleep. No slides, no theory—just you, a terminal, and the exact four lines of code that make every kernel tick.

You’ll level-up from baby steps to ninja territory in one adrenaline-fueled sprint. You’ll chain ** together until you’re juggling triple-star pointers like a circus pro, then watch & peel them back layer by layer. You’ll see why an array name is secretly a pointer, where the two diverge, and how to build an array of pointers that makes qsort() and Linux device tables look trivial. By the final keystroke, you’ll wield “many *s and many &s” without blinking, turn pointer-to-pointer into your secret weapon, and laugh at code that once looked like hieroglyphics, ready to debug any kernel structure on sight.

You’ll step inside actual RAM and treat memory like clay in your hands. You’ll point to ints, floats, and custom structs with surgical precision, then swap the clumsy (*p).field for the sleek p->field arrow that every Linux driver lives by. You’ll stride through arrays with p+1, discover why char* walks one byte at a time while int* leaps four, and sketch the exact memory map that turns a flat address into a living struct. By the end, you’ll read any kernel data structure blindfolded, fix off-by-one bugs before breakfast, and never again wonder “where exactly does this pointer land?

You’ll discover exactly what a function pointer is, master its complete syntax, and clean it up with a single typedef. You’ll then build and run a real function-pointer array that stores multiple functions and calls any one by index.

You’ll master the shapeshifting void*: what it is, why it exists, and how to wield it safely. You’ll see NULL in action, learn the exact difference between a null pointer and NULL itself, and then dive straight into real Linux kernel code where void* carries structs, buffers, and callbacks across subsystems.

You’ll master the heap with malloc() and free(), catch allocation failures the moment they happen, hunt down every byte lost to memory leaks, rescue code from dangling pointers, stop double-free crashes cold, and lock out pointer manipulation that wanders into unowned memory.

You will examine pointers in Baremetal Code, trace their use in FreeRTOS, and study how they work in Linux.

Understanding the concept of bit-manipulation, various operators available and doing hands on experiments to learn those.

Environment setup and a quick demo.

understanding what is GDB and how it works.

Hands on experiments to explore various GDB commands.

Diving into the basics of how the GDB commands can be automated by scripting.

Concluding thoughts and recommended next steps.

Course introduction and Environment setup to run the experiment.

A quick overview of the important concepts in the C language that will help with implementing Data Structures.

Understanding the terminology used to describe the performance aspect of the data structure.

Diving into the concepts of the foundational data structure of Linked Lists.

Understanding and implementing the Queues data structures

Understanding and implementing the Stack data structure in C.

Understanding why we would need the Tree data structure, the details and implementation in the C language.

Understanding the concept of bit-manipulation, various operators available and doing hands on experiments to learn those.

Understanding the vocabulary used in describing CPU architectures.

Learn ways to master any CPU architecture.

Explore how to think and reason about the CPU internals as a Software Engineer.

Explore the programmers model and the boot sequence of the ARM-M CPUs.

Concluding remarks and next steps.

The courses uses the QEMU emulator for a real hardware board (the experiments should also run on real hardware). To ensure that everyone has the same setup and doesn't get tangled in the setup issues - we use the GitHub Codespaces instance running a virtual machine configuration we defined. This section guides through the steps of accessing it.

This section provides a comprehensive introduction to the core concepts of ARM Cortex-M CPUs, laying the foundation for understanding their architecture and operation. Explore the mental model of the CPU, systems, and the Cortex-M controller, gaining insight into how these components interact.

Introduces the essentials of assembly programming for ARM Cortex-M CPUs, focusing on practical implementation. Start by exploring the processor boot-up process and writing their first assembly program, gaining hands-on experience with the Cortex-M environment. The section delves into the structure of instructions, their encoding, and how to analyze binary dumps to understand the low-level representation of code. Examine the anatomy of an assembly file, learning its components and organization. Master stack manipulation instructions, understanding their critical role in managing data and CPU context.

Covers the theoretical foundations of implementing a scheduler on ARM Cortex-M CPUs, enabling multitasking on a single processor. Explore how a single CPU can run multiple processes, uncovering the principles behind concurrent task execution. Covers the anatomy of a task, detailing its structure and role within a scheduler. Discover the critical techniques for context switching and scheduling, including the `trick` that facilitates seamless task transitions.

Practical implementation of a scheduler. Program the SysTick timer and verify its associated exception handling to ensure accurate timing for task scheduling. Covers techniques for saving and restoring CPU context, a critical step for seamless task switching. Set up tasks and their respective stacks, configuring the system to enable round-robin scheduling. Through hands-on exercises, implement round-robin scheduling and achieve process switching.

Final thoughts and next steps.

Understanding what make is and what it is used for.

Diving into the internals of how makefiles are to be written.

Implementing a project using the concepts learned in previous sections.

Exploring some other features of make.

This section guides on the setup we use and dives into the detail of executing the Rust code on a Cortex-M3 based emulation target.

Lectures are being recorded and will be added to the course...

A quick demo of a device driver written from scratch controlling the GPIO hardware directly.

This section introduces the hardware components and the boot flow for the SoC powering the Raspberry-Pi 4B. To prove the point we boot a baremetal firmware that prints on the UART.

Moving away from the baremetal boot, we prepare the SD-Card and flash a Linux image that we will develop and the load our device driver.

Write a quick-n-dirty GPIO driver to turn the LED ON/OFF. Reason about the character driver.