Need Help? Contact us at:

support@embeddedexpert.io

Realtime Operating Systems (RTOS) Learning Path

4 courses | 47+ hours | Complete Source Code Included

Your free gift is on its way to your inbox, but before you go

check out this very special offer, just for you!

1. FreeRTOS From Ground Up™ on ARM Processors : Old and New Editions

10+ hours of quality training | Complete source code included

This course teaches you the foundations of real-time systems and how to build real-time applications using FreeRTOS ,one of the most popular real-time operating systems for embedded systems. The course gives a detailed overview of the characteristics of the FreeRTOS real-time kernel, provides a detailed tutorial on the APIs to implement the various features of FreeRTOS and then goes on to build about 50 real-time projects .

This course does not assume prior knowledge of real-time systems and application programming. By the end of this course you should be able to build your own multitask FreeRTOS real-time applications which use all the features of a modern real-time application (such as semaphores, mutexes, event flags, hooks, queues, mailboxes etc )and test their performance.You should also be able to : Calculate the CPU Utilization of an RTOS, Understand Rate Monotonic Schedulers, port FreeRTOS to any ARM processor,Understand Round-Robin Schedulers,Understand Weighted-Round-Robin Schedulers, Understand First Come First Served Schedulers,Understand the Internals of an RTOS kernel, Implement and explain popular scheduling algorithms and so much more. Please take a look at the full course curriculum

I personally guarantee that by the end of this course you will be able to accomplish the following

Build Multitask real-time applications with FreeRTOS
Port FreeRTOS to any ARM Processor
Master FreeRTOS Task Management features
Master FreeRTOS Resource Management features
Master FreeRTOS Task Synchronization features
Master FreeRTOS Event Management features
Master CMSIS-RTOS Generic APId for FreeRTOS
Give a lecture on the FreeRTOS RealTime Kernel

Introduction
What is a Realtime Operating System (RTOS)
Understanding Context Switching
Comparing RTOS with ISR and Busy Wait Systems
The Concept of a Thread
Introduction to FreeRTOS
FreeRTOS naming conventions
Understanding FreeRTOS Macro Names
Coding : Configuring our System
FreeRTOS Thread Management
Overview of the TaskCreate functions
Coding : Creating Tasks
Coding : Creating Tasks from other Tasks
Coding : Working with Task functions
Coding : Understanding Task Priorities
Coding : Changing a Task Priority in Runtime
Coding : Reading the Priority of a Task
Coding : Suspending a Task
Coding : Resuming a suspended Task
Coding : Terminating a Task
Understanding Task States
Using the Blocked State to create delays
Coding : Blocking a Task
Coding : Executing Tasks Periodically
Overview of the Idle Task
Coding : Working with Idle Task
Overview of the Tick Hook
FreeRTOS Queue and Queueset Management
Understanding Queues and Queuesets
Coding : Working with Queues
Coding : Updating printfCoding : Synchronizing Tasks with Queues
Coding : Sending more complex data with Queues
Coding : Working with Queuesets

Understanding FreeRTOS Semaphores
Understanding Semaphores
Coding : Working with Binary Semaphores
Developing Some Drivers
Coding : Developing some driver (Pt.1)
Coding : Developing some driver (Pt.2)
Coding : Testing the drivers
Understanding FreeRTOS Semaphores (contd.)
Coding : Working with a Mutex
Coding : Working with Counting Semaphores
Gatekeepers
Coding : Implementing the Gatekeeper task
FreeRTOS Software Timers
Overview of Software Timers
Coding : Working with Software Timers
Coding : Stopping the Auto-Reload Timer during runtime
FreeRTOS Interrupt Management
Coding : Receiving data from the UART using Polling
Coding : Interacting with Interrupt Service Routines (ISRs)
Coding : Receiving an entire data packet
Understanding FreeRTOS EventGroups
Overview of EventGroups
Coding : Setting and Reading EventBits in an EventGroup
Coding : EventGroup with Multiple Setters
Coding :Synchronizing Tasks using EventGroups
Understanding FreeRTOS Notifications
Overview of Task Notifications
Coding : Working with Task Notifications
The FreeRTOS Scheduler
Understanding the FreeRTOS Scheduler
Coding : Understanding the Scheduler Configuration - Preemption Only
Coding : Understanding the Scheduler Configuration -Pseudo Timeslicing
CMSIS-RTOS Generic APIs
Introduction to CMSIS-RTOS
Coding : Creating Threads using CMSIS-RTOS2 APIs
Coding : Changing Thread priorities using CMSIS-RTOS2 APIs
Coding : Suspending Threads using CMSIS-RTOS2 APIs
Coding : Resuming Threads using CMSIS-RTOS2 APIs
Coding : Terminating Threads using CMSIS-RTOS2 APIs
Coding : Putting Threads in the Blocked State using CMSIS-RTOS2 APIs
Coding : Creating Software Timers using CMSIS-RTOS2 APIs
Coding : Creating Mutexes using CMSIS-RTOS2 APIs
Coding : Creating Semaphores using CMSIS-RTOS2 APIs
Coding : Creating Message Queues using CMSIS-RTOS2 APIs
Coding : Creating EventFlags using CMSIS-RTOS2 APIs

