Queue from ISR (xQueueSendFromISR) in FreeRTOS - Mini Project: Build & Apply

Queue from ISR (xQueueSendFromISR) in FreeRTOS

📖 Scenario: You are working on a simple embedded system using FreeRTOS. You want to send data from an interrupt service routine (ISR) to a task using a queue. This is a common way to safely pass information from hardware interrupts to the main program.

🎯 Goal: Build a FreeRTOS program that creates a queue, sets up a variable to send, uses xQueueSendFromISR inside a simulated ISR function to send data to the queue, and then prints the received data in the main task.

📋 What You'll Learn

Create a queue that can hold integers

Create a variable called dataToSend with the value 100

Use xQueueSendFromISR to send dataToSend to the queue inside a function called ISR_Handler

Receive the data from the queue in the main task and print it

💡 Why This Matters

🌍 Real World

Passing data from hardware interrupts to tasks is common in embedded systems to handle events like button presses or sensor readings safely.

💼 Career

Understanding how to use queues from ISRs is essential for embedded software developers working with real-time operating systems like FreeRTOS.

1

Create the queue

Create a queue called myQueue that can hold 5 integers using xQueueCreate.

FreeRTOS

# Create a queue called myQueue that holds 5 integers
# Your code here

Hint

Use xQueueCreate with 5 as the number of items and sizeof(int) as the item size.

2

Create the data variable

Create an integer variable called dataToSend and set it to 100.

FreeRTOS

QueueHandle_t myQueue = xQueueCreate(5, sizeof(int));
# Create an integer variable dataToSend with value 100
# Your code here

Hint

Just declare int dataToSend = 100;.

3

Send data from ISR

Write a function called ISR_Handler that uses xQueueSendFromISR to send dataToSend to myQueue. Use a variable BaseType_t xHigherPriorityTaskWoken initialized to pdFALSE and pass its address to xQueueSendFromISR. Do not forget to call portYIELD_FROM_ISR(xHigherPriorityTaskWoken) after sending.

FreeRTOS

QueueHandle_t myQueue = xQueueCreate(5, sizeof(int));
int dataToSend = 100;

// Write ISR_Handler function to send dataToSend to myQueue using xQueueSendFromISR
# Your code here

Hint

Remember to declare xHigherPriorityTaskWoken and call portYIELD_FROM_ISR after sending.

4

Receive and print data in main task

In the main function, declare an integer receivedData. Call ISR_Handler() to simulate the interrupt. Then use xQueueReceive to receive data from myQueue into receivedData with a timeout of 0. Finally, print receivedData using printf.

FreeRTOS

QueueHandle_t myQueue = xQueueCreate(5, sizeof(int));
int dataToSend = 100;

void ISR_Handler(void) {
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    xQueueSendFromISR(myQueue, &dataToSend, &xHigherPriorityTaskWoken);
    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}

int main(void) {
    // Declare receivedData
    // Call ISR_Handler to simulate interrupt
    // Receive data from myQueue
    // Print receivedData
    # Your code here
}

Hint

Call ISR_Handler() first, then use xQueueReceive with timeout 0, and print the received value.

Practice

1.

What is the primary purpose of xQueueSendFromISR() in FreeRTOS?

easy

A. To send data to a queue safely from an interrupt service routine (ISR)

B. To create a new queue in the system

C. To delete a queue from an ISR

D. To block a task until data is received

Solution

1. Step 1: Understand the function context

   xQueueSendFromISR() is designed to be called inside an ISR, where normal queue functions that can block are unsafe.

2. Step 2: Identify the function's role

   It safely sends data to a queue without blocking, allowing communication from ISR to tasks.

3. Final Answer:

   To send data to a queue safely from an interrupt service routine (ISR) -> Option A

4. Quick Check:

   Purpose of xQueueSendFromISR = safe queue send from ISR [OK]

Hint: Remember: xQueueSendFromISR is for sending data inside interrupts [OK]

Common Mistakes:

• Confusing it with queue creation or deletion
• Thinking it blocks the ISR
• Using normal queue send functions inside ISR

2.

Which of the following is the correct way to call xQueueSendFromISR()?

BaseType_t xQueueSendFromISR(QueueHandle_t xQueue, const void * pvItemToQueue, BaseType_t *pxHigherPriorityTaskWoken);

easy

A. xQueueSendFromISR(queue, data, NULL);

B. xQueueSendFromISR(queue, &data, NULL);

C. xQueueSendFromISR(&queue, &data, NULL);

D. xQueueSendFromISR(queue, &data);

Solution

