RTOS Programming Step by Step: Hands on using FreeRTOS,STM32Fx,Arduino

FastBit Embedded Brain Academy, Embedded/Firmware Engineering

Play Speed
  • 0.5x
  • 1x (Normal)
  • 1.25x
  • 1.5x
  • 2x
102 Videos (10h 53m)
    • Mastering RTOS : Promo Video

      4:32
    • Overview of the Course

      4:48
    • What is Real Time Application(RTAs) ??

      9:22
    • l2What is Real Time Operating System(RTOS)??

      5:20
    • RTOS vs GPOS-Task Scheduling

      3:33
    • RTOS vs GPOS-Latency

      5:20
    • RTOS vs GPOS-Priority inversion

      5:45
    • What is Multitasking??

      4:36
    • Why AS7 for Arduino

      6:27
    • Installing AS7 Software

      1:52
    • Creating a AS7 project for Arduino

      15:06
    • Writing Blinky Application for Arduino

      10:02
    • Downloading code to Arduino from AS7 using Flash utility software

      7:52
    • Downloading code to Arduino from AS7 using Debugger

      7:22
    • Testing virtual com port application on Arduino

      12:29
    • Adding freeRTOS Kernel to your project

      4:34
    • Running first freeRTOS application on Arduino

      3:35
    • AS7 Debugging Setp in,over,out , breakpoints, Processor status

      9:30
    • AS7 Debugging Using Watch windows

      4:59
    • AS7 Debugging Controlling LED'S using IO view

      8:10
    • FreeRTOS Heap and Stack Management

      8:21
    • Overview of FreeRTOS Synchronization and mutual exclusion Services

      8:56
    • Macros

      4:41
    • Variables

      9:36
    • Functions

      6:47
    • Exploring FreeRTOS configuration header file

      8:15
    • System clock frequency configuration

      5:21
    • What is Kernel timer and why it is needed

      9:13
    • What exactly Kernel Tick ISR does (Code exploration )

      9:40
    • Who configures the Kernel Tick Timer (Code exploration )

      6:42
    • Tracealyzer for FreeRTOS

      6:54
    • How Tracealyzer works

      6:57
    • System Requirements to use Tracealyzer

      5:07
    • Step 1 Adding Tracealyzer Recorder library to the Project

      9:00
    • Step 2 Initializing and Starting the Recorder

      9:22
    • Step 3 Running and Getting recorder memory dump and plotting

      10:27
    • What is task?

      9:18
    • Creating and Scheduling a task

      11:32
    • FreeRTOS behind the scene Task Creation

      2:36
    • Code Exercise 1 Implementation and Testing of 2 Tasks

      9:31
    • Analyzing the output of Code Exercise 1 Timing Diagram

      2:24
    • Analyzing Code Exercise 1 using Tracealyzer

      11:08
    • Code Exercise 2 Single Task Function Execution by 2 Tasks

      4:50
    • Deleting a Task

      2:27
    • Code Exercise 3 Deletion of a Task

      14:14
    • Interrupt Priority register and priority levels in ARM cortex M

      7:32
    • Priority of freeRTOS Tasks

      3:16
    • FreeRTOS Priority Configuration items

      15:51
    • FreeRTOS priority Set Get APIs

      4:59
    • Code Exercise 5 Changing Task priorities Dynamically

      6:26
    • Interrupt safe and interrupt unsafe APIs

      14:28
    • Understanding Task Yielding

      8:09
    • Running and Not Running state

      1:46
    • The Blocked state

      5:23
    • Suspended state

      3:06
    • Crude delay and its Effects

      3:41
    • Using Blocked state to create delay

      7:15
    • Code Exercise 6 Implementing delay using vTaskDelay()

      13:35
    • vTaskDelayUntil() API

      3:08
    • The Idle task and the Idle task hook function

      12:51
    • Code Exercise 9 Idle hook implementation

      9:37
    • Tick hook function

      1:44
    • Preemptive Scheduling

      6:06
    • Prioritized Preemptive Scheduling

      3:51
    • Co operative Scheduling

      8:26
    • Queues and its features

      4:55
    • Creating a Queue

      4:47
    • Sending data to Queue

      4:14
    • Receiving data from Queue

      2:20
    • Code Exercise 11 Send Receive operation on Q, also blocking on empty full Q

      12:37
    • Analyzing Code Exercise 11 using Tracealyzer

      5:44
    • Using Queues to Transfer Compound Data Types

      3:58
    • Trace output of Code Exercise 12

      5:19
    • Synchronization and Mutual exclusion in real world

      6:31
    • Creation of a semaphore

      3:50
    • Different types of semaphores

      3:54
    • Binary semaphore to synchronize between two Tasks

      3:56
    • Binary Semaphore to synchronize between task and Interrupt

      5:06
    • Code Exercise 14 Synchronization between Task and Interrupt

      10:25
    • Analyzing Code Exercise 14 using Tracealyzer

      5:56
    • Events latching

      8:36
    • counting semaphore to latch and process multiple events

      4:23
    • Code Exercise 15 Synchronizing a Task and Multiple Events

      7:38
    • Mutual Exclusion using Binary Semaphore

      6:57
    • Code Exercise 16 Mutual Exclusion between 2 tasks using Binary Semaphore

      10:16
    • Issue with Binary sema when used for Mutual exclusion

      5:23
    • Crude way to protect critical section

      3:38
    • FreeRTOS Memory Allocation Schemes and heap 1 c

      6:13
    • About PendSV and Its role in Context Switching

      10:29
    • Intro Understanding context switching code

      1:15
    • Intro 2

      1:00
    • Intro Understanding SVC handler

      0:32
    • Installing KEIL MDK 5

      2:16
    • Installing Software Packs

      2:06
    • STEP1 Adding FreeRTOS kernel to KEIL project

      3:53
    • STEP2 Adding Arch

      3:53
    • STEP3 Prepare a FreeRTOSConfig

      7:24
    • STEP4 Adding heap management file

      5:12
    • STEP5 Adding freeRTOS test application

      8:31
    • Testing and debugging on STM32 Part 1

      14:57
    • Testing and debugging on STM32 Part 2

      11:03
    • Using Percipio Tracealyzer with KEIL

      18:37