2. ARM Assembly Programming From Ground Up 1

15+ hours of quality training | Complete source code included

Covering ARM Systems Design, Architecture and Practical Assembly Programming, this is the most comprehensive ARM assembly course online. I'll take you step-by-step through engaging and fun video tutorials and teach you everything you need to know to succeed in ARM Assembly Programming. This course comes in two parts. This is the first part of the course.

By the end of this part you will master the ARM Instruction Set, the Thumb Instruction Set and the Thumb-2 Instruction Set. You will be able to create data structures such as FIFOs and LIFOs in Assembly. You will also be able design complex algorithms for performing Binary Search in assembly , and solving advance mathematical problems.

Setting Up Keil uVision 5
Download Keil uVision 5
Installing Keil uVision 5
Installing Packs
Overview of Keil uVision 5
Introduction to ARM Assembly Language
The Computing Devices
Number Systems
Assembly Tools
Translating Bits to Commands
Assembly Syntax
ARM Design Philosophy and RISC Architecture
The RISC Design Philosophy
The ARM Design Philosophy
Embedded Systems with ARM Processors
ARM Bus Technology and AMBA Bus Protocol
Memory
Peripherals
Von Neumann and Harvard architecture
Cache and Tightly Couple Memory
Memory Management extensions
Co-processor extensions
The Programmer's Model
Data Types
Processor Modes
ARM7TDMI Registers
ARM7TDMI Vector Table
ARM Cortex-M Registers
ARM Cortex-M Vector Table
ARM Data Flow Model
The Pipeline
ARM Processor Family
ARM Cortex-A and Cortex-R
ARM Cortex-M
Section Summary
Assembler Rules and Directives
Structure of an Assembly Module
The ARM,Thumb and Thumb-2 Instruction Sets
Predefined Register Names
Frequently used Directives
Coding : Simple Assembly Project with Startup File
Coding : Importance of the Reset_Handler
Coding : Simple Assembly Project without Startup File
Coding : Allocating space in memory with the SPACE Directive
Overview of Binary Operators
Coding : Swapping Register Content
Coding : Renaming Registers

