FreeRTOS: Save Memory and Speed Up by Ten Times with Task Notification Mechanism!

1. Basic Concepts

In FreeRTOS, there is an efficient and lightweight inter-task communication mechanism: Task Notification. This mechanism is used in FreeRTOS to implement unidirectional communication, event flags, counting semaphores, binary semaphores, and message passing.

The message notification mechanism in FreeRTOS can also be referred to as “Direct to Task Notifications”.

Each task (TaskHandle_t) has a built-in notification value (notification value), similar to a uint32_t type variable, initialized to 0. FreeRTOS reserves such a variable for each task to facilitate the passing of notification values.

2. Implementation Principles

The implementation principle of FreeRTOS’s Task Notification mechanism is a classic lightweight design paradigm. It utilizes a uint32_t variable within each task control block (TCB) in the kernel to achieve efficient inter-task synchronization and communication.

<1>. Infrastructure

In FreeRTOS, each task’s control block TCB_t contains a field for task notifications:

typedef struct tskTaskControlBlock
{
    ...
    volatile uint32_t ulNotifiedValue[ configTASK_NOTIFICATION_ARRAY_ENTRIES ];
    volatile uint8_t ucNotifyState[ configTASK_NOTIFICATION_ARRAY_ENTRIES ];
    ...
} TCB_t;

By default, configTASK_NOTIFICATION_ARRAY_ENTRIES == 1, meaning each task has one notification slot (one 32-bit notification value + one state bit). This can be configured for multiple slots, allowing tasks to have multiple “notification channels”.

<2>. Notification Value and State

Each notification slot consists of two parts:

Field	Description
`<span>ulNotifiedValue</span>`	Notification value (can be a count, bitmap, or a numeric value)
`<span>ucNotifyState</span>`	Notification state, three types: `<span>taskNOT_WAITING_NOTIFICATION</span>`, `<span>taskWAITING_NOTIFICATION</span>`, `<span>taskNOTIFICATION_RECEIVED</span>`

State Transition Process

Initial state: taskNOT_WAITING_NOTIFICATION

-&gt; Task calls ulTaskNotifyTake() or xTaskNotifyWait()
    -&gt; State changes to: taskWAITING_NOTIFICATION

-&gt; Other tasks or ISR send notifications
    -&gt; Notification value is modified (increment, set bits, overwrite, etc.)
    -&gt; State changes to: taskNOTIFICATION_RECEIVED

-&gt; Task unblocks and processes notification
    -&gt; State returns to: taskNOT_WAITING_NOTIFICATION

<3>. Comparison of Solutions

Why is it more efficient than semaphores or queues? This is mainly reflected in the following points:

Feature	Message Notification	Queue/Semaphore
Memory Overhead	Uses only 1 field in the task control block	Requires additional structure memory
Context Switching	Minimized, occurs only when necessary	Sometimes involves enqueue/dequeue switching
Multifunctionality	Can act as events, counters, binary semaphores, etc.	Single purpose
Speed	Extremely fast, minimal inline functions	Involves more boundary checks and copy operations

3. Interface Definitions

<1>. xTaskNotify()

BaseType_t xTaskNotify(
    TaskHandle_t xTaskToNotify,
    uint32_t ulValue,
    eNotifyAction eAction
)

Main Internal Operations

<1>. Find the corresponding TCB_t through xTaskToNotify
<2>. Operate on ulNotifiedValue based on eAction:

eSetBits: |= ulValue
eIncrement: ++
eSetValueWithOverwrite: = ulValue
eSetValueWithoutOverwrite: Only write if state != RECEIVED

<3>. Set ucNotifyState = taskNOTIFICATION_RECEIVED
<4>. If the target task is in taskWAITING_NOTIFICATION state:

Remove it from the blocked queue and place it in the ready queue
Determine if a context switch should be triggered (e.g., use portYIELD_FROM_ISR() in ISR)

<2>. xTaskNotifyWait()

BaseType_t xTaskNotifyWait(
    uint32_t ulBitsToClearOnEntry,
    uint32_t ulBitsToClearOnExit,
    uint32_t *pulNotificationValue,
    TickType_t xTicksToWait
)

Main Internal Logic

<1>. Clear the bits specified by entry: ulNotifiedValue &= ~ulBitsToClearOnEntry
<2>. If ucNotifyState != taskNOTIFICATION_RECEIVED:

Set task state to taskWAITING_NOTIFICATION
Add the task to the delay list (blocked)

<3> When notification arrives, the task unblocks:

Assign ulNotifiedValue to the user pointer
Clear the bits specified by exit
ucNotifyState = taskNOT_WAITING_NOTIFICATION

<3>. ulTaskNotifyTake()

uint32_t ulTaskNotifyTake(BaseType_t xClearCountOnExit, TickType_t xTicksToWait);

Function: Simulate Counting Semaphore

If ulNotifiedValue > 0:

Return that value (or 1)
If xClearCountOnExit == pdTRUE, clear it to 0
Otherwise decrement by 1

If the value is 0:

Set task state to taskWAITING_NOTIFICATION
Add to delay list, waiting for notification

<4>. xTaskNotifyGive()

