Detailed Explanation of FreeRTOS Task Management and Communication Mechanisms

1 Task Creation and Management

Task Creation

Use xTaskCreate() to create a task:

BaseType_t xTaskCreate(    TaskFunction_t pxTaskCode,     // Task function (entry)    const char * const pcName,     // Task name (for debugging)    configSTACK_DEPTH_TYPE usStackDepth, // Stack size (in words)    void * const pvParameters,     // Task parameters    UBaseType_t uxPriority,        // Priority (0~configMAX_PRIORITIES-1)    TaskHandle_t * const pxCreatedTask // Task handle (can be NULL));

Note: The task function must conform to the prototype void (*TaskFunction_t)(void *).

Task Deletion

vTaskDelete(TaskHandle_t xTaskToDelete); 

You can delete any task, including itself (pass in NULL).

Task Suspension and Wakeup

Suspend a task:vTaskSuspend(TaskHandle_t xTask);
Wake up a task:vTaskResume(TaskHandle_t xTask);

Used to control the execution timing of tasks, but care should be taken to avoid permanently suspending tasks, which can waste system resources.

2 Queues

Definition

A queue is a typical FIFO (First In First Out) data structure used for data communication between tasks or between interrupts and tasks.

Creating a Queue

QueueHandle_t xQueueCreate(UBaseType_t uxQueueLength, UBaseType_t uxItemSize); 

uxQueueLength: Maximum number of items the queue can hold
uxItemSize: Size of each item (in bytes)

Sending Data to the Queue

xQueueSend(xQueue, pvItemToQueue, xTicksToWait); 

xTicksToWait = 0: Non-blocking send
portMAX_DELAY: Block until successful (requires blocking API support)

Receiving Data from the Queue

xQueueReceive(xQueue, pvBuffer, xTicksToWait); 

3 Semaphores

Semaphores are used for synchronization and resource access control between tasks. FreeRTOS provides several types of semaphores:

1. Binary Semaphore

Used for synchronizing events or interrupt signals (like a “phone booth” model).

Create:xSemaphoreCreateBinary();
Take:xSemaphoreTake(xSemaphore, xBlockTime);
Give:xSemaphoreGive(xSemaphore);

Feature: The same task cannot take it again without releasing it.

2. Mutex

Suitable for protecting access to shared resources (like peripherals, memory, etc.) to prevent resource conflicts.

Create:xSemaphoreCreateMutex();

Characteristic: Only the task that obtained the mutex can release it; incorrect release can lead to deadlock.

3. Counting Semaphore

Used for resource counting or controlling concurrency (like a “parking space” model).

Create:xSemaphoreCreateCounting(uxMaxCount, uxInitialCount);
Current remaining resource count:uxSemaphoreGetCount(xSemaphore);

4. Recursive Mutex

Allows a task to take the lock multiple times within the same logic, with each take needing a corresponding release.

Create:xSemaphoreCreateRecursiveMutex();
Take:xSemaphoreTakeRecursive(xMutex, xBlockTime);
Give:xSemaphoreGiveRecursive(xMutex);

4 Software Timers

Software timers are used for delaying or periodically executing certain task functions, in a non-blocking manner.

Creating a Software Timer

TimerHandle_t xTimerCreate( const char * const pcTimerName, TickType_t xTimerPeriodInTicks, UBaseType_t uxAutoReload, // pdTRUE: periodic; pdFALSE: one-time void * const pvTimerID, TimerCallbackFunction_t pxCallbackFunction // Timer callback);

To start the timer, you need to call xTimerStart(). The system tick rate is defined by configTICK_RATE_HZ (usually set to 1000, meaning 1ms per tick).

5 Event Groups

Event groups provide a bit manipulation mechanism, suitable for multi-event synchronization (for example, KEY1 & KEY2 -> LED1_ON).

Creating and Setting

Create:xEventGroupCreate();
Set bits:xEventGroupSetBits(xEventGroup, uxBitsToSet);

Waiting for Event Bits to be Satisfied

xEventGroupWaitBits( xEventGroup, uxBitsToWaitFor, xClearOnExit, // whether to clear bits on exit xWaitForAllBits, // wait for all bits vs any bit xTicksToWait ); 

6 Task Notifications

Task notifications are a lightweight communication mechanism that is more efficient than queues and semaphores (supports up to 32-bit notification values).

Sending Notifications (in Interrupt)

xTaskNotifyFromISR(xTaskToNotify, ulValue, eAction, pxHigherPriorityTaskWoken); 

ulValue: Notification value
eAction: Notification mode (e.g., overwrite, accumulate)
pxHigherPriorityTaskWoken: Used for context switching in interrupts

Waiting for Notifications

xTaskNotifyWait( ulBitsToClearOnEntry, ulBitsToClearOnExit, pulNotificationValue, xTicksToWait ); 

Using task notifications can efficiently replace traditional mechanisms like semaphores and events.

Appendix: Common FreeRTOS Configuration Parameters

Macro Definition	Meaning
`<span>configMAX_PRIORITIES</span>`	Maximum number of priorities (usually 5 or higher)
`<span>configMINIMAL_STACK_SIZE</span>`	Minimum stack size for tasks (128 means 512 bytes)
`<span>configMAX_TASK_NAME_LEN</span>`	Maximum length of task names (usually 16)
`<span>configTICK_RATE_HZ</span>`

Below is a complete and well-structured FreeRTOS demo example code, including the basic process of task creation and starting the task scheduler, suitable for beginners to reference:

✅ Example: FreeRTOS Task Creation and Scheduler Start (in main function)

#include "FreeRTOS.h"#include "task.h"#include <stdio.h>// Task handles (optional)TaskHandle_t Task1Handle = NULL;TaskHandle_t Task2Handle = NULL;// Task function definitionsvoid Task1(void *pvParameters){    while (1)    {        printf("Task 1 is running...\n");        vTaskDelay(pdMS_TO_TICKS(1000));  // Delay 1000ms    }}void Task2(void *pvParameters){    while (1)    {        printf("Task 2 is running...\n");        vTaskDelay(pdMS_TO_TICKS(500));  // Delay 500ms    }}// Main functionint main(void){    // Create Task 1    xTaskCreate(        Task1,                   // Task function        "Task1",                 // Task name (for debugging)        128,                     // Stack size (in words, 128 x 4 = 512 bytes)        NULL,                    // Parameters        2,                       // Priority (range: 0 ~ configMAX_PRIORITIES-1)        &Task1Handle             // Task handle    );    // Create Task 2    xTaskCreate(        Task2,        "Task2",        128,        NULL,        1,                       // Lower priority than Task 1        &Task2Handle    );    // Start the task scheduler    vTaskStartScheduler();    // Will never reach here unless stack is insufficient or scheduler fails to start    while (1);}

🔍 Explanation

xTaskCreate(): Registers the task and prepares it for scheduling, must be called before vTaskStartScheduler().
vTaskDelay(): Implements task delay, using pdMS_TO_TICKS() macro to avoid hardcoding.
vTaskStartScheduler(): Starts the scheduler, after which FreeRTOS will automatically manage task switching.