ISR best practices in Arduino - Mini Project: Build & Apply

ISR Best Practices in Arduino

📖 Scenario: You are building a simple Arduino project that counts how many times a button is pressed using an interrupt. Interrupt Service Routines (ISRs) help your Arduino respond quickly to events like button presses without missing any.In this project, you will learn how to set up an ISR correctly and follow best practices to keep your program safe and responsive.

🎯 Goal: Create an Arduino sketch that uses an ISR to count button presses safely and display the count on the serial monitor.

📋 What You'll Learn

Use a hardware interrupt on pin 2 to detect button presses

Create a volatile variable to count button presses

Write a simple ISR that increments the count

Avoid using delay or Serial inside the ISR

Print the button press count in the main loop

💡 Why This Matters

🌍 Real World

Interrupts are used in many real-world devices to respond quickly to events like button presses, sensor signals, or communication data without missing any important changes.

💼 Career

Understanding ISR best practices is important for embedded systems developers, IoT engineers, and anyone working with microcontrollers to build responsive and reliable hardware projects.

1

Set up the button input and counter variable

Create a volatile int variable called buttonPressCount and set it to 0. Also, set pin 2 as an input with the internal pull-up resistor enabled inside the setup() function.

Arduino

volatile int buttonPressCount = 0;

void setup() {
  pinMode(2, INPUT_PULLUP);
  // Your code here
}

void loop() {
  // Your code here
}

Hint

Use volatile int buttonPressCount = 0; outside any function. Inside setup(), use pinMode(2, INPUT_PULLUP); to prepare the button pin.

2

Attach the interrupt and write the ISR

Attach an interrupt to pin 2 using attachInterrupt() inside setup(). Use the function buttonPressed as the ISR and trigger on the falling edge. Then, write the ISR function buttonPressed() that increments buttonPressCount by 1. Remember to keep the ISR short and simple.

Arduino

volatile int buttonPressCount = 0;

void setup() {
  pinMode(2, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(2), buttonPressed, FALLING);
  // Your code here
}

void loop() {
  // Your code here
}

void buttonPressed() {
  buttonPressCount++;
  // Your code here
}

Hint

Use attachInterrupt(digitalPinToInterrupt(2), buttonPressed, FALLING); inside setup(). The ISR buttonPressed() should only increment buttonPressCount.

3

Read and print the button press count safely

In the loop() function, create a local int variable called countCopy. Disable interrupts using noInterrupts(), copy buttonPressCount to countCopy, then re-enable interrupts with interrupts(). Finally, print countCopy to the serial monitor with the message "Button pressed: ". Initialize serial communication at 9600 baud in setup().

Arduino

volatile int buttonPressCount = 0;

void setup() {
  pinMode(2, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(2), buttonPressed, FALLING);
  Serial.begin(9600);
  // Your code here
}

void loop() {
  int countCopy;
  noInterrupts();
  countCopy = buttonPressCount;
  interrupts();
  Serial.print("Button pressed: ");
  Serial.println(countCopy);
  delay(500);
  // Your code here
}

void buttonPressed() {
  buttonPressCount++;
}

Hint

Use noInterrupts() and interrupts() to safely copy the volatile variable. Use Serial.print() and Serial.println() to show the count.

4

Test and observe the button press count

Upload the complete sketch to your Arduino. Press the button connected to pin 2 multiple times. Observe the serial monitor output showing the updated button press count every half second.

Arduino

volatile int buttonPressCount = 0;

void setup() {
  pinMode(2, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(2), buttonPressed, FALLING);
  Serial.begin(9600);
}

void loop() {
  int countCopy;
  noInterrupts();
  countCopy = buttonPressCount;
  interrupts();
  Serial.print("Button pressed: ");
  Serial.println(countCopy);
  delay(500);
  // Your code here
}

void buttonPressed() {
  buttonPressCount++;
}

Hint

Open the serial monitor at 9600 baud. Press the button and watch the count increase.

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