Debouncing a button in software in Arduino

Introduction

Buttons can send many signals when pressed once because of tiny vibrations. Debouncing helps to read a clean single press.

When you want to detect a single button press without errors.

When your button input causes multiple unwanted triggers.

When you need stable and reliable button reading in your project.

Syntax

Arduino

const int buttonPin = 2;  // pin where button is connected
int buttonState;          // current reading from the input pin
int lastButtonState = LOW; // previous reading
unsigned long lastDebounceTime = 0;  // last time the output was toggled
unsigned long debounceDelay = 50;    // debounce time in milliseconds

Use a small delay time (like 50 ms) to ignore quick changes.

Store the last stable state to compare with new readings.

Examples

This checks if the button reading changed, waits for debounce delay, then updates the button state.

Arduino

int reading = digitalRead(buttonPin);
if (reading != lastButtonState) {
  lastDebounceTime = millis();
}
if ((millis() - lastDebounceTime) > debounceDelay) {
  if (reading != buttonState) {
    buttonState = reading;
    if (buttonState == HIGH) {
      // button pressed
    }
  }
}
lastButtonState = reading;

This full example prints "Button pressed" only once per press, ignoring bounces.

Arduino

const int buttonPin = 2;
int buttonState = LOW;
int lastButtonState = LOW;
unsigned long lastDebounceTime = 0;
unsigned long debounceDelay = 50;

void setup() {
  pinMode(buttonPin, INPUT);
  Serial.begin(9600);
}

void loop() {
  int reading = digitalRead(buttonPin);
  if (reading != lastButtonState) {
    lastDebounceTime = millis();
  }
  if ((millis() - lastDebounceTime) > debounceDelay) {
    if (reading != buttonState) {
      buttonState = reading;
      if (buttonState == HIGH) {
        Serial.println("Button pressed");
      }
    }
  }
  lastButtonState = reading;
}

Sample Program

This program reads a button on pin 2 and prints "Button pressed" once each time you press the button, ignoring quick bounces.

Arduino

const int buttonPin = 2;
int buttonState = LOW;
int lastButtonState = LOW;
unsigned long lastDebounceTime = 0;
unsigned long debounceDelay = 50;

void setup() {
  pinMode(buttonPin, INPUT);
  Serial.begin(9600);
}

void loop() {
  int reading = digitalRead(buttonPin);

  if (reading != lastButtonState) {
    lastDebounceTime = millis();
  }

  if ((millis() - lastDebounceTime) > debounceDelay) {
    if (reading != buttonState) {
      buttonState = reading;
      if (buttonState == HIGH) {
        Serial.println("Button pressed");
      }
    }
  }

  lastButtonState = reading;
}

Important Notes

Make sure your button is connected with a pull-down or pull-up resistor to avoid floating input.

Debounce delay can be adjusted depending on your button quality.

Summary

Debouncing helps to get one clean signal from a noisy button press.

Use timing checks to ignore quick changes in button state.

This method improves reliability in button-controlled projects.

Practice

1. What is the main purpose of debouncing a button in software on an Arduino?

easy

A. To ignore rapid, repeated signals caused by mechanical noise

B. To increase the button press speed

C. To make the button LED blink faster

D. To reduce power consumption of the Arduino

Solution

1. Step 1: Understand button noise

   Mechanical buttons create multiple quick signals when pressed due to bouncing contacts.

2. Step 2: Purpose of debouncing

   Debouncing filters these quick repeated signals to register only one clean press.

3. Final Answer:

   To ignore rapid, repeated signals caused by mechanical noise -> Option A

4. Quick Check:

   Debouncing = Ignore noise [OK]

Hint: Debouncing stops false multiple presses from one button push [OK]

Common Mistakes:

• Thinking debouncing speeds up button presses
• Confusing debouncing with power saving
• Assuming debouncing controls LED blinking

2. Which Arduino function is commonly used to measure time for software debouncing?

easy

A. delay()

B. analogWrite()

C. digitalRead()

D. millis()

Solution

1. Step 1: Identify timing functions

   delay() pauses the program but is not ideal for debouncing timing checks.

2. Step 2: Use millis() for non-blocking timing

   millis() returns the time since the program started, allowing to check elapsed time without stopping code.

3. Final Answer:

   millis() -> Option D

4. Quick Check:

   Debounce timing uses millis() [OK]

Hint: Use millis() to track time without stopping code [OK]

Common Mistakes:

• Using delay() which blocks code execution
• Confusing digitalRead() with timing
• Using analogWrite() which controls PWM output

3. What will be the output on the serial monitor if the following code is run and the button is pressed once?

const int buttonPin = 2;
int buttonState = 0;
unsigned long lastDebounceTime = 0;
unsigned long debounceDelay = 50;

void setup() {
  pinMode(buttonPin, INPUT);
  Serial.begin(9600);
}

