The LIBRARY!

Reason from first principles, design solutions and control the world!

Library is a collection of courses that will guide you on the fundamentals and insights you need to design and implement Embedded Systems based solutions!

Embedded Systems Software Engineering includes writing firmware for micro-controllers and system software for application grade CPUs involving boot-loaders, device trees and higher level operating systems.


Bestseller Beginner Intermediate | Delivered by Piyush Itankar Mahmad Bharmal

(4.9) 1052 students enrolled.

Last updated: 19 July 2025 | English | Monthly and Yearly Access.


includes

Collection of 24  Courses.
200+ hrs  of recorded video lectures.
200+  lessons.
Emulator & Hardware based experiments.
10+  downloadable resources.
Workshops  by industry experts.
Certificate  on completion of course.
Cheat sheets and/or quick reference guides.
Case studies based on open-source code.
Coding exercises and challenges.
Several End-to-end project implementations.
New content regularly added!

take a look at the teaching style

list of courses included

This offering is a collection of courses, each of which is deliberately designed to give you insights and hands on experience on critical topics. How these are to be pursued is presented as a flow chart below.

Note: Every course the pyjamabrah team makes will be added to this collection. There will be no extra charge.

Roadmap and Career Options
Low Level with Pyjama Brah! (Public Draft)
The C Language
C Pointers
C - Mastering Bit Manipulation
Data Structures (in C)
ARM Cortex M - 101 (Introduction)
ARM Cortex M - 102 (Scheduler Design)
GNU Make and Automation
GNU Linker Scripts
FreeRTOS - Teardown and Porting
Git And Gerrit
The ART of Technical Discussions
AARCH64 - Introduction to ARM-A 64 Bit CPU (ARM-A 101)
aarch64 Baremetal Programming (ARM-A 102)
System Components - MMU/SMMU
Linux Device Drivers - Introduction (101)
Linux Device Drivers - Controlling Hardware (102)
FPGA Based Hardware Design (101)
Python Programming
Tech-Sync | Saved Recordings (Workshops)
Podcasts

recommended learning flow

With respect to the flow-chart below, the courses have a deliberate structure, design and order of pursuit. Our recommended paths are as follows -

  • Ad-Hoc: Course under this group don't have a dependency and can be pursued in any order. These are supposed to be light in terms of cognitive load and we recommend watching these while munching popcorn.
  • Essentials: This collection contains courses that are the foundation of Embedded Software Development. These focus on orienting and then mastering software concepts using the C Language.
  • Firmware: Courses in this collection are recommended if you work with microcontrollers. Focused on the ARM Cortex-M class of CPUs these courses focus on mastering the assembly, C and RTOS based programming of the controllers.
  • System Software: This track is recommended for those working with Application class CPU such as the ARM-A or RV64 based architecture. Courses focus on System Level components, Higher level OS (like Linux) and Base System Architecture level programming.
  • Hardware: The courses in this collection focus on introducing embedded software engineers to how hardware is designed. These are designed to be light on cognitive load and supposed to arm software engineers with the insights and imagination around how hardware operates. This should enable them to reason better and write clean software.
  • Advance:This collection will enable you to take control of the finer details like code/data placement in the memory, writing a build system from scratch etc. These are recommended for seniors who have to make memory, power and execution time related decisions.

You are free to follow a different flow if you know what you are looking for and doing...

what you will master through the journey

C programming, converting to Assembly and machine code.
Grasp ARM-M, ARM-A, and RISC-V memory maps and programmer's models.
Write and debug C programs for practical use.
Command C constructs - functions, pointers, structs, unions, enums.
Analyze data types - integers, floats, doubles, signed/unsigned, const, volatile.
Understand data type memory representation - 2's complement, floating-point encoding.
Implement control structures (if, else, switch, loops, goto) and track assembly effects.
Manipulate arrays, strings, pointers, and perform pointer arithmetic.
Leverage debug tools - GDB, make, addr2line etc.
Build mental models for pointers in firmware, Linux, FreeRTOS, Zephyr.
Master pointer operations - pointer-to-pointer, arrays, function pointers.
Handle pointer arithmetic, void pointers, NULL pointers in kernels.
Manage dynamic memory with malloc(), free(); avoid leaks, dangling pointers.
Learn low-level programming with RISC-V and Assembly.
Write and debug RISC-V (rv32i) assembly programs; convert C to assembly.
Use QEMU, GDB, Makefiles for low-level debugging.
Develop baremetal firmware, drivers; print “Hello, World!” on UART.
Understand ARM Cortex-M, Cortex-A architecture, registers, boot processes.
Write Cortex-M assembly, including schedulers with context switching, SysTick.
Master exception handling, vector tables, system registers via QEMU.
Create, debug Makefiles for build automation; write GNU linker scripts.
Use Git, Gerrit for version control, code reviews.
Dissect FreeRTOS kernel; port to new targets with task scheduling.
Develop Linux kernel modules; manage with insmod, rmmod, lsmod.
Implement /proc entries, system calls, device drivers in sandbox.
Explore embedded systems roles, job skills, and career paths.
Generate digital audio in C using sampling, file operations.
Simulate real-world coding with QEMU, Codespace, Multipass.
Build mental models of CPU, memory, state machines, scheduling.
Tackle technical discussions on C, memory, interrupts, bit manipulation.
Complete projects - schedulers, digital audio, Linux drivers.

