Arduino FreeRTOS From Ground Up™ : Build RealTime Projects

Convert a simple Arduino sketch into a real-time application using FreeRTOS by creating three tasks to control red, yellow, and blue leds.

Learn to debug real-time Arduino RTOS projects using a profiling tool that tracks thread activity and prints profiler values to the serial monitor to verify threads run.

Explore freeRTOS, an open-source real-time kernel, quality controlled and free for commercial use, with variants open RTOS and safe RTOS licensed by Real-Time Engineers Limited.

Explore the key features of FreeRTOS, including pre-emptive scheduling, versatile task priorities, queues, semaphores, mutexes, software timers, event groups, trace recording runtime statistics gathering, and tick-less timing on ARM processors.

Learn how FreeRTOS function names encode their return type and defining file. See examples like vtaskpriorityset, xReceive, and pvTimerGetTimerId, defined in task.c, queue.c, and timers.c.

Explore common FreeRTOS macros and their naming conventions, including file prefixes like port and task, and examine anomalies such as pdtrue and pdfalse, pdpass, pdfail.

Learn how freertos allocates processing time among tasks and uses priorities and task states to decide execution, and how to implement a task function with prototype void *pvParameters.

Learn how to create tasks in FreeRTOS using xtaskcrate, specify stack depth, task name, parameters, and priority, and manage task creation outcomes, swapped in, swapped out, and task handles.

Create real-time tasks from scratch in Arduino FreeRTOS, define leds pins, implement task functions, and use task create function with stack size and priority to control leds and serial output.

Use one FreeRTOS task function to control three LEDs by passing red, blue, and yellow as task parameters. Set pins 6, 7, 8 and create three tasks.

Explore Arduino FreeRTOS task priorities by creating three LED control tasks, toggling pins, adjusting priorities, and observing how the most ready to run task governs real-time execution.

Learn to change a running FreeRTOS task's priority using a task handle and vTaskPrioritySet, as yellow raises red's priority to 2 among three LED tasks on Arduino.

Learn how a FreeRTOS task changes its own priority at runtime using vTaskPrioritySet, with or without a task handle or null value, and see preemption in an Arduino demo.

Learn how to get a FreeRTOS task's priority on Arduino by creating tasks, using UX task priority get with task handles, and displaying results via serial output.

Learn to suspend a FreeRTOS task in an Arduino project using vTaskSuspend, with task handles and a timer-driven yellow led example.

Explore how a task suspends itself in an Arduino FreeRTOS project, using a suspend monitor and task handle changes, and observe the red, blue, and yellow task prints.

Discover how to suspend and resume a FreeRTOS task in Arduino using suspend and resume monitors, a suspended flag, and vTaskResume to coordinate a blue task with a yellow task.

Learn how to block tasks using the vTaskDelay API, convert milliseconds to ticks with pdMS_to_ticks, and implement real-time led blink patterns in a three-task FreeRTOS project.

Understand queue management in FreeRTOS, including creating queues, inter-task and interrupt communication, sending and receiving data, overwriting data when needed, and blocking on multiple queues with a five-item integer example.

Learn how to create and manage queues in FreeRTOS for Arduino, using queue handles, xQueueCreate, and data transfer with xQueueSend, xQueueSendToBack, xQueueSendToFront, and xQueueReceive, including blocking times.

Explore creating and using a simple queue in Arduino FreeRTOS, with a sender and receiver task exchanging a 32-bit value via xQueueSend and xQueueReceive, shown on serial output.

Send data from two sender tasks into a single queue and let a receiver task read it in FreeRTOS on Arduino. Learn queue creation, task parameters, and LED indicators.

Send data from two tasks to the same queue and receive from another task, printing received values and using status checks and LED indicators in FreeRTOS on Arduino.

Learn how to send custom structures onto FreeRTOS queues in an Arduino project, using a sender and receiver task, defining data source types, a struct, and queue operations.

Receive a structure from the queue with xQueueReceive, check the status. Determine the sender by the data source and print the appropriate message for sender 1 or sender 2.

Discover how cue sets let a task receive data from multiple cues without polling and identify which cue has data, on creating, adding to, and reading from cue sets.

Add queues or semaphores to a queue set with xQueueAddToSet using item handle and target set, then retrieve a handle via xQueueSelectFromSet with a wait time, returning immediately if 0.

Create queue sets in Arduino FreeRTOS by enabling queue sets, defining two queues, adding them to a queue set, and implementing two sender tasks and a receiver task.

Create two FreeRTOS sender tasks using queue sets to send messages to q1 and q2, while a receiver task reads them and a blue LED indicates transmission.

Software timers in FreeRTOS schedule a callback to run after a period or when triggered, with one-shot and auto-reload timers, and start, reset, or change period controls.

Create, start, and adjust software timers using the xTimerCreate and xTimerStart APIs. Manage timer handles, IDs, and auto reload or one shot modes, with tick conversions via pdMS_to_ticks.

Learn to create and manage one-shot and auto-reload software timers in freeRTOS, define timer periods, initialize timer handles, implement callbacks, and observe executions using tick counts.

Build and control multiple FreeRTOS software timers by creating two auto reload timers, using a single callback to handle both, starting, stopping, and counting executions to drive led indicators.

Learn to use binary semaphores for interrupt synchronization and deferred processing, enabling tasks to synchronize with interrupts and other tasks via xSemaphoreCreateBinary, xSemaphoreTake, and xSemaphoreGive.

Learn how to create a simple binary semaphore with FreeRTOS, define a semaphore handle, create a binary semaphore, and implement three LED controller tasks with serial output.

Explore how binary semaphores coordinate concurrent tasks in Arduino FreeRTOS by using xSemaphoreTake and xSemaphoreGive to serialize serial monitor access and prevent deadlock and collisions.

Enable counting semaphores in FreeRTOS to count events or manage resources, configuring max and initial counts with the counting API.

Master creating a counting semaphore in FreeRTOS, initialize the semaphore, and coordinate red, blue, and yellow LED tasks with serial output, ensuring safe access via take and give operations.

this lesson demonstrates using a counting semaphore to ensure mutual exclusion, keeping serial monitor text and led toggling single-task at a time, and shows risks when outputs run without semaphores.

Explore core real-time concepts like priority inversion, deadlock, and priority inheritance, including how higher priority tasks wait on lower priority tasks and how semaphores influence resource scheduling.

Create a mutex with xSemaphoreCreateMutex to provide mutual exclusive access to the serial monitor, then run two tasks that print without overlap.

Learn how a gatekeeper task implements mutual exclusion by serializing access to the standard output using a FreeRTOS queue, avoiding priority inversion and deadlocks.

Build a gatekeeper task in Arduino FreeRTOS to coordinate serial monitor prints via a queue. Receive messages from tasks and a tick hook interrupt and print them.