Interrupt-driven button handling in Arduino - Mini Project: Build & Apply

Interrupt-driven button handling

📖 Scenario: You want to make a simple Arduino project where pressing a button changes the state of an LED immediately, without waiting for the main program loop. This is useful when you want your Arduino to react quickly to button presses.

🎯 Goal: Build an Arduino program that uses an interrupt to detect when a button is pressed and toggles an LED on or off right away.

📋 What You'll Learn

Create a variable to store the LED pin number

Create a variable to store the button pin number

Set up the LED pin as output and the button pin as input with pull-up resistor

Create a volatile variable to hold the LED state

Attach an interrupt to the button pin to detect button presses

Write an interrupt service routine (ISR) to toggle the LED state

In the main loop, set the LED to the current state

Print the LED state to the Serial Monitor when it changes

💡 Why This Matters

🌍 Real World

Interrupt-driven button handling is used in devices where quick response to user input is important, like remote controls, game controllers, or safety switches.

💼 Career

Understanding interrupts and hardware input handling is essential for embedded systems developers, IoT engineers, and anyone working with microcontrollers.

1

Set up LED and button pins

Create two integer variables called ledPin and buttonPin. Set ledPin to 13 and buttonPin to 2. In the setup() function, set ledPin as an output and buttonPin as an input with the internal pull-up resistor enabled.

Arduino

int ledPin = 13;
int buttonPin = 2;

void setup() {
  pinMode(ledPin, OUTPUT);
  pinMode(buttonPin, INPUT_PULLUP);
  // Your code here
}

void loop() {
  // Your code here
}

Hint

Use pinMode to set the pin modes inside setup().

2

Create LED state variable and attach interrupt

Create a volatile bool variable called ledState and initialize it to false. In the setup() function, attach an interrupt to buttonPin using attachInterrupt(digitalPinToInterrupt(buttonPin), toggleLED, FALLING). Define an empty function called toggleLED() that will be the interrupt service routine.

Arduino

int ledPin = 13;
int buttonPin = 2;
volatile bool ledState = false;

void setup() {
  pinMode(ledPin, OUTPUT);
  pinMode(buttonPin, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(buttonPin), toggleLED, FALLING);
  // Your code here
}

void loop() {
  // Your code here
}

void toggleLED() {
  // Your code here
}

Hint

Use attachInterrupt in setup() and define toggleLED() as the ISR.

3

Toggle LED state inside the interrupt

Inside the toggleLED() function, toggle the value of ledState by setting it to its opposite using ledState = !ledState;. In the loop() function, set the LED output to ledState using digitalWrite(ledPin, ledState ? HIGH : LOW);.

Arduino

int ledPin = 13;
int buttonPin = 2;
volatile bool ledState = false;

void setup() {
  pinMode(ledPin, OUTPUT);
  pinMode(buttonPin, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(buttonPin), toggleLED, FALLING);
}

void loop() {
  digitalWrite(ledPin, ledState ? HIGH : LOW);
  // Your code here
}

void toggleLED() {
  ledState = !ledState;
  // Your code here
}

Hint

Toggle ledState inside toggleLED() and update the LED in loop().

4

Print LED state changes to Serial Monitor

In the setup() function, start the serial communication with Serial.begin(9600);. Create a non-volatile boolean variable called lastLedState initialized to false. In the loop() function, check if ledState is different from lastLedState. If yes, print "LED is ON" or "LED is OFF" accordingly using Serial.println(), then update lastLedState to ledState. Keep the LED output code as before.

Arduino

int ledPin = 13;
int buttonPin = 2;
volatile bool ledState = false;
bool lastLedState = false;

void setup() {
  pinMode(ledPin, OUTPUT);
  pinMode(buttonPin, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(buttonPin), toggleLED, FALLING);
  Serial.begin(9600);
  // Your code here
}

void loop() {
  digitalWrite(ledPin, ledState ? HIGH : LOW);
  if (ledState != lastLedState) {
    if (ledState) {
      Serial.println("LED is ON");
    } else {
      Serial.println("LED is OFF");
    }
    lastLedState = ledState;
  }
  // Your code here
}

void toggleLED() {
  ledState = !ledState;
}

Hint

Use Serial.begin(9600); in setup() and print messages in loop() when the LED state changes.

Practice

1. What is the main advantage of using interrupts for button handling on an Arduino?

easy

A. The Arduino can react immediately when the button is pressed without waiting.

B. It makes the button press slower but more reliable.

C. It allows the button to be pressed multiple times at once.

D. It disables other parts of the program while the button is pressed.

Solution

1. Step 1: Understand what interrupts do

   Interrupts pause the main program to run a special function immediately when an event happens, like a button press.

2. Step 2: Compare interrupt behavior to normal checking

   Without interrupts, the program must keep checking the button, which can delay response. Interrupts react instantly.

