Mastering FreeRTOS using STM32

Discover how rtos schedulers manage multitasking with preemptive, cooperative, round-robin, fixed priority, and earliest deadline first policies, ensuring deterministic task switching and balanced cpu time across ready tasks.

Explore how RTOS memory management allocates and frees memory for tasks, stacks, and queues, contrasting static memory allocation, dynamic memory allocation, memory pools, and stack overflow protection for deterministic performance.

Explore inter-task communication in RTOS, covering semaphores, mutexes with priority inheritance, event flags, queues, and buffers. Learn best practices to avoid deadlocks and latency, including direct-to-task notifications and signaling mechanisms.

Master interrupt handling in RTOS by learning how ISRs signal tasks via binary semaphores, queues, or direct task notifications, while keeping ISRs minimal and deferring heavy work to tasks.

Configure a simple UART debugging template on STM32 with HL drivers and HAL interfaces, enabling a virtual COM port and transmitting messages at 115200 baud to monitor program flow.

redirect printf to the UART peripheral to print debugging messages directly over UART using the STM32 stdio wrapper and the _io_putc function, or use int _write for the same effect.

Explore how the FreeRTOS configuration file controls compile-time options to enable or disable features like dynamic and static memory, heap choices, and task scheduling, alongside CMSIS-RTOS v2 wrappers.

Explain how FreeRTOS utilizes core resources on a microcontroller, including SysTick timer, MSP/PSP stacks, and pendSV for context switching. Show estimated flash and RAM usage for task stacks.

Explore dynamic memory allocation in FreeRTOS on stm32, why malloc and calloc are unsuitable for embedded systems, and how pvPortMalloc and pvPortFree enable thread-safe, deterministic memory management with heap1–heap5.

Learn how heap_1 in FreeRTOS uses a fixed pre-rtos heap to allocate task control blocks and stacks before startup. Ensure determinism and prevent memory fragmentation in embedded systems.

Explore heap 2, 3, and the upgraded heap 4 in FreeRTOS for STM32, highlighting best-fit allocation and fragmentation risks. Heap 3 offers thread-safe malloc, while heap 4 adds features.

Explore FreeRTOS heap utilities and macros for memory profiling, including config total heap size, get free heap size, minimum ever free heap size, vtask get info, and malloc failed hook.

Enable static memory allocation in FreeRTOS by setting configSUPPORT_STATIC_ALLOCATION to 1, letting developers supply memory blocks and use static kernel functions like xTaskCreateStatic for compile-time knowledge and determinism.

Master task creation in FreeRTOS using static and dynamic APIs, restricted and privileged variants, and affinity for multi-core CPUs, covering TCB and stack RAM requirements.

Learn to create multiple FreeRTOS tasks on STM32, define task functions, start the scheduler, and debug via the serial port to observe task switching and per-task counters.

Discover how FreeRTOS schedules tasks by priority, preemption, and time slicing, and how changing priorities with vTaskPrioritySet and configMaxPriorities shapes CPU time.

Explore how task priorities shape FreeRTOS scheduling on STM32 by debugging priority scenarios, time slicing, and delays, showing how high and low priority tasks share CPU time.

create a new task from within another task in FreeRTOS, using xTaskCreate, and explore shared variable access and time-sliced execution.

Explore FreeRTOS task states on STM32, contrasting continuous and event-driven tasks, and learn how ready, running, blocked, and suspended states interact with priorities, timeouts, queues, and semaphores.

Learn how FreeRTOS delay functions work, comparing vTaskDelay and vTaskDelayUntil, converting milliseconds to ticks with pdMS_to_ticks, and using the blocked state for periodic or timed tasks.

Explore how the idle task maintains a runnable state in FreeRTX, with config idle yield, and how task delete and task hook function enable memory cleanup and background processing.

Use vTaskDelete to remove a running task in FreeRTOS, enabled when config include vTaskDelete is set to 1; if a task is created dynamically, idle frees its memory.

Explore nonreentrant functions and why they are unsafe with interrupts and concurrent calls. Learn how to make code reentrant or thread and ISR safe using local variables and synchronization.

Learn how local storage in free RDoS stores per-task data in the task control block (TCB) to support thread-specific state and manage re-entrant versus non-re-entrant functions.

Explore how real-time scheduling algorithms decide which task runs on a single-core system. Learn about fixed priority, preemption, time slicing, and round-robin behavior, plus tickless idle power savings.

Master preemptive scheduling with and without time slicing in FreeRTOS, including config preemption, config time slicing, idle tasks, and round-robin behavior among same-priority tasks.

Discover how FreeRTOS queues provide FIFO inter-task communication with fixed length and item size, enabling decoupled data transfer; compare queue by copy versus queue by reference, and note memory management.

Explores how FreeRTOS queues are accessed by multiple tasks and ISRs, with blocking reads and writes, priority-based unblocking, and queue sets for multi-queue blocking.

Create and manage FreeRTOS queues with xQueueCreate or xQueueCreateStatic, setting queue length and item size. Send data with xQueueSendToBack or xQueueSendToFront, waiting with ticks when full, and reset with xQueueReset.

Learn how to receive data from a FreeRTOS queue with xQueueReceive, which copies the front item to a buffer, removes it, and uses xTicksToWait to wait.