Why interrupts are needed in Embedded C - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why use interrupts instead of polling?

In embedded systems, why are interrupts preferred over polling for handling external events?

A Interrupts allow the CPU to perform other tasks and respond immediately when an event occurs.

B Interrupts slow down the CPU because they require constant checking of event flags.

C Polling uses less power than interrupts because it checks events continuously.

D Polling is better because it guarantees no events are missed.

💡 Hint

Think about how the CPU can do other work while waiting for an event.

Interrupts let the CPU work on other tasks and only stop to handle events when they happen, making the system more efficient.

❓ Predict Output

intermediate

Output of interrupt-driven vs polling code

What will be the output of the following embedded C code snippets?

Assume an external button press triggers an interrupt.

Embedded C

/* Interrupt-driven code snippet */
volatile int button_pressed = 0;
void ISR_button() {
    button_pressed = 1;
}
int main() {
    while(1) {
        if(button_pressed) {
            printf("Button pressed!\n");
            button_pressed = 0;
        }
    }
}

/* Polling code snippet */
int main() {
    while(1) {
        if(read_button_pin() == PRESSED) {
            printf("Button pressed!\n");
        }
    }
}

A Both print 'Button pressed!' repeatedly while button is pressed.

B Interrupt-driven never prints; polling prints once per press.

C Both print 'Button pressed!' only once per press.

D Interrupt-driven prints 'Button pressed!' once per press; polling prints repeatedly while pressed.

💡 Hint

Consider how often the print statement runs in each method.

Interrupt-driven code sets a flag once per press, printing once. Polling checks continuously and prints repeatedly while the button is held.

🔧 Debug

advanced

Identify the problem with this interrupt handler

What issue does this interrupt handler code have?

Embedded C

volatile int count = 0;
void ISR_timer() {
    count++;
    delay(1000); // Delay inside interrupt
}
int main() {
    setup_timer_interrupt(ISR_timer);
    while(1) {
        // main loop
    }
}

A Interrupt handler is missing a return statement.

B Incrementing count inside interrupt causes data corruption.

C Delay inside interrupt blocks other interrupts and main code, causing system lag.

D Timer interrupt is not enabled properly.

💡 Hint

Think about what happens if the interrupt takes too long.

Delays inside interrupts block the CPU from handling other tasks or interrupts, causing slow or unresponsive behavior.

📝 Syntax

advanced

Correct syntax for declaring an interrupt service routine (ISR)

Which option shows the correct way to declare an ISR for a button press in embedded C?

A void ISR_button(void) __interrupt { /* code */ }

B void __interrupt() ISR_button(void) { /* code */ }

C void ISR_button() interrupt { /* code */ }

D interrupt void ISR_button() { /* code */ }

💡 Hint

Look for the correct placement of the interrupt keyword and function signature.

In many embedded C compilers, the ISR is declared with void __interrupt() before the function name.

🚀 Application

expert

Design a system using interrupts to handle multiple sensors

You have three sensors connected to an embedded system. Each sensor triggers an interrupt when it detects an event. How should you design the interrupt handling to efficiently process events from all sensors?

A Use separate ISRs for each sensor, set flags in each ISR, and process all flags in the main loop.

B Use one ISR for all sensors and process all sensor data inside the ISR directly.

C Disable interrupts and poll sensors continuously in the main loop instead of using ISRs.

D Use one ISR that ignores sensor events and processes data only in the main loop.

💡 Hint

Consider how to keep ISRs short and avoid blocking.

Separate ISRs set flags quickly, letting the main loop handle processing without blocking interrupts, improving responsiveness.

Practice

1. Why are interrupts needed in embedded C programming?

easy

A. To allow the program to respond quickly to important events

B. To make the program run slower

C. To avoid using functions

D. To increase the size of the program

Solution

1. Step 1: Understand the role of interrupts

   Interrupts let the program stop what it is doing and handle urgent tasks immediately.

2. Step 2: Compare options

   Only To allow the program to respond quickly to important events correctly states that interrupts help respond quickly to important events.

3. Final Answer:

   To allow the program to respond quickly to important events -> Option A