3. Final Answer:

   The Arduino can react immediately when the button is pressed without waiting. -> Option A

4. Quick Check:

   Interrupts = Immediate reaction [OK]

Hint: Interrupts react instantly, no waiting needed [OK]

Common Mistakes:

• Thinking interrupts slow down button response
• Believing interrupts disable other code permanently
• Confusing interrupts with polling multiple presses

2. Which of the following is the correct syntax to attach an interrupt to pin 2 that calls the function buttonPressed on a FALLING edge?

easy

A. attachInterrupt(digitalPinToInterrupt(2), buttonPressed, FALLING);

B. attachInterrupt(2, buttonPressed, RISING);

C. attachInterrupt(buttonPressed, 2, FALLING);

D. attachInterrupt(2, FALLING, buttonPressed);

Solution

1. Step 1: Recall attachInterrupt syntax

   The correct syntax is attachInterrupt(digitalPinToInterrupt(pin), ISR_function, mode).

2. Step 2: Match parameters to the question

   Pin is 2, function is buttonPressed, mode is FALLING edge.

3. Final Answer:

   attachInterrupt(digitalPinToInterrupt(2), buttonPressed, FALLING); -> Option A

4. Quick Check:

   attachInterrupt(pin, function, mode) = attachInterrupt(digitalPinToInterrupt(2), buttonPressed, FALLING); [OK]

Hint: Use digitalPinToInterrupt(pin) for correct pin number [OK]

Common Mistakes:

• Swapping function and pin arguments
• Using pin number directly without digitalPinToInterrupt
• Mixing up trigger modes like RISING and FALLING

3. What will be the output on the serial monitor after pressing the button once in this code?

volatile bool pressed = false;

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

void loop() {
  if (pressed) {
    Serial.println("Button pressed!");
    pressed = false;
  }
}

void buttonISR() {
  pressed = true;
}

medium

A. Compilation error due to volatile variable

B. Button pressed! (printed repeatedly forever)

C. No output at all

D. Button pressed! (printed once)

Solution

1. Step 1: Understand ISR and flag usage

   The ISR sets the volatile flag 'pressed' to true when the button is pressed.

2. Step 2: Check loop behavior

   The loop prints "Button pressed!" once when 'pressed' is true, then resets it to false, so it prints only once per press.

3. Final Answer:

   Button pressed! (printed once) -> Option D

4. Quick Check:

   ISR sets flag, loop prints once [OK]

Hint: ISR sets flag; loop prints once per press [OK]

Common Mistakes:

• Thinking the message prints repeatedly without reset
• Assuming volatile causes errors
• Ignoring that flag resets after printing

4. Identify the error in this interrupt-driven button code:

volatile int count = 0;

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

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

void countPresses() {
  count++;
}

medium

A. Using delay() in loop causes missed interrupts

B. Modifying a multi-byte variable without disabling interrupts

C. Incrementing a non-volatile variable in ISR

D. attachInterrupt() called with wrong pin number

Solution

1. Step 1: Check variable type and ISR safety

   'count' is volatile int (multi-byte). Incrementing it in ISR and reading in loop can cause inconsistent values.

2. Step 2: Understand atomicity issue

   Incrementing multi-byte variables is not atomic; main code reading 'count' may see partial updates causing errors.

3. Final Answer:

   Modifying a multi-byte variable without disabling interrupts -> Option B

4. Quick Check:

   Multi-byte variable access must be atomic [OK]

Hint: Use atomic operations or disable interrupts for multi-byte vars [OK]

Common Mistakes:

• Ignoring atomicity of multi-byte variables
• Thinking delay() blocks interrupts
• Assuming attachInterrupt pin is wrong without checking

5. You want to count how many times a button connected to pin 4 is pressed, but only if the button is pressed and held for at least 2 seconds. Which approach best uses interrupts to achieve this?

hard

A. Poll the button state in loop without interrupts and count presses.

B. Use attachInterrupt on RISING edge to increment count immediately on press.

C. Use attachInterrupt on FALLING edge to start a timer, then check duration in loop before incrementing count.

D. Use attachInterrupt on CHANGE edge and increment count inside ISR.

Solution

1. Step 1: Understand requirement for press duration

   Counting only if pressed for 2 seconds means timing the press length, not just detecting press.

2. Step 2: Use interrupt to detect press start and timer in loop

   Interrupt on FALLING edge detects press start; loop checks if button held 2 seconds before counting.

3. Final Answer:

   Use attachInterrupt on FALLING edge to start a timer, then check duration in loop before incrementing count. -> Option C

4. Quick Check:

   Interrupt detects press start; loop checks hold time [OK]

Hint: Interrupt starts timer; loop checks hold duration [OK]

Common Mistakes:

• Incrementing count immediately without timing
• Using CHANGE edge causing multiple triggers
• Polling without interrupts misses instant detection