Teach on Udemy

Turn what you know into an opportunity and reach millions around the world.

Learn More

Your cart is empty.

Keep shopping

Learn FreeRTOS from scratch

Name: Learn FreeRTOS from scratch
Rating: 2.8 (91 reviews)

Learn about FreeRTOS basics. Practise it's APIs with different examples.

Created byAbdur Rehman Khalil

Last updated 5/2017

English

What you'll learn

Understand RTOS Concepts in FreeRTOS context
Working knowledge of FreeRTOS APIs
Understand of FreeRTOS Environment and Coding Style
Use Hardware Peripherals in FreeRTOS Application Development
Apply for Job in Embedded Industry

Course content

7 sections • 55 lectures • 2h 17m total length

Introduction to the Course2:27
This Lecture gives you an introduction to the Video.
Introduction to FreeRTOS1:09
This lecture gives you an introduction to the FreeRTOS.
Why use Real-Time Kernel3:53
This lecture helps you to figure out why you should use a Real-Time Kernel.
Introduction to Multi-Tasking in Small Embedded Systems2:42
This lecture gives you an introduces you to Multi-Tasking in Small Embedded Systems.
Required Tools and Hardware0:11
This Lecture lists down all Tools and Hardware you are going to need through out this course.
Before you Start...0:29
This Lecture contains the things you should know before you start...

Introduction0:22
This Lecture introduces this section.
Download all Required Software0:14
This lecture contains a list of all software we are going to use through out this course and links to download them.
STM32 Board Firmware: Checking if up-to-date and Updating0:36
Adding you STM32 Board to STM32CubeMX0:34
This lecture shows you how to add you STM32 MCU/Board to your STM32CubeMX Software before you can start creating the project.
Hello World: STM32CubeMX6:30
This Lecture shows you how to create a Example project in STM32CubeMX.
Hello World: SW4STM324:48
Learn to set up a SW4STM32 FreeRTOS project, navigate Inc and Src folders, integrate m_function.c/h, and configure internal builder and no-optimization builds for usart2 output.
Hello World: Running and Debugging2:03
Connect your STM32 board to your computer, install drivers, locate the serial port, then debug with SW4STM32 IDE at 115200 baud and monitor the handler task output.
Adding Tracealyzer to Project4:23
Copy the necessary C files into the FreeRTOS project and update compiler settings and macros. Configure includes and prepare for debugging with tracealyzer integration.
STM32 References documents0:30
This lecture contains a list of Reference Document for STM32 devices. This lecture also contains screenshots of commonly used pinouts for different STM32 devices.

Introduction to Task Management0:15
This Lecture introduces this section.
Creating Tasks6:00
This lecture teaches you the theory of creating tasks.
Example 1 Creating Tasks3:12
Let's create some Tasks.
Example 2 Using Task parameter2:00
Remember Task Parameters? Let's use'em.
Task Priorities3:38
This Lecture help you understand the concept of priorities in Tasks.
Example 3 Experimenting with priorities0:27
Get Ready! We are about to prioritize our tasks.
Expanding the 'Non Running' State5:20
This lecture shows you different states inside, "Non-Running" state.
Example 4 Using the Blocked state to create a delay2:00
Let's put that famous "Blocking" state to use and use it to create a delay.
vTaskDelayUntil()2:05
This lecture teaches you about the delay API function provided by FreeRTOS, itself.
Example 5 Converting the example tasks to use vTaskDelayUntil()2:02
Let's get our hands dirty and practice with this delay API provided by FreeRTOS.
Example 6 Combining blocking and non-blocking tasks2:10
Lets work with both the delays we have studied up-till now understand their differences in detail.
The Idle Task and the Idle Task Hook3:14
Well, you can still do something while sitting IDLE. This lecture teaches you how tasks can do that.
Example 7 Defining a Idle task hook function2:01
Let's get those IDLE Tasks do some work for us.
Changing Priority of a Task2:28
This lecture looks into the details of changing a task priority.
Example 8 Changing Task Priorities2:28
Let play with Task priorities on a higher level.
Deleting Task1:47
Example 9 Deleting Tasks1:19
Let's Delete some tasks.

Introduction to Queue Management0:08
This Lecture introduces this Section.
Characteristics of a Queue5:21
Using a Queue8:40
Learn to create and manage queues with xQueueCreate, send data to back or front with xQueueSendToBack and xQueueSendToFront, and retrieve or inspect messages using xQueueReceive, xQueuePeek, and uxQueueMessagesWaiting.
Example 10 Blocking when receiving from a queue5:18
Example 11 Blocking when sending to a queue or sending structures on a queue2:34
Working with Large Data2:05

