Recently, I used FreeRTOS in a project and became curious about idle tasks and hook functions, so I wanted to understand what these two are used for. Here, I will share some of my insights.1. Idle TaskThe idle task is a task that is created by default after the FreeRTOS system starts, and it has the lowest priority.The idle task is a special task; when there are no other tasks that need to run in the system, the system will schedule the idle task to execute, ensuring that there is always a task running in the system.The code flow of the idle task is as follows; interested friends can take a look:OS_Start() –> vTaskStartScheduler() –> prvCreateIdleTasks() –> Task function in portTASK_FUNCTION( prvIdleTask, pvParameters )The implementation of the idle task involves several key steps:1) Check if there are tasks that need to be deleted2) Handle tasks with the same priority as the idle task3) Execute the idle hook function (if defined)4) Enter low-power mode when appropriate.The loop of the idle task roughly includes the following content:
for( ;; ){ // Check if any task has deleted itself prvCheckTasksWaitingTermination(); // If there are tasks with the same priority as the idle task, decide whether to yield CPU immediately based on configuration if (listCURRENT_LIST_LENGTH( &( pxReadyTasksLists[ tskIDLE_PRIORITY ] ) ) > 1) { taskYIELD(); } // Call the idle hook function if( configUSE_IDLE_HOOK == 1 ) { vApplicationIdleHook(); } // Enter low-power mode if( configUSE_TICKLESS_IDLE != 0 ) { // Other code omitted... }}Analyzing the code of the idle task reveals that the idle task is responsible for releasing memory of deleted tasks, including memory that users have allocated, which is usually also released in the idle task.Generally speaking, if it involves releasing system resources or memory recovery, it is recommended to execute it in the idle task to ensure that memory can be released in a timely manner when there are no other tasks that need to run in the system.In summary, the idle task is very important in the system; its existence ensures that the system is in a “busy” state, and at any time, there must be a task that can be executed.The responsibilities of the idle task can be summarized as follows:(1) Memory Management:The idle task is responsible for releasing the resources of tasks that have been deleted, including the task’s stack and Task Control Block (TCB). This is achieved by checking if any task has deleted itself and allowing the idle task to clean up the resources.(2) Handling Idle Priority Tasks:When there are other tasks with the same priority as the idle task in the system, the idle task will decide whether to yield the CPU immediately based on the configuration configIDLE_SHOULD_YIELD. This helps ensure that user tasks can obtain timely CPU time.(3) Executing the Idle Task Hook Function:If an idle hook function is defined, this function is called during each idle task cycle.(4) Low-Power Tickless Mode:During idle cycles, FreeRTOS can stop periodic system tick interrupts, allowing the microcontroller to enter low-power mode, thereby reducing power consumption.2. Hook FunctionsThe term hook function sounds a bit strange, haha. Why is it called a hook?In simple terms, a hook function is essentially a callback function!This mechanism is used in operating systems to fulfill certain functionalities, and almost all hook functions called by FreeRTOS need to be implemented by the developer.Most hook functions are configured and trimmed in the FreeRTOSConfig.h file.
When you want to use a certain hook function feature, you need to define the hook function and add the logic you want to implement.For example, for the idle task hook function mentioned earlier, when vApplicationIdleHook() is enabled, you need to define this function in your code:
void vApplicationIdleHook(void) { // Define the operations to be implemented by the hook function }What are the common types of hook functions?FreeRTOS provides many hook functions, each with its specific usage conditions and purposes. Common hook functions and their usage conditions are as follows:(1) Idle Task Hook Function:The role of the idle task has been explained earlier. To use the idle task hook function, the configuration is as follows:
1) Set configUSE_IDLE_HOOK to 1 in FreeRTOSConfig.h 2) Implement void vApplicationIdleHook() function(2) Tick Hook FunctionThe tick hook function is called whenever a tick interrupt occurs and is periodic. It is generally used to update system time and check the task delay list. The configuration is as follows:
1) Set configUSE_TICK_HOOK to 1 in FreeRTOSConfig.h 2) Implement void vApplicationTickHook() functionSince the tick hook function is called in the system clock tick interrupt, which is provided by hardware timers, its cycle time is quite precise. It is generally used for operations that require high time accuracy.For example:1) Periodically trigger ADC sampling, generate PWM signals, toggle levels, etc.2) Statistics on CPU usage, task execution time, etc., can record tick counts and calculate the proportion of task running time.3) Periodically check task stacks, memory information, task status, etc.(3) Stack Overflow Hook FunctionThis hook function is quite useful; it will be called if a task’s stack overflows, allowing you to be promptly informed of the stack overflow.To use this stack overflow hook function, you need to configure:
1) Set configCHECK_FOR_STACK_OVERFLOW to 1 or 2 in FreeRTOSConfig.h 2) Implement void vApplicationStackOverflowHook(TaskHandle_t pxTask, char *pcTaskName) function(4) Daemon Task Hook FunctionThis hook function is called when the daemon task (such as Timer service) starts.Common applications of this hook function include:1) Execute initialization code (such as initializing peripherals, configuring hardware resources, etc.) before the daemon task runs.2) Monitor or debug the startup process of the daemon task.3) Dynamically adjust the priority or stack size of the daemon task.Configuration for using this hook function:
1) Set configUSE_DAEMON_TASK_STARTUP_HOOK and configUSE_TIMER to 1 in FreeRTOSConfig.h 2) Implement void vApplicationDaemonTaskStartupHook() function(5) Task Creation/Deletion Hook FunctionThis hook function is triggered when a task is created or deleted.This is actually very useful, especially when you need to dynamically create/delete tasks in the code. It can be used to monitor whether task creation/deletion is successful and take corresponding measures in case of failure to ensure system stability.Configuration for the task creation hook function:
1) Define configUSE_APPLICATION_TASK_TAG as 1 in FreeRTOSConfig.h (Note: This function may differ in different FreeRTOS versions) 2) Register the hook function vApplicationTaskCreateHook()Configuration for the task deletion hook function:
1) Define configUSE_TASK_HOOKS as 1 in FreeRTOSConfig.h (Note: This function may differ in different FreeRTOS versions) 2) Register the hook function vApplicationTaskDeleteHook()Note:1) Note that hook functions are called in the kernel context, so they must be concise and non-blocking. Especially in the deletion hook function, do not call functions that may cause task blocking (such as delay functions), as the task is about to be deleted.2) Hook functions are commonly used for debugging, resource monitoring, resource tracking, etc. If you do not need them, you can choose not to implement them, and it is better to disable them through configuration macros.3) Ensure that when implementing hook functions, the function names and prototypes match exactly to avoid linking errors. After all, finding bugs can be quite exhausting! If you find this article helpful, please give it a follow!Give it a thumbs up!