What is Temperature Sensor|Types and Uses

A counting semaphore is a synchronization mechanism used in real-time operating systems like FreeRTOS to control access to shared resources. Unlike binary semaphores that can only have two states, counting semaphores can have multiple states, representing the number of available resources.

In FreeRTOS, counting semaphores are used to manage resources that have multiple instances, such as memory buffers or communication channels. The counting semaphore maintains a count of the available resources and allows tasks to access them based on the current count.

What is Counting Semaphore in FreeRTOS?

In FreeRTOS, a counting semaphore is a synchronization object that is used to protect a shared resource or coordinate the execution of tasks. Unlike binary semaphores, counting semaphores can have a value greater than one, which means that multiple tasks can take the semaphore simultaneously, up to the maximum count value.

Counting semaphores in FreeRTOS work by maintaining a count of the number of available resources or permits. When a task wants to access the shared resource or obtain a permit, it calls the xSemaphoreTake() API with a timeout value (if desired). If the semaphore count is greater than zero, the task is allowed to take the semaphore and the count is decremented. If the semaphore count is zero, the task is blocked until another task gives the semaphore back using the xSemaphoreGive() API, which increments the count and unblocks any waiting tasks.

How Counting Semaphore works in FreeRTOS?

In FreeRTOS, a counting semaphore works by maintaining a count of the number of available resources or permits. When a task wants to access the shared resource or obtain a permit, it calls the xSemaphoreTake() API with a timeout value (if desired).

If the semaphore count is greater than zero, the task is allowed to take the semaphore and the count is decremented. If the semaphore count is zero, the task is blocked until another task gives the semaphore back using the xSemaphoreGive() API, which increments the count and unblocks any waiting tasks.

Here is an example of how counting semaphore works in FreeRTOS:

Create a counting semaphore: Use the xSemaphoreCreateCounting() API to create a counting semaphore and specify the maximum count value. This will initialize the semaphore count to zero.

Take the semaphore: A task can take the semaphore by calling the xSemaphoreTake() API. If the semaphore count is greater than zero, the task will be able to take the semaphore and the count will be decremented. If the semaphore count is zero, the task will be blocked until another task gives the semaphore back.

Give the semaphore: A task can give the semaphore back by calling the xSemaphoreGive() API. This will increment the semaphore count and unblock any waiting tasks.

Delete the semaphore: Use the vSemaphoreDelete() API to delete the counting semaphore when it is no longer needed.

Counting semaphores are useful for coordinating the access to a shared resource or limiting the number of tasks that can execute a particular section of code simultaneously. They can also be used to signal events between tasks or limit the amount of resources that are consumed by a task.

When to use Counting Semaphore?

Counting semaphores are typically used in FreeRTOS when multiple tasks need to access a shared resource or perform a certain action in a controlled manner.

Here are some common use cases for counting semaphores:

1. Resource Sharing: Counting semaphores can be used to manage access to shared resources such as buffers, queues, and other data structures. For example, a task that needs to read data from a buffer can take a semaphore to ensure that it has exclusive access to the buffer until it is finished reading. Other tasks that need to read from the same buffer can also take the semaphore, as long as the count is not zero. This allows multiple tasks to share the same resource without causing data corruption or other synchronization issues.
2. Task Synchronization: Counting semaphores can be used to synchronize the execution of multiple tasks that need to work together to accomplish a common goal. For example, in a real-time system, a set of tasks may need to be triggered to execute in a specific order. By using counting semaphores to signal the completion of each task, the next task in the sequence can be allowed to execute.
3. Rate Limiting: Counting semaphores can be used to limit the rate at which tasks can access a resource or perform an action. For example, if a task needs to perform a certain action at a fixed rate, a counting semaphore can be used to ensure that the task does not exceed the desired rate.

APIs for counting semaphore in FreeRTOS

FreeRTOS provides a set of APIs for creating, taking, giving, and deleting counting semaphores. Here are the APIs for counting semaphore in FreeRTOS:

xSemaphoreCreateCounting(): This API is used to create a counting semaphore. It takes two parameters - the maximum count value and the initial count value. The API returns a handle to the created semaphore.

xSemaphoreTake(): This API is used to take the counting semaphore. If the semaphore count is greater than zero, the API decrements the count and returns immediately. If the semaphore count is zero, the API blocks the task until the semaphore becomes available.

xSemaphoreGive(): This API is used to give the counting semaphore back. It increments the semaphore count and unblocks any waiting tasks that are blocked on the semaphore.

xSemaphoreGiveFromISR(): This API is used to give the counting semaphore back from an interrupt service routine (ISR). It is similar to the xSemaphoreGive() API, but it is safe to call from an ISR.

xSemaphoreTakeFromISR(): This API is used to take the counting semaphore from an ISR. It is similar to the xSemaphoreTake() API, but it is safe to call from an ISR.

