Enabling and disabling interrupts in Embedded C - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this interrupt enable code?

Consider this embedded C code snippet that enables global interrupts. What will be the value of the status variable after execution?

Embedded C

volatile unsigned char status = 0;
void enable_interrupts() {
    __asm__("sei"); // Set Interrupt Enable
    status = 1;
}

int main() {
    enable_interrupts();
    return status;
}

A Undefined behavior

B 0

C 1

D Compilation error

💡 Hint

The sei assembly instruction sets the global interrupt enable flag. The status variable is set right after.

The sei instruction enables interrupts, but it does not affect the status variable. Since status = 1; is executed immediately after, the value of status is 1.

❓ Predict Output

intermediate

What error occurs when disabling interrupts incorrectly?

What error will this code produce when compiled?

Embedded C

void disable_interrupts() {
    __asm__("cli"); // Missing semicolon fixed
}

A SyntaxError: missing semicolon

B No error, runs fine

C Runtime error: interrupt disable failed

D Compilation error: expected ';' before '}' token

💡 Hint

Check the syntax carefully after the inline assembly statement.

The missing semicolon after the inline assembly causes a compilation error expecting a semicolon before the closing brace.

🧠 Conceptual

advanced

Which statement about interrupt enabling is true?

Which of the following statements about enabling interrupts in embedded C is correct?

A The <code>sei</code> instruction enables global interrupts immediately.

B Interrupts can only be enabled in the main function.

C Enabling interrupts globally disables all interrupts.

D Disabling interrupts is done by the <code>sei</code> instruction.

💡 Hint

Recall what sei and cli instructions do.

The sei instruction sets the global interrupt enable flag, enabling interrupts immediately. cli disables interrupts. Interrupts can be enabled anywhere in code, not just main.

❓ Predict Output

advanced

What is the value of flag after this interrupt disable sequence?

Given this code snippet, what is the value of flag after disable_interrupts() is called?

Embedded C

volatile int flag = 0;
void disable_interrupts() {
    __asm__("cli");
    flag = 42;
}

int main() {
    disable_interrupts();
    return flag;
}

A 42

B Undefined behavior

C Compilation error

D 0

💡 Hint

The cli instruction disables interrupts, but does not affect variable assignments.

The cli disables interrupts, but the assignment flag = 42; executes normally. So flag becomes 42.

🚀 Application

expert

Which option correctly toggles interrupts safely?

You want to temporarily disable interrupts, perform a critical task, then restore the previous interrupt state. Which code snippet correctly does this?

A

cli();
// critical code
sei();

B

unsigned char sreg = SREG;
cli();
// critical code
SREG = sreg;

C

sei();
// critical code
cli();

D

unsigned char sreg = SREG;
sei();
// critical code
SREG = sreg;

💡 Hint

Think about saving and restoring the interrupt state to avoid unintended side effects.

Option B saves the status register (SREG) which holds the interrupt flag, disables interrupts with cli(), runs critical code, then restores the original state. This preserves the previous interrupt state safely.

Option B always enables interrupts at the end, which may not restore the original state. Option B enables interrupts before disabling them, which is incorrect. Option B enables interrupts before critical code, which defeats the purpose.

Practice

1. What is the main purpose of using __disable_irq() in embedded C programming?

easy

A. To permanently disable the CPU

B. To temporarily stop all interrupts from occurring

C. To enable all interrupts

D. To reset the microcontroller

Solution

1. Step 1: Understand the function of __disable_irq()

   This function is used to stop interrupts temporarily so that critical code can run without interruption.

2. Step 2: Differentiate from other options

   It does not permanently disable the CPU, enable interrupts, or reset the microcontroller.

3. Final Answer:

   To temporarily stop all interrupts from occurring -> Option B

4. Quick Check:

   __disable_irq() stops interrupts temporarily [OK]

Hint: Disable interrupts to protect critical code sections [OK]

Common Mistakes:

• Thinking it permanently disables the CPU
• Confusing disable with enable interrupts
• Assuming it resets the device

2. Which of the following is the correct syntax to enable interrupts in embedded C?

easy

A. __enableInterrupts();

B. enable_irq();

C. __enable_irq();

D. enableInterrupt();

Solution

1. Step 1: Recall the standard function name

   The correct function to enable interrupts is __enable_irq() with double underscores and parentheses.

2. Step 2: Check other options for syntax errors

   Other options miss underscores or have incorrect function names.

3. Final Answer:

   __enable_irq(); -> Option C

4. Quick Check:

   Correct function syntax = __enable_irq(); [OK]

Hint: Look for double underscores and exact function name [OK]

Common Mistakes:

• Omitting underscores
• Using incorrect function names
• Missing parentheses

3. Consider the following code snippet:

__disable_irq();
// Critical section code
__enable_irq();
int x = 5;

What is the effect of this code on interrupts?

medium

A. Interrupts are disabled during the critical section and enabled afterward

B. Interrupts remain disabled after the code runs

C. Interrupts are enabled before and after the critical section

D. Interrupts are never disabled

Solution

1. Step 1: Analyze the order of function calls

   The code disables interrupts first, runs critical code, then enables interrupts again.

2. Step 2: Understand the effect on interrupts

   Interrupts are stopped during the critical section and allowed again afterward.

3. Final Answer:

   Interrupts are disabled during the critical section and enabled afterward -> Option A

4. Quick Check:

   Disable then enable interrupts around critical code [OK]

Hint: Disable before critical code, enable after [OK]

Common Mistakes:

• Assuming interrupts stay disabled
• Thinking interrupts are enabled all the time
• Ignoring the order of calls

4. Identify the error in this code snippet:

void process() {
  __enable_irq();
  // critical code
  __disable_irq();
}

medium

A. Interrupts are enabled before critical code and disabled after, which is incorrect

B. The function names are misspelled

C. Missing semicolons after function calls

D. No error, code is correct

Solution

1. Step 1: Check the order of enabling/disabling interrupts

   Interrupts should be disabled before critical code and enabled after, but here it is reversed.

2. Step 2: Confirm function names and syntax

   Function names and semicolons are correct, so no syntax errors.

3. Final Answer:

   Interrupts are enabled before critical code and disabled after, which is incorrect -> Option A

4. Quick Check:

   Disable before critical code, enable after [OK]

Hint: Disable interrupts before critical code, not after [OK]

Common Mistakes:

• Reversing enable and disable calls
• Assuming order does not matter
• Ignoring critical section protection

5. You want to protect a shared variable counter from being changed by interrupts during update. Which code snippet correctly uses interrupt control to do this safely?

hard

A. __disable_irq();
__enable_irq();
counter++;

B. __enable_irq();
counter++;
__disable_irq();

C. counter++;
__disable_irq();
__enable_irq();

D. __disable_irq();
counter++;
__enable_irq();

Solution

1. Step 1: Understand the need to protect the update

   The shared variable update must happen without interruption to avoid inconsistent data.

2. Step 2: Check which snippet disables interrupts before update and enables after

   __disable_irq();
   counter++;
   __enable_irq();

   disables interrupts before incrementing and enables them after, protecting the update.

3. Final Answer:

   __disable_irq(); counter++; __enable_irq(); -> Option D

4. Quick Check:

   Disable interrupts before critical update, enable after [OK]

Hint: Disable interrupts before update, enable after [OK]

Common Mistakes:

• Enabling interrupts before update
• Updating variable outside disabled section
• Disabling and enabling interrupts without protecting update