After publishing “Introduction to FreeRTOS – Queues (1)”, some students reported that they found it difficult to understand. This article builds upon the foundation laid in “Introduction to FreeRTOS – Queues (1)” and provides further explanations and insights into the concept of queues in FreeRTOS, incorporating some personal interpretations and views.

Detailed Explanation and Practical Applications of FreeRTOS Queues

What is a Queue?

Imagine you are in line to buy ice cream. The first person is at the front of the line, and the first person to finish buying ice cream will leave the queue, followed by the second person, and so on. If you enjoy playing badminton, you can also understand it this way: when you put shuttlecocks into a shuttlecock container, you always put them in from the front, and take them out the same way, which means that the shuttlecock you take out is definitely the one you put in first. The characteristic of a queue is “First In, First Out” (FIFO). In FreeRTOS, queues also follow this rule.

In embedded systems, queues are a very common and important concept. It is like a queue waiting for processing, where each person (or task) waits in line to be processed one by one. In FreeRTOS, queues are also used as a tool for storing data and passing information between tasks. Next, we will not only explain the basic theory of FreeRTOS queues but also demonstrate their application in projects with practical examples, citing some authoritative explanations and evaluations.

The Role of Queues

In a multitasking system, tasks need to exchange data or notify each other. For example, one task produces data while another task consumes it. A queue acts like a transfer station for data, allowing tasks to pass data through the queue while ensuring that the data is processed in order.

As explained in the official FreeRTOS documentation: “Queues are the primary means of communication between tasks, ensuring that multiple tasks can share data safely and efficiently.” This highlights the importance of queues as a data exchange channel in multitasking systems.

How to Use Queues in FreeRTOS?

Creating a Queue

In FreeRTOS, we can create a queue using<span>xQueueCreate()</span>. For example:

QueueHandle_t xQueue = xQueueCreate(10, sizeof(int));

This queue can hold 10<span>int</span> type data.

Sending Data to the Queue

If you are the first person in line to buy ice cream, you can put your data (ice cream flavor) into the queue. Use<span>xQueueSend()</span> to place data into the queue:

int data = 5;
xQueueSend(xQueue, &data, portMAX_DELAY);

Now the data is in the queue, waiting to be retrieved by subsequent tasks.

Receiving Data from the Queue

If you are the second person in line, waiting for the first person to finish buying ice cream before you buy, you can use<span>xQueueReceive()</span> to retrieve data from the queue:

int receivedData;
xQueueReceive(xQueue, &receivedData, portMAX_DELAY);

Data will be retrieved in order, ensuring that the first data to enter the queue is the first to be taken out.

Practical Application Cases

Case 1: Producer-Consumer Model

In embedded systems, the producer-consumer problem is a very classic scenario. We can use queues to implement collaboration between producer tasks and consumer tasks.

Requirements

• • The producer task periodically generates sensor data and places it into the queue.
• • The consumer task retrieves data from the queue and processes it (for example, sending the data to a display or other devices).

Example Code

// Producer Task
void producerTask(void *pvParameters) {
    int sensorData = 0;
    while (1) {
        // Produce data
        sensorData++;
        // Send data to the queue
        xQueueSend(xQueue, &sensorData, portMAX_DELAY);
        vTaskDelay(pdMS_TO_TICKS(1000));  // Generate data every second
    }
}

// Consumer Task
void consumerTask(void *pvParameters) {
    int receivedData;
    while (1) {
        // Receive data from the queue
        if (xQueueReceive(xQueue, &receivedData, portMAX_DELAY) == pdPASS) {
            // Process the received data
            printf("Received data: %d\n", receivedData);
        }
    }
}

Explanation

• • The producer task generates one data point every second and places it into the queue.
• • The consumer task retrieves data from the queue and prints it out. In practical applications, this data can be further processed or transmitted to other devices.

Case 2: Data Communication Between Tasks and Interrupts

FreeRTOS queues can also be used for communication between tasks and interrupt service routines. In some applications, we may need to pass data to a task for processing when an interrupt occurs. Queues are an ideal solution.

