Lesson Objectives:

1. Understand the behavior of a push button as an input device.
2. Learn how to connect a button to Arduino and read its state.
3. Explore the concept of signal noise and why debouncing is necessary.
4. Learn both software and hardware debouncing techniques.
5. Use Red Pitaya to visualize the noisy signal and analyze the effects of debouncing

Theory

How Push Buttons Work

Push buttons (or tactile switches) are simple mechanical devices used to create a temporary connection between two contacts when pressed. They are widely used in embedded systems—for example, to trigger events, control user interfaces, or change system modes.

The Problem: Contact Bounce

When a push button is pressed or released, its mechanical contacts do not change state cleanly. Instead, due to mechanical vibrations, the contacts “bounce” for a few milliseconds. This produces rapid, brief transitions between ON and OFF states.

• Without Debouncing: The microcontroller may read these rapid transitions as multiple presses instead of a single intended press, leading to erratic behavior.

Debouncing

Debouncing is the process of filtering out the unwanted rapid transitions so that the system registers only one clean press or release.

• Software Debouncing:

Implemented in code by waiting a fixed delay (e.g., 50 ms) after detecting a state change before accepting the new state. This approach uses timers to ensure that the button state remains stable before updating the system.

• Hardware Debouncing:

Uses analog components to smooth the noisy signal before it reaches the microcontroller. A common solution is to place a capacitor (e.g., 0.1 µF) in parallel with the push button. Together with a resistor (or the pull-down resistor already in use), this RC network filters out the rapid fluctuations (bounces) and produces a smoother, more reliable signal.

Fall Time

• Definition: The duration it takes for the voltage to drop from a higher level (commonly 90% of its final amplitude) to a lower level (commonly 10%).
• Why It Matters:
• Longer fall times can introduce timing errors in digital circuits.
• In the context of button signals, a larger capacitor slows the voltage drop, extending the fall time.

Visualization with Red Pitaya

Using an oscilloscope like the Red Pitaya STEMlab 125-14, engineers can observe:

• Without Debouncing: The waveform shows rapid spikes (bounces) as the button is pressed or released.
• With Debouncing (Software and Hardware): The signal becomes smooth, with a clean transition corresponding to a single press or release.

Real-World Importance

Accurate button detection is critical in embedded applications (e.g., keypads, control panels, consumer electronics). Reliable debouncing ensures that the system responds correctly, avoiding multiple triggers or erratic behavior.

Hardware Setup

A. Components:

• Push button (Tactile Switch)
• 10 kΩ resistor (Pull-down)
• 0.1 µF capacitor (for hardware debouncing)
• Arduino Uno (or similar)
• Breadboard and jumper wires
• Red Pitaya STEMlab 125-14 (for later visualization)

B. Circuit Assembly:

1. Connecting the Push Button (With Hardware Debouncing):
• Button Connection:
• Insert the push button on the breadboard.
• Connect one terminal of the button to Arduino digital pin 2.
• Connect the same terminal to ground through a 10 kΩ resistor (acting as a pull-down).

• Powering the Button:
• Connect the other terminal of the button to Arduino 5V.

2. Oscilloscope Connection:
• Connect the probe tip of the Red Pitaya to the node at digital pin 2 (or at the junction before the pull-down resistor) and the ground clip to Arduino GND to visualize the signal.

Circuit Diagram:

Arduino Programming: Reading Button States

When using a simple Arduino sketch to read a push button, you might notice unexpected behavior—especially when observing the signal on a Red Pitaya oscilloscope. In the image, you can see a momentary fluctuation (circled in red) each time the button is pressed or released.

Why Does This Happen?

• Mechanical Bounce: The physical contacts of the push button briefly “bounce” when changing states. Instead of a clean transition from LOW to HIGH (or vice versa), you get multiple rapid transitions over a few milliseconds.
• Signal Glitch on the Oscilloscope: This glitch is the oscilloscope’s visual record of the bouncing effect. The waveform doesn’t settle immediately at its new level; instead, it oscillates for a short time.

A. Without Debouncing:

1. Code:

Write a simple sketch that reads the raw button state and prints it to the Serial Monitor.

Copy

const int buttonPin = 2;  // Button connected to pin 2

void setup() {
  pinMode(buttonPin, INPUT);  // Configure pin 2 as an input
  Serial.begin(9600);         // Start serial communication
}

void loop() {
  int buttonState = digitalRead(buttonPin);  // Read the raw button state
  Serial.println(buttonState);               // Print the state (HIGH or LOW)
  delay(10);                                 // Small delay for readability
}

2. Observation:
• Observe rapidly fluctuating 1s and 0s on the Serial Monitor when pressing or releasing the button.
• Discuss how these fluctuations are caused by contact bounce.

B. Software Debouncing:

1. Code:

Modify the sketch to include a simple software debounce.

Copy

const int buttonPin = 2;  // Button connected to pin 2
int stableState = HIGH;   // Initial stable state (using INPUT_PULLUP, HIGH means not pressed)
int lastReading = HIGH;   // Last raw reading
unsigned long lastDebounceTime = 0;
const unsigned long debounceDelay = 50;  // 50 ms debounce delay