course contents and preview lectures ...

The list below is a complete list of courses, lectures, quizzes, code reviews, projects, notes etc available on the learning portal at the moment.

This list is constantly update with new content every few days...

Roadmap and Career Options

This short course focuses on orienting the college graduates and those new to the industry on what the usual roles, responsibilities are and what opportunities they can expect.

Understanding Embedded Systems
what is embedded systems and how it relates to EE, ECE and CS
What is firmware and Systems Engineering
Firmware Engineering
Understanding What Firmware engineering is
Memory Map and the Programmer's model
State Machines and OS Primitives
Roles and Exploring job listing
Systems Software Engineering
HLOS, Application Grade CPU and Virtual Memory
Roles and Skills
Exploring Opportunities and Skillset

Low Level with Pyjama Brah! (Public Draft)

We are writing a book to teach C by understanding the CPU/Memory programmers model, exploring the ISA for RISC-V, the assembly, writing baremetal firmware/driver, and ends with printing “Hello, World!” on the UART. The book covers lot more than just C. Things like Assembly, Makefile, GDB based Debugging, Linker Scripts, C, Driver Writing etc… The public draft is available for FREE for online reading. Table of contents is as follows -

Part I - Mental Models
C: History and Relevance
Computer System Model
Storage Model
CPU Model
Instruction Set (RISC-V)
Setup - Virtual Lab
Part II - Assembly
Text to 0s and 1s
Assembly Language
Directives and Generated Assembly
Build Process
Part III - C Language
Keywords
Anatomy of Code
Not C Keywords!
C: Pointers
C: More Pointers
The power of structs
Object Oriented Approach
Part IV - Programming Embedded Systems
Mixing Assembly & C
CPU Boot Process
Code and Data Placement
C: Address Map and Struct
Interacting with Qemu UART
Where to Next?

The C Language

This course dives into the practical applications of the C language, emphasizing hands-on learning to solidify key concepts. Delivered in an engaging and unconventional style, the lessons go beyond theory, equipping you with the skills to apply C programming in real-world scenarios. By the end of the course, you’ll feel confident in your mastery of the C language, adept at using it alongside the tools and utilities professional C programmers rely on daily.

C Language Tour
Roadmap and Mindset
Sandbox Environment and Basic C Program
Keep an Eye on Functions, Pointers and Structs
Example of the RAW power - Functions, Struct and Pointers
Mental Models to brain tattoo
Mental Model of the System
The mental model of the CPU
The mental model of the Memory
From Text to Binary
Instruction Encoding and the rv32i ISA
A tour of Toolchain, QEMU, GDB
Demo - assembly to binary, QEMU and GDB
Instruction Encoder Decoder, Makefile and GDB Dashboard
Dwelling in the World of Assembly
Anatomy of Assembly Program, writing code, debugging in GDB
Decomposing C to Assembly and the relation
C Keywords - Data Types
Getting CPU from assembly to jump to C program
Introducing the C Keywords
Data types, Variables and Integers
Datatypes - float and double
Exploring sizes of data types and location in memory
How integers are stored - 2s complement
floating point number encoding and few examples
more floating point - float and double
signed and unsigned
const and volatile
demo - const and volatile
void, c standard and gnu C manual
typedef and sizeof
structs and unions
enums as named numbers
C Keywords - Branching and Looping
if, else, switch, case, default, do, while, for, continue and break
goto and return
Demo - if, else if and else effects at assembly level
Demo - switch case and effects at assembly level
Demo - loops - for, do, while, continue and effects at assembly level
Demo - goto and jumps across functions
auto, register, extern and static
Demo - auto keyword7
Demo - register keyword
Demo - extern keyword
Demo - static keyword
Variables and Functions
Introduction to Variables and Functions
definition vs declaration
Demo - variable and function names
Arithmetic operations and pitfalls
Project-1: Calculator in C
Problem statement
Problem statement walkthrough
Setup, variables and I/O
Using conditions, switch and loops
debugging scanf issue and cleaning up the code
guarding against bad inputs and concluding the project
Strings, Array and Pointers
Strings and concept of array and pointers
Defining and Assigning Arrays
Arrays and out of bound access
Strings and Character arrays
Introduction to the concept of pointers
Syntax related to Pointers
Demo - introduction to working with data pointers
Detour - Endianness
Demo - Difference between array and pointers
Project-2: Generating Digital Audio
Generating Digital Audio - walkthrough
Math concepts and sampling
Generating samples and file operations
Demo - Playing the Digital Audio
User Defined Data types
Revisiting types of data types
Structures - Sneak peak
Anatomy of Struct and examples
Demo - structs
unions and how they defer from struct
Demo - union
Enums and fun experiments
Enum and Scope
Project-3: Embedded Sensor Management
Problem Statement
Introduction and Walkthrough
Converting specification to data structure
The case for union and saving memory
Accessing elements with nested union and structs
more being uploaded...

C Pointers

C pointers are crucial in Firmware and System Software (based on the C language) design. Linux, Unix, FreeRTOs, Zephyr, ThreadX etc kernels use C pointers heavily. This Course dives into the mental models and inner workings of pointers!