void loop() {
  int reading = digitalRead(buttonPin);
  if (reading != buttonState) {
    lastDebounceTime = millis();
  }
  if ((millis() - lastDebounceTime) > debounceDelay) {
    if (reading != buttonState) {
      buttonState = reading;
      if (buttonState == HIGH) {
        Serial.println("Button pressed");
      }
    }
  }
}

medium

A. Button pressed printed multiple times rapidly

B. Button pressed printed once

C. Syntax error, code won't compile

D. No output printed

Solution

1. Step 1: Analyze initial buttonState and reading

   buttonState starts at 0 (LOW). If button is pressed, reading becomes HIGH (1).

2. Step 2: Check debounce logic

   The code updates lastDebounceTime when reading differs from buttonState, and after debounce delay, if reading still differs, buttonState updates and prints.

3. Step 3: Confirm output

   After debounce delay, buttonState updates and "Button pressed" is printed once.

4. Final Answer:

   Button pressed printed once -> Option B

5. Quick Check:

   Debounce logic allows one print after stable press [OK]

Hint: Debounce logic prints once after stable press [OK]

Common Mistakes:

• Assuming print happens immediately on press
• Ignoring debounce delay effect
• Thinking code has syntax errors

4. Identify the error in this debounce code snippet and select the fix:

const int buttonPin = 3;
int buttonState = LOW;
unsigned long lastDebounceTime = 0;
unsigned long debounceDelay = 50;

void loop() {
  int reading = digitalRead(buttonPin);
  if (reading != buttonState) {
    lastDebounceTime = millis();
  }
  if ((millis() - lastDebounceTime) > debounceDelay) {
    buttonState = reading;
    if (buttonState == HIGH) {
      Serial.println("Pressed");
    }
  }
}

medium

A. Initialize buttonState as HIGH instead of LOW

B. Move buttonState = reading inside the first if block

C. Add pinMode(buttonPin, INPUT_PULLUP) in setup()

D. Change debounceDelay to 5000 for longer delay

Solution

1. Step 1: Check hardware setup assumptions

   Without enabling INPUT_PULLUP, the button pin may float causing unreliable readings.

2. Step 2: Importance of INPUT_PULLUP

   Using INPUT_PULLUP activates internal pull-up resistor, stabilizing input and making debounce logic reliable.

3. Final Answer:

   Add pinMode(buttonPin, INPUT_PULLUP) in setup() -> Option C

4. Quick Check:

   Use INPUT_PULLUP for stable button input [OK]

Hint: Use INPUT_PULLUP to avoid floating pin errors [OK]

Common Mistakes:

• Changing initial buttonState without hardware reason
• Moving state update incorrectly breaking debounce logic
• Setting too long debounce delay unnecessarily

5. You want to detect a single button press and toggle an LED state only once per press using software debounce. Which approach below correctly implements this behavior?

const int buttonPin = 4;
const int ledPin = 13;
int ledState = LOW;
int lastButtonState = LOW;
unsigned long lastDebounceTime = 0;
unsigned long debounceDelay = 50;

void setup() {
  pinMode(buttonPin, INPUT_PULLUP);
  pinMode(ledPin, OUTPUT);
  digitalWrite(ledPin, ledState);
  Serial.begin(9600);
}

void loop() {
  int reading = digitalRead(buttonPin);
  if (reading != lastButtonState) {
    lastDebounceTime = millis();
  }
  if ((millis() - lastDebounceTime) > debounceDelay) {
    if (reading != lastButtonState) {
      lastButtonState = reading;
      if (lastButtonState == LOW) {
        ledState = !ledState;
        digitalWrite(ledPin, ledState);
        Serial.println(ledState ? "LED ON" : "LED OFF");
      }
    }
  }
}

hard

A. This code toggles LED once per press correctly

B. LED toggles multiple times due to missing debounce

C. LED never toggles because lastButtonState is not updated

D. Code causes syntax error due to missing semicolons

Solution

1. Step 1: Check debounce timing logic

   The code updates lastDebounceTime when reading changes, then waits debounceDelay before accepting new state.

2. Step 2: Confirm state update and toggle

   Inside debounce check, lastButtonState updates to reading, and LED toggles only when button is pressed (LOW due to INPUT_PULLUP).

3. Step 3: Verify output and toggle behavior

   LED state flips once per valid press, and serial prints correct status.

4. Final Answer:

   This code toggles LED once per press correctly -> Option A

5. Quick Check:

   Debounce + toggle once per press = Correct [OK]

Hint: Toggle LED only when stable press detected after debounce [OK]

Common Mistakes:

• Not updating lastButtonState causing repeated toggles
• Ignoring debounce delay causing multiple toggles
• Confusing HIGH/LOW logic with INPUT_PULLUP