Queue from ISR (xQueueSendFromISR) in FreeRTOS - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the purpose of xQueueSendFromISR in FreeRTOS?

xQueueSendFromISR is used to send data to a queue safely from an Interrupt Service Routine (ISR) without causing conflicts with the main program.

beginner

Why can't we use xQueueSend inside an ISR?

xQueueSend may block or use operations not safe in interrupts. ISRs must be fast and non-blocking, so xQueueSendFromISR is designed specifically for ISR context.

intermediate

What is the role of the pxHigherPriorityTaskWoken parameter in xQueueSendFromISR?

This parameter is a pointer to a variable that indicates if sending to the queue caused a higher priority task to unblock. If set to pdTRUE, a context switch can be requested after the ISR.

intermediate

Show a simple example of using xQueueSendFromISR inside an ISR.

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

intermediate

What should you always do after calling xQueueSendFromISR if pxHigherPriorityTaskWoken is set to pdTRUE?

You should request a context switch using portYIELD_FROM_ISR() to ensure the higher priority task runs immediately after the ISR.

Which function is safe to use inside an ISR to send data to a queue?

A xQueueSendFromISR

B xQueueSend

C vTaskDelay

D xQueueReceive

xQueueSendFromISR is designed for use inside ISRs. xQueueSend is not safe in ISR context.

What does the pxHigherPriorityTaskWoken parameter indicate?

A If the queue is empty

B If the queue is full

C If the ISR completed successfully

D If a higher priority task was woken by the send

This parameter tells if sending to the queue caused a higher priority task to unblock.

What should you do if pxHigherPriorityTaskWoken is set to pdTRUE after xQueueSendFromISR?

A Ignore it

B Request a context switch with <code>portYIELD_FROM_ISR</code>

C Restart the ISR

D Call <code>vTaskDelay</code>

You should request a context switch to run the higher priority task immediately.

Why must ISRs avoid blocking functions like xQueueSend?

A Because ISRs cannot access queues

B Because ISRs run in user mode

C Because blocking delays ISR completion and can cause system issues

D Because ISRs run slower than tasks

ISRs must be fast and non-blocking to keep the system responsive.

What type of variable is pxHigherPriorityTaskWoken?

A Pointer to a BaseType_t

B Integer

C Boolean

D Void pointer

It is a pointer to a BaseType_t variable used to indicate if a higher priority task was woken.

Explain how xQueueSendFromISR works and why it is important in FreeRTOS ISRs.

Think about how ISRs must be fast and how tasks might be waiting on queues.

Describe the steps you take inside an ISR to send data to a queue and handle task switching.

Focus on the order and purpose of each step.

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