Mental Models, Motivation and Reasoning about pointers
What to Imagine?
What is a pointer?
Why pointers?
Pointers - Syntax and Code
Environment Setup
Declaring|Defining a Pointer
Pointer Variable and Address
* and & in relation to pointer variable
Multi-level Pointers
Use of * and &
Array and Pointers - Similarity and differences
Many *s and Many &s
Pointer to pointer
Array of pointers
Different types of Pointers
Pointer to Data
Pointing to data with a Data type
Pointer to a struct, *, . and ->
Pointer Arithmetic
Memory model and pointer to data
Pointer to Code - Function Pointers or Callbacks
What is a function pointer?
Function pointers syntax
typedef and function pointers
Example - function pointer array
Void Pointers
What is a void pointer?
What is NULL and NULL pointer?
void pointers in - Linux source code
Pointers, Dynamic Allocation and Problems
heap/ malloc() and free()
Allocation failure
Memory Leak
Dangling Pointer
Double free()
pointer manipulation and unowned memory
Open Source Code and Pointers
Baremetal Code
FreeRTOS
Linux

C - Mastering Bit Manipulation

A short course on how to think about and do bit manipulation in the C Language

The idea behind bit manipulation
Operators and practical aspects of Bit Manipulation
Bit Masking, Setting and Clearing Bits

Data Structures (in C)

A short course on understanding, implementing and using data structures in C.

Introduction
Need of DSA in Embedded Programming
Setup and work environment
Review of concepts in C
Three essential concepts in C
One dimensional array
Visualizing and working with multi-dimensional array
The concept of structs
Everything you should know about struct
Pointers and Addresses
Pointers to struct
Abstract Data Types and Vocabulary
Abstract Data Types and Operations
Space and Time complexity
Linked Lists
Visualising Linked List
Code to represent a node and initialisation
Adding nodes and Traversing the list
Adding nodes at the end and reasoning about time
Testing the Runtime for insertion
Searching for given data
Deleting data
Insert operation
Shipping the code as static Library
Queues
The concept of Queue and why we use it
Implementing the add interface
Improving run time of the add operation
Fetching the first entry in the Queue
more lectures to be added in this section
Stacks
Lectures are being recorded and be released over the weekend.
Graphs
Lectures are being recorded and be released over the weekend.
Trees
Lectures are being recorded and be released over the weekend.

ARM Cortex-M (101) - Understanding the Processor

An introductory course on the ARM Cortex-M CPUs. How to go about learning them.

Introduction
ARM CPU Architectures
Micro Architecture Vs Architecture
How to Learn and Master CPUs
Mental model of CPU Memory interactions
How to master CPU - Different models to learn
Mental Models and How to use them
Programmers model - Register Set
Modes and Privileges
CPU boot-up and Register Set
CPU boot up and Vector Table
Exploring Cortex-M3 registers using QEMU
Conclusion
where to next.... Invitation

ARM Cortex-M (102) - Scheduler Design using Assembly

Learn the assembly programming for ARM Cortex-M CPUs by writing a scheduler from scratch, without using any IDE, SDK or boiler plate code. Course is under development. Content will be added when it's ready.

Environment Setup
End Goal
Environment Setup
How the ARM M-class CPUs Work
Mental Model of the CPU, Systems and the Cortex M Controller
From bit to the Programmers model and NVIC
Various ARM Architecture and CPUs - M0, M3, M23 etc.
Programmers model for the M Class CPUs
Privilege and Modes of operation
Boot up process
Exception Handling and Register Save/Restore
Assembly Programming
Booting the Processor and First Assembly Program
Instructions, Encoding and binary dump
Anatomy of assembly file
Cortex m3 instructions and experiments
Stack manipulation instructions
Implementing the Scheduler - Theory
How can Single CPU run multiple processes?
Anatomy of a Task
Trick to Context Switching and Scheduling
Exception Entry, Exit and SysTick timer
Implementing the Scheduler - Hands on
Programming SysTick and confirming the exception
saving and restoring CPU context
Setting up the tasks and the stack and trying to round robin
Round robin and switching between processes
Conclusion
Things to be mindful of
FreeRTOS - the struggle to get to context switching

GNU Make and Automation

Make is a build automation tool that automatically updates files in your project based on their dependencies. It's primarily used for compiling source code, but can also be used to run other commands or perform tasks.

The Basics
Setup and Quick Introduction
First makefile and basic rules
Dependencies and when make misbehaves
Dependencies and Variables
Resolving dependencies - target as a dependency
A better example and variables
Pattern Rules and some internal variables
Variable for target, pattern substitution, functions and debugging makefile
Executing shell commands and assigning value to variable
Simple Project
Organising the source code and use of shell function
Discovering the header paths
Generating the path to headers and targets without recipe
Other Features
Different names for Makefile and including other makefiles
Passing values form commandline, ?= and +=
macros

GNU Linker Script

This hands-on course dives into the details of writing linker scripts (based on GNU LD). Linker scripts are a must-have skill for firmware and systems engineers who have to deal with scenarios where the placement of various sections (code, data, etc) in the memory needs granular control. Engineers who work on Bootrom, Firmwares, Bootloaders, or otherwise are involved in lower-level systems code.

