Enabling and disabling interrupts in Embedded C - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the purpose of enabling interrupts in embedded systems?

Enabling interrupts allows the microcontroller to respond immediately to important events by temporarily pausing the main program and running a special function called an interrupt service routine (ISR).

beginner

How do you disable interrupts in embedded C?

You disable interrupts by clearing the global interrupt enable bit, often using a function or macro like __disable_irq() or by clearing the interrupt enable flag in a control register.

intermediate

Why should interrupts sometimes be disabled temporarily?

Interrupts are disabled temporarily to protect critical sections of code from being interrupted, which prevents data corruption or inconsistent states.

intermediate

What is the difference between enabling individual interrupts and enabling global interrupts?

Enabling individual interrupts allows specific interrupt sources to trigger, while enabling global interrupts allows the CPU to respond to any enabled interrupt source.

beginner

Show a simple example in embedded C to disable and then enable interrupts.

__disable_irq(); // Disable all interrupts // Critical code here __enable_irq(); // Enable all interrupts

What happens when interrupts are disabled in an embedded system?

A The CPU ignores all interrupt requests.

B The CPU runs interrupt service routines immediately.

C The CPU resets automatically.

D The CPU speeds up execution.

Disabling interrupts means the CPU will ignore interrupt requests until they are enabled again.

Which function is commonly used in embedded C to enable global interrupts?

A interrupt_enable()

B __enable_irq()

C start_interrupts()

D enable_global()

__enable_irq() is a common intrinsic function to enable global interrupts.

Why might you disable interrupts before accessing shared data?

A To reset the microcontroller.

B To speed up the program.

C To save power.

D To prevent other code from changing the data during access.

Disabling interrupts prevents interrupt routines from modifying shared data while it is being accessed.

What is an interrupt service routine (ISR)?

A A function that resets the CPU.

B A function that disables interrupts.

C A special function that runs when an interrupt occurs.

D A function that runs only at startup.

An ISR is a special function that executes in response to an interrupt.

Which of these is NOT a reason to disable interrupts?

A Allowing the CPU to sleep.

B Preventing data corruption.

C Protecting critical code sections.

D Avoiding inconsistent program states.

Disabling interrupts is not used to put the CPU to sleep; sleep modes are handled differently.

Explain how and why interrupts are enabled and disabled in embedded C programming.

Think about how the CPU handles urgent tasks and how to safely manage shared data.

Describe a scenario where disabling interrupts is necessary and how you would implement it in code.

Consider when data might be changed by both main code and interrupts.

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