Introduction to Interrupt Management0:10
This Lecture introduces this Section.
Deferred Interrupt Procesing4:49
Explore deferred interrupt processing and how binary semaphores are used for synchronization in FreeRTOS, detailing the scheme behind this coordination.
Writing FreeRTOS interrupt handler4:25
Example 12 Using a binary semaphore to synchronize a task with an interrupt6:07
Counting Semaphores5:30
Example 13 Using a counting semaphore to synchronize a task with an interrupt2:01
Using Queues within an Interrupt Service Routine2:38
Example 14 Sending and receiving on a queue from within an interrupt2:33
Build a FreeRTOS project with two tasks and two queues, where a periodic task sends five numbers to a queue and an ISR outputs strings to a printer task.

Introduction0:17
This lecture introduces you to this section.
GPIO on STM321:27
This lecture is the heart of this section. It teaches you about GPIO's on STM32. This lecture look at the GPIO types, there states and HAL GPIO driver. Understanding of content in this lecture is a pre-req. for example in the next lecture.
Blinking OnBoard LED1:43
In this lecture, we will see how we can Blink our on-board LED from a Task.
Taking Input from OnBorad Button1:22
Let's take input from a button from a Task and Turn LED ON/OFF accordingly.
The Button Trigger1:00
Why wait for button to change its state when we have Interrupts! Lets look at 'em.
Using External GPIO pins0:24
On-Board sounds good but what about External GPIOs? In this Lecture, we will look see how we can get input/set output from/to External GPIOs.

Requirements

Basic C Programming
Some familiarity with Embedded Systems
Hardware: Any STM32 Board
Motivation!

Description

Welcome to this FREE course on FreeRTOS. This Course will help you getting started with FreeRTOS. It includes hands-on practice on STM32. All Software Tools used in this course are freely available. All you need is a STM32 Board!

This course will teach you the best way to work with FreeRTOS. Using STM32CubeMX design interface, we will generate basic code for our Application Project. Then we will use SW4STM32 IDE to write, compile and debug our application code. We will also learn how to visualize the trace output.

Why this Course?

The basic aim of this course was to remove the knowledge-and-practice gap between engineering universities and embedded industry by providing interested students with the opportunity to Learn about RTOS and practice it on some hardware, for FREE!

Course Curriculum explained

The first Section gives you an introduction to the course. Then we will get all required tools, software and hardware in section two and will create and run a Hello World Project to make sure we have everything we need setup.

Next four section, Section 3-6, introduces and explains to you different RTOS concepts in context of FreeRTOS. These section introduces different APIs provided by freeRTOS to implement those concepts. These section include a variety of application to work on those APIs explaining how to actually programming them, showing there output and verifying the result by visualizing the trace output.

Now that we you have a understanding of different APIs provided by freeRTOS, Its time to move forward and start interacting with hardware. For this purpose, following sections will be included shortly:

Section 7: Interfacing Hardware (INCLUDED!!!)
Section 8: Serial Communication (coming soon)
Section 9: I2C Communication (coming soon)
Section 10: SPI Communication (coming soon)
Section 11: Using Watchdog timer (coming soon)

Now, we have a good knowledge of RTOS concepts in context of FreeRTOS and writing application for freeRTOS. It time for us to look at "freeRTOS" itself. Following Section will be included to familiarize ourselves with freeRTOS

Section 12: Writing Code, the "freeRTOS" Style (coming soon)
Section 13: freeRTOSConfig.h (coming soon)
Section 14: freeRTOS Scheduling (coming soon)

Now, that we have dealt with the basic stuff one-by-one, let rap this course up by creating a Final Project, that will include all that we have previously learned.

Section 15: A Practical Problem: Elevator Management System (coming soon)

About Course Content:

Most of the content i.e. Section 1,2, 7-15, of this course is written and produced by me for this course. However, Some of the concepts in Sections 3-6 are taken from different sources specially the from book “Using the FreeRTOS Real Time Kernel - A Practical Guide - Cortex-M3 Edition” by Richard Barry.

Hardware Requirements:

To follow along this course all you need is a STM32 Board! I am using STM32F103RbT6. You can use any STM32 board you want. When ever changes are required to be made, it's mentioned explicitly, both in lecture videos and code also.

Who this course is for:

Any one interested in learning FreeRTOS
Fresh Graduates looking to join Embedded Industry
Engineering Students
Software Development Engineers
Embedded Engineers
IoT Developers

Learn FreeRTOS from scratch

What you'll learn

Explore related topics

Course content

Introduction6 lectures • 11min

Getting started with FreeRTOS9 lectures • 20min

Task Management17 lectures • 42min

Queue Management6 lectures • 24min

Interrupt Management8 lectures • 28min

Resource Management3 lectures • 6min

Interfacing Hardware Components6 lectures • 6min

Requirements

Description

Who this course is for: