How can I debounce a switch on both positive and negative-going edges?

Question

I would like to connect a mechanical switch to an interrupt pin on an Arduino Uno processor where the interrupt is configured for CHANGE interrupts (i.e., triggers on either a positive-going or negative-going signal).

I've found numerous approaches for implementation of debounce circuitry for positive or negative going signals, but I have not found suggestions for circuitry that can debounce either positive-going or negative-going signals.

Essentially, I want to use a single interrupt pin that can detect the opening or closing of an external switch, and I'd like to debounce the input using a hardware approach.

---

To be a bit more specific, the switch in question will open and close up to 200 times per second and I'd like to determine the amount of time it is closed each time it goes through an on/off cycle. I.e., I'm not talking about a button pushed by the user.

Answer 1

To debounce either edge of a changing signal, use hysteresis. Many debouncing algorithms assume an active high or active low signal, but you need to detect both.

Here is the essence of the hysteresis algorithm:

    bool input_state = digitalRead(INPUT_PIN);
    unsigned long current_ms = millis();

    edge = rise = fall = false;

    // Hysteresis:
    //   If there is no change, reset the debounce timer.
    //   Else, compare the time difference with the debounce delay.
    if (input_state == output_state)
    {
      last_ms = current_ms;
    }
    else
    {
      if ((current_ms - last_ms) >= DEBOUNCE_DELAY_ms)
      {
        // Successfully debounced, so update the outputs.
        is_debounced = true;
        rise = input_state && !output_state;
        fall = !input_state && output_state;
        edge = rise || fall;
        output_state = input_state;
      }
      else
      {
          is_debounced = false;
      }
    }

This could be called from an interrupt service routine something like this:

ISR(TIMER0_COMPA_vect)
{
  static Debouncer button1(BUTTON_PIN, DEBOUNCE_DELAY_ms);
  static bool led_state = false;
  
  button1.UpdateISR();
  
  // Toggle the LED on either edge of the debounced signal.
  if (button1.Edge())
  {
    led_state = !led_state;
    digitalWrite(LED_PIN, led_state);
  }
}

Here is a link the full code of the hysteresis debouncer on GitHub which uses the millis() timer, but you might need to change it to use the micros() timer and possibly increase the interrupt frequency for greater accuracy in your application. You also need to figure out the length of DEBOUNCE_DELAY. Use an oscilloscope to see what the switch bounce noise looks like.

Answer 2

If it is an physically latching switch, I usually use this type of code in 10ms loop with RC filtering on pin(not necessary). Of course, you can use a pin change interrupt, but it is a little tricky, because you cannot miss/forget to handle even one edge on input. Example, you detect rising edge in PCINT rutine, than you start debouncing ON state like counting some numbers of positive levels, but meantime you can switch button OFF so you detect negative edge, i.e. cancel the positive debouncing or at least think about this option. The usable thing about PCINT when hadling latching switch is to hold microcontroller "idle" if no interrupt come and if interrupt come enable something like my rutine in main().

if(SWITCHED) {

    switched_on_count++;  
    switched_off_count = 0;

    if(switched_on_count > 10) {
        switched_on_count = 0;

        if(BUTTON == OFF) {                                             
                BUTTON = ON;        
        }                                       
    }
                                                    
} else {

    switched_off_count++;           
    switched_on_count = 0;

    if(switched_off_count > 10) {
        switched_off_count = 0;

        if(BUTTON == ON) {                                              
                BUTTON = OFF;       
        }                   
    }

}

Answer 3

A simple way to do this is with an interating algorith.

It is similar to the algorithm proposed by @Michal Podmanický however you do not need to maintain a counter for both ON and OFF positions. You simply use an iterator variable, that damps the oscillating input (i.e. bouncing switch) and changes the reading state only when the threshold is reached, either when the iterator is back to 0 for low state, or when it reached the positive threshold for high state.

#define MAXIMUM (10) // set this value depending on how quicly your fct is called
// and how bouncy your hardware is
uint8_t iterator = 0; // starts low

bool debounce(bool input)
{
  bool now_debounced_input;
    if (input == 0)
    {
        if (iterator > 0)
            iterator--;
    }
    else if (iterator < MAXIMUM)
        iterator++;

    if (iterator == 0)
        now_debounced_input = 0;
    else if (iterator >= MAXIMUM)
    {
        iterator = MAXIMUM; // Defensive code
        now_debounced_input = 1;
    }
return now_debounced_input ;
}

Answer 4

In broad terms, what you need is to get the logical output of the switch through a Low-Pass Filter. There are several possibles implementations : hardware (RC-filter into a µC pin, more complex ones) ; or software (the answers of JCSB and Michal P. for example). The best ones will depends on the specifics on the circuit you're designing. If you need to sample the value at 1 kHz, hardware implementations may be preferable to avoid software load, especially if your µC is not fast.

It's important to note that you may need to take into the delay induced by the Low-Pass Filter if your application needs to be especially reactive (although it shouldn't be a problem @ 1kHz).

I would also advise to use an hysteresis filter (a Schmitt trigger for example) between the LP-Filter output and the input of your system to avoid too much variation of the value : the solutions of JCSB and Michal P. intrinsically provide this function, software-side.

Answer 5

All - I decided to digitize the switch waveform. Given that I can determine duty cycle and other things in post-processing. I appreciate everyone's input and plan to try some of the suggestions later on as I would like to better understand switch debouncing and interrupt handling. Thanks again! - Jim