ISR-safe API functions (FromISR suffix) in FreeRTOS - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does the 'FromISR' suffix in FreeRTOS API functions indicate?

It indicates that the function is safe to call from an Interrupt Service Routine (ISR). These functions are designed to be used in interrupt context without causing issues like blocking or priority inversion.

beginner

Why can't regular FreeRTOS API functions be called directly from an ISR?

Regular FreeRTOS API functions may block or use operations that are not safe in interrupt context, such as waiting for a resource. ISRs must be fast and non-blocking, so special 'FromISR' versions are provided to be safe in ISRs.

intermediate

How do 'FromISR' functions handle task switching differently?

They use a pointer parameter to indicate if a context switch should happen after the ISR completes. This allows the kernel to defer the switch safely until after the interrupt, maintaining system stability.

beginner

Give an example of a FreeRTOS API function and its ISR-safe counterpart.

Example: xQueueSend() is the regular function to send to a queue. Its ISR-safe counterpart is xQueueSendFromISR(), which can be safely called inside an ISR.

intermediate

What is the purpose of the 'pxHigherPriorityTaskWoken' parameter in 'FromISR' functions?

It is a pointer to a variable that the function sets to pdTRUE if calling the function caused a higher priority task to become ready to run. This informs the ISR that a context switch should be requested after the ISR finishes.

What is the main reason to use 'FromISR' functions in FreeRTOS?

A They are safe to call inside Interrupt Service Routines.

B They run faster than regular functions.

C They allocate more memory.

D They block until a resource is available.

FromISR functions are specifically designed to be safe when called inside ISRs, avoiding blocking and unsafe operations.

Which parameter in 'FromISR' functions helps decide if a context switch is needed?

A pxHigherPriorityTaskWoken

B xQueueHandle

C xTicksToWait

D pvParameters

The pxHigherPriorityTaskWoken pointer is set by the function to indicate if a higher priority task was woken.

Can you call xQueueSend() directly inside an ISR?

A Yes, always.

B Only if interrupts are disabled.

C No, use xQueueSendFromISR() instead.

D Only if the queue is empty.

xQueueSend() is not safe in ISRs; the FromISR version must be used.

What happens if a 'FromISR' function sets pxHigherPriorityTaskWoken to pdTRUE?

A Nothing happens.

B The ISR must request a context switch after it finishes.

C The ISR disables interrupts.

D The system crashes.

Setting pxHigherPriorityTaskWoken to pdTRUE signals that a higher priority task is ready and a context switch should occur.

Which of these is NOT true about 'FromISR' functions?

A They never block.

B They can be called from normal tasks.

C They use special parameters for context switching.

D They are unsafe in ISRs.

'FromISR' functions are specifically designed to be safe in ISRs.

Explain why FreeRTOS provides 'FromISR' versions of API functions and how they differ from regular API calls.

Think about what makes interrupt routines special and how these functions avoid problems.

Describe the role of the pxHigherPriorityTaskWoken parameter in ISR-safe FreeRTOS API functions.

Consider how FreeRTOS decides when to switch tasks after an interrupt.

Practice

1.

What is the main reason to use FreeRTOS API functions with the FromISR suffix inside an interrupt service routine (ISR)?

easy

A. They disable all interrupts during execution.

B. They are safe to call from ISRs and handle interrupt context correctly.

C. They run tasks faster than normal API functions.

D. They automatically create new tasks inside the ISR.

Solution

1. Step 1: Understand ISR context constraints

   Inside an ISR, normal FreeRTOS API functions are unsafe because they may block or cause race conditions.

2. Step 2: Role of FromISR functions

   Functions with the FromISR suffix are designed to be safe in interrupt context by avoiding blocking and managing critical sections properly.

3. Final Answer:

   They are safe to call from ISRs and handle interrupt context correctly. -> Option B

4. Quick Check:

   FromISR functions = ISR safe calls [OK]

Hint: Use FromISR functions only inside interrupts for safety [OK]

Common Mistakes:

• Calling normal API functions inside ISR causing crashes
• Assuming FromISR functions disable interrupts
• Thinking FromISR creates tasks automatically

2.

Which of the following is the correct way to declare a variable to track if a higher priority task was woken inside an ISR?

?

easy

A. int higherPriorityTaskWoken = 0;

B. bool higherPriorityTaskWoken = false;

C. BaseType_t higherPriorityTaskWoken = pdFALSE;

D. volatile int higherPriorityTaskWoken = 1;

Solution

1. Step 1: Identify FreeRTOS type for ISR task wake flag

   FreeRTOS uses BaseType_t for portability and defines pdFALSE and pdTRUE for boolean values.

2. Step 2: Correct initialization

   The variable must start as pdFALSE to indicate no task was woken yet.

3. Final Answer:

   BaseType_t higherPriorityTaskWoken = pdFALSE; -> Option C

4. Quick Check:

   Use BaseType_t and pdFALSE for ISR flags [OK]