BaseType_t xTaskNotifyGive(TaskHandle_t xTaskToNotify);

Send a “notification” to a specific task

Calling xTaskNotifyGive() will perform the following operations:

Increment the notification value of the target task ulNotifiedValue[0] (equivalent to giving a counting semaphore);
Set the notification state of that task ucNotifyState[0] to taskNOTIFICATION_RECEIVED;
If the target task is in the waiting notification state of ulTaskNotifyTake(), it will be removed from the blocked list and become ready;
If the target task has a higher priority than the current task, it can trigger a context switch.

4. Application Examples

4.1. Notification Types

FreeRTOS supports various ways of task notifications to simulate different communication/synchronization models:

<1>. Binary Semaphore Mode

Use xTaskNotifyGive() and ulTaskNotifyTake().
One notification corresponds to one release (similar to binary semaphore).

<2>. Counting Semaphore Mode

Increase count with multiple xTaskNotifyGive().
ulTaskNotifyTake(pdTRUE, xTicksToWait) will clear the value to 0 after reading.

<3>. Event Flag Mode

Use xTaskNotify() with eSetBits mode to set certain bits of the notification value.
xTaskNotifyWait() combined with ulBitsToClearOnEntry and ulBitsToClearOnExit to handle multiple event bits.

<4>. Message Mode

Use xTaskNotify() with eSetValueWithOverwrite or eSetValueWithoutOverwrite.
The notification value is passed as a message to the task.
Often combined with xTaskNotifyWait() or ulTaskNotifyTake() to retrieve.

4.2. Signal Definitions

typedef enum
{
  eNoAction = 0,            // No action, just wake up the task
  eSetBits,                 // Set specified bit positions in the notification value (event group)
  eIncrement,               // Notification value +1 (similar to counting semaphore)
  eSetValueWithOverwrite,   // Overwrite notification value
  eSetValueWithoutOverwrite // Do not overwrite notification value, fail if notification has not been taken
} eNotifyAction;

4.3. Code Examples

Simple Signal (e.g., ISR notifying a task)

void ISR_Handler(void)
{
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    vTaskNotifyGiveFromISR(xTaskHandle, &amp;xHigherPriorityTaskWoken);
    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}

void Task(void *pvParameters)
{
    for(;;)
    {
        // Block waiting for notification, block for up to 100 ticks
        ulTaskNotifyTake(pdTRUE, pdMS_TO_TICKS(100));
        // Execute task processing after being notified
    }
}

Event Bit Mode

// Sender sets event bits
xTaskNotify(taskHandle, 0x04, eSetBits);

// Receiver waits for event bits
uint32_t ulNotificationValue;
xTaskNotifyWait(0x00,      // Do not clear the value before entry
                0xFFFFFFFF, // Clear all bits on exit
                &amp;ulNotificationValue,
                portMAX_DELAY);

if (ulNotificationValue &amp; 0x04) {
    // Received specific event bit
}

4.4. Application Summary

Advantages

Efficient (no heap memory allocation, minimal context switching)
Lightweight (each task has its own notification value)
Supports various synchronization/communication models

Considerations

Each task has only one notification value.
Cannot buffer multiple messages like queues, suitable for high real-time, low data volume communication.
When using eSetValueWithoutOverwrite, be cautious whether the notification value has been taken.

FreeRTOS: Save Memory and Speed Up by Ten Times with Task Notification Mechanism!

Previous Recommendations

RECOMMEND

FreeRTOS: Save Memory and Speed Up by Ten Times with Task Notification Mechanism!

[1]. 【FreeRTOS Development】Message Buffer: An Advanced Choice for Task Communication

[2]. 【FreeRTOS Development】In-Depth Analysis of Stream Buffers: A Powerful Tool for Real-Time Byte Stream Communication!

[3]. 【Linux Basics】How to Analyze CPU Performance in Embedded Systems

[4]. 【FreeRTOS Development】Completely Understand Event Flag Groups: A Powerful Tool for Multi-Task Synchronization

I am Aike, an embedded software engineer.

Follow me for more embedded insights.

Remember to like, share, and click to see more,

Your encouragement is my greatest motivation to continue sharing!

See you next time.

Looking forward to your

sharing

likes

views

NEWS

WeChat ID｜aike_eureka

Baijiahao｜Master Embedded Systems

1. Basic Concepts

2. Implementation Principles

<1>. Infrastructure

<2>. Notification Value and State

State Transition Process

<3>. Comparison of Solutions

3. Interface Definitions

<1>. xTaskNotify()

Main Internal Operations

<2>. xTaskNotifyWait()

Main Internal Logic

<3>. ulTaskNotifyTake()

Function: Simulate Counting Semaphore

<4>. xTaskNotifyGive()

Send a “notification” to a specific task

4. Application Examples

4.1. Notification Types

<1>. Binary Semaphore Mode

<2>. Counting Semaphore Mode

<3>. Event Flag Mode

<4>. Message Mode

4.2. Signal Definitions

4.3. Code Examples

Simple Signal (e.g., ISR notifying a task)

Event Bit Mode

4.4. Application Summary

Advantages

Considerations

Leave a Comment Cancel reply