xTaskNotifyGive() as lightweight semaphore in FreeRTOS - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this FreeRTOS task notification example?

Consider two tasks: TaskA and TaskB. TaskA calls xTaskNotifyGive(TaskBHandle); and TaskB waits using ulTaskNotifyTake(pdTRUE, portMAX_DELAY);. What will TaskB receive?

FreeRTOS

void TaskA(void *pvParameters) {
    // Notify TaskB
    xTaskNotifyGive(TaskBHandle);
    vTaskDelay(pdMS_TO_TICKS(1000));
}

void TaskB(void *pvParameters) {
    // Wait for notification
    uint32_t count = ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
    printf("Notification count: %lu\n", count);
    vTaskDelete(NULL);
}

A Notification count: 2

B Notification count: 0

C Notification count: 1

D The code causes a runtime error

💡 Hint

Think about what xTaskNotifyGive() does to the notification value and how ulTaskNotifyTake() reads it.

xTaskNotifyGive() increments the notification value by 1. ulTaskNotifyTake(pdTRUE, portMAX_DELAY) blocks until the notification value is non-zero, then returns the value and resets it to zero. So TaskB receives 1.

🧠 Conceptual

intermediate

Which statement best describes xTaskNotifyGive() as a lightweight semaphore?

In FreeRTOS, how does xTaskNotifyGive() function as a lightweight semaphore?

A It increments a task's notification value, signaling availability of a resource.

B It creates a new semaphore object in the kernel.

C It blocks the calling task until a resource is free.

D It resets the task notification value to zero.

💡 Hint

Think about what happens to the task notification value when xTaskNotifyGive() is called.

xTaskNotifyGive() increments the notification value of a task, which can be used to signal that a resource is available, similar to giving a semaphore.

🔧 Debug

advanced

Why does this code cause TaskB to block forever?

TaskA calls xTaskNotifyGive(TaskBHandle); twice quickly. TaskB calls ulTaskNotifyTake(pdTRUE, 1000); once. TaskB never proceeds. Why?

FreeRTOS

void TaskA(void *pvParameters) {
    xTaskNotifyGive(TaskBHandle);
    xTaskNotifyGive(TaskBHandle);
    vTaskDelete(NULL);
}

void TaskB(void *pvParameters) {
    uint32_t count = ulTaskNotifyTake(pdTRUE, 1000);
    if(count == 0) {
        printf("Timeout waiting for notification\n");
    } else {
        printf("Received notification count: %lu\n", count);
    }
    vTaskDelete(NULL);
}

A Because ulTaskNotifyTake resets the count to zero after first call, second notify is lost.

B Because TaskB never calls ulTaskNotifyTake twice to consume both notifications.

C Because xTaskNotifyGive does not increment the notification value.

D Because TaskA deletes itself before TaskB starts.

💡 Hint

Consider how many notifications TaskB consumes with one call to ulTaskNotifyTake().

ulTaskNotifyTake(pdTRUE, timeout) returns the current notification count and resets it to zero. If TaskA calls xTaskNotifyGive() twice before TaskB calls ulTaskNotifyTake(), the count will be 2. But TaskB only calls ulTaskNotifyTake() once, so it consumes both notifications at once. The code should not block forever; if it does, likely TaskB is not running or the timeout is too short.

📝 Syntax

advanced

Which option correctly uses xTaskNotifyGive() and ulTaskNotifyTake() as a semaphore?

Choose the code snippet that correctly uses xTaskNotifyGive() and ulTaskNotifyTake() to synchronize two tasks.

A

xTaskNotifyGive(TaskHandle);
uint32_t count = ulTaskNotifyTake(pdFALSE, portMAX_DELAY);

B

xTaskNotifyGive(TaskHandle);
uint32_t count = ulTaskNotifyTake(pdTRUE);

C

xTaskNotifyGive(TaskHandle, 1);
uint32_t count = ulTaskNotifyTake(pdTRUE, portMAX_DELAY);

D

xTaskNotifyGive(TaskHandle);
uint32_t count = ulTaskNotifyTake(pdTRUE, portMAX_DELAY);

💡 Hint

Check the parameters of ulTaskNotifyTake() and how xTaskNotifyGive() is called.

xTaskNotifyGive() takes only the task handle as parameter. ulTaskNotifyTake() takes a boolean to clear the notification value and a timeout. The correct usage is ulTaskNotifyTake(pdTRUE, portMAX_DELAY); to block until notified and clear the count.

🚀 Application

expert

How many notifications can ulTaskNotifyTake() accumulate before blocking?

If TaskA calls xTaskNotifyGive(TaskBHandle); 5 times quickly, and TaskB calls ulTaskNotifyTake(pdTRUE, portMAX_DELAY); once, what is the value returned by TaskB?

A 5

B 0

C 1

D It causes a runtime error

💡 Hint

Think about how xTaskNotifyGive() increments the notification value and how ulTaskNotifyTake() returns it.

xTaskNotifyGive() increments the notification value each time it is called. If called 5 times before ulTaskNotifyTake(), the notification value is 5. The call to ulTaskNotifyTake(pdTRUE, portMAX_DELAY) returns 5 and resets the count to zero.