Requirements

• • Capture an event (e.g., sensor data) in the interrupt service routine (ISR).
• • Pass the event data to the task, which is responsible for further processing or responding.

Example Code

// Interrupt Service Routine
void IRAM_ATTR myISR(void) {
    static int eventData = 1;
    // Place data into the queue
    xQueueSendFromISR(xQueue, &eventData, NULL);
}

// Task
void myTask(void *pvParameters) {
    int receivedData;
    while (1) {
        // Receive data from the queue
        if (xQueueReceive(xQueue, &receivedData, portMAX_DELAY) == pdPASS) {
            // Process the received data
            printf("ISR Event: %d\n", receivedData);
        }
    }
}

Explanation

• • The interrupt service routine captures an event and sends the event data to the queue using<span>xQueueSendFromISR()</span>.
• • The task receives data from the queue and processes it. Through the queue, we can ensure safe data transfer between interrupts and tasks.

Advanced Usage: Collaboration Between Queues and Tasks

Queues not only store data but also help tasks collaborate. For example, in a multitasking application, the producer task sends data to the queue, and the consumer task retrieves data from the queue for processing.

Blocking and Non-blocking

In some cases, queue operations may be blocked until there is space in the queue or data to retrieve. For example, when the queue is full, the task sending data will wait until there is space available in the queue.

xQueueSend(xQueue, &data, portMAX_DELAY);  // Block until there is space in the queue

Alternatively, you can use a non-blocking approach:

xQueueSend(xQueue, &data, 0);  // Non-blocking, returns immediately if the queue is full

Similarly, retrieving data from the queue can also be blocking or non-blocking:

xQueueReceive(xQueue, &receivedData, portMAX_DELAY);  // Block until data is available

xQueueReceive(xQueue, &receivedData, 0);  // Non-blocking, returns immediately if the queue is empty

Queues in ESP-IDF

When developing with ESP-IDF, the usage of queues is similar to that in FreeRTOS. ESP-IDF is based on FreeRTOS, so it inherits the queue mechanism from FreeRTOS. You can still use<span>xQueueCreate()</span> and other functions to create queues and send and receive data.

However, ESP-IDF has some additional optimizations and integrations in practical applications. For example, ESP-IDF provides some dedicated queue APIs that facilitate data exchange between tasks and interrupts. Typically, ESP-IDF queues can be used in the following scenarios:

1. 1. Data Sharing Between Tasks: One task produces data, and another task consumes it.
2. 2. Data Communication Between Interrupts and Tasks: In the interrupt service routine, data can be placed into the queue, and tasks can retrieve data from the queue for processing.

Authoritative Interpretations and Evaluations

According to the official FreeRTOS website: “Queues provide a simple and effective way to pass data between multiple tasks, ensuring orderly exchange of data among multiple tasks.”

Additionally, “Mastering the FreeRTOS Real-Time Kernel” mentions: “FreeRTOS queues, as a lightweight and easy-to-implement synchronization mechanism, are suitable for various embedded applications and are key to ensuring task collaboration.”

This highlights the importance and efficiency of queues in multitasking processing.

Conclusion

Queues in FreeRTOS serve as a bridge for data transmission in multitasking systems, ensuring that data is passed between tasks in a first-in, first-out order. Through queues, tasks can efficiently and safely exchange data.

• • Queues have blocking and non-blocking modes, allowing flexible handling of task waiting and responses.
• • ESP-IDF has optimized FreeRTOS queues, making them more efficient in embedded systems.
• • Real-life queuing scenarios and the badminton example can help us understand how queues work. Imagine yourself waiting in line for ice cream, where everyone is served in order; this is the essence of a queue.

By learning and using FreeRTOS queues, we can better manage data transmission between tasks, making multitasking operations in the system more efficient and controllable. It is recommended to combine this article with “Introduction to FreeRTOS – Queues (1)” to gain a deeper understanding of the concepts and usage of queues in FreeRTOS, which will surely yield greater insights.