Load-Store Instructions
Memory Demarcations
Frequently used Load/Store Instructions (Part I)
Frequently used Load/Store Instructions (Part II)
Frequently used Load/Store Instructions (Part III)
Pre-Indexed Addressing
Post-Indexed Addressing
Endianness
Defining Memory Areas
Coding : Copying Data from One Memory Location to Another
Dealing with Constants and Literals
The Encoding of the MOV Instruction
The ARM Rotation Scheme
Loading Constants with the LDR Instruction
Loading Constants with the MOVW and MOVT Instructions
Loading Labels with ADR, ADRL and LDR Instructions
Coding : Solving a Simple Equation Method 1
Coding : Solving a Simple Equation Method 2 - Storing Constants in Memory
Coding : Solving a Simple Equation Method 3 - Using Register Relative Addressing
Coding : Solving a Simple Equation Method 4 - Compact Code
Arithmetic and Logic Instructions
Flags
The N and V Flags
The Z and C Flags
Compare/Test Instructions
Overview of Boolean Operations
Coding : Experimenting with the PSR Flags
Coding : Experimenting with the Carry Flag
Coding : Experimenting with the Overflow Bit
Introduction to Shifts and Rotations
Understanding Logical Shifts
Understanding Rotations
Some Shift and Rotate Examples
Coding : Experimenting with the Logical Shift Left Instruction
Overview Addition and Subtraction Instructions
Coding : Finding the Maximum Value in a Dataset
Coding : Adding Signed Data
Coding : Finding the Minimum Signed Data
Overview of Saturated Math Instructions
Overview of Multiplication Instructions
Multiplying by Constants
Coding : Solving a More Complex Equation
Overview of the Division Instruction
Coding : Performing Division by Subtraction
Overview of DSP Instructions
Fractional Notation
Bit Manipulation Instructions
Understanding Q Notation
Branch and Loop Instructions
Introduction to Branches and Loops
Branching
Compare and Branch
Loops in Assembly
Conditional Execution
The IF-THEN Block
Coding : Computing the Factorial of a Number using the IF-THEN Block
Tables
Introduction to Tables
Navigating a Lookup Table
Coding : Constructing a Floating-Point Lookup Table
Coding : Constructing a Floating-Point Lookup Table - Version 2
Coding : Creating a Program to Rapidly Compute the Sine of a Value (Part I)
Creating a Program to Rapidly Compute the Sine of a Value (Part II)
Coding : Creating a Program to Rapidly Compute the Sine of a Value (Part III)
Coding : Creating Jump Tables
Stack Instructions
Introduction to the Stack
The LDM and STM Instructions
Syntax of the PUSH and POP Instructions
Coding : Creating a Simple Stack
Coding : Saving and Restoring Context
Mixing C and Assembly
Coding : Inline Assembly
Coding : Exporting a Subroutine from Assembly to C
Coding : Exporting a Function from C to Assembly

STM32 General Purpose Input/Output(GPIO)
Coding : Assigning Symbolic Names to Relevant GPIO Registers
Coding : Toggling GPIO Outputs
Coding : Toggling GPIO Outputs with the BSRR Register
Coding : Developing the GPIO Input Driver (Part I)
Coding : Developing the GPIO Input Driver (Part II)
Writing Assembly Programs with STM32CubeIDE
Coding : Writing a Simple Assembly Project
Coding : Developing a GPIO Driver (Part I)
Coding : Developing a GPIO Driver (Part II)
Coding : Converting Keil uVision Assembly to CubeIDE GCC Assembler Project
STM32 Universal Asynchronous Receiver-Transmitter(UART)
Overview of the UART Protocol
Coding : Assigning Symbolic Names to Relevant UART Registers
Coding : Writing the UART Initialization Subroutine
Coding : Sending Characters through the UART
Coding : Testing the UART Transmit (TX) Subroutine
Coding : Writing the UART Receive (RX) Driver
Coding : Combining UART RX and TX
Coding : Calling UART Subroutines from C code
STM32-The System Tick Timer
Overview of the System Tick Timer
Coding : Assigning Symbolic Names to Relevant SysTick Registers
Coding : Writing the Systick Init Subroutine
Coding : Testing the SysTick Driver
STM32 General Purpose Timers (GPTM)
Overview of General Purpose Timers
Coding : Assigning Symbolic Names to Relevant GPTM Registers
Coding : Developing the General Purpose Timer Driver
STM32 Analog to Digital Converter (ADC)
Overview of the ADC
Coding : Assigning Symbolic Names to Relevant ADC Registers
Coding : Writing the ADC Driver
Coding : Testing the ADC Driver
Coding : Calling ADC Subroutines from C code
TM4C123 General Purpose Input/Output(GPIO)
Overview of ARM Cortex-M General Purpose Input/Output Module
Coding : Assigning Symbolic Names to Relevant GPIO Output Registers
Coding : Writing the GPIO Output Driver
Coding : Toggling GPIO Outputs
Coding : Assigning Symbolic Names to Relevant GPIO Input Registers
Coding : Writing the GPIO Input Driver
TM4C123 System Tick Timer
Overview of the System Tick Timer
Coding : Assigning Symbolic Names to Relevant SysTick Registers
Coding : Writing the SysTick Timer Driver
Coding : Creating Delay Subroutines with SysTick Timer
TM4C123 Universal Asynchronous Receiver-Transmitter(UART)
Overview of the UART Protocol
Coding : Assigning Symbolic Names to Relevant UART Registers
Coding : Writing the UART Driver
Coding : Testing the UART Driver

3. Build Your Own RealTime OS (RTOS) From Ground Up™ on ARM 1

13+ hours of quality training | Complete source code included

