Mastering RTOS: Hands on FreeRTOS and STM32Fx with Debugging

About Course

>> The Complete FreeRTOS Course with Programming and Debugging <<

Latest update: RTOS debugging using SEGGER SystemView Trace tools, STM32 hal. Peripheral APIs and More examples are added.

Subtitles(CCs) and transcripts are available for this course.

Dedicated Support team to answer Q/A

The course is designed for Beginners to Advanced audience.

Short Description:

“The Biggest objective of this course is to demystifying RTOS practically using FreeRTOS and STM32 MCUs”

STEP-by-STEP guide to port/run FreeRTOS using development setup which includes,

1) STM32CUBEIDE + STM32F4xx + FreeRTOS + SEGGER SystemView

Demystifying the complete Architecture (ARM Cortex M) related code of FreeRTOS which will massively help you to put this kernel on any target hardware of your choice.

Development board used in this course:

If you already have an STM32 Based development board, then please continue using the same. The course uses STM32F407x DISCOVERY(STM32F407G-DISC1) board

Software used in this course:

1) STM32CUBEIDE which can run on all OS platforms(WIN/OSX/LINUX) (free)

2) SEGGER Systemview software free edition

Operating system information:

WIN/MAC/UBUNTU

Debugging FreeRTOS with SEGGER SYSVIEW software

In this course debugging freeRTOS with SEGGER Systemview software is covered with STEP-BY-STEP guidance. please watch the preview videos.

Embedded Debugging and Quizzes

Debugging embedded code is really interesting and learning various debugging techniques and features are very much essential to have a good grip on embedded debugging.

Also, the course consists of various interview questions which will test your knowledge gained !.

My promise!

I will personally answer your questions about this material, either privately or in a group discussion. If you are in any way not satisfied, for any reason, you can get, No questions asked a full refund from Udemy within 30 days. But I am confident you won’t need to. I stand behind this course 100% and am committed to helping you.

Learning order of FastBit Embedded Brain Academy Courses,

If you are a beginner in the field of embedded systems, then you can take our courses in the below-mentioned order.
This is just a recommendation from the instructor for beginners.

1) Microcontroller Embedded C Programming: absolute beginners(Embedded C)

2) Embedded Systems Programming on ARM Cortex-M3/M4 Processor(ARM Cortex M4 Processor specific)

3) Mastering Microcontroller with Embedded Driver Development(MCU1)

4) Mastering Microcontroller: TIMERS, PWM, CAN, RTC,LOW POWER(MCU2)

5) Mastering Microcontroller: STM32-LTDC, LCD-TFT, LVGL(MCU3)

6) Embedded System Design using UML State Machines(State machine)

7) Mastering RTOS: Hands-on FreeRTOS and STM32Fx with Debugging(RTOS)

8) ARM Cortex M Microcontroller DMA Programming Demystified(DMA)

9) STM32Fx Microcontroller Custom Bootloader Development(Bootloader)

10) Embedded Linux Step by Step using Beaglebone Black(Linux)

11) Linux device driver programming using Beaglebone Black(LDD1)

Understanding various RTOS concepts with FreeRTOS Programming and Debugging
Learn Complete Step by step method to run FreeRTOS on STM32 MCUs using OpenSTM32 System Workbench
Using STM32 Standard Peripheral Driver APIs to configure peripherals
FreeRTOS Task Creation , Deletion, Scheduling using with code examples
Important scheduling policies of FreeRTOS Scheduler
FreeRTOS Stack and Heap Management
Right ways of Synchronizing between tasks using Semaphores.
Right ways of Synchronizing between a task and an interrupt using semaphores
Synchronization between multiple events and a task
FreeRTOS Queue management like creation, sending, receiving, blocking, etc
Implementing mutual exclusion between Tasks using Mutex services and semaphores
Understanding Context Switching with in detail code explanation
Understanding Architecture specific codes like SVC_handler, PendSV_handler, SysTick Handler line by line
You will learn about kernel Tick timer, its importance, the kernel tick frequency and its configuration details.
Understanding complete ARM Cortex M and FreeRTOS Priority model and its configuration related informations
FreeRTOS Debugging using SEGGER SystemView Software
Lots of articles which explains line by line the ARM Cortex M related FreeRTOS architecture specific codes
Low power instructions use case in FreeRTOS scenario
Lots of coding exercises
Debugging with SEGGER software toolkit by taking snapshot and continuous mode recording

