ISR best practices in Arduino - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this ISR example?

Consider the following Arduino code with an ISR that increments a counter. What will be printed to the serial monitor?

Arduino

volatile int counter = 0;

void setup() {
  Serial.begin(9600);
  attachInterrupt(digitalPinToInterrupt(2), incrementCounter, RISING);
}

void loop() {
  Serial.println(counter);
  delay(1000);
}

void incrementCounter() {
  counter++;
}

A The counter value increases rapidly and prints large numbers quickly.

B The counter value remains 0 because ISRs cannot modify variables.

C The counter value increases approximately once per second.

D The program will not compile due to ISR syntax errors.

💡 Hint

Think about how often the interrupt triggers and how the counter variable is updated.

The ISR increments the counter every time the interrupt triggers on pin 2's rising edge. If the signal on pin 2 is fast or noisy, the counter will increase rapidly. The loop prints the current counter value every second, so you will see large numbers increasing quickly.

🧠 Conceptual

intermediate

Why should variables shared between ISR and main code be declared volatile?

In Arduino programming, why is it important to declare variables shared between an ISR and the main program as volatile?

A To automatically synchronize the variable between multiple Arduino boards.

B To allow the variable to be stored in EEPROM memory for persistence after reset.

C To make the variable accessible only inside the ISR and not in the main program.

D To prevent the compiler from optimizing out accesses to the variable, ensuring the main code always reads the latest value updated by the ISR.

💡 Hint

Think about how the compiler might optimize variables that seem unchanged in the main code.

The volatile keyword tells the compiler that the variable can change unexpectedly, such as inside an ISR. Without it, the compiler might cache the variable in a register and not see updates made by the ISR, causing incorrect behavior.

🔧 Debug

advanced

Identify the problem with this ISR code snippet

Examine the following ISR code. What issue might cause unexpected behavior?

Arduino

volatile int count = 0;

void setup() {
  attachInterrupt(digitalPinToInterrupt(3), countUp, FALLING);
}

void loop() {
  // main code
}

void countUp() {
  count += 2;
  delay(10);
}

A The variable <code>count</code> is not declared volatile, so updates may be missed.

B Using <code>delay()</code> inside an ISR causes the program to hang or behave unpredictably.

C The interrupt is attached to the wrong pin number, causing no interrupts to trigger.

D The ISR function must return a value, but <code>countUp()</code> returns void.

💡 Hint

Consider what functions are safe to use inside an ISR.

Using delay() inside an ISR is unsafe because it relies on interrupts and timers that are disabled during ISR execution. This can cause the program to freeze or behave erratically.

📝 Syntax

advanced

Which ISR declaration is correct in Arduino?

Which of the following ISR function declarations is syntactically correct for Arduino?

A void ISR_handler() { /* code */ }

B int ISR_handler() { /* code */ return 0; }

C void ISR_handler(void) { /* code */ }

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

💡 Hint

Think about the standard function declaration syntax in Arduino C++.

In Arduino, ISR functions must be declared as void and take no parameters. The syntax void ISR_handler(void) is correct. The interrupt keyword is not used in Arduino. Returning a value or using other keywords causes errors.

🚀 Application

expert

How to safely update a multi-byte variable in an ISR?

You have a 16-bit volatile variable volatile uint16_t sensorValue; updated inside an ISR and read in the main loop. How should you safely read sensorValue in the main loop to avoid corrupted data?

A Disable interrupts before reading <code>sensorValue</code>, then re-enable them after reading.

B Read <code>sensorValue</code> directly without disabling interrupts because it is volatile.

C Use <code>noInterrupts()</code> inside the ISR before updating <code>sensorValue</code>.

D Declare <code>sensorValue</code> as <code>volatile uint8_t</code> to avoid multi-byte issues.

💡 Hint

Think about atomicity when reading multi-byte variables shared with ISRs.

Multi-byte variables like 16-bit integers can be corrupted if an interrupt occurs during reading. To avoid this, disable interrupts before reading the variable and re-enable them after. Declaring volatile alone does not guarantee atomic access.

Practice

1. What is the main reason to keep Interrupt Service Routines (ISRs) short and simple in Arduino?

easy

A. To use more memory

B. To avoid delaying other important tasks and interrupts

C. To make the code look cleaner

D. To allow ISRs to run slower

Solution

1. Step 1: Understand ISR impact on program flow

   ISRs interrupt the main program to handle urgent events, so they must finish quickly to avoid blocking other tasks.

