FreeRTOS - Teardown and Porting

Port FreeRTOS on a new target from scratch

Note: This course is already included in the Library Access!

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. Along the way, learn the internals of how the OS is structured and how it works.


Bestseller Beginner Intermediate

(4.9) 2000+ students enrolled.

Last updated: 12 October 2025 | English | 365 days Access.


includes

~ 5 hr  of recorded video lectures.
22  lessons.
Emulator  based experiments.
No  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.
1 End-to-end project implementations.
New content regularly added!

a message for you...

what you will master through the journey

Understand FreeRTOS and its role in embedded systems
Learn the benefits of using FreeRTOS for real-time applications
Set up development tools and Codespace for FreeRTOS
Visualize course objectives through a demo walkthrough
Master the ARM M CPU programmer’s model and essentials
Boot an ARM M CPU from scratch
Transition from assembly to C functions in FreeRTOS source
Troubleshoot function call issues in C
Locate and utilize FreeRTOS source code and documentation
Integrate the FreeRTOS kernel into a project
Fix errors in portmacro.h for platform compatibility
Configure FreeRTOSConfig.h for project needs
Enable heap for dynamic memory allocation
Set the scheduling rate for task execution
Compile the FreeRTOS kernel successfully
Run a compiled FreeRTOS binary on a target platform
Investigate task creation failures
Debug memory allocation issues using GDB
Correct boot-up code and memory initialization
Install and configure exception handlers
Diagnose and resolve hard faults
Enable and verify the FreeRTOS scheduler

course contents and preview lectures ...

Introduction and Setup

Introduces FreeRTOS, covering its purpose and importance in embedded systems development. Through a guided demo walkthrough, you will understand the course’s end goals and the tools required. The section concludes with hands-on guidance on setting up a Codespace environment, ensuring a smooth start to FreeRTOS development.

What and Why FreeRTOS
Demo walkthrough - End goal and Tools
Codespace Setup

Booting the ARM M CPU from Scratch

This section dives into the fundamentals of the ARM M CPU, exploring its programmer’s model and essential concepts critical for embedded development. Through a practical demo, you will gain hands-on experience in booting the ARM-M CPU from scratch, laying a solid foundation for integrating FreeRTOS on the platform.

Programmers model and Essentials of ARM M CPU
Demo - Booting the CPU

Exploring FreeRTOS Source

This section guides on navigating the FreeRTOS source code, starting with transitioning from assembly code to C functions. You will troubleshoot and resolve issues related to function calls in C, ensuring smooth code execution. Additionally, the section covers how to locate, download, and effectively use FreeRTOS source code and documentation for project development.

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

This section focuses on the practical steps to integrate the FreeRTOS kernel into a project. You will learn to identify and resolve errors in portmacro.h, configure FreeRTOSConfig.h for project-specific needs, and enable heap memory for dynamic allocation. The section also covers setting the scheduling rate to control task execution and guides you through achieving a successful kernel compilation for the target platform.

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

This section equips you with the skills to run a compiled FreeRTOS binary on a target platform and troubleshoot runtime issues. You will investigate why tasks fail to create, using GDB to diagnose memory allocation failures. The section concludes with correcting boot-up code and memory initialization to ensure system stability.

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

This section focuses on advanced debugging techniques for FreeRTOS. You will learn to install and configure exception handlers to manage system errors effectively. The section guides you through identifying and resolving the causes of hard faults. Finally, you will master the process of enabling and verifying the FreeRTOS scheduler to ensure seamless task execution.

Installing the Exception Handlers
Hunting the cause for the Hard Fault
Getting the Scheduling to work

What is so special about this course?

There are several courses online that dive into how to use FreeRTOS. This one take a different approach and dives into the internals of FreeRTOS and how to port it from scratch on a new micro-controller. Learning it this way will ensure that you understand the internals of this RTOS and reason better when using it.

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

FeatureUs!Others
Explain the CPU and the boot process.
Explain the minimum files to enable the FreeRTOS scheduler.
Explain the porting process.
Explain the configuration options.
Dive into the details of the implementation of the tasks.
Explain how to start the scheduler.
Explain the details of how to enable the OS for a new target without copy pasting other examples.
Develop without IDE and automated tools. Enable the port by hand from scratch.

Instructors

Mahmad Bharmal
Embedded Engineer (L4), 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.
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 learning the underlying details of how the CPU works.
Functional internet connection.

Who this course is for

Students in Academia with operating systems as a subject in the course.
Those wanting to learn assembly programming.
Those interested in the ARM Cortex-M CPU working.
Those looking to understand how a scheduler works.

FAQs

Do I need to know Assembly Language?

No. You will learning the required basics (and advance concepts) as part of the course.


Is this course good for beginners?

Familiarity is not assumed. Some idea of OS keywords can help.


Why is the course validity 365 days?

We need to maintain the servers that host the courses. At the moment we have enough capital to keep the server afloat for another year. We are striving to make this a lifetime access course. As the funds trickle in, we will revisit the validity and might update it for all the enrolled learners. It is however no a promise!


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.


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. We will not support debugs on your personal support.


Is doubt resolution support provided?

The courses is self-paced. We do not support Q/A or doubt resolution. The platform provides a way for you to ask questions that other students can respond to.


Why is the course based on emulator?

We wanted the learners to be able to experiment without investing into any hardware. Once the learner is comfortable with the material, they can try the experiment on the real hardware.