Collection of courses; a structured path to learning Firmware Engineering!.

Bestseller Beginner Intermediate

(4.9) 3000+ students enrolled.

Last updated: 1st December 2025 | English | Yearly Access.

includes

Collection of 17  Courses.

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

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.

Roadmap to Learning Embedded Systems

Low Level with Pyjama Brah! (Public Draft)

The C Language

C Pointers

C - Mastering Bit Manipulation

Data Structures (in C)

GDB (gnu debugger)

ARM Cortex M - 101 (Introduction)

ARM Cortex M - 102 (Assembly, Scheduler Design)

GNU Make and Automation

GNU Linker Scripts

FreeRTOS - Teardown and Porting

Zephyr 101

Git And Gerrit

FPGA Based Hardware Design (101)

Python Programming

the Journey

what you will master through the journey

C programming, converting to Assembly and machine code.

Grasp ARM-M programmer's models.

Write and debug (using gdb) 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, ld etc.

How Cortex-M CPUs boot.

Baremetal Programming of Cortex-M CPUs in Assembly.

Port FreeRTOS to new target using minimal configuration and files.

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 Cortex-M and Assembly.

Use QEMU, GDB, Makefiles for low-level debugging.

Develop baremetal firmware, drivers; print “Hello, World!” on UART.

Understand ARM Cortex-M registers and 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.

Build mental models of CPU, memory, state machines, scheduling.

Tackle technical discussions on C, memory, interrupts, bit manipulation.

Using python for automation.

Hardware design on FPGA.

contents and preview lectures ...

Roadmap to Learning Embedded Systems

This short course introduces the field of embedded systems, how to pursue it and what are the some of the possible journeys.

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

Operators

Types of operators

Arithmetic Operators

Arithmetic Operators at Assembly Level

Relational Operators

Relational Operators - Assembly Level decomposition

Use of Relational Operators

Logical Operators

Logical Operator - Assembly decomposition

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

GDB - Debugging, Scripting and Tricks

A short course on GDB and how to use it for debugging C based applications running on Linux as native applications and Firmware Code running on a development board.

Introduction, plan and setup

course intro and environment setup

A quick demo - gdb look and feel

what is GDB and how it works

what is GDB

A model for how GDB works and dependencies

gdb commands

debug symbols, file, run, break and continue

DETOUR - fixing the annoying messages

list, layout, next, step

info commands

printing, setting variables, memory locations

setting conditional break points

watch points - write, read and access

printing ro examining memory regions - array, pointers

backtrace and stack frame navigation

Automation using command file and GDB dashboard

gdb command file, automation and dumping memory regions

GDB Dashboard

Debugging a Hardware Target

Hardware Setup

Demo - Debugging Hardware Target

Conclusion and Next steps

Conclusion

Notes

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

Stacks

The concept of stacks and various operations

Implementing the push operation

Implementing the peek and pop operations

Trees

Concept of Tree and Terminology

Operations on Tree and managing nodes

Adding node to tree and challenges

Walking the Tree and explore free pointers

strategy to find slot for new node

Implementing the algorithm to find free slot

Implementing the add() api (part - 1)

Debugging the add() api and confirming the addition of nodes

traversal - preorder, inorder, post-order and breadth first

Graphs

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

Fixing errors and Testing on real hardware

Correcting the Linker script and reasoning about SVC

Working with the Hardware, uploading the code

Loading the code to board and exploring task scheduling

Conclusion and Next steps

Exploring the Scheduler implementation

Summary and What to pursue next

Zephyr 101

Zephyr is a very popular RTOS backed by the Linux foundation, for IoT devices. This is a short course that introduces the OS and guides through executing a `hello world!` application on Cortex-M3 controller.

Introduction

What to expect

Notes

Environment Setup

About the Environment

Setup Docker and Test

Fetch and Setup the Zephyr SDK

Components for Zephyr development

Setting up the Zephyr SDK

Setting up Python Virtual Environment

Getting the Source code and Compiling the Firmware

Fetch the Zephyr OS Source Code

Update the Zephyr OS repository

Compiling the Application

Running on QEMU

Load and run the firmware on QEMU

Exiting QEMU

Code Organisation

TODO

Conclusion and Next Steps

TODO

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

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

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

How to learn Firmware Development

Every embedded system has a CPU with firmware running on it. Being able to master Firmware engineering comes down to mastering the following -

1. C Language