Introduction and Setup
Environment Setup
Opening and Closing the Codespace Environment
Compilation Process, Linker and the linkerscript
Demo - Resolving addresses and Merging sections
C Code and Allocation in Memory
Diagnostic Tools
Our own Linker Script
Goal
Anatomy, Memory details, Sections
Sneaky linker and linking multiple objects
Including and discarding sections from same file
Discarding and wildcard
Two memory systems
.rodata, problems with Single memory bank
Defining two memories and the problem with .data section
Introducing VMA and LMA
Copying .data section from ROM to RAM
Current location counter, variables and destination info
Address of .data section in the ROM
Code to copy .data section from ROM to RAM
Zero Initialising the .bss section
Creating custom sections and placing them
Linker command language
What is the linker command language
Linker Script and Statement
Expressions
Values
Symbol Names and naming rules
Location Counter
Expression Evaluation
Assignment operation
Assignment statement placement - relative and absolute addresses
Symbol types - Absolute and Relocatable

FreeRTOS - Teardown and Porting

Learn FreeRTOS kernel by tearing it down to it's bare minimum and doing a port for a new target from scratch. This includes booting the CPU from scratch and placing the code in memory manually.

Introduction and Setup
What and Why FreeRTOS
Demo walkthrough - End goal and Tools
Codespace Setup
Booting the ARM M CPU from Scratch
Programmers model and Essentials of ARM M CPU
Demo - Booting the CPU
Exploring FreeRTOS Source
Jumping from Assembly code to function in C files
Fixing the problem of function calls in C
Getting the FreeRTOS source code and documentation
Integrating FreeRTOS Kernel
Starting to Integrate the FreeRTOS-Kernel
Finding and fixing the portmacro.h errors
Finding and adding the FreeRTOSConfig.h
Enabling heap for dynamic memory allocation
Setting the Scheduling Rate
Getting the Kernel to compile successfully
Investigating Runtime Instabilities
Running the compiled binary
Investigating why task is not getting created
GDB Investigation - Memory Allocation failure
Correcting the boot-up code and memory init
Debugging and Getting the Scheduler to run
Installing the Exception Handlers
Hunting the cause for the Hard Fault
Getting the Scheduling to work
more lectures being recorded...

Git and Gerrit - the collaboration kit

Git and Gerrit are pivotal tools in the software development industry, each serving distinct yet complementary roles that enhance collaboration, code quality, and workflow efficiency.

Orientation, Context and Tour of Git
Introduction and Team Setup
Simulating the real world on local machine
Quick Tour of GIT - why and how
Where to install git from
Git commands
the init command
status and adding files to staging area
commits and git data management
discarding experimental changes with checkout
resetting and discarding commits
more lectures are being recorded...

The ART of Technical Discussions

Organised collection of topics, projects and questions from the web that a Embedded Engineer should know and be able to reasons about.

Format and Introduction
Introduction and Format of the Course
Key Concepts in C
Key concepts in C
C Program and Memory Layout
.text section and behaviour in freestanding and hosted environment
Stack, the location and what all goes there
Understanding Heap and the need
demo - code analysis
structs and union
volatile and const
bit-manipulation and pointers
General Embedded Systems
Section Introduction
Some History of computing system
CPU, Memory, ISA and IO
The concept of Interrupts
More lectures being recorded...

ARM Cortex-A (101) - Introduction to the 64bit ARM CPUs

Introduction to ARM-A Class CPUs implementing the AARCH64 architecture.

Introduction
Who is ARM as the Company?
A Class CPUs, Architecture and Micro Architecture
CPU, Memory and Mental Models
How to learn CPU - different models
CPU as seen by Software Programmer - Programmers model
Execution Levels and Execution Worlds
Programmers guide and revisiting uArch
Long discussion on Els and Secure/non-secure
Exception Levels
Secure and Non-Secure world
Use cases and Software Execution in different ELs
Use case for Secure World Software Execution
Revisiting the Document
Programmer's Model - Registers
GPRs, QEMU and Demo
Exploring the idea of System Registers, SCTLR as example
Processor State Register - CPSR or PSTATE
Idea of Exceptions and saving CPU state
Special Registers
Case study and Conclusion
Boot process - Single core and Multi Core
Setup and Demo - Glitch at the end
Revisiting the Demo
Next

aarch64 Bare-metal Programming (ARM-A 102)

A short course on programming the ARM-A Class CPU (aarch64 based Cortex-A72) from scratch using the Raspberry Pi 4B as the platform.

Introduction and Essentials
Course Introduction
Repository and documentation
Tour of Hardware Components
Operating system as development environment
System on Chip (SoC) and Boot Flow
What is System on Chip (SoC)
Getting the RaspberryPI OS and exploring the contents
The Raspberry Pi 4B Boot sequence
The Raspberry Pi 4B Boot Sequence
Files on the SDCard
Preparing the SDCard and booting RaspberryPi
RPI 4b and FT232H connection
Environment Setup for Development and Debug - OpenOCD, JTAG and GDB
The case for hardware debugging
Setting up OpenOCD from source and GDB Dashboard
OpenOCD and GDB in Action
FT232H and Raspberry PI connection for JTAG mode
Compiling first assembly program
debugging our code with OpenOCD and GDB
More lectures are being recorded and will be added soon.

System Components - MMU/SMMU

A Course dedicated to understand the concepts of Virtual memory and the hardware components that enable it - the Memory Management Unit (MMU) and the System Memory Management Unit (SMMU).