Course Content

Overview of the course

A Message from the Professor
What is this course all about

05:34

RTOS Introduction

Development board used in our courses

IDE install (OpenSTM32 System Workbench)

Downloading and Installing FreeRTOS

Creating FreeRTOS based project for STM32 MCUs

FreeRTOS Task Creation

FreeRTOS Hello World App and Testing on hardware

Semi hosting and UART setup

Understanding ARM Semi-hosting feature

09:43
Using MCU peripherals and implementing initialization codes

04:13
MCU pin configuration table and UART VCP connection

10:20
UART pin configuration using STD. Periph. Libray APIs

10:38
Exercise UART Parameter Inits

06:35
Exercise UART Printmsg implementation using std periph. libary

08:13
Exercise Testing UART prints

03:30
Exercise Testing our hello world application over UART

03:48
Exercise Usage of taskYIELD() and explanation

08:10

FreeRTOS app debugging using SEGGER SystemView Tools

Downloading SEGGER SystemView Software

01:28
SEGGER SystemView Installation and first look

03:34
What is SEGGER SystemView

03:46
SEGGER SystemView visualization modes

04:09
SEGGER SystemView Target integration preparation

06:31
SEGGER SystemView Target integration step by step

14:20
SEGGER SystemView taking FreeRTOS trace using snapshot mode

08:05
SEGGER SystemView jlink reflash utility download

03:00
SEGGER SystemView taking FreeRTOS trace using Continuous recording

05:40
Analyzing the trace An Overview

11:52
Analyzing FreeRTOS helloword application using SystemView Trace

06:07

IDLE Task and Timer Svc Task of FreerRTOS

FreeRTOS Scheduler

FreeRTOS and ARM Cortex Mx Arch. Specific details

Context switching

Exercise Button and LED Task and Interrupt Coding

Exercise Button and LED task

04:37
Exercise Adding FreeRTOS source to project

03:17
Exercise Task create of button and LED task

07:12
Exercise GPIO configuration code

08:10
Exercise GPIO configuration code cntd.

00:00
Exercise Task handler implementation and testing on the target

03:51
Exercise working with task and interrupt

01:07
Understanding GPIO Interrupts delivery in STM32 MCUs

19:22
Exercise LED task and Button interrupt handling code implementation

08:46
Understanding Trace of button interrupt and led task execution

09:34

FreeRTOS Task Notification

FreeRTOS Licensing model and API interface

Overview of FreeRTOS Memory manage, STACK and Synchronization services

FreeRTOS Kernel Coding Style

FreeRTOS Task Deletion

ARM Cortex M Interrupt Priority and FreeRTOS Task Priority

Interrupt safe APIs and Task yielding

FreeRTOS Task States

FreeRTOS Importance of Delay APIs

FreeRTOS Hook Functions

FreeRTOS Scheduling Policies

FreeRTOS Queue Management

Queues and its features

04:49
Creating a Queue

04:47
Sending data to Queue

04:14
Receiving data from Queue

02:20
Exercise FreeRTOS Command Processing app

06:19
Exercise Task Implementation

03:06
Creation of Command Queue

07:10
Creation of UART write Queue

01:18
Coding for UART interrupt settings

11:55
UART ISR implementation

05:04
Implementing menu print task

05:36
Implementing UART write task

04:05
UART ISR coding

03:53
Implementation of command handling task

06:05
Implementation of command processing task

04:54
Command processing helper function implementation

07:25
Software timers discussion

13:41
Software timers discussion contd.

00:55
Solving race condition between task and ISR

03:42
Memory freeing and RTC testing

08:18
Full Application testing

