Introduction
In Real-Time Operating Systems (RTOS), multiple tasks run concurrently and often need to share resources. Without proper synchronization, race conditions, deadlocks, and unpredictable behavior can occur. This blog explores three essential synchronization mechanisms—Mutexes, Semaphores, and Message Queues—with hands-on examples.
Using Mutexes for Resource Protection
A mutex (mutual exclusion) ensures that only one task accesses a shared resource at a time, preventing data corruption.
Example: Protecting Shared Resource
#include “FreeRTOS.h”
#include “task.h”
#include “semphr.h”
SemaphoreHandle_t mutex;
void Task1(void *pvParameters) {
while (1) {
if (xSemaphoreTake(mutex, portMAX_DELAY)) {
// Access shared resource
printf(“Task 1 is accessing resource\n”);
vTaskDelay(pdMS_TO_TICKS(500));
xSemaphoreGive(mutex);
}
}
}
void setup() {
mutex = xSemaphoreCreateMutex();
xTaskCreate(Task1, “Task1”, 100, NULL, 1, NULL);
vTaskStartScheduler();
}
Best Practice: Always release the mutex after use to prevent deadlocks.
Managing Task Synchronization with Semaphores
A semaphore is a signaling mechanism that allows tasks to coordinate execution. Unlike mutexes, semaphores can be used for task notifications.
Example: Binary Semaphore for Task Synchronization
SemaphoreHandle_t binSemaphore;
void ISR()
{
BaseType_t xHigherPriorityTaskWoken = pdFALSE;
xSemaphoreGiveFromISR(binSemaphore, &xHigherPriorityTaskWoken);
portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}
void Task2(void *pvParameters)
{
while (1)
{
if (xSemaphoreTake(binSemaphore, portMAX_DELAY))
{
printf(“Task 2 triggered by ISR\n”);
}
}
}
void setup()
{
binSemaphore = xSemaphoreCreateBinary();
xTaskCreate(Task2, “Task2”, 100, NULL, 1, NULL);
vTaskStartScheduler();
}
Best Practice: Use semaphores to notify tasks instead of busy-wait loops to save CPU cycles.
Using Message Queues for Inter-Task Communication
A message queue allows tasks to send and receive structured data asynchronously.
Example: Sending Sensor Data Between Tasks
QueueHandle_t sensorQueue;
void SensorTask(void *pvParameters) {
int sensorData = 100;
while (1) {
xQueueSend(sensorQueue, &sensorData, portMAX_DELAY);
vTaskDelay(pdMS_TO_TICKS(1000));
}
}
void DisplayTask(void *pvParameters) {
int receivedData;
while (1) {
if (xQueueReceive(sensorQueue, &receivedData, portMAX_DELAY)) {
printf(“Received Sensor Data: %d\n”, receivedData);
}
}
}
void setup() {
sensorQueue = xQueueCreate(5, sizeof(int));
xTaskCreate(SensorTask, “Sensor”, 100, NULL, 1, NULL);
xTaskCreate(DisplayTask, “Display”, 100, NULL, 1, NULL);
vTaskStartScheduler();
}
Best Practice: Ensure sufficient queue size to prevent data loss due to overflow.
Conclusion
Synchronization is vital in RTOS to ensure safe and efficient task execution. Mutexes protect shared resources, semaphores enable event-driven execution, and message queues facilitate structured inter-task communication. Mastering these tools will help build robust and reliable embedded systems.
