ISR best practices (keep it short) in Embedded C - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why keep ISRs short?

Why is it important to keep Interrupt Service Routines (ISRs) short in embedded C programming?

A To enable ISRs to run in parallel with main code without synchronization

B To minimize interrupt latency and avoid blocking other interrupts

C To increase the stack size used by the ISR

D To allow ISRs to perform complex calculations without delay

💡 Hint

Think about how long the CPU is busy inside an ISR and how it affects other tasks.

Keeping ISRs short reduces the time the CPU spends handling interrupts, which lowers latency and prevents blocking other interrupts.

❓ Predict Output

intermediate

Output of ISR flag clearing code

What is the output of this embedded C code snippet after the ISR runs?

Embedded C

volatile int flag = 0;

void ISR_Handler() {
    flag = 1;
    // Clear interrupt flag here
}

int main() {
    flag = 0;
    ISR_Handler();
    if(flag == 1) {
        printf("Interrupt handled\n");
    } else {
        printf("No interrupt\n");
    }
    return 0;
}

A Runtime error due to flag not being volatile

B No interrupt

C Compilation error due to missing interrupt attribute

D Interrupt handled

💡 Hint

Consider what the ISR does to the flag variable and how main checks it.

The ISR sets the flag to 1, so main prints "Interrupt handled".

🔧 Debug

advanced

Identify the ISR bug causing missed interrupts

Which option shows the bug that can cause missed interrupts in this ISR code?

Embedded C

volatile int count = 0;

void ISR_Handler() {
    count++;
    // Missing interrupt flag clear
}

A ISR does not clear the interrupt flag, causing missed interrupts

B ISR uses a global variable, which is not allowed

C ISR increments count without disabling interrupts

D ISR uses a volatile variable, which is incorrect

💡 Hint

Think about what happens if the interrupt flag is not cleared inside the ISR.

If the interrupt flag is not cleared, the interrupt may not trigger again, causing missed interrupts.

📝 Syntax

advanced

Correct ISR declaration syntax

Which option shows the correct way to declare an ISR function in embedded C?

A void ISR_Handler() interrupt { /* code */ }

B interrupt void ISR_Handler() { /* code */ }

C void __interrupt() ISR_Handler(void) { /* code */ }

D void ISR_Handler(void) __interrupt { /* code */ }

💡 Hint

Check the placement of the __interrupt keyword and function signature.

The correct syntax places __interrupt before the function name with void parameter list.

🚀 Application

expert

Determine the number of ISR executions

Given this embedded C code, how many times will the ISR increment the counter if the interrupt triggers 5 times rapidly?

Embedded C

volatile int counter = 0;

void ISR_Handler() {
    counter++;
    // Interrupt flag cleared here
}

int main() {
    // Simulate 5 rapid interrupts
    for(int i=0; i<5; i++) {
        ISR_Handler();
    }
    printf("Counter: %d\n", counter);
    return 0;
}

A 5

B 1

C 0

D Undefined behavior

💡 Hint

Consider how many times the ISR is called and how it increments the counter.

The ISR is called 5 times in the loop, so the counter increments 5 times.