1. Step 1: Check parameter types

   The function expects a queue handle, a pointer to the data, and a pointer to a BaseType_t variable for task wake flag.

2. Step 2: Match correct call

   xQueueSendFromISR(queue, &data, NULL); passes the queue handle, address of data, and NULL for the last parameter, which is valid if you don't care about task wake.

3. Final Answer:

   xQueueSendFromISR(queue, &data, NULL); -> Option B

4. Quick Check:

   Correct parameters and pointers used = xQueueSendFromISR(queue, &data, NULL); [OK]

Hint: Always pass data address and pxHigherPriorityTaskWoken pointer [OK]

Common Mistakes:

• Passing data instead of its address
• Passing queue address instead of handle
• Omitting the third parameter

3.

Given the following code snippet inside an ISR, what will be the value of result after execution?

BaseType_t xHigherPriorityTaskWoken = pdFALSE;
int data = 10;
BaseType_t result = xQueueSendFromISR(myQueue, &data, &xHigherPriorityTaskWoken);

Assume myQueue has space available.

medium

A. pdFAIL (0)

B. pdFALSE (0)

C. pdTRUE (1)

D. pdPASS (1)

Solution

1. Step 1: Understand return values of xQueueSendFromISR

   The function returns pdPASS (1) if the item was successfully sent to the queue, pdFAIL (0) otherwise.

2. Step 2: Analyze queue state

   Since myQueue has space, the send will succeed, so result will be pdPASS (1).

3. Final Answer:

   pdPASS (1) -> Option D

4. Quick Check:

   Queue has space, send success = pdPASS (1) [OK]

Hint: If queue has space, xQueueSendFromISR returns pdPASS (1) [OK]

Common Mistakes:

• Confusing pdPASS with pdTRUE
• Assuming it returns pdFALSE on success
• Ignoring queue capacity

4.

Identify the error in this ISR code snippet using xQueueSendFromISR():

void ISR_Handler(void) {
    int value = 5;
    BaseType_t xHigherPriorityTaskWoken;
    xQueueSendFromISR(myQueue, &value, &xHigherPriorityTaskWoken);
    if(xHigherPriorityTaskWoken) {
        portYIELD_FROM_ISR();
    }
}

medium

A. value should be a pointer, not an int

B. portYIELD_FROM_ISR() is called incorrectly

C. xHigherPriorityTaskWoken is not initialized before use

D. xQueueSendFromISR() cannot be called inside ISR

Solution

1. Step 1: Check variable initialization

   xHigherPriorityTaskWoken must be initialized to pdFALSE before calling xQueueSendFromISR() to avoid unpredictable behavior.

2. Step 2: Verify other parts

   Calling portYIELD_FROM_ISR() conditionally is correct; value is passed by address; calling xQueueSendFromISR() inside ISR is valid.

3. Final Answer:

   xHigherPriorityTaskWoken is not initialized before use -> Option C

4. Quick Check:

   Initialize xHigherPriorityTaskWoken = pdFALSE before use [OK]

Hint: Always init xHigherPriorityTaskWoken to pdFALSE before sending [OK]

Common Mistakes:

• Not initializing xHigherPriorityTaskWoken
• Misusing portYIELD_FROM_ISR
• Passing data incorrectly

5.

You want to send multiple sensor readings from an ISR to a task using xQueueSendFromISR(). Which approach correctly ensures the task runs immediately if it has higher priority?

void SensorISR(void) {
    static int sensorData = 0;
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    sensorData++;
    xQueueSendFromISR(sensorQueue, &sensorData, &xHigherPriorityTaskWoken);
    // What should be done here?
}

hard

A. Call portYIELD_FROM_ISR(xHigherPriorityTaskWoken); after sending

B. Call vTaskDelay(1); inside the ISR

C. Call taskYIELD(); inside the ISR unconditionally

D. Do nothing; the task will run eventually

Solution

1. Step 1: Understand task wake mechanism

   After sending data from ISR, if a higher priority task was woken, you must request a context switch immediately.

2. Step 2: Use correct yield function

   portYIELD_FROM_ISR(xHigherPriorityTaskWoken); triggers a context switch only if needed, which is the correct approach.

3. Final Answer:

   Call portYIELD_FROM_ISR(xHigherPriorityTaskWoken); after sending -> Option A

4. Quick Check:

   Use portYIELD_FROM_ISR with xHigherPriorityTaskWoken to yield [OK]

Hint: Use portYIELD_FROM_ISR with flag to yield only if needed [OK]

Common Mistakes:

• Calling blocking functions like vTaskDelay in ISR
• Calling taskYIELD unconditionally inside ISR
• Ignoring portYIELD_FROM_ISR call