FreeRTOS mutex/binary semaphore and deadlock

Question

I am new to FreeRTOS, so I started with what I think is a great tutorial, the one presented by Shawn Hymel. I'm also implementing the code that I'm writting in a ESP32 DevkitC V4.

However, I think that I don't understand the difference between binary semaphores and mutexes. When I run this code that tries to avoid deadlock between two tasks that use two mutexes to protect a critical section (as shown in the tutorial):

// Use only core 1 for demo purposes
#if CONFIG_FREERTOS_UNICORE
  static const BaseType_t app_cpu = 0;
#else
  static const BaseType_t app_cpu = 1;
#endif

//Settings
TickType_t mutex_timeout = 1000 / portTICK_PERIOD_MS;
//Timeout for any task that tries to take a mutex!

//Globals
static SemaphoreHandle_t mutex_1;
static SemaphoreHandle_t mutex_2;

//**********************************************************
//Tasks

//Task A (High priority)
void doTaskA(void*parameters){

    while(1){

        //Take mutex 1
        if( xSemaphoreTake(mutex_1, mutex_timeout) == pdTRUE){
            Serial.println("Task A took mutex 1");
            vTaskDelay(1 / portTICK_PERIOD_MS);    
        //Take mutex 2
            if(xSemaphoreTake(mutex_2, mutex_timeout) == pdTRUE){
                Serial.println("Task A took mutex 2");

                //Critical section protected by 2 mutexes
                Serial.println("Task A doing work");
                vTaskDelay(500/portTICK_PERIOD_MS);         //simulate that critical section takes 500ms
            } else {
                Serial.println("Task A timed out waiting for mutex 2. Trying again...");
                }
        } else {
            Serial.println("Task A timed out waiting for mutex 1. Trying again...");
        }

        //Return mutexes
        xSemaphoreGive(mutex_2);
        xSemaphoreGive(mutex_1);

        Serial.println("Task A going to sleep");
        vTaskDelay(500/portTICK_PERIOD_MS);
        //Wait to let other task execute
    }
}

//Task B (low priority)
void doTaskB(void * parameters){

    while(1){

        //Take mutex 2 and wait to force deadlock
        if(xSemaphoreTake(mutex_2, mutex_timeout)==pdTRUE){
            Serial.println("Task B took mutex 2");
            vTaskDelay(1 / portTICK_PERIOD_MS);         

            if(xSemaphoreTake(mutex_1, mutex_timeout) == pdTRUE){
                Serial.println("Task B took mutex 1");
        

                //Critical section protected by 2 mutexes
                Serial.println("Task B doing work");
                vTaskDelay(500/portTICK_PERIOD_MS);         //simulate that critical section takes 500ms
            } else {
                Serial.println("Task B timed out waiting for mutex 1");
                }
        } else {
            Serial.println("Task B timed out waiting for mutex 2");
            }

        //Return mutexes
        xSemaphoreGive(mutex_1);
        xSemaphoreGive(mutex_2);

        Serial.println("Task B going to sleep");
        vTaskDelay(500/portTICK_PERIOD_MS);
        //Wait to let other task execute
    }

}

void setup(){
    Serial.begin(115200);

    vTaskDelay(1000 / portTICK_PERIOD_MS);
    Serial.println();
    Serial.println("---FreeRTOS Deadlock Demo---");

    //create mutexes
    mutex_1 = xSemaphoreCreateMutex();
    mutex_2 = xSemaphoreCreateMutex();

    //Start task A (high priority)
    xTaskCreatePinnedToCore(doTaskA, "Task A", 1500, NULL, 2, NULL, app_cpu);

    //Start task B (low priority)
    xTaskCreatePinnedToCore(doTaskB, "Task B", 1500, NULL, 1, NULL, app_cpu);

    vTaskDelete(NULL);
}

void loop(){

}

My ESP32 starts automatically rebooting after both tasks reach their first mutex in execution, displaying this message:

---FreeRTOS Deadlock Demo---
Task A took mutex 1
Task B took mutex 2
Task A timed out waiting for mutex 2. Trying again...

assert failed: xQueueGenericSend queue.c:832 (pxQueue->pcHead != ((void *)0) || pxQueue->u.xSemaphore.xMutexHolder == ((void *)0) || pxQueue->u.xSemaphore.xMutexHolder == xTaskGetCurrentTaskHandle())

I am unable to interpret the error. However, when I change the definition of the mutexes to binary semaphores in setup():

//create mutexes
mutex_1 = xSemaphoreCreateBinary();
mutex_2 = xSemaphoreCreateBinary();

The code runs fine in the ESP32. Would anyone please explain me why this happens? Many thanks and sorry if the question wasn't adequately made, as this is my first one.

FreeRTOS mutex/binary semaphore and deadlock

0 Answers