Debouncing a button in software in Arduino - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this debouncing code snippet?

Consider this Arduino code that reads a button and debounces it. What will be printed to the serial monitor if the button is pressed and held steadily?

Arduino

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

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

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;
}

A Button pressed (printed once when button is first pressed)

B Button pressed (printed twice quickly)

C No output printed

D Button pressed (printed repeatedly while button is held)

💡 Hint

Think about how the debounce delay prevents multiple triggers while the button state is stable.

The code prints "Button pressed" only once when the button state changes from LOW to HIGH after the debounce delay. Holding the button steady does not cause repeated prints.

🧠 Conceptual

intermediate

Why is software debouncing needed for buttons?

When you press a physical button, why do we need to debounce it in software?

A Because the button sends a continuous analog signal that needs filtering

B Because the button press causes multiple rapid on/off signals due to mechanical bounce

C Because the microcontroller cannot read digital signals directly

D Because the button changes voltage slowly over several seconds

💡 Hint

Think about what happens inside a button when you press it physically.

Mechanical buttons do not switch cleanly. They rapidly open and close contacts for a few milliseconds causing multiple signals. Software debouncing filters these out.

🔧 Debug

advanced

Identify the bug in this debounce code

What is the problem with this Arduino debounce code snippet?

Arduino

const int buttonPin = 3;
int buttonState = 0;
int lastButtonState = 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 == lastButtonState) {
    lastDebounceTime = millis();
  }

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

  lastButtonState = reading;
}

A The debounce timer resets when readings are the same, causing no stable detection

B The buttonPin is not set as INPUT_PULLUP

C The Serial.begin is called after pinMode, which is incorrect

D The buttonState variable is not declared as volatile

💡 Hint

Check the condition that resets the debounce timer.

The debounce timer should reset when the reading changes, not when it stays the same. Resetting on same reading prevents stable detection.

📝 Syntax

advanced

Which option fixes the syntax error in this debounce code?

Fix the syntax error in this line of Arduino debounce code:

buttonState = reading if (millis() - lastDebounceTime) > debounceDelay;

A buttonState = reading if (millis() - lastDebounceTime > debounceDelay) {}

B buttonState = reading; if (millis() - lastDebounceTime > debounceDelay)

C if ((millis() - lastDebounceTime) > debounceDelay) buttonState = reading;

D if (millis() - lastDebounceTime > debounceDelay) { buttonState == reading; }

💡 Hint

Remember the correct syntax for an if statement in C++.

The if statement must have parentheses around the condition and a statement or block after it. Assignment uses =, not ==.

🚀 Application

expert

How many times will "Pressed" print if button is pressed and held for 1 second?

Given this debounce code, how many times will the message "Pressed" print if the button is pressed and held steadily for 1 second?

const int buttonPin = 4;
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("Pressed");
      }
    }
  }

  lastButtonState = reading;
}

A 50 times

B 20 times

C 100 times

D 1 time

💡 Hint

Consider how the debounce logic only prints on state change after delay.

The code prints "Pressed" only once when the button state changes from LOW to HIGH after the debounce delay. Holding the button does not cause repeated prints.

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