2. Step 2: Consider consequences of long ISRs

   If ISRs are long, they delay other interrupts and slow down the main program, causing performance issues.

3. Final Answer:

   To avoid delaying other important tasks and interrupts -> Option B

4. Quick Check:

   Keep ISRs short = avoid delays [OK]

Hint: Short ISR means faster response and less delay [OK]

Common Mistakes:

• Thinking ISR length only affects code readability
• Assuming ISRs can run as long as needed
• Ignoring impact on other interrupts

2. Which of the following is the correct way to declare a variable shared between an ISR and the main program?

easy

A. volatile int counter = 0;

B. int counter = 0;

C. static int counter = 0;

D. const int counter = 0;

Solution

1. Step 1: Identify variable usage in ISR and main code

   Variables shared between ISR and main code must be declared volatile to prevent compiler optimizations that cause wrong values.

2. Step 2: Check each declaration

   Only 'volatile int counter = 0;' tells the compiler the variable can change anytime, ensuring correct behavior.

3. Final Answer:

   volatile int counter = 0; -> Option A

4. Quick Check:

   Shared variable = volatile [OK]

Hint: Use volatile for variables changed in ISR [OK]

Common Mistakes:

• Forgetting volatile keyword
• Using const for variables that change
• Using static without volatile

3. What will be the output of this Arduino code snippet?

volatile int count = 0;
void setup() {
  Serial.begin(9600);
  attachInterrupt(digitalPinToInterrupt(2), increment, RISING);
}
void loop() {
  Serial.println(count);
  count = 0;
  delay(1000);
}
void increment() {
  count++;
}

Assuming pin 2 receives 3 rising signals per second, what will Serial print each second?

medium

A. 1

B. 0

C. 3

D. Random values

Solution

1. Step 1: Understand ISR increments

   Each rising signal on pin 2 triggers the ISR 'increment' which increases 'count' by 1.

2. Step 2: Calculate increments per second

   3 rising signals per second means 'count' increases by 3 every second.

3. Final Answer:

   3 -> Option C

4. Quick Check:

   3 signals/sec = count increments 3 times [OK]

Hint: ISR increments count per event; count matches event rate [OK]

Common Mistakes:

• Ignoring volatile keyword effect
• Assuming count resets automatically
• Thinking ISR runs slower than events

4. Identify the error in this ISR code snippet:

volatile int flag = 0;
void setup() {
  attachInterrupt(digitalPinToInterrupt(3), toggleFlag, FALLING);
}
void loop() {
  if(flag) {
    // do something
    flag = 0;
  }
}
void toggleFlag() {
  flag = !flag;
}

medium

A. Not declaring 'flag' as volatile

B. Missing Serial.begin() in setup

C. Incorrect interrupt mode FALLING

D. Using non-atomic operation on 'flag' inside ISR

Solution

1. Step 1: Analyze ISR operation on 'flag'

   The ISR toggles 'flag' using '!flag', which is a read-modify-write operation and not atomic.

2. Step 2: Understand atomicity importance

   Non-atomic operations on shared variables can cause race conditions and unpredictable behavior.

3. Final Answer:

   Using non-atomic operation on 'flag' inside ISR -> Option D

4. Quick Check:

   ISR must avoid non-atomic variable changes [OK]

Hint: Avoid read-modify-write on shared vars in ISR [OK]

Common Mistakes:

• Ignoring atomicity of operations
• Thinking volatile alone fixes all issues
• Confusing interrupt mode with logic error

5. You want to count button presses using an ISR on pin 2. Which approach best follows ISR best practices in Arduino?

hard

A. Increment a volatile counter in ISR; read and reset it safely in loop

B. Print a message directly inside the ISR using Serial.println()

C. Use delay() inside ISR to debounce the button

D. Declare the counter as static inside ISR without volatile

Solution

1. Step 1: Review ISR best practices for counting events

   ISRs should be short and only update volatile variables; printing or delays inside ISR are bad.

2. Step 2: Evaluate each option

   Increment a volatile counter in ISR; read and reset it safely in loop uses a volatile counter incremented in ISR and safely handled in loop, which is correct.

3. Final Answer:

   Increment a volatile counter in ISR; read and reset it safely in loop -> Option A

4. Quick Check:

   Keep ISR short; update volatile vars only [OK]

Hint: Update volatile counter in ISR; handle logic outside [OK]

Common Mistakes:

• Using Serial.print inside ISR causing delays
• Using delay() inside ISR causing blocking
• Not declaring shared variables volatile