C is the workhorse when it comes to firmware. While there are languages like Rust and C++ that can be used, C is still the dominant language. Primarily because of the ease with which the hardware can be manipulated. Mastering C is must.

The C Language course will guide you through hands on experiments using the RISC-V CPU emulated using QEMU. You will learn the basics of Assembly, RISC-V instruction set, how to boot the CPU, Precondition to be full-filled before the CPU can run machine code generated as a result of the C code. The goal is to enable you precisely predict what the CPU will do as a result of the line of C code!

C Pointer and C - Bit Manipulation are focused on hammering home how pointers and bit-manipulation are used. While the C Language course covers, these two tracks focus on demonstrating the use.

Data Structures (in C) is a dedicated to showing how various data-structures are implemented using the C language and how to use them in design.

2. Tools and Utilities

Knowing how to write C code is the bare minimum, being able to automate the build and control the placement of code in memory banks is a non-negotiable for a firmware engineer. These two topics are covered exclusively in the GNU Make and GNU Linker Scripts courses.

Besides these, almost always, there is a need to debug the firmware - the course on GDB covers the details of debugging firmware on a hardware target.

3. CPU - ARM Cortex-M

Every firmware engineer should know a CPU architecture end-to-end. We chose ARM Cortex-M. These are the most popular 32-Bit CPUs on the planet at the moment.

ARM Cortex-M (101) introduces the ARM M line of CPUs and the programming model making you comfortable with how the CPU boots, how it handles interrupts and how it interacts with the memory. This course is focused on making you comfortable and confident about find the information you need about this architecture.

The ARM Cortex-M (102) - Scheduler Design using Assembly focuses on guiding you through the assembly instructions available to program the M class CPUs. The types of assembly instructions and how to write assembly programs using them. To deepen your understanding of the programmer’s model of the CPU and the exception handling, the course ends with you implementing a scheduler to switch between two assembly programs. This project is deliberate and opens the door to learning operating systems.

4. Operating Systems

The CPUs in Embedded Systems are responsible for driving the system from one state to another. The states are managed in firmware and often there is a separate software sequence managing individual state machine (if there is more than one).

The firmware then is based on an RTOS. We picked FreeRTOS and Zephyr because they are very popular. The FreeRTOS - Teardown and Porting course is focused on diving into the details of how the RTOS boots and how you can enable it on a new board/target. This course builds on the Scheduler implementation in assembly from the ARM Cortex-M (102) course and uses the insights to explain the implementation of the FreeRTOS kernel.

The course on Zephyr, focuses on introducing the OS and how to get it going.

5. Other helpful skills

When developing a firmware, you will usually work with a team. The course on Git/Gerrit explain how git version control can be used for effective collaboration.

All too often there is also some automation using Python involved, the course on Python Programming focuses on demonstrating how python is used. As part of this course, you will learn the object-oriented programming by comparing the language constructs to C.

Finally, the FPGA based Hardware Design (101) is to introduce you to the world of hardware engineering and how digital logic is designed. At the end of this course, you will be able to think and reason very clearly about the code you write and how the hardware reacts as a result.

Hardware

The courses are based on the emulation target for ST32VLDISCOVERY available in QEMU. Getting the hardware is not strictly require, but if you do so - we recommend you setup the environment locally on a linux machine.

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

Mahmad Bharmal

Embedded Engineer (L4), Google

Computer Engineer holding a Master’s degree in Embedded Systems. Worked on improving the debug architecture of the Bluetooth Firmware at Intel. Worked on ARM64 architecture, programming and exercising latest ARMv8/v9 extensions - programming in low-level FWs (ARM TF-A, trusty) and kernels (LK and Linux) at Google. Currently exploring the Pixel Watch Kernel and BSP (boot-loaders, Linux Kernel, Android HALs and frameworks).

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.

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

(not a hard requirement) ST32VLDISCOVERY board.

Who this course is for

Students in Academia with C as a subject in the course.

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

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.

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 this pack are well structured and focused on developing a skill.

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.

What is the hardware used?

We used ST32VLDISCOVERY when developing the courses and examples. Getting the hardware is optional since we use the emulation target available in QEMU. If you want to try all the experiments on hardware, we recommend doing so on a local Linux machine.

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.

What is the validity period?

You will have access to the content for 365 days, post which the access expires and you may need to subscribe again.

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@pyjamacafe.com and be sure to include the details of your past investment. We will work on a custom discount for you.