This course teaches you how to build a Real-Time Operating Systems through intensive practice and theory. It starts by getting you excited through an introduction to the internals of a Real-Time Kernel on ARM Processors, which you shall implement yourself in code.Then we move on to learn all there is about Real-Time Operating Systems, their various parts, how they work and then we finally build our own Real-Time Operating System exploring different scheduling algorithms and Inter-Thread communication tools.

At the end of this course you should be able to build your own Real-Time Operating System from scratch, give your own lecture on Real-Time Operating Systems, be able to build a Round-Robin Scheduler, be able to build a Periodic Scheduler, be able to calculate the CPU utilization of your RTOS, be able to build an OS Kernel etc. Please see the course curriculum section to find out all the amazing content awaiting you.

I personally guarantee that by the end of this course you will be able to accomplish the following

Build a Real-Time Operating System from Scratch
Build Round-Robin Schedulers
Build Cooperative Schedulers
Build Periodic Schedulers
Build First Come First Served Scheduler
Build Rate Monotonic Schedulers
Build a board support package from scratch
Calculate the CPU Utilization of an RTOS
Understand the OS Support Features of the Cortex-M Architecture
Understand the Internals of an RTOS Kernel
Be Implement to implement and explain popular scheduling algorithms

Setting Up Keil uVision 5
Download Keil uVision 5
Installing Keil uVision 5
Installing Packs
Changing the Compiler
Introduction
Microcontroller choices
Overview of the STM32F4-DISCOVERY Board
Overview of the TM4C123 Tiva C LaunchPad
Overview of the STM32F4- NUCLEO Board
Other components
Internals of A Real-Time Kernel on ARM Processors
Introduction
Coding : Setting Up the Project
Coding : Analyzing the Reference Documents
Coding : Pin configuration
Coding : Testing pin configuration
Coding : Adding a Time Base
Coding : The Blocking Code
Coding : The Exception Stack Frame
Coding : The Exception Stack Frame (PART II)
Coding : Creating the Stack Frames
Coding : Switching Threads
Introduction to Real-time Operating Systems
What is an RTOS?
Performance Metrics of Real Time Operating Systems

Thread Control Block (TCB)
Features of the Thread Control Bock
Implementing a Thread Control Block
The Scheduler and Scheduling Algorithms
The Scheduler
Process vs. Thread
Classification of Schedulers
Preemption
Scheduler Criteria
CPU Utilization
Scheduling Algorithm Optimization
Overview of Popular Scheduling Algorithms
First Come First Served (FCFS) Scheduler
Round Robin (RR) Scheduler
Round Robin (RR) Scheduler (PART II)
Quanta
Weighted Round Robin (WRR) Scheduler
Internals of the Round Robin Scheduler
Context Switching
The Context Switching process

The Kernel
The Kernel
RTOS Scheduler : Using SysTick Exceptions only
Introduction
Coding : Project Setup
Coding : Building the Kernel interface file
Coding : Building the Kernel components ( Thread Control Block and Thread Stack)
Coding : Building the Kernel components ( osKernelAddThread )
Coding : osKernelLaunchThread
Coding : Building the Kernel's Scheduler in assembly (PART I)
Coding : Building the Kernel's Scheduler in assembly (PART II)
Coding : Building the Kernel's Scheduler in assembly (PART III)
Coding : Building the Kernel's Scheduler in assembly (PART IV)
Testing the RTOS
BOOT Sequence
Cortex-M Boot Sequence PART I
Cortex-M Boot Sequence PRT II
Introduction to Threads
The Thread
Classification of Threads

Software Flows
Busy Wait System
Multi-Threaded Systems (With ISRs)
Real-Time Systems
The Stack
Stack & Memory Map
Stack Manipulation
Overview of Cortex-M OS Support Features
Inside the Microcontroller
Operation Modes
The Shadow Stack Pointer
SVC Exceptions
Coding : Creating SVC Services (PART I)
Creating SVC Services (PART II)
Coding : Creating SVC Services (PART III)
Creating SVC Services (PART IV)
Coding : Creating SVC Services (PART V)
Coding : Creating SVC Services (PART VI)
PendSV Exceptions
Exclusive access instructions
The SysTick

4. Build Your Own RealTime OS (RTOS) From Ground Up™ on ARM 2

9+ hours of quality training | Complete source code included

