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.

While there are several resources available online. Each offers a narrow view of one entity of the several. We have created and organized courses, that will take you from Zero to Hero in Firmware and Systems Software Engineering.

Bestseller Beginner Intermediate | Delivered by Piyush Itankar Mahmad Bharmal

(4.9) (25 ratings) 731 students

Last updated: 12 June 2025 | English | Half-Yearly and Yearly Access.

includes

100+ hrs  on-demand Video.

200+  Recorded lessons.

10+  downloadable resources.

Certificate  on completion of course.

Cheat sheets and/or quick reference guides.

Case studies based on open-source code.

Coding exercises and challenges.

5+ End-to-end project implementations.

New content regularly added!

One IDEA to master Embedded Programming!!

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. We will continue to add more courses and content.

Roadmap and Career Options

Low Level with Pyjama Brah! (Public Draft)

The C Language

C Pointers

C - Mastering Bit Manipulation

Data Structures

ARM Cortex M - 101

ARM Cortex M - 102 (Scheduler Design)

GNU Make and Automation

GNU Linker Scripts

FreeRTOS - Teardown and Porting

Git And Gerrit

The ART of INTERVIEWING

AARCH64 - Introduction to ARM A 64 Bit CPU

System Components - MMU/SMMU

Linux Device Drivers - Introduction

Linux Device Drivers - Controlling Hardware

FPGA Based Hardware Design - 101

Python Programming

Tech-Sync | Saved Recordings

There are various starting points towards an end. These are discussed in detail in a later section...

what you learn

Master 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.

Content List

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...

Low Level with Pyjama Brah! (Public Draft)

I am 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.

Low Level with Pyjama Brah!

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

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

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 - 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

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

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).

Problems with multiple processes and physical addresses

Exploring reasons for Memory Management

More lectures being recorded...

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

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

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...

(planned) ARM aarch64 - Bare-metal Programming

This course is being recorded at the moment and will be added soon.

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

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 ♥️

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 Half-Yearly 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.

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.

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

Feature	Us!	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. 25 ratings

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 Half-Yearly 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.