02:25

Semaphore for Synchronization, mutual exclusion and Interrupt Management

Synchronization and Mutual exclusion in real world

06:31
Creation of a semaphore

03:51
Different types of semaphores

03:54
Binary semaphore to synchronize between two Tasks

03:56
Exercise Synchronization between 2 Tasks

08:45
Binary Semaphore to synchronize between task and Interrupt

04:54
Events latching

08:36
counting semaphore to latch and process multiple events

04:23
Exercise Synchronizing a Task and Multiple Events

08:10

Mutual exclusion

Add this certificate to your resume to demonstrate your skills & increase your chances of getting noticed.

Student Ratings & Reviews

No Review Yet

About Course

What Will You Learn?

Course Content

Overview of the course

A Message from the Professor

What is this course all about

RTOS Introduction

What is Real Time Application(RTAs)

What is Real Time Operating System(RTOS)

RTOS vs GPOS Task Scheduling

RTOS vs GPOS Latency

RTOS vs GPOS Priority inversion

What is Multitasking

Development board used in our courses

About MCU Development board

STM32F4 Discovery and Nucleo Board Details

ST-Link Driver Installation

ST Link Firmware Upgrade

IDE install (OpenSTM32 System Workbench)

Downloading Open STM32 System Workbench

Installing Open STM32 System Workbench

Downloading and Installing FreeRTOS

Downloading FreeRTOS From freertos.org

Installing FreeRTOS

Creating FreeRTOS based project for STM32 MCUs

Creating FreeRTOS based project for STM32 MCUs Part-1

Creating FreeRTOS based project for STM32 MCUs Part-2

Creating FreeRTOS based project for STM32 MCUs Part-3

Creating FreeRTOS based project for STM32 MCUs Part-4

Creating FreeRTOS based project for STM32 MCUs Part-5

Understanding SystemCoreClock variable

FreeRTOS Task Creation

What is task

Task Create API

Scheduling of Tasks

FreeRTOS behind the scene Task Creation

FreeRTOS Hello World App and Testing on hardware

Exercise Introduction

Exercise Understanding MCU clock configuration Part-1

Exercise Understanding MCU clock configuration Part-2

Exercise Creating FreeRTOS Tasks Part-1

Exercise Creating FreeRTOS Tasks Part-2

Exercise Testing via debugger Part-1

Exercise Testing via debugger Part-2

Semi hosting and UART setup

Understanding ARM Semi-hosting feature

Using MCU peripherals and implementing initialization codes

MCU pin configuration table and UART VCP connection

UART pin configuration using STD. Periph. Libray APIs

Exercise UART Parameter Inits

Exercise UART Printmsg implementation using std periph. libary

Exercise Testing UART prints

Exercise Testing our hello world application over UART

Exercise Usage of taskYIELD() and explanation

FreeRTOS app debugging using SEGGER SystemView Tools

Downloading SEGGER SystemView Software

SEGGER SystemView Installation and first look

What is SEGGER SystemView

SEGGER SystemView visualization modes

SEGGER SystemView Target integration preparation

SEGGER SystemView Target integration step by step

SEGGER SystemView taking FreeRTOS trace using snapshot mode

SEGGER SystemView jlink reflash utility download

SEGGER SystemView taking FreeRTOS trace using Continuous recording

Analyzing the trace An Overview

Analyzing FreeRTOS helloword application using SystemView Trace

IDLE Task and Timer Svc Task of FreerRTOS

IDLE task and its significance

FreeRTOS Timer Services task and other details

FreeRTOS Scheduler

Overview of FreeRTOS Scheduler

FreeRTOS Scheduler and xTaskStartScheduler() API explanation

Understanding implementation of xPortStartScheduler() of port.c

FreeRTOS and ARM Cortex Mx Arch. Specific details

FreeRTOS Kernel interrupts

RTOS Tick and SysTick Timer explanation

Who configures the RTOS Tick Timer

What RTOS Tick ISR (SysTick ISR) does summary

Context switching

Introduction to context switching