Detailed Explanation of FreeRTOS Task Management Mechanism

1. Basic Concepts of Tasks

In FreeRTOS, a task is the basic unit of execution in the system, similar to an independent small program, with its own execution flow, stack space, local variables, and Task Control Block (TCB). Each task focuses on specific functionality, collaborating to achieve the overall goals of the system. For example, in a smart home control system, there might be tasks responsible for collecting temperature and humidity data, processing user commands, and controlling household appliances.

2. Task States

Ready State

Meaning: The task is ready to run, meets execution conditions, and is waiting for the scheduler to allocate CPU time slices. All tasks in the ready state are arranged in the ready task list according to their priority, with higher priority tasks placed ahead, having a better chance of obtaining CPU usage rights first.
Example: In a multi-sensor data collection system, once all sensors are initialized, the corresponding collection tasks enter the ready state, waiting for their turn to collect the latest data.

Running State

Meaning: The state where the CPU resources are currently occupied, executing the task code. On a single-core processor, only one task can be in the running state at any given time. Through the scheduler’s rapid switching, it creates the illusion that multiple tasks are running simultaneously.
Example: After the system starts, the default idle task usually obtains CPU execution rights first, entering the running state, mainly responsible for performing low-priority work, such as reclaiming memory fragments, when the system is idle.

Blocked State

Meaning: The task cannot continue executing for some reason, actively giving up CPU usage rights and entering the blocked state. Common reasons for blocking include waiting for an event to occur (such as waiting for a semaphore, new messages in a message queue), executing a timed delay operation (such as needing to pause for a while before continuing), or waiting for resources to become available (such as waiting for a shared peripheral to complete the previous operation). Tasks in the blocked state are placed in the corresponding blocked list, and when the blocking condition is lifted, the task will re-enter the ready state.
Example: In a network communication task, after sending data, the task waits for the confirmation message from the receiver; at this time, the task enters the blocked state until it receives the confirmation message, after which it will return to the ready state to continue subsequent operations.

Suspended State

Meaning: The task is forcibly paused by an external instruction and does not participate in task scheduling until it receives a resume instruction to re-enter the ready or running state. The difference between the suspended state and the blocked state is that the blocked state is actively waiting for a condition, while the suspended state is usually a pause operation imposed by other tasks or the system for management needs (such as debugging or temporary resource control).
Example: When debugging a complex embedded system, if a developer suspects a particular task might have issues, they can manually suspend that task to troubleshoot the problem, resuming its execution once the issue is resolved.

Please open in the WeChat client

3. Task State Transitions

From Ready State to Running State

: When the scheduler determines that the currently running task needs to switch (such as time slice expiration or a higher priority task becoming ready), it selects the highest priority task from the ready task list, switches its state to running, and uses context switching to start executing the new task.
From Running State to Ready State

: There are mainly two situations. One is when using a time-slice round-robin scheduling strategy, the task’s time slice runs out, and the scheduler places it back in the ready task list, waiting for the next round of scheduling; the other is when a higher priority task enters the ready state, the currently running task is preempted and returns to the ready state queue.
From Running State to Blocked State

: The task actively calls blocking-related functions during execution, such as vTaskDelay() for timed delays, at which point the task enters the blocked state, waiting for the delay time to end; or calls xSemaphoreTake() to wait for a semaphore, and if the semaphore is unavailable, the task will also block until the semaphore is released.
From Blocked State to Ready State

: When the conditions awaited by the blocked task are met, such as the timed delay period expiring, the awaited semaphore being released, or new messages in the message queue, the task will be awakened, transitioning from the blocked state back to the ready state, waiting for the scheduler to schedule it again.
From Running State to Suspended State

: By externally calling the vTaskSuspend() function, the specified task is suspended, immediately stopping its execution and entering the suspended state, not participating in scheduling until the <code>vTaskResume() or <code>vTaskResumeFromISR() (used for resuming tasks from interrupts) functions are executed to restore the task.
From Suspended State to Ready State

