Semaphore timeout handling in FreeRTOS

Introduction

Semaphore timeout handling helps your program wait for a resource only for a limited time. This avoids getting stuck forever if the resource is not available.

When you want to wait for a task or resource but don't want to wait forever.

When you want to retry an action if it takes too long to get permission.

When you want to handle errors if a resource is busy for too long.

Syntax

FreeRTOS

BaseType_t xSemaphoreTake( SemaphoreHandle_t xSemaphore, TickType_t xTicksToWait );

xSemaphore is the semaphore you want to take (use).

xTicksToWait is how long to wait in ticks before giving up.

Examples

Wait up to 1000 milliseconds to take the semaphore. If not available, handle timeout.

FreeRTOS

if (xSemaphoreTake(xSemaphore, pdMS_TO_TICKS(1000)) == pdTRUE) {
    // Got the semaphore
} else {
    // Timeout happened
}

Try to take the semaphore without waiting.

FreeRTOS

if (xSemaphoreTake(xSemaphore, 0) == pdTRUE) {
    // Take semaphore immediately or fail
}

Sample Program

This program creates a binary semaphore and two tasks. Task1 waits up to 2 seconds to take the semaphore, does some work, then releases it. Task2 waits up to 1 second to take the semaphore. If it times out, it prints a timeout message.

FreeRTOS

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

SemaphoreHandle_t xSemaphore;

void vTask1(void *pvParameters) {
    printf("Task1: Waiting for semaphore...\n");
    if (xSemaphoreTake(xSemaphore, pdMS_TO_TICKS(2000)) == pdTRUE) {
        printf("Task1: Got the semaphore!\n");
        vTaskDelay(pdMS_TO_TICKS(1500)); // Simulate work
        xSemaphoreGive(xSemaphore);
        printf("Task1: Released the semaphore.\n");
    } else {
        printf("Task1: Timeout waiting for semaphore.\n");
    }
    vTaskDelete(NULL);
}

void vTask2(void *pvParameters) {
    printf("Task2: Waiting for semaphore...\n");
    if (xSemaphoreTake(xSemaphore, pdMS_TO_TICKS(1000)) == pdTRUE) {
        printf("Task2: Got the semaphore!\n");
        xSemaphoreGive(xSemaphore);
        printf("Task2: Released the semaphore.\n");
    } else {
        printf("Task2: Timeout waiting for semaphore.\n");
    }
    vTaskDelete(NULL);
}

int main(void) {
    xSemaphore = xSemaphoreCreateBinary();
    if (xSemaphore == NULL) {
        printf("Failed to create semaphore.\n");
        return 1;
    }

    // Give semaphore initially so Task1 can take it
    xSemaphoreGive(xSemaphore);

    xTaskCreate(vTask1, "Task1", 1000, NULL, 2, NULL);
    xTaskCreate(vTask2, "Task2", 1000, NULL, 1, NULL);

    vTaskStartScheduler();

    // Should never reach here
    for(;;);
}

Important Notes

Use pdMS_TO_TICKS() to convert milliseconds to ticks for the timeout.

If you set xTicksToWait to 0, the function returns immediately if the semaphore is not available.

Always check the return value to know if you got the semaphore or if a timeout happened.

Summary

Semaphore timeout lets you wait for a resource only for a limited time.

Use xSemaphoreTake() with a timeout to avoid blocking forever.

Always handle the case when the timeout happens to keep your program responsive.

Practice

1.

What does the timeout parameter in xSemaphoreTake() control?

easy

A. How long the task waits for the semaphore before giving up

B. The priority of the task waiting for the semaphore

C. The number of times the semaphore can be taken

D. The size of the semaphore queue

Solution

1. Step 1: Understand the role of timeout in xSemaphoreTake()

   The timeout parameter specifies the maximum time the task will wait to obtain the semaphore.

2. Step 2: Relate timeout to task blocking

   If the semaphore is not available within this time, the function returns failure, preventing indefinite blocking.

3. Final Answer:

   How long the task waits for the semaphore before giving up -> Option A

4. Quick Check:

   Timeout controls wait duration = B [OK]

Hint: Timeout limits wait time to avoid blocking forever [OK]

Common Mistakes:

• Confusing timeout with task priority
• Thinking timeout changes semaphore count
• Assuming timeout affects queue size

