Why interrupt handling is critical in RTOS in FreeRTOS - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define an interrupt service routine (ISR) in FreeRTOS.

FreeRTOS

void vExampleISR(void) {
    BaseType_t xHigherPriorityTaskWoken = [1];
    // ISR code here
}

Drag options to blanks, or click blank then click option'

ApdFALSE

BpdTRUE

CpdPASS

DpdFAIL

Attempts:

3 left

💡 Hint

Common Mistakes

Using pdTRUE instead of pdFALSE to initialize xHigherPriorityTaskWoken.

In FreeRTOS, pdFALSE is used to initialize xHigherPriorityTaskWoken to indicate no higher priority task was woken yet.

2fill in blank

medium

Complete the code to notify a task from an ISR in FreeRTOS.

FreeRTOS

void vExampleISR(void) {
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    vTaskNotifyGiveFromISR(taskHandle, [1]);
    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}

Drag options to blanks, or click blank then click option'

ANULL

BpdFALSE

CxHigherPriorityTaskWoken

D&xHigherPriorityTaskWoken

Attempts:

3 left

💡 Hint

Common Mistakes

Passing the variable directly instead of its address.

Passing NULL which disables task wake notification.

The function vTaskNotifyGiveFromISR requires a pointer to xHigherPriorityTaskWoken to update it if a higher priority task was woken.

3fill in blank

hard

Fix the error in the ISR code to correctly clear the interrupt flag.

FreeRTOS

void vExampleISR(void) {
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    // Clear interrupt flag
    [1];
    vTaskNotifyGiveFromISR(taskHandle, &xHigherPriorityTaskWoken);
    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}

Drag options to blanks, or click blank then click option'

ACLEAR_INTERRUPT_FLAG()

Bclear_interrupt_flag()

CClearInterruptFlag()

DclearInterruptFlag()

Attempts:

3 left

💡 Hint

Common Mistakes

Using lowercase or camelCase function names that do not exist.

Interrupt flags are usually cleared by a macro or function named in uppercase like CLEAR_INTERRUPT_FLAG() to ensure the hardware interrupt is acknowledged properly.

4fill in blank

hard

Fill both blanks to create a dictionary comprehension that maps interrupt names to their priority levels, only including priorities higher than 3.

FreeRTOS

