configMAX_SYSCALL_INTERRUPT_PRIORITY in FreeRTOS - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this FreeRTOS priority check?

Consider the following FreeRTOS configuration snippet and interrupt priority check:

#define configMAX_SYSCALL_INTERRUPT_PRIORITY 5
void ISR_Handler(void) {
    uint8_t priority = get_interrupt_priority();
    if(priority >= configMAX_SYSCALL_INTERRUPT_PRIORITY) {
        printf("Safe to call FreeRTOS API\n");
    } else {
        printf("Unsafe to call FreeRTOS API\n");
    }
}

// Assume get_interrupt_priority() returns 4

What will be printed when ISR_Handler() runs?

FreeRTOS

#define configMAX_SYSCALL_INTERRUPT_PRIORITY 5
void ISR_Handler(void) {
    uint8_t priority = get_interrupt_priority();
    if(priority >= configMAX_SYSCALL_INTERRUPT_PRIORITY) {
        printf("Safe to call FreeRTOS API\n");
    } else {
        printf("Unsafe to call FreeRTOS API\n");
    }
}

// get_interrupt_priority() returns 4

A Unsafe to call FreeRTOS API

B Compilation error due to missing function

C Safe to call FreeRTOS API

D Runtime error due to invalid priority

💡 Hint

Remember lower numeric priority values mean higher urgency in FreeRTOS.

Since the interrupt priority (4) is less than configMAX_SYSCALL_INTERRUPT_PRIORITY (5), it is unsafe to call FreeRTOS API functions from this interrupt.

🧠 Conceptual

intermediate

What does configMAX_SYSCALL_INTERRUPT_PRIORITY control?

In FreeRTOS, what is the role of configMAX_SYSCALL_INTERRUPT_PRIORITY?

A It configures the maximum number of system calls allowed per interrupt.

B It sets the highest interrupt priority from which FreeRTOS API calls are allowed.

C It defines the lowest interrupt priority in the system.

D It disables all interrupts above a certain priority level.

💡 Hint

Think about which interrupts can safely use FreeRTOS API functions.

configMAX_SYSCALL_INTERRUPT_PRIORITY sets the highest (numerically lowest) interrupt priority that can safely call FreeRTOS API functions. Interrupts with higher priority (numerically lower) must not call FreeRTOS API.

🔧 Debug

advanced

Why does this ISR cause a crash when calling FreeRTOS API?

Given this ISR code snippet:

#define configMAX_SYSCALL_INTERRUPT_PRIORITY 3
void ISR_Handler(void) {
    uint8_t priority = get_interrupt_priority(); // returns 2
    vTaskNotifyGiveFromISR(taskHandle, NULL);
}

Why might this cause a system crash?

A The configMAX_SYSCALL_INTERRUPT_PRIORITY value must be set to 0.

B The taskHandle is NULL causing a null pointer dereference.

C vTaskNotifyGiveFromISR requires a different API call for this priority level.

D The interrupt priority (2) is higher than configMAX_SYSCALL_INTERRUPT_PRIORITY (3), so calling FreeRTOS API is unsafe.

💡 Hint

Check the priority comparison rules for calling FreeRTOS API from interrupts.

Interrupts with priority numerically less than configMAX_SYSCALL_INTERRUPT_PRIORITY (meaning higher urgency) must not call FreeRTOS API functions. Here priority 2 is higher than 3, so the call is unsafe and causes a crash.

📝 Syntax

advanced

Which option correctly defines configMAX_SYSCALL_INTERRUPT_PRIORITY for Cortex-M3?

For a Cortex-M3 microcontroller with 4 bits of priority, which definition correctly sets configMAX_SYSCALL_INTERRUPT_PRIORITY to priority level 5?

A #define configMAX_SYSCALL_INTERRUPT_PRIORITY (5 << (8 - 4))

B #define configMAX_SYSCALL_INTERRUPT_PRIORITY 5

C #define configMAX_SYSCALL_INTERRUPT_PRIORITY (5 >> (8 - 4))

D #define configMAX_SYSCALL_INTERRUPT_PRIORITY (5 << 4)

💡 Hint

Remember Cortex-M uses the top bits of the priority byte for priority levels.

Cortex-M3 uses 4 bits for priority, stored in the high bits of an 8-bit register. Shifting 5 left by (8 - 4) = 4 bits correctly positions the priority.

🚀 Application

expert

How many interrupt priorities can safely call FreeRTOS API if configMAX_SYSCALL_INTERRUPT_PRIORITY is 10?

Assuming a system with 256 interrupt priority levels (0 highest, 255 lowest), and configMAX_SYSCALL_INTERRUPT_PRIORITY is set to 10, how many interrupt priority levels can safely call FreeRTOS API functions?

A 245 priority levels (11 through 255 inclusive)

B 10 priority levels (1 through 10 inclusive)

C 246 priority levels (10 through 255 inclusive)

D 256 priority levels (all priorities)

💡 Hint

Count all priorities numerically greater than or equal to configMAX_SYSCALL_INTERRUPT_PRIORITY.

Interrupt priorities from 10 up to 255 inclusive can safely call FreeRTOS API. That is 246 levels total.