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.