xSemaphoreGive() and xSemaphoreTake() in FreeRTOS

Introduction

These functions help tasks share resources safely by controlling access one at a time.

When two or more tasks need to use the same hardware like a sensor or display.

When you want to make sure only one task changes a shared variable at a time.

When a task must wait for another task to finish before continuing.

When you want to avoid conflicts or crashes caused by multiple tasks running together.

Syntax

FreeRTOS

BaseType_t xSemaphoreTake(SemaphoreHandle_t xSemaphore, TickType_t xTicksToWait);
BaseType_t xSemaphoreGive(SemaphoreHandle_t xSemaphore);

xSemaphoreTake() tries to take (lock) the semaphore. It waits up to xTicksToWait ticks.

xSemaphoreGive() releases (unlocks) the semaphore so other tasks can take it.

Examples

This waits forever until the semaphore is available, then uses it and releases it.

FreeRTOS

if (xSemaphoreTake(xSemaphore, portMAX_DELAY) == pdTRUE) {
    // Access shared resource
    xSemaphoreGive(xSemaphore);
}

This tries to take the semaphore but only waits 10 ticks before giving up.

FreeRTOS

if (xSemaphoreTake(xSemaphore, 10) == pdTRUE) {
    // Use resource
    xSemaphoreGive(xSemaphore);
} else {
    // Could not get semaphore in 10 ticks
}

Sample Program

This program creates a binary semaphore and two tasks. Each task waits to take the semaphore, prints messages when it takes and gives it back, simulating work with a delay.

FreeRTOS

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

SemaphoreHandle_t xSemaphore;

void vTask1(void *pvParameters) {
    if (xSemaphoreTake(xSemaphore, portMAX_DELAY) == pdTRUE) {
        printf("Task 1 took the semaphore\n");
        vTaskDelay(100 / portTICK_PERIOD_MS); // Simulate work
        xSemaphoreGive(xSemaphore);
        printf("Task 1 gave the semaphore\n");
    }
    vTaskDelete(NULL);
}

void vTask2(void *pvParameters) {
    if (xSemaphoreTake(xSemaphore, portMAX_DELAY) == pdTRUE) {
        printf("Task 2 took the semaphore\n");
        vTaskDelay(50 / portTICK_PERIOD_MS); // Simulate work
        xSemaphoreGive(xSemaphore);
        printf("Task 2 gave the semaphore\n");
    }
    vTaskDelete(NULL);
}

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

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

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

    vTaskStartScheduler();

    // Should never reach here
    return 0;
}

Important Notes

Always give the semaphore once before tasks try to take it if you use a binary semaphore.

Use portMAX_DELAY to wait forever or a number of ticks to wait for a limited time.

Check the return value of xSemaphoreTake() to know if you got the semaphore or timed out.

Summary

xSemaphoreTake() locks the semaphore to use a resource.

xSemaphoreGive() unlocks the semaphore to let others use the resource.

They help tasks share resources safely without conflicts.

Practice

1. What is the main purpose of xSemaphoreTake() in FreeRTOS?

easy

A. To lock the semaphore and gain exclusive access to a resource

B. To unlock the semaphore and release the resource

C. To create a new semaphore

D. To delete an existing semaphore

Solution

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

   This function is used by a task to lock a semaphore, which means it tries to gain exclusive access to a shared resource.

2. Step 2: Differentiate from xSemaphoreGive()

   xSemaphoreGive() is used to release or unlock the semaphore, not to lock it.

3. Final Answer:

   To lock the semaphore and gain exclusive access to a resource -> Option A

4. Quick Check:

   xSemaphoreTake() locks = B [OK]

Hint: Take locks resource, Give unlocks it [OK]

Common Mistakes:

• Confusing take with give
• Thinking take creates semaphore
• Mixing up locking and unlocking

2. Which of the following is the correct syntax to take a semaphore named xSemaphore with a block time of 100 ticks?

easy

A. xSemaphoreTake(100, xSemaphore);

B. xSemaphoreTake(xSemaphore, 100);

C. xSemaphoreGive(xSemaphore, 100);

D. xSemaphoreGive(100, xSemaphore);

Solution