xSemaphoreGiveRecursive(): This API is used to give the counting semaphore back in a recursive manner, i.e., the same task that has taken the semaphore multiple times can give it back multiple times.

vSemaphoreDelete(): This API is used to delete the counting semaphore. It takes a handle to the semaphore as a parameter.

Counting semaphores are useful for coordinating the access to a shared resource or limiting the number of tasks that can execute a particular section of code simultaneously. They can also be used to signal events between tasks or limit the amount of resources that are consumed by a task.

What are the advantages of using Counting Semaphore in freeRTOS?

Here are some advantages of using counting semaphore in FreeRTOS:

1. Resource sharing: Counting semaphores are useful for controlling access to a shared resource. They can be used to ensure that only a limited number of tasks can access the resource at the same time.
2. Priority inversion avoidance: Counting semaphores can be used to prevent priority inversion, a problem that can occur when a high-priority task is blocked by a low-priority task that is holding a shared resource.
3. Event signaling: Counting semaphores can be used to signal events between tasks. For example, a task can wait for a certain number of events to occur before continuing execution.
4. Resource management: Counting semaphores can be used to manage resources, such as memory or network connections. By limiting the number of resources that can be used at the same time, counting semaphores can prevent resource exhaustion and ensure that all tasks have access to the necessary resources.
5. Efficient memory usage: Counting semaphores can be more memory-efficient than binary semaphores when multiple resources need to be managed. Instead of creating multiple binary semaphores, a single counting semaphore can be used to manage all the resources.

Overall, counting semaphores provide a flexible and efficient way to manage resources and coordinate access between tasks in FreeRTOS.

What are the limitations of using counting semaphore in freeRTOS?

Here are some limitations of using counting semaphore in FreeRTOS:

1. Overuse: If counting semaphores are overused, they can lead to complex code and potential deadlocks. Careful consideration should be given to whether a counting semaphore is the best choice for a particular situation.
2. Priority inversion: While counting semaphores can be used to prevent priority inversion, they can also cause it if not used correctly. For example, if a low-priority task is holding a counting semaphore and a high-priority task attempts to take it, the high-priority task will be blocked, leading to priority inversion.
3. Starvation: Counting semaphores can cause task starvation if not used correctly. If a task is constantly taking a counting semaphore, other tasks may be starved of the resource.
4. Complex implementation: Counting semaphores can be more complex to implement and use than binary semaphores. Careful consideration should be given to the implementation and usage of counting semaphores to ensure correct behavior.

while counting semaphores are useful in many situations, they require careful consideration and implementation to avoid potential problems. Proper usage and management of counting semaphores can help prevent deadlocks, priority inversion, and task starvation.

Example code for Implementing Counting Semaphore

We are using ESP32 and ARduino IDE to implement this code

#if CONFIG_FREERTOS_UNICORE

#define ARDUINO_RUNNING_CORE 0

#else

#define ARDUINO_RUNNING_CORE 1

#endif

SemaphoreHandle_t countingSemaphore;

void task1(void *pvParameters)

{

    while (1)

    {

        Serial.println(uxSemaphoreGetCount( countingSemaphore));

        if (xSemaphoreTake(countingSemaphore, portMAX_DELAY) == pdTRUE)

        {

            Serial.println("task 1");

            Serial.print("semaphore taken ");

            Serial.println(uxSemaphoreGetCount( countingSemaphore));

            

         }

        

        

         vTaskDelay(2000 / portTICK_PERIOD_MS);         

         Serial.println();

         Serial.println();

         //vTaskDelete(NULL);

    

    }

}

void setup()

{

  

    Serial.begin(115200);

    countingSemaphore = xSemaphoreCreateCounting(3,0);

    Serial.println(uxSemaphoreGetCount( countingSemaphore));

    xSemaphoreGive(countingSemaphore);

    xSemaphoreGive(countingSemaphore);

    xSemaphoreGive(countingSemaphore);

    Serial.println(uxSemaphoreGetCount( countingSemaphore));

    xTaskCreatePinnedToCore(task1, "Task 1", 1024, NULL, 1,NULL ,ARDUINO_RUNNING_CORE);

    

    

}

void loop()

{

    // Do nothing

}

Conclusion

In conclusion, both binary semaphores and counting semaphores are useful synchronization mechanisms in FreeRTOS, with different advantages and limitations.

Binary semaphores are simple to use and can prevent priority inversion but are limited to signaling and releasing a single resource. On the other hand, counting semaphores are more flexible and can manage multiple resources, but require careful management to prevent deadlocks, priority inversion, and task starvation.

In general, choosing between binary semaphores and counting semaphores depends on the specific requirements of the system and the resources that need to be managed. It is important to carefully evaluate the advantages and limitations of each type of semaphore before making a decision.

Related Youtube Video:

FreeRTOS: Using counting semaphore|ESP32 and Arduino IDE