: When the function to resume the task is executed, and the task has no other blocking conditions, the suspended task will directly return to the ready state, waiting for the scheduler to arrange its execution.

4. Task Creation

Defining the Task Function

: Developers first need to write the task function, which includes the specific execution logic of the task. It is an infinite loop structure to ensure the task continues running unless deleted or exited actively. For example:

void vTaskFunction(void *pvParameters){    for(;;)    {        // Task specific operation code, such as reading sensor data, processing data, controlling peripherals, etc.        vTaskDelay(1000 / portTICK_PERIOD_MS); // Delay 1 second to avoid excessive CPU usage    }}

Setting Task Parameters

: When creating a task, a parameter can be passed to the task function, which is received through the pvParameters pointer, allowing the task to perform differentiated operations based on different parameters, enhancing the task's versatility.
Specifying Task Priority

: Each task has a priority, with lower numerical values indicating higher priority. When creating a task, developers should reasonably set the priority based on the task’s importance and real-time requirements. For example, a task that monitors emergency alarm signals in real-time should be assigned a higher priority to ensure timely response.
Allocating Task Stack

: The task stack is used to store local variables, function return addresses, and other information during task execution. The stack size should be determined based on the task’s complexity and possible maximum nesting depth; too small may lead to stack overflow, while too large wastes memory resources. The xTaskCreate() function is used to create tasks, as shown below:

xTaskCreate(vTaskFunction, "Task Name", stack_size, pvParameters, task_priority, &task_handle);

Where vTaskFunction is the task function, "Task Name" is the task name (for debugging identification), stack_size is the stack size, pvParameters is the parameter passed to the task, task_priority is the task priority, and &task_handle is the task handle used for subsequent operations on the task (such as deletion, suspension, etc.).

5. Task Deletion

When a task has completed its mission or needs to be removed due to system resource adjustments, the vTaskDelete() function can be called to delete the task. After the task is deleted, the system will reclaim the stack space, task control block, and other resources occupied by that task, making the released resources available for new tasks. For example:

vTaskDelete(task_handle);

Here, task_handle is the handle of the task to be deleted, obtained during task creation. It is important to ensure that the task is in an appropriate state when deleting it to avoid deleting critical tasks that are currently running, which could lead to system instability; it is generally recommended to perform deletion operations when the task is in a blocked state or another stable state.

6. Task Priority and Scheduling Strategies

Principles of Priority Setting

: Allocate priorities based on the real-time nature, importance, and impact on the overall functionality of the system. Assign the highest priority to tasks directly related to system safety and real-time control (such as emergency braking tasks in industrial control systems); assign lower priority to tasks such as data collection and background processing that are relatively less urgent. Additionally, consider the priority inversion problem, where a low-priority task holding resources required by a high-priority task may cause the high-priority task to be blocked for a long time. This can be avoided by reasonably using mutexes, semaphores, and other synchronization mechanisms.
Types of Scheduling Strategies

Preemptive Scheduling

: This is one of the most commonly used scheduling strategies in FreeRTOS. When a high-priority task enters the ready state, it will immediately preempt CPU usage rights from the currently executing low-priority task, ensuring real-time response for critical tasks. For example, in a medical monitoring device, when an alarm task for abnormal vital signs becomes ready, it will preempt the currently ongoing data collection task to prioritize handling the alarm information.
Time-Slice Round-Robin Scheduling

: For tasks of equal priority, the CPU time is allocated in a time-slice round-robin manner. Each task takes turns to obtain a fixed time slice (usually based on the system tick clock) to execute. When the time slice expires, the task pauses execution and returns to the ready state, waiting for the next round of time slice allocation. This strategy is suitable for scenarios where multiple tasks have similar importance and require balanced CPU resources, such as in a small server system handling requests from different users with the same priority, ensuring fairness through round-robin scheduling.

In practical applications, it is common to combine these two scheduling strategies, flexibly switching or mixing them based on different operational phases and task needs to achieve optimal system performance.