4. Quick Check:

   Interrupts = Quick response [OK]

Hint: Interrupts = fast response to events [OK]

Common Mistakes:

• Thinking interrupts slow down the program
• Confusing interrupts with normal function calls
• Believing interrupts increase program size unnecessarily

2. Which of the following is the correct syntax to declare an Interrupt Service Routine (ISR) in embedded C?

easy

A. void ISR_name() interrupt;

B. void ISR_name(void) __interrupt;

C. void ISR_name(void) __interrupt(0);

D. void ISR_name() __interrupt(5);

Solution

1. Step 1: Recall ISR declaration syntax

   In embedded C, ISRs are declared with the __interrupt keyword and the interrupt vector number in parentheses.

2. Step 2: Identify correct option

   void ISR_name(void) __interrupt(0); uses __interrupt(0), which is the correct form for declaring ISR with vector 0.

3. Final Answer:

   void ISR_name(void) __interrupt(0); -> Option C

4. Quick Check:

   ISR syntax = __interrupt(vector) [OK]

Hint: ISR needs __interrupt with vector number [OK]

Common Mistakes:

• Omitting the vector number in __interrupt
• Using interrupt without __
• Missing void parameter list

3. Consider this embedded C code snippet:

volatile int flag = 0;
void ISR_timer(void) __interrupt(1) {
    flag = 1;
}

int main() {
    while(flag == 0) {
        // wait for interrupt
    }
    return 0;
}

What is the role of the interrupt here?

medium

A. To set flag to 1 when timer interrupt occurs

B. To reset the flag to 0 continuously

C. To stop the program immediately

D. To cause a syntax error

Solution

1. Step 1: Analyze ISR function

   The ISR sets the variable flag to 1 when the interrupt occurs.

2. Step 2: Understand main loop behavior

   Main waits in a loop until flag becomes 1, meaning it waits for the interrupt to happen.

3. Final Answer:

   To set flag to 1 when timer interrupt occurs -> Option A

4. Quick Check:

   ISR sets flag = 1 [OK]

Hint: ISR changes flag to signal event [OK]

Common Mistakes:

• Thinking flag resets to 0 automatically
• Assuming interrupt stops program
• Confusing syntax error with correct code

4. Find the error in this ISR declaration:

void ISR_button() interrupt 2 {
    // handle button press
}

medium

A. ISR cannot have parameters

B. ISR function must return int

C. interrupt number 2 is invalid

D. Missing __ before interrupt keyword

Solution

1. Step 1: Check ISR declaration syntax

   In embedded C, the interrupt keyword must be preceded by double underscores: __interrupt.

2. Step 2: Verify other parts

   ISR functions return void and have no parameters, which is correct here. Interrupt number 2 is valid.

3. Final Answer:

   Missing __ before interrupt keyword -> Option D

4. Quick Check:

   ISR syntax needs __interrupt [OK]

Hint: ISR must use __interrupt keyword [OK]

Common Mistakes:

• Using single underscore or no underscore
• Changing return type from void
• Adding parameters to ISR

5. You want your embedded program to monitor a sensor and also perform other tasks without delay. How does using interrupts help achieve this?

hard

A. Interrupts require the program to wait for sensor manually

B. Interrupts pause other tasks and immediately run sensor code when triggered

C. Interrupts disable sensor monitoring to save power

D. Interrupts make the program run tasks one after another slowly

Solution

1. Step 1: Understand multitasking with interrupts

   Interrupts allow the program to stop current tasks and quickly handle sensor events.

2. Step 2: Compare options

   Interrupts pause other tasks and immediately run sensor code when triggered correctly describes how interrupts improve responsiveness by pausing other tasks to run sensor code immediately.

3. Final Answer:

   Interrupts pause other tasks and immediately run sensor code when triggered -> Option B

4. Quick Check:

   Interrupts = immediate sensor handling [OK]

Hint: Interrupts handle urgent tasks immediately [OK]

Common Mistakes:

• Thinking interrupts slow down program
• Believing interrupts disable sensors
• Assuming manual waiting is needed