Setting the Background
Problems with multiple processes and physical addresses
Exploring reasons for Memory Management
Imagining Memory Management Unit
Logical Placing of MMU Hardware
Regarding Virtual memory assumption - Small Clarification
MMU's mappings and where are they stored and retrieved
Towards Efficient Desing of MMU mappings
FIrst level optimisations mappings
Continued - One Last Optimisation trick

Linux Device Drivers (101) - Writing and understanding a dummy driver

A hands on Introduction to Linux Device Driver development. Recommended for those getting started with driver development.

Development Environment
A sandbox to run our experiments
mac-setup
Linux Setup
Windows-setup
Multipass relaunch and installing utilities
Linux Kernel and Roles of Device Drivers
Linux Kernel, System and Bootup
User Space, Kernel Space, system calls and device drivers
Files and File operations, System Calls and Drivers
Basic Loadable Kernel module and utilities
Our first Loadable module - Minimum Code based
Deep Dive - make and Makefile
Using lsmod utility to list loaded Kernel Modules
insmod, module and the kernel
rmmod, kernel and module unloading
modinfo and the mod.c file
Extending the Driver to be user interactable
proc file system, system calls and user interaction
Exploring entries in /proc
creating the /proc file entry and screwing up the kernel
Implementing the read operation
Data Passing
Passing data to user from kernel
User space app example and challenge for you
Conclusion
Quick Revision, What we did not cover and where to next..

Linux Device Drivers (102) - Controlling the Hardware

Course on writing and understanding how the Linux Device Drivers controls real hardware. In this course, we write a kernel driver for the GPIO port of Raspberry Pi - 4.

Introduction and Expectations
Hardware and Demo
The generic Boot flow for SoCs
more videos being recorded

Linux Device Drivers: Kernel Facilities & Helper Functions

The Linux kernel doesn't use the Standard C Library and implements the functions as it's own modern libraries. This course is focused on exploring the facilities and helper functions the kernel provides to manage data and different activities from the driver.

Expectations and Getting Started
Introduction and what we will cover
Environment Setup
Browsing the Linux Kernel Source
the container_of() macro
What it is and why care?
Discovering the implementation of container_of()
Implementation in the Kernel
Linked Lists
Linked Lists and how the kernel helps us
the linux/list.h file
Exploring the list_head struct and understanding how lists will work
Initializing head pointer
Adding to the list
Traversing the list
Deleting entries from the list
Be mindful when deleting
The Kernel sleeping mechanism *
wait queue *
static declaration *
dynamic declaration *
blocking declaration *
unblocking declaration *
Example of wait queue *
Standard Timers *
Jiffies vs Hz *
The timer API *
Timer Setup and Initialisation *
Standard timer example *
High-Resolution timers (HRT) *
The API and parameters *
HRT Setup and Initialisation *
Dynamic tick/tickless kernel *
Delays and Sleep in the Kernel *
Atomic Context *
Non-Atomic Context *
Kernel locking mechanism *
the Mutex APIs *
the Spinlock APIs *
Spinlock vs Mutex *
Work deferring mechanism *
Softwirqs and ksoftirqd *
Tasklets - declaring *
Enabling and Disabling a tasklet *
Tasklet scheduling *
Work queues *
Dedicated work queue *
Kernel threads *
Kernel interruption mechanism *
Register an interrupt handler *
Interrupt handler and lock *
Concept of bottom halves *
Limitations and solutions for bottom halves *
Threaded IRQs *
Invoking user space application from the kernel *
Lectures marked with a * are begin recorded and will be available soon.

Python Programming

A quick course on getting up and running with the Python programming language for Embedded Engineers. The course focuses on enabling C programmers with the important insights and mental models to be used when working with Python.

Introduction and Setup
Welcome Message
Codespaces Setup and Basics
Setting Dark theme
The Mindset when working with Python
Everything is an Object
Objects, Operations and Loose types
Scripting and feeding files to interpreter
Key Ideas
The Keywords
Scripts and Functions
Function Calls
Splitting code in files and importing
more lectures will be uploaded in due time...

Embedded Systems Podcast!

Casual chats with Industry Experts focused on their career paths, technology trends, skills and opportunities.

Manav | SoC Design flow, MIPS, RISC-V and Automotive
Jegan | Automotive Embedded Software, Autosar and Opportunities

Tech Syncs - Workshops on ad-hoc topics

Live Tech Syncs with learners every once in a while where we discuss ad-hoc topics relating to Firmware and System Software Engineering.

ARM Cortex-M CPUs (part - 1) | 30 April 2025
ARM Cortex-M CPUs : Memory Model (part - 1) | 03 May 2025
RISC-V - Introduction | 08 May 2025
ARM Cortex-M CPUs : Memory Model (part - 2) | 14 May 2025
Raspberry Pi PICO 2 SoC Deep Dive (Part 1) | 25 May 2025
Understanding PCIe (Part I)| 28 May 2025
AutoSAR - Introduction | 07 June 2025
Understanding PCIe (Part II) | 10 June 2025
What Every Programmer Should Know About Memory | (tbd)

Source Code Walkthrough

Learn how to tame huge code bases written in C. Techniques, tricks and general patterns that help understanding the structure and abstractions used in a repository.

