Methods for Multithreaded Access to UART in RTOS

Reader *Shi San* asks: Can the blogger introduce methods for multiple tasks to access the same hardware under RTOS? For example, multiple tasks need to use the serial port to print information.

My answer is: Both mutexes and queues can solve the access conflict problem.

Multithreaded access to the same serial hardware is commonly used in many systems, such as multiple threads using UART to send and receive data, multiple threads reading and writing SPI_FLASH, I2C_E2PROM, and CAN bus data, etc…

If each thread tries to simultaneously access the same serial port for read and write operations, problems can easily arise. To resolve these conflicts, certain methods need to be employed. Below, using UART as an example, I will discuss the basic methods of mutexes and queues based on FreeRTOS.

Ⅰ

Mutex Access Method

Mutex: A variable that can be in one of two states: unlocked and locked.

Principle: Create a mutex, Thread A occupies the resource (uses UART to send data). At this time, Thread B and other threads cannot occupy the resource. When Thread A finishes using the resource (UART has finished sending data), it releases the resource, allowing other threads to seize the resource.

Create Mutex

Thread A occupies resource

Use resource (send data)

Thread A releases resource

Higher priority thread B occupies resource

Use resource

Thread B releases resource

Subsequently, higher priority threads occupy the resource

·

·

·

Code:

//Create mutex resource
SemaphoreHandle_t xSemaphore = NULL;
xSemaphore = xSemaphoreCreateMutex();

void TaskA(void *pvParameters)
{
  for(;;)
  {
    //Occupy resource
    if(xSemaphoreTake(xSemaphore, 10 ) == pdTRUE)
    {
      //Use resource (send data)
      USART_SendNByte();
      //Release resource
      xSemaphoreGive(xSemaphore);
    }
  }
}

Difference Between Semaphore and Mutex:

Semaphore: Used for multithreaded synchronization; when one thread completes a certain action, it signals other threads, allowing them to execute certain actions;

Mutex: Used for multithreaded mutual exclusion; when one thread occupies a certain resource, other threads cannot access it until that thread exits, allowing other threads to access the resource;

Ⅱ

Queue Operation Method

The queue operation method follows the FIFO principle (First In First Out). For example: if Thread A wants to use UART to send a string of data, it adds it to the queue; then Thread B also wants to use UART to send a string of data.

In this case, Thread A adds its data to the queue, and then Thread B adds its data to the queue.

In another UART sending thread, data is read from the queue in FIFO order and sent out accordingly.

Create a queue (data sending queue)

Create a task (UART sending data thread)

Thread A adds to queue

Thread B adds to queue

·

·

·

On the other side, the thread reads queue data in order and uses UART to send it out.

Code:

QueueHandle_t xQueue;
xQueue = xQueueCreate(QUEUE_LENGTH, QUEUE_ITEM_SIZE);

xTaskCreate(UART_Send_Task, "UART_Send", STACK_SIZE, NULL, TASK_PRIORITY, NULL);

void TaskA(void *pvParameters)
{
  for(;;)
  {
    //Thread related operations

    //Add to queue
    xQueueSend(xQueue, &TaskA_Buf, 10)
  }
}

void TaskB(void *pvParameters)
{
  for(;;)
  {
    //Thread related operations

    //Add to queue
    xQueueSend(xQueue, &TaskB_Buf, 10)
  }
}

void UART_Send_Task(void *pvParameters)
{
  for(;;)
  {
    //Loop to read queue BUF
    if(xQueueReceive(xQueue, &Buf, 10) == pdTRUE)
    {
      USART_SendNByte(&Buf);
    }
  }
}

The above two methods are commonly used, and I hope everyone can master them. The above only aims to help everyone understand the principles; the code should not be directly copied and pasted for use.

Recommended Reading:

LED Status Light Task (Thread) Design (Based on RTOS)

Revisiting the Classic PID Algorithm

Ⅲ

Finally

1. Pin the public account, so you won’t have trouble finding me;

2. Remember to give me a thumbs up!

3. Search for “strongerHuang” on WeChat or scan the QR code below to follow and see more exciting content in my bottom menu!

Long press to identify the QR code to follow

Appreciation is recognition and support for the author!