Semaphore timeout handling in FreeRTOS - Step-by-Step Execution

Concept Flow - Semaphore timeout handling

Task tries to take semaphore

↓

Is semaphore available?

Yes→Take semaphore, proceed

No↓

Wait with timeout

↓

Timeout reached?

No→Semaphore becomes available

↓

Take semaphore, proceed

↓

Timeout error, handle failure

The task tries to take a semaphore. If unavailable, it waits up to a timeout. If timeout expires, it handles failure; otherwise, it proceeds after taking the semaphore.

Execution Sample

FreeRTOS

if(xSemaphoreTake(sem, pdMS_TO_TICKS(1000)) == pdTRUE) {
    // Got semaphore
} else {
    // Timeout occurred
}

Task tries to take semaphore with 1000 ms timeout and handles success or timeout.

Execution Table

Step	Action	Semaphore State	Timeout Counter (ms)	Result
1	Task calls xSemaphoreTake	Unavailable	1000	Waiting
2	Wait 200 ms, semaphore still unavailable	Unavailable	800	Waiting
3	Wait 500 ms, semaphore still unavailable	Unavailable	300	Waiting
4	Semaphore becomes available	Available	300	Semaphore taken, proceed
5	Task proceeds with semaphore	Unavailable (taken)	300	Success
6	End of operation	Unavailable (taken)	300	Exit

💡 Semaphore taken before timeout expired, task proceeds successfully.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	Final
Semaphore State	Unavailable	Unavailable	Unavailable	Unavailable	Available	Unavailable (taken)
Timeout Counter (ms)	1000	1000	800	300	300	300
Result	None	Waiting	Waiting	Waiting	Semaphore taken	Success

Key Moments - 3 Insights

Why does the task wait instead of immediately failing when the semaphore is unavailable?

Because the xSemaphoreTake function waits up to the specified timeout (see execution_table steps 1-3) before deciding if it can take the semaphore or must timeout.

What happens if the semaphore becomes available before the timeout expires?

The task immediately takes the semaphore and proceeds (see execution_table step 4), stopping the wait early.

How is the timeout value updated during waiting?

The timeout counter decreases as time passes while waiting (see variable_tracker Timeout Counter), reflecting remaining wait time.

Visual Quiz - 3 Questions

Look at the execution table, at which step does the semaphore become available?

A Step 4

B Step 3

C Step 2

D Step 5

💡 Hint

Check the 'Semaphore State' column in the execution_table rows.

According to the variable tracker, what is the timeout counter value after step 3?

A 1000 ms

B 800 ms

C 300 ms

D 0 ms

💡 Hint

Look at the 'Timeout Counter (ms)' row after 'After Step 3' column in variable_tracker.

If the semaphore never becomes available, what would happen according to the flow?

A Task takes semaphore immediately

B Task times out and handles failure

C Task waits forever

D Task ignores semaphore and proceeds

💡 Hint

Refer to the concept_flow where timeout leads to failure handling.

Concept Snapshot

Semaphore timeout handling in FreeRTOS:
- Use xSemaphoreTake(sem, timeout) to wait for semaphore
- If semaphore available, function returns pdTRUE immediately
- If unavailable, task waits up to timeout duration
- If timeout expires, function returns pdFALSE
- Handle success or timeout accordingly

Full Transcript

In FreeRTOS, when a task tries to take a semaphore, it may not be immediately available. The task calls xSemaphoreTake with a timeout value in ticks. If the semaphore is free, the task takes it and continues. If not, the task waits up to the timeout duration. During waiting, the timeout counter decreases. If the semaphore becomes available before timeout, the task takes it and proceeds. If the timeout expires first, the function returns failure, and the task handles the timeout case. This process ensures tasks do not wait forever and can respond to semaphore availability or timeout events.

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