Little Kernel (LK)
Setup and getting started
Reverse engineering directory structure
Reverse engineering the APP structure
Deciphering compilation logs
LK Startup Code deciphering
Two Segways - Towards deciphering Boot Code
LK Startup Code broad Overview
ARM64 Exception Levels - Quick Refresher
aarch64 Exception level switching
FPU SVE/NEON, Cache Configuration
All about Stacks and SP
Page table setup in Memory
MMU Initialisation and TTBR setup
Stack Setup and BSS section
Secondary Cores Boot path
Trampoline Vector path
Calling kernel's main()
more videos being recorded...

FPGA based Hardware Design (101)

This course focuses on Digital Circuit Design using FPGAs (Field Programmable Gate Arrays). Recommended for Software Engineers to help them understand how the underlying electronic machines work.

Quick Demo
Demo - FPGA and deploying simple circuits on it
Essentials
Understanding the Transistor
Using transistors as a base for logic gates
What is an FPGA
Exploring the iCEBreaker Development board
What does programming FPGA mean?
icestudio and simple circuit
Mental model for the internals of the FPGA
Build flow and tools
More lectures to be uploaded soon

Important: Planned courses are not yet ready for learners and will be added as the current recording concludes.

Email from one of the learners ♥️

One of the subscribers wrote to us, this...

The Philosophy behind the courses?

We have been creating content for the Embedded Software Engineering community for over a year now. If you have been following us, you would know that we have launched courses in the past, with Firmware Engineering Arsenal (later renamed to Firmware Engineering) being the most popular one. The Courses on C lnaguage and C Pointer have been an all time hit and got us to where we are.

We noticed that we (a small) team were having a hard time supporting different courses individually. And learners were feeling left out when we included one course in one bundle but not another. To make life easy for all, we have decided to offer all the courses to everyone under Monthly and yearly subscription plans. This we believe will free us from the complications that come with attended to everyone on different chat windows.

To help reinforce all the learnings and ensure the learner has a deep sense of practical usage of the lessons, we have introduced Tech Sync (Workshops) where we present live on topics and take questions.

View of the Learning Portal

Learning Paths - For anxiety free life!

Embedded Engineering has not had a linear path. We are attempting to being order to the chaos. The courses are deliberately designed and ordered in the way they are. You can take each course individually or just follow the learning paths shown in the image below. The ones of the left are for firmware engineers (or aspiring candidates) and the ones on right are for those interested in systems software engineering.

Learning Paths

Firmware Engineering

Firmware Engineering involves working with microntrollers. These are typically 32-Bit CPUs (like ARM Cortex-M, RISC-V RV32 etc) with focus on power saving. Engineers tend to either write bare metal code or use an RTOS (like FreeRTOS, Zephys, ThreadX etc) if there is a need to handle complicated state machines.

Having a good understanding of what the CPU does as the result of the C code is a skill that will put you in the top 1% of the entry level Firmware engineers. Being able to understand a senior and co-operate to write the code is more than enough. Notice that the C language and C Pointers course will exactly help you become this. The C Language course is all about insights and based on the RISC-V CPU. So not only do you learn C the way it should be (by being able to reason down to the CPU) but also you learn programmers model and assembly for the RISC-V CPU. Double win!

The ARM Cortex-M 101/102 Introduces the ARM-M Architecture and focuses on booting and programming the CPU in Assembly. You will write a secheduler in assembly as part of these courses, this is deliberate and makes way for understanding FreeRTOS which follows. Going through these courses, you will notice how similar the RISC-V and ARM-M architectures are. By the end of the ARM courses, you will be having the skills of a senior firmware engineer.

The FreeRTOS course is laser focused on tearing down and reasoning about the scheduler and the OS primitives (mutex, semaphores etc). There are many engineers who work with FreeRTOS on a daily basis but don’t understand the internals and thus, hit a glass-roof in their career. Being able to reason about OS constructs like mutex, semaphore, spinlocks etc is important. You will also learn the rare skill of porting FreeRTOS from scratch on a new ARM-M target!!

To grow up the ladder you will need to master the CPU’s programmer model, architecture and be able to use the toolchain (gcc, ld, as, ar, gdb etc) to place the code/data in the memory, debug the solution and write build automation help.

Senior or Staff level engineers worry about details like power, performance, stability and fault tolerance of the firmware. Being an absolute master of C, CPU Architecture, Operating Systems and Debug tools is a must! If you notice, the courses are lined up to get you to becoming a master…

Systems Engineering

Stellar Systems Software Engineers are firmware engineers who are working with Application Grade CPU (ARM Cortex-A, RISC-V RV64, AMD, Intel etc), Complex and interconnected system capable of running Higher Level Operating System (Linux, Mac-OS, Windows etc), Hypervisors and Virtualizer and Systems capable of running general applications like the chrome browsers.

The Application processors are complicated in their architecture and have layers privileges and modes. Systems Engineer need to have a good understanding of the CPUs to be able to reason about the systems level on-goings. They are involved in working with Bootloaders, hypervisors, OS Kernel (Linux, Windows etc) and need to be very thorough with the understanding of the Operating Systems.

The courses included focus on the ARM Cortex-A (aarch64) and RISC-V RV64 architectures. The introductory courses give a over all view of the given architecture. Once the architecture is understood, the next in line is the Linux Device Drivers. The 101 course, provides a deep insight into how the Linux Kernel Drivers work and the anatomy of a general character driver.

