Idle task and idle hook in FreeRTOS

Introduction

The idle task runs when no other tasks are ready to run. The idle hook lets you add your own code to run during this idle time.

You want to save power by putting the CPU to sleep when nothing else needs to run.

You want to perform background maintenance tasks without disturbing main tasks.

You want to monitor system health or statistics when the system is idle.

You want to clean up memory or resources during idle time.

Syntax

FreeRTOS

void vApplicationIdleHook(void) {
    // Your code here
}

The idle hook function must be named exactly vApplicationIdleHook.

You must enable the idle hook in FreeRTOSConfig.h by setting #define configUSE_IDLE_HOOK 1.

Examples

This example puts the CPU to sleep when idle to save power.

FreeRTOS

void vApplicationIdleHook(void) {
    // Put CPU to low power mode
    __WFI(); // Wait For Interrupt instruction
}

This example counts how many times the idle hook runs.

FreeRTOS

void vApplicationIdleHook(void) {
    // Increment a counter to track idle time
    idleCounter++;
}

Sample Program

This program creates one task that prints a message every second. The idle hook increments a counter whenever the system is idle.

FreeRTOS

#include "FreeRTOS.h"
#include "task.h"
#include <stdio.h>

volatile int idleCounter = 0;

void vApplicationIdleHook(void) {
    idleCounter++;
}

void vTaskFunction(void *pvParameters) {
    for (;;) {
        printf("Task running\n");
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}

int main(void) {
    xTaskCreate(vTaskFunction, "Task1", configMINIMAL_STACK_SIZE, NULL, 1, NULL);
    vTaskStartScheduler();
    // Scheduler should never return
    for (;;) {}
    return 0;
}

Important Notes

The idle task has the lowest priority and runs only when no other tasks are ready.

Do not block or call delay functions inside the idle hook; it must return quickly.

The idle hook is a good place for low priority background work or power saving.

Summary

The idle task runs when no other tasks are ready.

The idle hook lets you add code to run during idle time.

Enable the idle hook in FreeRTOSConfig.h and implement vApplicationIdleHook.

Practice

1.

What is the main purpose of the FreeRTOS idle task?

easy

A. It runs when no other tasks are ready to run

B. It handles all interrupts in the system

C. It manages memory allocation for tasks

D. It schedules tasks based on priority

Solution

1. Step 1: Understand the role of the idle task

   The idle task runs only when no other higher priority tasks are ready to execute.

2. Step 2: Compare options with the idle task role

   Options A, B, and C describe other system functions, not the idle task's main role.

3. Final Answer:

   It runs when no other tasks are ready to run -> Option A

4. Quick Check:

   Idle task runs when system is idle = D [OK]

Hint: Idle task runs only when CPU is free from other tasks [OK]

Common Mistakes:

• Confusing idle task with interrupt handler
• Thinking idle task manages memory
• Assuming idle task schedules other tasks

2.

Which of the following is the correct way to enable the idle hook in FreeRTOS?

#define configUSE_IDLE_HOOK  ???

easy

A. NULL

B. 0

C. TRUE

D. 1

Solution

1. Step 1: Identify the config macro for idle hook

   The macro configUSE_IDLE_HOOK enables or disables the idle hook feature.

2. Step 2: Determine the correct value to enable it

   Setting configUSE_IDLE_HOOK to 1 enables the idle hook; 0 disables it.

3. Final Answer:

   1 -> Option D

4. Quick Check:

   Enable idle hook = 1 [OK]

Hint: Enable idle hook by setting configUSE_IDLE_HOOK to 1 [OK]

Common Mistakes:

• Using 0 disables the idle hook
• Using NULL or TRUE are invalid for this macro
• Confusing with other config macros

3.

Given the following code snippet, what will be printed?

void vApplicationIdleHook(void) {
    static int count = 0;
    count++;
    if (count == 3) {
        printf("Idle hook called 3 times\n");
    }
}

Assuming the idle hook is enabled and the system is idle for 5 cycles, what is the output?

medium

A. No output

B. Idle hook called 5 times

C. Idle hook called 3 times

D. Idle hook called 1 time

Solution

1. Step 1: Analyze the idle hook function behavior

   The function increments count each time it runs and prints only when count == 3.

2. Step 2: Determine output after 5 idle cycles

   On the 3rd call, it prints the message once. On calls 4 and 5, no print occurs because the condition is only for count == 3.

3. Final Answer:

   Idle hook called 3 times -> Option C

4. Quick Check:

   Print only at count 3 = A [OK]

Hint: Print triggers only once when count equals 3 [OK]

Common Mistakes:

• Assuming print happens every call
• Confusing count with number of prints
• Expecting output for all 5 cycles

4.

Identify the error in this FreeRTOS idle hook implementation:

void vApplicationIdleHook(void) {
    int count = 0;
    count++;
    if (count == 5) {
        // Do something
    }
}

medium

A. Idle hook function must return an int

B. count should be declared static to retain its value

C. count variable should be global

D. Idle hook cannot use if statements

Solution

1. Step 1: Understand variable lifetime in idle hook

   The variable count is declared inside the function, so it resets to 0 every call.

2. Step 2: Fix variable to retain value across calls

   Declaring count as static keeps its value between calls, allowing counting.

3. Final Answer:

   count should be declared static to retain its value -> Option B

4. Quick Check:

   Use static for persistent variables in idle hook [OK]

Hint: Use static variables to keep count across idle hook calls [OK]

Common Mistakes:

• Declaring count as local resets it every call
• Expecting idle hook to return a value
• Thinking global variable is required

5.

You want to perform a low-priority background task every time the system is idle, but only after 10 idle cycles. Which is the best way to implement this using the idle hook?

hard

A. Use a static counter in vApplicationIdleHook and run the task when counter reaches 10, then reset it

B. Create a high priority task that waits for 10 ticks before running

C. Run the background task directly in the main function loop

D. Disable the idle hook and run the task in the timer interrupt

Solution

1. Step 1: Understand the requirement for background task timing

   The task should run during idle time, specifically after 10 idle cycles.

2. Step 2: Use idle hook with a static counter

   Using a static counter inside vApplicationIdleHook allows counting idle cycles and running the task at the right time.

3. Step 3: Evaluate other options

   High priority task or timer interrupt are not suitable for low-priority background work during idle. Running in main loop is not reliable in FreeRTOS.

4. Final Answer:

   Use a static counter in vApplicationIdleHook and run the task when counter reaches 10, then reset it -> Option A

5. Quick Check:

   Idle hook + static counter for delayed background task [OK]

Hint: Count idle calls with static variable, run task at target count [OK]

Common Mistakes:

• Using high priority task defeats idle purpose
• Running task in main loop ignores FreeRTOS scheduling
• Disabling idle hook loses idle time execution