Mastering Real Time Operating System (RTOS) with ARM Cortex Mx Processor, STM32Fx , Arduino

Kiran N, Embedded Software and Firmware Engineer

Play Speed
  • 0.5x
  • 1x (Normal)
  • 1.25x
  • 1.5x
  • 2x
97 Videos (11h 26m)
    • Overview

      4:54
    • What is real time application ??

      9:22
    • What 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
    • Project Creation and FreeRTOS Source code Integration

      8:58
    • Project Creation and FreeRTOS Source code Integration contd

      7:01
    • MCU specific initialization

      11:27
    • Testing FreeRTOS Application on Target

      14:22
    • Testing FreeRTOS Application on Target Contd

      7:04
    • About freertos

      6:26
    • freertos licensing

      9:30
    • FreeRTOS API Interfac

      4:36
    • FreeRTOS File Directory Structure

      13:03
    • Overview of FreeRTOS Scheduler

      4:51
    • Overview of FreeRTOS Task Management

      1:37
    • Overview of FreeRTOS Memory Management

      16:43
    • 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:14
    • What exactly Kernel Tick ISR does

      9:40
    • Who configures the Kernel Tick Timer

      6:42
    • Tracealyzer for FreeRTOS

      6:54
    • How Tracealyzer works

      6:57
    • System Requirements to use Tracealyzer

      5:07
    • Installing Percepio Tracealyzer Application and Percepio Eclipse plugin

      6:18
    • Integrating Tracealyzer Recorder Library

      6:57
    • Integrating Tracealyzer Recorder Library contd

      7:51
    • Testing Tracealyzer

      6:23
    • 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
    • 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

      8:26
    • Co operative Scheduling

      3:51
    • 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
    • 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