interrupt_priorities = {name: level for name, level in interrupts.items() if level [1] [2]

Drag options to blanks, or click blank then click option'

A>

B3

C<

D5

Attempts:

3 left

💡 Hint

Common Mistakes

Using '<' instead of '>' causing wrong filtering.

Using wrong threshold values.

The comprehension filters interrupts with priority levels greater than 3 using level > 3.

5fill in blank

hard

Fill all three blanks to create a dictionary comprehension that maps task names in uppercase to their stack sizes, only for tasks with stack size greater than 1000.

FreeRTOS

task_stacks = [1]: [2] for [3], [2] in tasks.items() if [2] > 1000

Drag options to blanks, or click blank then click option'

Aname.upper()

Bstack_size

Cname

Dtask

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong variable names or forgetting to convert names to uppercase.

The comprehension uses name as the loop variable, maps name.upper() to stack_size, and filters stack sizes greater than 1000.

Practice

1. Why is interrupt handling critical in a FreeRTOS system?

easy

A. It allows the system to respond quickly to important events.

B. It slows down task switching to save power.

C. It prevents any tasks from running concurrently.

D. It disables all hardware peripherals during execution.

Solution

1. Step 1: Understand the role of interrupts in RTOS

   Interrupts notify the system immediately when an event occurs, allowing fast response.

2. Step 2: Connect interrupt handling to system responsiveness

   Quick interrupt handling ensures tasks can react on time, keeping the system efficient.

3. Final Answer:

   It allows the system to respond quickly to important events. -> Option A

4. Quick Check:

   Interrupts = Fast response [OK]

Hint: Interrupts make RTOS react fast to events [OK]

Common Mistakes:

• Thinking interrupts slow down the system
• Believing interrupts stop all tasks
• Assuming interrupts disable hardware

2. Which of the following is the correct way to write an ISR (Interrupt Service Routine) in FreeRTOS?

easy

A. void ISR_Handler() { vTaskDelay(100); }

B. void ISR_Handler() { while(1) {} }

C. void ISR_Handler() { delay(1000); }

D. void ISR_Handler() { BaseType_t xHigherPriorityTaskWoken = pdFALSE; xSemaphoreGiveFromISR(&xSemaphore, &xHigherPriorityTaskWoken); }

Solution

1. Step 1: Identify correct ISR practices in FreeRTOS

   ISRs must be quick and use FreeRTOS-safe functions like xSemaphoreGiveFromISR.

2. Step 2: Check each option for ISR correctness

   void ISR_Handler() { BaseType_t xHigherPriorityTaskWoken = pdFALSE; xSemaphoreGiveFromISR(&xSemaphore, &xHigherPriorityTaskWoken); } uses xSemaphoreGiveFromISR with proper parameters, which is correct.

3. Final Answer:

   void ISR_Handler() { BaseType_t xHigherPriorityTaskWoken = pdFALSE; xSemaphoreGiveFromISR(&xSemaphore, &xHigherPriorityTaskWoken); } -> Option D

4. Quick Check:

   Use FreeRTOS-safe calls in ISR [OK]

Hint: Use FreeRTOS-safe calls inside ISR [OK]

Common Mistakes:

• Calling blocking functions like vTaskDelay inside ISR
• Using infinite loops inside ISR
• Using non-ISR safe delay functions

3. Consider this FreeRTOS ISR snippet:

void ISR_Handler() {
  BaseType_t xHigherPriorityTaskWoken = pdFALSE;
  xSemaphoreGiveFromISR(&xSemaphore, &xHigherPriorityTaskWoken);
  portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}

What is the main effect of calling portYIELD_FROM_ISR(xHigherPriorityTaskWoken);?

medium

A. It disables all interrupts until the next tick.

B. It forces a context switch if a higher priority task was woken.

C. It delays the ISR execution by one tick.

D. It resets the semaphore to zero.

Solution

1. Step 1: Understand portYIELD_FROM_ISR usage

   This macro requests a context switch if a higher priority task was woken by the ISR.

2. Step 2: Analyze the effect on task scheduling

   If xHigherPriorityTaskWoken is true, the scheduler switches to that task immediately after ISR.

3. Final Answer:

   It forces a context switch if a higher priority task was woken. -> Option B

4. Quick Check:

   portYIELD_FROM_ISR triggers context switch [OK]

Hint: portYIELD_FROM_ISR triggers immediate switch if needed [OK]

Common Mistakes:

• Thinking it disables interrupts
• Assuming it delays ISR
• Believing it resets semaphores

4. You wrote this ISR in FreeRTOS:

void ISR_Handler() {
  vTaskDelay(10);
  xSemaphoreGiveFromISR(&xSemaphore, NULL);
}

What is the problem with this code?

medium

A. xSemaphoreGiveFromISR cannot be called with NULL as second argument.

B. ISR must not give semaphores.

C. Calling vTaskDelay inside ISR is invalid and causes errors.

D. The ISR should not have a void return type.

Solution

1. Step 1: Identify invalid function usage in ISR

   vTaskDelay is a blocking call and cannot be used inside an ISR.

2. Step 2: Understand ISR restrictions

   ISRs must be short and non-blocking; vTaskDelay violates this rule.

3. Final Answer:

   Calling vTaskDelay inside ISR is invalid and causes errors. -> Option C

4. Quick Check:

   No blocking calls in ISR [OK]

Hint: Never use blocking calls like vTaskDelay in ISR [OK]

Common Mistakes:

• Using blocking functions inside ISR
• Passing NULL incorrectly to ISR-safe functions
• Thinking ISR return type matters here

5. In a FreeRTOS system, you want to ensure that a high-priority task responds immediately to a hardware event. Which approach best uses interrupt handling to achieve this?

hard

A. Use an ISR to give a semaphore using xSemaphoreGiveFromISR and trigger a context switch if needed.

B. Use a long ISR that processes the entire event and blocks other interrupts.

C. Disable all interrupts and poll the hardware event in the main task loop.

D. Use an ISR to set a flag and call vTaskDelay inside the ISR to wait.

Solution

1. Step 1: Identify best practice for fast task response

   Giving a semaphore from ISR and triggering context switch wakes the high-priority task immediately.

2. Step 2: Evaluate other options for drawbacks

   Delays or polling slow response; long ISRs block system responsiveness.

3. Final Answer:

   Use an ISR to give a semaphore using xSemaphoreGiveFromISR and trigger a context switch if needed. -> Option A

4. Quick Check:

   Semaphore from ISR + context switch = fast response [OK]

Hint: Give semaphore from ISR and yield for immediate task run [OK]

Common Mistakes:

• Using delays inside ISR
• Polling instead of interrupts
• Writing long blocking ISRs