Hint: Use BaseType_t and pdFALSE to track task wake in ISR [OK]

Common Mistakes:

• Using plain int instead of BaseType_t
• Initializing flag to 1 instead of pdFALSE
• Using bool which may not be portable

3.

Consider this ISR code snippet:

BaseType_t higherPriorityTaskWoken = pdFALSE;
xQueueSendFromISR(queue, &data, &higherPriorityTaskWoken);
if (higherPriorityTaskWoken) {
    portYIELD_FROM_ISR();
}

What happens if higherPriorityTaskWoken is set to pdTRUE after xQueueSendFromISR?

medium

A. The ISR requests a context switch to the higher priority task immediately after ISR.

B. The ISR disables all interrupts until the higher priority task runs.

C. The queue send operation fails silently.

D. The higher priority task is blocked until the ISR finishes.

Solution

1. Step 1: Understand higherPriorityTaskWoken flag

   This flag indicates if a task with higher priority than the current one was made ready by the ISR.

2. Step 2: Role of portYIELD_FROM_ISR()

   If the flag is true, calling portYIELD_FROM_ISR() requests a context switch to that higher priority task immediately after ISR exit.

3. Final Answer:

   The ISR requests a context switch to the higher priority task immediately after ISR. -> Option A

4. Quick Check:

   higherPriorityTaskWoken true triggers context switch [OK]

Hint: If higherPriorityTaskWoken true, call portYIELD_FROM_ISR() [OK]

Common Mistakes:

• Thinking interrupts are disabled by portYIELD_FROM_ISR()
• Assuming queue send fails if flag is true
• Believing higher priority task waits for ISR to finish

4.

Identify the error in this ISR code snippet:

void ISR_Handler(void) {
    BaseType_t higherPriorityTaskWoken = pdFALSE;
    xSemaphoreGive(semaphore);
    if (higherPriorityTaskWoken) {
        portYIELD_FROM_ISR();
    }
}

What is the problem here?

medium

A. The variable higherPriorityTaskWoken should be global.

B. The semaphore is given twice causing overflow.

C. The portYIELD_FROM_ISR() call is outside the ISR.

D. The higherPriorityTaskWoken variable is not passed to xSemaphoreGiveFromISR.

Solution

1. Step 1: Check function used for semaphore give

   The code uses xSemaphoreGive, which is not safe inside ISR context.

2. Step 2: Correct ISR-safe function usage

   Inside ISR, xSemaphoreGiveFromISR must be used with higherPriorityTaskWoken passed by reference to track task wake.

3. Final Answer:

   The higherPriorityTaskWoken variable is not passed to xSemaphoreGiveFromISR. -> Option D

4. Quick Check:

   Use FromISR functions with higherPriorityTaskWoken [OK]

Hint: Always pass higherPriorityTaskWoken to FromISR functions [OK]

Common Mistakes:

• Using normal API functions inside ISR
• Not passing higherPriorityTaskWoken pointer
• Declaring higherPriorityTaskWoken as global unnecessarily

5.

You want to send data from an ISR to a task using a queue. Which sequence correctly uses FreeRTOS ISR-safe API functions to do this and ensure the higher priority task runs immediately if woken?

?

hard

A. BaseType_t higherPriorityTaskWoken = pdFALSE;
xQueueSendFromISR(queue, &data, &higherPriorityTaskWoken);
if (higherPriorityTaskWoken) portYIELD_FROM_ISR();

B. xQueueSend(queue, &data, 0);
BaseType_t higherPriorityTaskWoken = pdFALSE;
if (higherPriorityTaskWoken) portYIELD_FROM_ISR();

C. BaseType_t higherPriorityTaskWoken = pdTRUE;
xQueueSendFromISR(queue, &data, NULL);
portYIELD_FROM_ISR();

D. BaseType_t higherPriorityTaskWoken = pdFALSE;
xQueueSend(queue, &data, 0);
portYIELD_FROM_ISR();

Solution

1. Step 1: Use ISR-safe queue send function

   Inside ISR, xQueueSendFromISR must be used with a pointer to higherPriorityTaskWoken.

2. Step 2: Check higherPriorityTaskWoken and yield

   If higherPriorityTaskWoken is set to pdTRUE, call portYIELD_FROM_ISR() to request immediate context switch.

3. Final Answer:

   BaseType_t higherPriorityTaskWoken = pdFALSE; xQueueSendFromISR(queue, &data, &higherPriorityTaskWoken); if (higherPriorityTaskWoken) portYIELD_FROM_ISR(); -> Option A

4. Quick Check:

   Use FromISR + check flag + yield [OK]

Hint: Use xQueueSendFromISR with flag and yield if true [OK]

Common Mistakes:

• Using normal xQueueSend inside ISR
• Not passing higherPriorityTaskWoken pointer
• Calling portYIELD_FROM_ISR unconditionally