We focus on the ARM-A class CPUs just because they are very popular and used in Mobiles, Watches, Tablets, Desktops/Laptops and Servers! Investment into learning this architecture is to prepare for the future and bullet proof your career!

General Skills

Honing technical skills is not enough. For these reasons we have included courses on general skills that a Firmware/Systems Software Engineer should have. When working in teams, collaboration is a big one and most semiconductor companies use tools like Git and Gerrit for source code management. Master these will enable you to be a reliable teammate!

The ART of Technical Discussions is a collection of special topics and experiences that will arm you with the knowledge and mindset to have a productive technical discussions with s seniors!

More!

We will be adding more courses in the paths so eventually this becomes a robust and reliable path to take as to become a firmware or systems software engineer. The subscribers of course will get the updates for free :)

Our Recommendation

Unless you are a student or an early professional who cannot afford the Yearly plan, our recommendation is to go for the Yearly Subscription to get the most bang for the buck.

Certificate

The journey through the course is a challenging one! Our courses are packed with insights and will take time to sink in. You will be awarded with a Certificate of Mastery when you complete 95% of the course work.

What you see above is a sample certificate (`Piyush Itankar` is a sample student name). The design of this certificate will be modified from time to time to make it more shiny and reflect the rightly earned pride!

There will always be a dedicated certificate identification number to verify it with us. This should enable anyone to check the authenticity of the certificate.

How this is different from Others

FeatureUs!Others
C language and pointers with focus on machine behavior
Detailed analysis of data types and significance.
Assembly and C Coding without IDE
Detailed explanation and view of Programmer's model of CPU.
Mental models of various components in the System to reason based off.
A Bottom-Up Approach with the tinge of answering the `Whys`.
Thorough explanation of toolchain utilities (gcc, as, ld, ar, gdb etc)
Connecting the concepts with practical use cases and use in industry.
Hands-on experiments to prove every concept.
Focused on practical professional insights
Teach multiple CPU architectures (ARM-M, ARM-A, RISC-V).
Cover the toolchain utilities like compiler, assembler, linker and debug tools like GDB?
Learn at your own pace.
Superficial and confusing explanation
Burn a hole in the pocket with Fee
On campus presence required.

Instructors

Piyush Itankar
Embedded Engineer (L5), Google
Electrical Engineer holding a Master’s degree in Embedded Systems, with a proven track record at industry giants. At Intel, contributed expertise to Navigation Firmware, Bluetooth Driver development, and RF validation software. Currently thriving as an Embedded Software Engineer at Google, drove innovation in Firmware development for the Power Management Sub-system on Tensor SoCs (Pixel Phones) and presently advancing system software for the Pixel Watch.
Mahmad Bharmal
Embedded Engineer (L4), Google
Computer Science Engineer with a Masters in Embedded Systems Design. Worked on Firmware for Intel's Bluetooth solutions, followed by Silicon Validation Software for the Tensor SoCs, and presently working on the Pixel Watch Software. He is system software expert with a decade of experience.

Praise from our learners

(4.9) course rating.

Here’s what those who are learning from the courses have to say about the content and delivery.