void setup() {
  pinMode(buttonPin, INPUT_PULLUP);  // Use internal pull-up resistor
  Serial.begin(9600);
}

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

  // If the reading changes, reset the debounce timer.
  if (currentReading != lastReading) {
    lastDebounceTime = millis();
  }

  // If the reading has been stable for longer than debounceDelay, consider it the new stable state.
  if ((millis() - lastDebounceTime) > debounceDelay) {
    if (currentReading != stableState) {
      stableState = currentReading;
      // Print the debounced state (HIGH when not pressed, LOW when pressed)
      Serial.println(stableState);
    }
  }

  lastReading = currentReading;
  delay(10);  // Short delay for readability
}

How This Code Works:

1. Initial Setup:
• The button is connected with INPUT_PULLUP so that it reads HIGH by default and LOW when pressed.
2. Reading and Debouncing:
• The code reads the current state of the button (currentReading).
• If this reading differs from the previous reading (lastReading), the debounce timer is reset.
• Only if the reading remains stable for more than 50 ms (the debounceDelay), the new state is accepted and stored as stableState.
• The debounced state is then printed to the Serial Monitor.
3. Delay:
• A short delay of 10 ms is included for readability and to avoid overwhelming the serial output.

This debouncing implementation filters out the rapid transitions caused by contact bounce, ensuring that each physical button press is registered as a single, clean transition.

Why Use millis() Instead of delay()?

Non-Blocking Timing:

• delay():

When you use delay(), the program halts execution for the specified number of milliseconds. This makes it impossible to perform any other tasks during that period. In applications requiring multitasking (e.g., reading sensor data, updating displays, handling multiple inputs), using delay() can cause the system to become unresponsive.

• millis():

The millis() function returns the number of milliseconds since the Arduino started running the current program. By using millis(), you can check how much time has passed without stopping program execution. This allows you to write non-blocking code that can handle multiple tasks concurrently.

Example in Debouncing:

• In the debouncing code above, millis() is used to determine if the button state has remained stable for at least 50 ms before updating the stable state.
• This approach ensures that while the program waits for the bounce to settle, it can continue to monitor the button and perform other tasks if necessary.

Flexibility and Responsiveness:

• With millis(), you can implement multiple timers in the same program. This is essential for projects where you need to manage several time-dependent operations simultaneously.
• Using millis() helps keep your program responsive to new inputs, as it doesn't halt the entire program flow.

C. Hardware Debouncing:

A. 0.1 µF Capacitor

1. Setup:
• Place the 0.1 µF capacitor between the button pin (Arduino pin 2) and ground.
• Run the same raw reading code (no software debounce) to see the hardware effect.
2. Oscilloscope Analysis:
• The bouncing transitions should be shorter or less pronounced.
• Fall Time: The signal will drop more slowly than without a capacitor, but not excessively.

B. 1 µF Capacitor

1. Setup:
• Replace the 0.1 µF capacitor with a 1 µF capacitor.
• Keep the same circuit and code.
2. Oscilloscope Analysis:
• Notice a longer fall time (and rise time) due to the larger capacitor.
• The bouncing may be even more filtered, but the signal transitions are slower, leading to a noticeable “tail” on the oscilloscope.

3. Trade-Off:
• While a larger capacitor reduces bounce more effectively, it also extends the time it takes for the signal to change from HIGH to LOW (and vice versa). This can delay button recognition in fast applications.

Comparing Signals:

• Discuss how the bouncing is visible in the raw reading.
• Show how debouncing (both software and hardware) smooths out the signal.
• Ask students which method they think is more suitable for their application and why.

Wrap-Up and Discussion

Key Takeaways:

1. Button Behavior:
• Mechanical push buttons exhibit bouncing, causing multiple rapid transitions.
2. Debouncing Importance:
• Debouncing—whether implemented in software or hardware—is essential for reliable button readings in embedded systems.
3. Visualization:
• Tools like the Red Pitaya can help visualize and analyze the noisy signals, reinforcing the need for proper signal conditioning.

Real-World Application:

• Discuss how accurate button detection is critical in applications such as keypads, industrial control panels, and consumer electronics.
• Highlight that both software and hardware debouncing can be used, often together, to improve reliability.

Questions and Answers

Q1: What is contact bounce and why does it occur in push buttons?

A1: Contact bounce is the rapid, unintended toggling of the button state due to mechanical vibrations when a button is pressed or released. The contacts make and break the connection multiple times before settling, causing noisy signals.

Q2: How does software debouncing work?

A2: Software debouncing involves waiting a fixed amount of time (e.g., 50ms) after detecting a state change. The code then checks if the button state remains stable for that period before accepting the change, filtering out the rapid transitions caused by bouncing.

Q3: How does hardware debouncing using a capacitor help stabilize the button signal?

A3: A capacitor in parallel with the push button forms an RC circuit with the resistor, which smooths out rapid voltage fluctuations. When the button is pressed or released, the capacitor charges or discharges gradually, effectively filtering out the high-frequency bouncing and resulting in a smoother, more stable signal.

Q4: Why might you choose hardware debouncing over software debouncing, or vice versa?

A4: Hardware debouncing reduces the burden on the microcontroller and provides immediate signal smoothing, which can be more reliable in noisy environments. However, it requires additional components. Software debouncing is more flexible and easier to implement but consumes processing time and may not be as effective in extremely noisy conditions. Often, a combination of both methods yields the best results.

Q5: How does using an oscilloscope like the Red Pitaya help in understanding button behavior?

A5: The oscilloscope provides a visual representation of the button’s voltage signal. It shows the rapid spikes caused by bouncing and how the signal becomes smoother when debouncing is applied. This visualization helps in understanding the timing and magnitude of noise in the system, reinforcing the importance of debouncing.