xTaskNotifyGive() as lightweight semaphore in FreeRTOS - Step-by-Step Execution

Concept Flow - xTaskNotifyGive() as lightweight semaphore

Task A: Calls xTaskNotifyGive(TaskB)

↓

Task B: Waits on ulTaskNotifyTake()

↓

Notification count increments

↓

Task B unblocks and continues

↓

Task B processes resource

↓

Task B loops back to wait for next notification

Task A sends a notification to Task B using xTaskNotifyGive(), incrementing a count. Task B waits with ulTaskNotifyTake() and unblocks when notified, acting like a lightweight semaphore.

Execution Sample

FreeRTOS

void TaskA(void *pvParameters) {
  for(;;) {
    xTaskNotifyGive(TaskBHandle);
    vTaskDelay(1000 / portTICK_PERIOD_MS);
  }
}

void TaskB(void *pvParameters) {
  for(;;) {
    ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
    // process resource
  }
}

Task A notifies Task B every second; Task B waits for notification and processes resource when notified.

Execution Table

Step	Action	Task B Notify Count	Task B ulTaskNotifyTake() Return	Task B State	Output
1	Task B starts and calls ulTaskNotifyTake(pdTRUE, portMAX_DELAY)	0	Blocks (waits)	Blocked	No output
2	Task A calls xTaskNotifyGive(TaskBHandle)	1	Still blocked	Blocked	No output
3	Task B unblocks, ulTaskNotifyTake() returns 1	0 (cleared)	Returns 1	Running	Processes resource
4	Task B loops and calls ulTaskNotifyTake() again	0	Blocks (waits)	Blocked	No output
5	Task A calls xTaskNotifyGive(TaskBHandle) again	1	Still blocked	Blocked	No output
6	Task B unblocks, ulTaskNotifyTake() returns 1	0 (cleared)	Returns 1	Running	Processes resource
7	Task B loops and calls ulTaskNotifyTake() again	0	Blocks (waits)	Blocked	No output
Exit	No more notifications sent	0	Blocks indefinitely	Blocked	Waiting forever

💡 Task B blocks indefinitely waiting for notification because Task A stops sending notifications.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 5	After Step 6	Final
Task B Notify Count	0	1	0	1	0	0
Task B ulTaskNotifyTake() Return	N/A	Blocked	1	Blocked	1	Blocked
Task B State	Blocked	Blocked	Running	Blocked	Running	Blocked

Key Moments - 3 Insights

Why does Task B block on ulTaskNotifyTake() even though Task A called xTaskNotifyGive()?

Task B blocks initially because no notification was sent yet (Step 1). After Task A calls xTaskNotifyGive() (Step 2), the notification count increments but Task B is still blocked until it unblocks (Step 3).

What happens to the notification count after ulTaskNotifyTake() returns?

The notification count is cleared to zero after ulTaskNotifyTake() returns (Step 3 and Step 6), ensuring the semaphore behavior.

Can multiple notifications accumulate if Task A calls xTaskNotifyGive() multiple times before Task B calls ulTaskNotifyTake()?

Yes, the notification count increments with each xTaskNotifyGive() call, allowing Task B to unblock multiple times without missing notifications, acting like a counting semaphore.

Visual Quiz - 3 Questions

Look at the execution table, what is the Task B Notify Count after Step 2?

A 0

B 1

C 2

D Blocked

💡 Hint

Check the 'Task B Notify Count' column at Step 2 in the execution_table.

At which step does Task B unblock and ulTaskNotifyTake() return 1 for the first time?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look at the 'Task B ulTaskNotifyTake() Return' and 'Task B State' columns in the execution_table.

If Task A stops calling xTaskNotifyGive(), what happens to Task B's state after Step 7?

A Blocked indefinitely

B Ready but not running

C Running

D Terminated

💡 Hint

Refer to the 'Task B State' and 'Exit' row in the execution_table.

Concept Snapshot

xTaskNotifyGive() increments a task's notification count.
ulTaskNotifyTake() waits and clears this count.
Together, they act as a lightweight semaphore.
Task B blocks until notified by Task A.
Notification count allows multiple signals.
Useful for simple task synchronization.

Full Transcript

This visual trace shows how xTaskNotifyGive() and ulTaskNotifyTake() work together as a lightweight semaphore in FreeRTOS. Task A calls xTaskNotifyGive() to notify Task B, incrementing a notification count. Task B waits on ulTaskNotifyTake(), which blocks until the count is positive. When notified, ulTaskNotifyTake() returns and clears the count, allowing Task B to proceed. This mechanism allows Task B to block and unblock efficiently, synchronizing tasks without heavy semaphore overhead. The execution table tracks notification counts, task states, and function returns step-by-step, clarifying how notifications accumulate and are consumed.