Step 1. Circuit Setup

The circuit for this project is the same as the one used in Debouncing via Software, but instead of the full breadboard, this project will use a mini breadboard and pins 7 and 8. Other than these minor differences the result should be the exact same as in Debouncing via Software, when the button is pressed the LED shines and the computer receives the number of times the button has been pressed.

1. Place the button so that it bridges the valley of the breadboard, like in Fig. 1.
2. Place a wire from a 5V power source pin to one of the legs of the button.
3. Place a resistor (10 kΩ) on the same side button as the wire to 5V pin, but on the other leg.
4. Place a wire from pin 7 to the leg of the button that is across the valley from the leg with the resistor.
5. Place another wire from ground (GND) to the other end of the 10 kΩ resistor
6. Place another 10 kΩ resistor on the same row as the other resistor and wire to ground.
7. Connect the cathode (short end) of the LED to the end of the newly placed resistor and the anode (long end) so that it is across the valley.
8. Finally, place the final wire from the anode (short end) of the LED to pin 8.

Step 2: Downloading the Bounce Library

The bounce library can be found at http://playground.arduino.cc/code/bounce. Once the library has been downloaded, unzip the folder that was just downloaded. Then place the resulting folder in the libraries folder of your sketchbook. If you do not know where this is, it can be found by going to FILE->preferences and looking at the Sketchbook location. Alternatively, hitting Ctrl+comma(,) takes you to the same screen. Figure 2 should be the window that opens and the sketchbook location will be at the top of that window.

Now that you know where the location of your sketchbook in MPIDE, navigate to it and you'll see a bunch of folders with the same names as the various projects you've saved in the computer. To install a library, since this is going to be the first library you have installed, you will need to make a folder called libraries, which will hold the user installed “Libraries,”. So, now that we have a location to install the bounce library, copy the unzipped bounce folder and paste it into the newly created “Libraries” folder. You can check to see if the library was installed by starting (or restarting if already open) MPIDE, selecting Sketch->Import Library, and look towards the bottom of that menu for Bounce. It should be under “Contributed”, which simply means that it was added by the user and not included by default. Figure 3 is the window you should see if the library was installed correctly. Also, this is the same process to import a library into a sketch, except that you would click on the library name to do so.

When you click on the Bounce library in the import library menu, you should see #include <Bounce> at the top of your sketch. What this means is that when the sketch is verified/compiled, it will include the Bounce library.

Well, we've included the Bounce library, but what does that mean? What is a library? A library is simply a collection of functions and classes that are used to make a task or collection of tasks easier to deal with. The Bounce library is a library to make debouncing a button or switch as easy as calling digitalRead(). The concept is the same as in Software Debouncing project, but with the debouncing code inside the Bounce class instead of the loop function.

Step 3: Programming Global Variables

We have five global variables that will be used in the sketch. The first two variables are simply the pins for the button and the LED. We are making them global because we want access to them in both the setup() and loop() function. They are const because the pins won't change during the program. We will call these variables “btnPinGlb” and “ledPinGlb” where the PinGlb part simply means that the variable represents a pin and that it is a global variable (all functions can use it).

The next variable is the amount to delay for the button debouncing. This variable is const unsigned int because we won't change the delay in the debounce and a negative delay makes no sense. This variable will be called debounceDelayGlb. See Debouncing via Software for more information on why we need a debounce delay.

The next variable is the count of the times the button has been pressed. It is an unsigned int since there can't be negative button presses. The name of this variable will be countGlb because it is a global variable. The final variable is actually a class object (a variable that is a class), and that is the Bounce class. Due to how the Bounce class does not have a default constructor, it requires two inputs: the pin to debounce and the time to delay for debouncing. We will just call the variable bouncerGlb because it is a global variable. However, to create this variable with the inputs it requires, we must treat it like we would a function. Observe the following code on how to create this variable:

				  Bounce bouncerGlb(btnPinGlb, debounceDelayGlb);
                

As you can see in the code, we use the pin which the button is connected to and the debounce delay. We insert them into the Bounce class variable as if it were a function to initialize it with the values of btnPinGlb and debounceDelayGlb.

Step 4: Compiling the Code

Now we have all of the information we need to debounce a button using the bounce library. The code for our sketch should look something like this:

                  #include <Bounce.h>
                  
                  // Define variables for the pins we are using.
                  const int btnPinGlb = 7;
                  const int ledPinGlb = 8;
                  
                  // Used for the initialization of the Bounce class.
                  const unsigned int debounceDelayGlb = 50;
                  
                  // Times the button has been pressed.
                  unsigned int countGlb = 0;
                  
                  /* Initialize the Bounce class on pin 7 (btnPin) with 
                   * a delay of 50 (debounceDelayGlb)
                   */
                  Bounce bouncerGlb(btnPinGlb,debounceDelayGlb);
                  
                  void setup()
                  {
                    // Set the button to INPUT and LED to OUTPUT
                    pinMode(btnPinGlb,INPUT);
                    pinMode(ledPinGlb,OUTPUT);
                    
                    // Start Serial communications.
                    Serial.begin(9600);
                  }
                  
                  void loop()
                  {
                    // Update the bounce class.
                    bouncerGlb.update();
                    
                    // Get current button state from the bounce class.
                    int currentBtnState = bouncerGlb.read();
                    
                    // If there is a rising edge, increment count and send it to the computer.
                    if(bouncerGlb.risingEdge()){
                      countGlb++;
                      Serial.println(countGlb);
                    }
                    
                    // Write the current button state to the LED.
                    digitalWrite(ledPinGlb, currentBtnState);
                  }