Round Robin Scheduler Recap
Review on basic RTOS concepts
Coding : Creating osKernel files
Coding : Writing the osKernel Initialization functions
Coding : Writing the osKernelAddThreads function
Coding : Writing the osKernelLaunch function
Coding : Writing the osSchedulerLaunch routine in Assembly (Part I)
Coding : Writing the osSchedulerLaunch routine in Assembly (Part II)
Coding : Cooperate Schedulers
The PendSV Thread Switcher
Period Scheduling
Coding : Type 1 Periodic Scheduling
Coding : Type 1 Periodic Scheduling with Multiple Periodic Threads
Coding : Type 2 Periodic Scheduling : Using Hardware Interrupts
Coding : Type 3 Periodic Scheduling : Using Thread Control Blocks
Coding : Type 4 Periodic Scheduling : Using TCB and Hardware Interrupt
Board Support Package (BSP)
Coding : Developing the GPIO Output Board Support APIs (Part I)
Coding : Developing the GPIO Output Board Support APIs (Part II)
Coding : Testing the GPIO Output Board Support APIs
Coding : Developing the ADC Board Support APIs
Coding : Developing the TIMER Board Support APIs
Coding : Developing the GPIO Input Board Support APIs
Coding : Setting Up Probes

Inter-Thread Communication
Semaphores Recap
Coding : Creating a SpinLock Semaphore
Coding : Using Semaphores for Mutually Exclusive LCD Access
Coding : Synchronizing Tasks using Semaphores (Rendezvous)
Coding : Creating a Cooperative Semaphore
Coding : Creating the osThreadSleep API
Inter-Thread Data Transfer
Coding : Sending Data between Threads using Mailboxes
Coding : Sending Data between Threads using FIFO Queues
Priority Scheduling
Coding : Developing A Priority Scheduler
Sporadic Scheduling
Coding : Scheduling Sporadic Threads
Fixed Scheduling
Coding : Developing a UART Driver for monitoring results
Coding : Building a Finite State Machine
Coding : Building a Finite State Machine (continued)
Coding : Implementing a Fixed Scheduler with a Finite State Machine

NOT UNDERSTANDING THE CODE

Sometimes I could get my firmware to work but I couldn’t understand a large portion of the code.

I didn’t know what some of the registers were doing. "Why do we write this hexadecimal number into that particular register ?" I would often ask.

CODE NOT WORKING - WASTED TIME

Other times I could understand every line of code in the firmware but couldn’t get the firmware to work.

CANNOT BUILD ANYTHING NEW -LACK OF CONFIDENCE, IMPOSTER

Because I wasn’t good enough, I couldn’t build exactly what I wanted if there were no already made drivers and libraries out there that I could use. Worst of all I couldn’t even get another microcontroller to work apart from the microcontroller used in class.

Long story short, I overcame all of this....

I devised a plan to master the fundamentals...

Quickly read the sections of interest in the datasheet...

Created my own firmware development checklist...

Created my own study guide...

I started creating courses to help other people like yourself master embedded systems development in the most efficient way possible, no waste of time, no frustrations. There is no need for you to go through the same roadblocks and frustrations I went through some years ago.

Our courses have been reviewed by 1000+ students

Here are some of the reviews

Now it's time for you also to benefit from the...

Modern Embedded-C
From Ground Up

I'm Ready to Enroll Get Instant Access When You Get Started Today

Here's a recap of

EVERYTHING You'll Get

When You Purchase This AMAZING Offer!

1. FreeRTOS From Ground Up™ on ARM Processors ($49.99 Value)
2. ARM Assembly Programming From Ground Up 1 ($49.99 Value)
3. Build Your Own RealTime OS (RTOS) From Ground Up™ on ARM 1 ($49.99 Value)
4. Build Your Own RealTime OS (RTOS) From Ground Up™ on ARM 2 ($49.9 Value)

Total Value: $199.96

But today, you're getting all of this...

For Only $69.99

I'm Ready To Buy!Get Instant Access When You Get Started Today

30 Day Money Back Guarantee

Remember, I have no doubt you will love the training but should in case you are not completely satisfied you can request a refund within 30 days of purchase and you shall be fully refunded with no questions asked.

Sounds fair ?

I know there are some websites out there that offer you something cool for a low price, but then stick you into some program that charges your card every month.

This isn't one of them. There's NO hidden cost.

Thanks for taking the time to read this letter and I hope you enjoy the training!

-Israel N Gbati