Rushikesh Patil
(5)
One of the most essential and affordable course bundles for aspiring firmware engineers! I particularly appreciated the detailed explanations in the C pointers and ARM Cortex-M & assembly programming courses.
Shweta S
(5)
A well structured course for beginners to expirenced professionals, one who is keen in learning what the C program does to the underlying system, this course is for them. I personally enjoyed the debugging using the gdb dashboard. I am looking forward to dive deeper as the course unfolds, I highly recommend this course for all the embedded engineers.
Rohit Alate
(5)
Hello Team, if possible , please create the playlist in some sequence in which we should go through , so it will be really helpful.thanks in advance, and content wise you guys are amazing..... and i would say thanks to team to creating such platform for us...
PADMALAYA RAWAL
(5)
This bundle is crazily interactive. Be aware that it will make you addicted to learning more about embedded systems beyond just looking for jobs. Thanks to the team, who are adding more courses to the bundle, it's never going to be outdated! Loving it❤️‍🔥
Inturi Sri Sasi Kiran
(5)
I am taking a moment to give shout out the the authors of this course, sorry actually it's not just a course it is standard text book for an Embedded Engineer or who wants learn Embedded Engineering. I will strongly recommend this course to the college students especially those who are looking for a career in the Embedded sector.
Gnanesh Sureshchandra
(5)
This course gives you exactly what you need to know about pointers! And more importantly how to think about pointers this is really important, and every embedded engineer must know. Once again thanks a lot for this content creators. Expecting more courses from you in future. (for: C Pointers)
Arjun
(5)
Awesome, within an hour, if an engineer learns the boot up process of arm - cortex-m, that is unbelievable, instructor is really apt at the matter. Thanks (for: ARM Cortex-M 101)
Selva Gandhi P
(5)
I want to say that this course has truly been eye-opening for building my career. Thank you so much, brother, for all the support and guidance. 🙏🏻
Imene Benamor
(5)
I'm currently taking this course, and it's been great so far! The content is clear, practical, and easy to follow. I'm already learning a lot and looking forward to diving deeper. Would definitely recommend it to anyone looking to build or strengthen their skills in embedded systems.
Earnest Kihara
(5)
I wish I had came across this course when I was getting started into embedded C, thankyou Piyush for coming up with this course ,its worth it . I recommend it to all beginner and intermiadiate students and anyone else who feels there is some dots they can't connect in C
Pavankalyan G
(5)
Really enjoyed reading this book! It provides great insights and is well-written.
@n.5s4584
(5)
I just wanted to take a moment to appreciate the amazing content you create! Your videos are not only engaging but also incredibly valuable. I’ve learned so much from your channel, and I always look forward to your uploads. Thank you for sharing your knowledge and insights—keep up the great work! Wishing you all the success you deserve.
@its_me_to-i4e
(5)
Your content is amazing! Last time, I bought the advanced C pointer course, and it was so helpful for embedded systems. Please consider making the course fees more affordable so that students like me can easily access them. Keep up the great work
@sharifyy
(5)
your content is amazing, I give it 5 stars
@techpartel9858
(5)
The flow of this course is Amazing. It covers a whole system overview of how your C code runs and how it's dumped in your hardware. Everything is excellent. Thank you, @piyush.
@Simi-bc8sb
(4.9)
Great content. I really appreciate. Thank you
@ElizabethGreene
(5)
31/Jan/2025
Was there any reason why you preferred the RISCV32i chip over an x86 chip in QEMU? I appreciate the lesson in cross compiling too, but was curious why. Thanks for making these. 10/10
@soumyadipkar9451
(5)
31/Jan/2025
Enjoyed the session a lot sir! GDB Dashboard is truly amazing! 🔥
@vimalathithand917
31/Jan/2025
Just what I was looking for ! I'm sure that this series is going to be a blast ! Please don't stop the series in the middle and thanks a lot !
@aadishm4793
30/Jan/2025
Great content!!
@Ujjaval___
30/Jan/2025
AMAZING VIDEOS
@aadishm4793
30/Jan/2025
Awesome as all the videos 👍👍🔥
@Padmalayarawal
(5)
30/Jan/2025
Really loved your new content, can't ask for more crazy stuff.
@shabeehabbas4737
29/Jan/2025
Hello bro just saw the this video and I cant wait to start the course, the roadmap is unconventional which is why I think its the most awesome one, please dont stop uploading such great content ❤❤❤
@ankitrajbhar6045
(5)
31/Jan/2025
This is what I actually needed in life today.. thanks a tons..
Bhanu Sri Dasari
(5)
Great content
Ashith Polepalli
(5)
Excellent content to learn firmware
Rahul Kumar
(5)
no second thought.. go for it
Vikas Naga
(5)
The best course in Embedded System so far.
Mariyam Shahid
(5)
the best content on c!
@EEShyama
Loving these lectures!! Please keep them coming.
@RavindraBhandari-nf8vs
(4)
31/Jan/2025
I like your teaching method 🫡

Requirements

GitHub account to do the hands-on coding in Codespaces.
Interest in the lower level working of the system.
Some exposure to Digital systems is good (but not strictly required).
Basic understanding of number systems, logic gates, bits and bytes is good to have (but not strictly required).

Who this course is for

Students in Academia with C as a subject in the course.
Early Career Professionals using C as development language.
Firmware and System Software Engineers looking to revisit concepts.
Electrical/Electronics Engineers working on hardware programming.
Systems Engineer seeking gain system level insights.
Those curious to learn the underlying details of Systems and how to program it using C.

FAQs

What is the difference between these courses (paid) and the content on YouTube?

Some lectures from different courses have been put on YouTube as Preview. The are not structured and jump to a topic. The Courses in the Subscription are well structured and focused on developing a skill.


Is this recommended for beginners?

Yes! The courses are taught as if the learner has no idea about the subject. Each course starts of by ensuring that the basics needed to understand the followup lectures is understood.


Why a subscription model?

We are billed for the hosting and bandwidth by the platform provider. While we would very much like to offer lifetime validity, given the recurring bills, we have to ensure we continue to earn enough to be able to fund the effort and bring more value to our learners. The Monthly plan is for those who cannot afford the yearly subscription but can benefit from burst learning. To get the most out of our content, we recommend subscribing to the yearly plan.


Do I need a special machine configuration to take this course?

No! All you will need is an internet connection and the Chrome browser. The hands-on examples and lab work is based on GitHub codespaces platform. We use GitHub Codespace to ensure that you don't struggle with the setup and focus on the learnings. You are always free to setup the environment locally. Although, we won't support that, but you are free to do so. The courses, as much possible use a Emulator target of a real board, so if you wanted to run the code on real board. You can do so.


Why is a GitHub account needed?

The Experiments and Labs are based on the GitHub provided Codespaces virtual machine. Codespaces will enable a common work environment for all the learners and avoid the hassle of special setup.


Can I change my email-id post purchase?

As much as we'd like to support that, your account will be linked to your email-id post purchase.


What name will be printed on the Certificate?

The name you use on the platform will be printed as is on the Certificate when it is generated.


Can I follow the steps on my own PC?

Yes for the most part. Better yet would be if you have a linux machine.


I previously purchased a course from inpyjama/pyjamabrah, any discount for me?

Yes. We can offer a discount on the yearly subscription. Please reach us at support@pyjamabrah.com and be sure to include the details of your past investment. We will work on a custom discount for you.