xQueueSend() and xQueueReceive() in FreeRTOS

Introduction

These functions help tasks send and receive data safely between each other in FreeRTOS. They make sure data is passed without conflicts.

When one task needs to send a message or data to another task.

When tasks must share information without interfering with each other's work.

When you want to wait for data from another task before continuing.

When you want to avoid data loss by using a queue to hold messages temporarily.

Syntax

FreeRTOS

/* Queue handle is created elsewhere */
BaseType_t xQueueSend(QueueHandle_t xQueue, const void * pvItemToQueue, TickType_t xTicksToWait);
BaseType_t xQueueReceive(QueueHandle_t xQueue, void *pvBuffer, TickType_t xTicksToWait);

xQueueSend() adds an item to the back of the queue.

xQueueReceive() removes an item from the front of the queue.

Examples

Sends the integer 42 to the queue. If the queue is full, it waits 10 ticks before giving up.

FreeRTOS

/* Sending an integer to the queue, wait up to 10 ticks if full */
int valueToSend = 42;
xQueueSend(myQueue, &valueToSend, 10);

Waits indefinitely until an item is available, then stores it in receivedValue.

FreeRTOS

/* Receiving an integer from the queue, wait forever if empty */
int receivedValue;
xQueueReceive(myQueue, &receivedValue, portMAX_DELAY);

Checks if queue is empty without waiting. If empty, returns immediately.

FreeRTOS

/* What if queue is empty? xQueueReceive returns pdFALSE immediately if xTicksToWait is 0 */
int data;
if(xQueueReceive(myQueue, &data, 0) == pdFALSE) {
    // No data available
}

Tries to send data without waiting. If queue is full, it fails immediately.

FreeRTOS

/* What if queue is full? xQueueSend returns errQUEUE_FULL if no space after waiting */
int newData = 100;
if(xQueueSend(myQueue, &newData, 0) == errQUEUE_FULL) {
    // Queue is full, data not sent
}

Sample Program

This program creates a queue that holds one integer. The sender task sends the number 10 to the queue. The receiver task waits and receives that number, printing it out. The output shows the order of sending and receiving.

FreeRTOS

#include "FreeRTOS.h"
#include "queue.h"
#include "task.h"
#include <stdio.h>

QueueHandle_t myQueue;

void senderTask(void *params) {
    int valueToSend = 10;
    printf("Sender: Sending %d to queue\n", valueToSend);
    if(xQueueSend(myQueue, &valueToSend, pdMS_TO_TICKS(100)) == pdPASS) {
        printf("Sender: Sent successfully\n");
    } else {
        printf("Sender: Failed to send\n");
    }
    vTaskDelete(NULL);
}

void receiverTask(void *params) {
    int receivedValue = 0;
    printf("Receiver: Waiting to receive from queue\n");
    if(xQueueReceive(myQueue, &receivedValue, portMAX_DELAY) == pdPASS) {
        printf("Receiver: Received %d from queue\n", receivedValue);
    } else {
        printf("Receiver: Failed to receive\n");
    }
    vTaskDelete(NULL);
}

int main(void) {
    myQueue = xQueueCreate(1, sizeof(int));
    if(myQueue == NULL) {
        printf("Failed to create queue\n");
        return 1;
    }
    printf("Queue created\n");

    xTaskCreate(senderTask, "Sender", 1000, NULL, 1, NULL);
    xTaskCreate(receiverTask, "Receiver", 1000, NULL, 1, NULL);

    vTaskStartScheduler();

    // Should never reach here
    printf("Scheduler ended\n");
    return 0;
}

Important Notes

Time complexity: Both xQueueSend() and xQueueReceive() run in constant time O(1).

Space complexity: Depends on queue length and item size; each item uses memory in the queue buffer.

Common mistake: Not checking the return value to know if send or receive succeeded.

Use xQueueSend() when you want to add data safely to a queue; use xQueueReceive() when you want to get data from the queue, optionally waiting if empty.

Summary

xQueueSend() puts data into a queue safely for other tasks to get.

xQueueReceive() gets data from the queue, waiting if needed.

Always check return values to handle full or empty queues properly.

Practice

1. What is the primary purpose of the xQueueSend() function in FreeRTOS?

easy

A. To remove an item from a queue

B. To add an item to a queue for other tasks to receive

C. To create a new queue

D. To delete an existing queue

Solution

1. Step 1: Understand the role of xQueueSend()

   xQueueSend() is used to place data into a queue so that other tasks can retrieve it later.

2. Step 2: Differentiate from other queue functions

   Functions like xQueueReceive() remove data, while xQueueCreate() and xQueueDelete() manage queue lifecycle, not data transfer.