2.

Which of the following is the correct way to call xSemaphoreTake() with a 100 tick timeout?

SemaphoreHandle_t sem;

easy

A. xSemaphoreTake(&sem, 100);

B. xSemaphoreTake(100, sem);

C. xSemaphoreTake(sem, &100);

D. xSemaphoreTake(sem, 100);

Solution

1. Step 1: Check function signature

   xSemaphoreTake takes the semaphore handle first, then the timeout as TickType_t.

2. Step 2: Match parameters correctly

   Passing sem as first argument and 100 as timeout matches the correct syntax.

3. Final Answer:

   xSemaphoreTake(sem, 100); -> Option D

4. Quick Check:

   Semaphore handle first, timeout second = A [OK]

Hint: Semaphore handle is first argument in xSemaphoreTake [OK]

Common Mistakes:

• Swapping arguments order
• Passing address of timeout
• Passing address of semaphore handle

3.

What will be the output of this code snippet?

SemaphoreHandle_t sem = xSemaphoreCreateBinary();
if(xSemaphoreTake(sem, 10) == pdTRUE) {
    printf("Got semaphore\n");
} else {
    printf("Timeout occurred\n");
}

medium

A. Got semaphore

B. No output

C. Timeout occurred

D. Compilation error

Solution

1. Step 1: Understand semaphore initial state

   xSemaphoreCreateBinary creates a semaphore initially empty (not given).

2. Step 2: Check xSemaphoreTake behavior

   Since semaphore is empty and no give is called, xSemaphoreTake waits 10 ticks then times out.

3. Final Answer:

   Timeout occurred -> Option C

4. Quick Check:

   Empty semaphore + timeout = timeout message [OK]

Hint: Binary semaphore starts empty, so take times out if not given [OK]

Common Mistakes:

• Assuming semaphore is initially given
• Ignoring timeout effect
• Expecting compilation error

4.

Identify the error in this code snippet that uses xSemaphoreTake() with timeout:

SemaphoreHandle_t sem = xSemaphoreCreateBinary();
if(xSemaphoreTake(sem, portMAX_DELAY)) {
    // Critical section
} else {
    // Handle timeout
}

medium

A. Using portMAX_DELAY disables timeout, so else block never runs

B. Semaphore handle is not initialized

C. Missing sem give before take

D. Incorrect if condition syntax

Solution

1. Step 1: Understand portMAX_DELAY meaning

   portMAX_DELAY means wait indefinitely for the semaphore.

2. Step 2: Analyze if-else behavior

   Since wait is infinite, timeout never occurs, so else block is unreachable.

3. Final Answer:

   Using portMAX_DELAY disables timeout, so else block never runs -> Option A

4. Quick Check:

   portMAX_DELAY means infinite wait = C [OK]

Hint: portMAX_DELAY means wait forever, no timeout occurs [OK]

Common Mistakes:

• Thinking else block handles timeout with portMAX_DELAY
• Assuming semaphore uninitialized causes error here
• Confusing syntax error with logic error

5.

You want to wait for a semaphore but only up to 50 ticks. If the semaphore is not available, you want to perform a fallback task immediately. Which code snippet correctly implements this behavior?

hard

A. if(xSemaphoreTake(sem, portMAX_DELAY)) {
// Use resource
} else {
// Fallback task
}

B. if(xSemaphoreTake(sem, 50) == pdTRUE) {
// Use resource
} else {
// Fallback task
}

C. if(xSemaphoreTake(sem, 0) == pdFALSE) {
// Use resource
} else {
// Fallback task
}

D. if(xSemaphoreTake(sem, 50)) {
// Fallback task
} else {
// Use resource
}

Solution

1. Step 1: Check timeout usage

   Using 50 ticks as timeout means wait up to 50 ticks for semaphore.

2. Step 2: Verify fallback logic

   If take returns pdTRUE, resource is used; else fallback task runs immediately after timeout.

3. Final Answer:

   Correctly waits 50 ticks and runs fallback if timeout -> Option B

4. Quick Check:

   Timeout 50 ticks + fallback on failure = A [OK]

Hint: Wait with timeout, fallback in else block after failure [OK]

Common Mistakes:

• Using portMAX_DELAY disables fallback
• Swapping if-else blocks
• Using zero timeout incorrectly