Nested interrupts in Embedded C - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of nested interrupt simulation

Consider the following embedded C code simulating nested interrupts. What will be the output printed to the console?

Embedded C

#include <stdio.h>

volatile int flag = 0;

void ISR1() {
    printf("ISR1 start\n");
    if (flag == 0) {
        flag = 1;
        ISR2();
    }
    printf("ISR1 end\n");
}

void ISR2() {
    printf("ISR2 start\n");
    printf("ISR2 end\n");
}

int main() {
    printf("Main start\n");
    ISR1();
    printf("Main end\n");
    return 0;
}

A

Main start
ISR2 start
ISR2 end
ISR1 start
ISR1 end
Main end

B

Main start
ISR1 start
ISR1 end
ISR2 start
ISR2 end
Main end

C

Main start
ISR1 start
ISR2 start
ISR2 end
ISR1 end
Main end

D

Main start
ISR1 start
ISR2 start
ISR1 end
ISR2 end
Main end

💡 Hint

Think about how ISR1 calls ISR2 before finishing.

ISR1 starts and prints 'ISR1 start'. Since flag is 0, it sets flag to 1 and calls ISR2. ISR2 prints its start and end messages. Then ISR1 resumes and prints 'ISR1 end'. Finally, main prints 'Main end'.

🧠 Conceptual

intermediate

Understanding interrupt priority in nested interrupts

In an embedded system with nested interrupts enabled, which statement about interrupt priority is true?

A Interrupts always execute in the order they are triggered regardless of priority.

B A higher priority interrupt can preempt a lower priority interrupt.

C A lower priority interrupt can preempt a higher priority interrupt.

D Nested interrupts are disabled automatically when an interrupt occurs.

💡 Hint

Think about which interrupt can interrupt another.

Higher priority interrupts can preempt lower priority ones, allowing nested interrupts. Lower priority interrupts cannot preempt higher priority ones.

🔧 Debug

advanced

Identify the error causing nested interrupt failure

This code is intended to enable nested interrupts, but nested interrupts never occur. What is the main reason?

Embedded C

#include <stdio.h>
#include <signal.h>

void ISR1(int signum) {
    printf("ISR1 start\n");
    // Nested interrupts should be enabled here
    printf("ISR1 end\n");
}

void ISR2(int signum) {
    printf("ISR2 executed\n");
}

int main() {
    signal(SIGINT, ISR1);
    signal(SIGTERM, ISR2);
    while(1) {}
    return 0;
}

A Nested interrupts are not enabled because the signal handlers do not re-enable signals inside ISR1.

B Nested interrupts are disabled because the main loop is empty and blocks signals.

C Nested interrupts fail because ISR2 is not called inside ISR1.

D Nested interrupts are disabled because signal handlers are not registered correctly.

💡 Hint

Signals are blocked during their handler unless explicitly re-enabled.

In many systems, signals are blocked during their handler execution. To allow nested interrupts, the handler must re-enable signals or use special flags. Here, ISR1 does not re-enable signals, so nested interrupts do not occur.

📝 Syntax

advanced

Identify the syntax error preventing nested interrupt simulation

Which option contains the correct syntax to enable nested interrupts in this embedded C snippet?

Embedded C

void ISR1() {
    // Enable nested interrupts here
    __enable_irq();
    // ISR code
}

A

void ISR1() {
    __enable_irq();
}

B

void ISR1() {
    enable_irq();
    // ISR code
}

C

void ISR1() {
    __enable_irq;
    // ISR code
}

D

void ISR1() {
    __enable_irq();
    // ISR code
}

💡 Hint

Check function call syntax carefully.

Option D correctly calls the function __enable_irq() with parentheses. Option D uses a wrong function name. Option D misses parentheses, causing a syntax error. Option D is correct syntax but incomplete as it lacks ISR code, so A is the best complete option.

🚀 Application

expert

Calculate the number of nested interrupt levels possible

An embedded system supports 4 levels of interrupt priority (0 highest, 3 lowest). Nested interrupts are enabled so that higher priority interrupts can preempt lower ones. If an interrupt of priority 3 is running, how many more nested interrupts can occur before the CPU stops nesting?

A 3

B 4

C 2

D 1

💡 Hint

Count how many higher priority levels exist above priority 3.

Priority levels are 0 (highest), 1, 2, 3 (lowest). If priority 3 interrupt is running, interrupts with priority 0, 1, and 2 can preempt it, so 3 more nested interrupts can occur.