1. Step 1: Recall function signature of xSemaphoreTake()

   The correct syntax is xSemaphoreTake(SemaphoreHandle, BlockTimeTicks); where the first argument is the semaphore handle and second is the block time.

2. Step 2: Match the options with correct order

   xSemaphoreTake(xSemaphore, 100); matches the correct order: xSemaphoreTake(xSemaphore, 100);. Options B and D use xSemaphoreGive which is wrong here. xSemaphoreTake(100, xSemaphore); reverses the arguments.

3. Final Answer:

   xSemaphoreTake(xSemaphore, 100); -> Option B

4. Quick Check:

   Take(semaphore, time) = C [OK]

Hint: Take(semaphore, time) is correct order [OK]

Common Mistakes:

• Swapping arguments order
• Using xSemaphoreGive instead of xSemaphoreTake
• Passing block time as first argument

3. Consider the following code snippet:

if (xSemaphoreTake(xSemaphore, 10) == pdTRUE) {
    // Critical section
    xSemaphoreGive(xSemaphore);
    printf("Access granted\n");
} else {
    printf("Access denied\n");
}

What will be printed if the semaphore is already taken by another task and not given back within 10 ticks?

medium

A. Access granted

B. Runtime error

C. No output

D. Access denied

Solution

1. Step 1: Understand xSemaphoreTake() behavior with timeout

   If the semaphore is already taken and not released within the 10 tick block time, xSemaphoreTake() returns pdFALSE.

2. Step 2: Analyze the if condition and output

   Since xSemaphoreTake() returns pdFALSE, the else branch executes, printing "Access denied".

3. Final Answer:

   Access denied -> Option D

4. Quick Check:

   Semaphore busy + timeout = Access denied [OK]

Hint: If take fails within timeout, else branch runs [OK]

Common Mistakes:

• Assuming take always succeeds
• Ignoring block time effect
• Expecting 'Access granted' always

4. Identify the error in this code snippet:

if (xSemaphoreGive(xSemaphore) == pdTRUE) {
    // Critical section
    xSemaphoreTake(xSemaphore, portMAX_DELAY);
}

medium

A. xSemaphoreGive should not be called before taking the semaphore

B. xSemaphoreTake should not use portMAX_DELAY

C. xSemaphoreGive returns void, so comparison is invalid

D. No error, code is correct

Solution

1. Step 1: Understand correct semaphore usage order

   A task must first take (lock) the semaphore before giving (unlocking) it. Calling xSemaphoreGive() before xSemaphoreTake() is incorrect.

2. Step 2: Check function return types and usage

   xSemaphoreGive() returns BaseType_t, so comparing to pdTRUE is valid. Using portMAX_DELAY in xSemaphoreTake() is allowed to wait indefinitely.

3. Final Answer:

   xSemaphoreGive should not be called before taking the semaphore -> Option A

4. Quick Check:

   Give before Take is wrong order [OK]

Hint: Always take before give [OK]

Common Mistakes:

• Calling give before take
• Misunderstanding return values
• Thinking portMAX_DELAY is invalid

5. You have two tasks sharing a resource protected by a binary semaphore xSemaphore. Task A takes the semaphore, performs work, then gives it back. Task B tries to take the semaphore with a 50 tick timeout. If Task A forgets to give the semaphore back, what will happen to Task B?

hard

A. Task B will block forever waiting for the semaphore

B. Task B will immediately take the semaphore without blocking

C. Task B will block for 50 ticks, then continue without the resource

D. Task B will cause a system crash

Solution

1. Step 1: Understand semaphore blocking with timeout

   Task B calls xSemaphoreTake() with a 50 tick timeout, so it will wait up to 50 ticks for the semaphore to become available.

2. Step 2: Analyze effect of Task A not giving semaphore back

   If Task A never gives the semaphore back, Task B will wait the full 50 ticks, then xSemaphoreTake() returns pdFALSE, so Task B continues without the resource.

3. Final Answer:

   Task B will block for 50 ticks, then continue without the resource -> Option C

4. Quick Check:

   Timeout reached without give = block then continue [OK]

Hint: Timeout means wait then fail, not infinite block [OK]

Common Mistakes:

• Assuming infinite block without timeout
• Thinking semaphore is taken immediately
• Believing system crashes on semaphore misuse