3. Final Answer:

   To add an item to a queue for other tasks to receive -> Option B

4. Quick Check:

   xQueueSend() adds data [OK]

Hint: Remember: Send puts data in, Receive takes data out [OK]

Common Mistakes:

• Confusing sending with receiving
• Thinking it creates or deletes queues
• Ignoring the function's data transfer role

2. Which of the following is the correct syntax to send data to a queue using xQueueSend()?

easy

A. xQueueSend(queueHandle, data, 0);

B. xQueueSend(&queueHandle, data, portMAX_DELAY);

C. xQueueSend(queueHandle, &data, portMAX_DELAY);

D. xQueueSend(queueHandle, &data);

Solution

1. Step 1: Check parameter types for xQueueSend()

   The function expects the queue handle, a pointer to the data, and a timeout value.

2. Step 2: Match the correct syntax

   xQueueSend(queueHandle, &data, portMAX_DELAY); correctly passes the queue handle, address of data, and a timeout constant portMAX_DELAY.

3. Final Answer:

   xQueueSend(queueHandle, &data, portMAX_DELAY); -> Option C

4. Quick Check:

   Queue handle + &data + timeout = correct syntax [OK]

Hint: Always pass data by address and include timeout [OK]

Common Mistakes:

• Passing data by value instead of pointer
• Omitting the timeout parameter
• Passing queue handle by address

3. Consider the following code snippet:

int value = 10;
if (xQueueSend(queue, &value, 0) == pdPASS) {
    int receivedValue = 0;
    if (xQueueReceive(queue, &receivedValue, 0) == pdPASS) {
        printf("%d", receivedValue);
    }
}

What will be printed when this code runs?

medium

A. 10

B. 0

C. No output (queue empty)

D. Compilation error

Solution

1. Step 1: Analyze xQueueSend() call

   The value 10 is sent to the queue with zero wait time. If the queue is not full, it returns pdPASS.

2. Step 2: Analyze xQueueReceive() call

   The code tries to receive from the queue immediately. Since the value was just sent, it will receive 10 and print it.

3. Final Answer:

   10 -> Option A

4. Quick Check:

   Send 10, receive 10, print 10 [OK]

Hint: Send then receive immediately prints sent value [OK]

Common Mistakes:

• Assuming queue is empty at receive
• Confusing return values with data
• Ignoring zero timeout behavior

4. What is wrong with this code snippet?

int data = 5;
if (xQueueSend(queue, data, 10) != pdPASS) {
    // handle error
}

medium

A. Data should be passed by pointer, not by value

B. Timeout value 10 is invalid

C. Return value should not be compared to pdPASS

D. Queue handle is missing

Solution

1. Step 1: Check parameter types in xQueueSend()

   The second parameter must be a pointer to the data, but here data is passed by value.

2. Step 2: Identify the error cause

   Passing data by value causes a type mismatch and likely a compilation error or incorrect behavior.

3. Final Answer:

   Data should be passed by pointer, not by value -> Option A

4. Quick Check:

   Pass &data, not data [OK]

Hint: Always pass address of data to queue functions [OK]

Common Mistakes:

• Passing data directly instead of pointer
• Misunderstanding timeout parameter
• Ignoring return value check

5. You want to send multiple integers to a queue and then receive them in order. Which approach correctly uses xQueueSend() and xQueueReceive() to achieve this without losing data?

hard

A. Use xQueueReceive() to send data and xQueueSend() to receive data

B. Send all integers at once by passing an array pointer to xQueueSend(), then receive with one xQueueReceive()

C. Send integers without checking return values, then receive once expecting all data

D. Send each integer with xQueueSend() using a timeout, then receive each with xQueueReceive() using a timeout, checking return values each time

Solution

1. Step 1: Understand queue data handling

   Queues handle one item at a time, so each integer must be sent individually with xQueueSend().

2. Step 2: Properly receive data

   Each item must be received individually with xQueueReceive(), checking return values to avoid errors or data loss.

3. Step 3: Eliminate incorrect options

   Send all integers at once by passing an array pointer to xQueueSend(), then receive with one xQueueReceive() is wrong because queues do not send arrays as single items. Send integers without checking return values, then receive once expecting all data risks data loss by ignoring return values. Use xQueueReceive() to send data and xQueueSend() to receive data reverses function roles.

4. Final Answer:

   Send each integer with xQueueSend() using a timeout, then receive each with xQueueReceive() using a timeout, checking return values each time -> Option D

5. Quick Check:

   Send and receive items one by one, check returns [OK]

Hint: Send and receive items individually, always check returns [OK]

Common Mistakes:

• Trying to send multiple items at once
• Ignoring return values causing lost data
• Mixing up send and receive functions