Go Down

### Topic: [SOLVED] Dealing with a noisy interrupt signal (Read 12883 times)previous topic - next topic

#### dlloyd

#45
##### Apr 17, 2016, 12:49 amLast Edit: Apr 17, 2016, 07:03 am by dlloyd
@Robin2: Yes, thanks, your post got me researching the possibility of using a timer to temporarily turn off the input interrupt. Then I stumbled upon this thread that was attempting a similar approach but was incomplete. However, I needed a wider timing range and needed to use the timer as a monostable multivibrator (one-shot timer). More specifically, a retriggerable one-shot timer because the debounce timing re-starts after each invalid interrupt. This is why I called the timing interval "stableWidth" as it waits for a period of stability in the signal.

#### Robin2

#46
##### Apr 17, 2016, 10:24 am

...R
Two or three hours spent thinking and reading documentation solves most programming problems.

#### dlloyd

#47
##### Apr 20, 2016, 04:26 pmLast Edit: May 03, 2016, 02:48 am by dlloyd
The "debouncer" code now works automatically for all interrupt modes and external interrupt INT0 and INT1. The maximum input frequency for all modes is around 38 kHz when timer0 interrupt is disabled. With timer0 interrupt enabled, the maximum frequency is about 32kHz. Latency for all modes is about 3.6 µs.

Tested with an SPI pattern generator uploaded to an Arduino Pro Mini. The signal is squarewave with multiple transitions on each edge and other areas (34 total / cycle). The signal has frequency of 38.3 kHz and is connected to an UNO external interrupt pin (2 or 3).

For CHANGE mode, the clean output toggles.

For RISING and FALLING modes, the clean output toggles once for the required mode. Noise on both edges and in between is eliminated even though the opposite edge extends well beyond the stableWidth interval.

Noise on the opposite edge is a common problem that is difficult to eliminate. For a squarewave, a simple ignore interval will not work unless it extends beyond 50% of the waveform which severely limits the usable frequency range when debouncing. By knowing the previous stable state, this issue has been resolved.

Noise in between the signals is also ignored providing there is at least one high and one low stable interval.

FALLING mode:

]

RISING mode:

The code:

Code: [Select]
const byte intPin = 2; // can use pin 2 or 3
volatile byte intNum, notIntNum, intSense, intState, clockSelect;
volatile byte extendedCompare, extendedCounter;

unsigned long stableWidth = 125000; // 2-1000000µs interval

void setup()
{
pinMode(intPin, INPUT_PULLUP);
pinMode (LED_BUILTIN, OUTPUT);
//pinMode (11, OUTPUT); // for monitoring OC2A output
//TIMSK0 = 0;           // for testing with timer0 disabled
attachInterrupt(digitalPinToInterrupt(intPin), inputPin_ISR, CHANGE);
stabilizerInit();
}

void loop()
{
}

ISR(TIMER2_COMPA_vect)
{
extendedCounter++;
if (extendedCounter >= extendedCompare)
{
extendedCounter = 0;                    // reset extended counter
TCCR2B = 0;                             // stop timer clock
TCNT2 = 0;                              // reset timer counter
intState = (PIND & _BV (intPin)) == 0;  // read intPin
EIFR = intNum;                          // reset pending intPin interrupt
EIMSK |= intNum;                        // enable intPin interrupt
}
}

void inputPin_ISR()
{
if (intSense == 1) {                      // if CHANGE mode
PINB |= _BV (5);                        // toggle pin 13

} else if (intSense == 2 && intState) {   // if FALLING mode and previously stable high)
PINB |= _BV (5);                        // toggle pin 13

} else if (intSense == 3 && !intState) {  // if RISING mode and previously stable low)
PINB |= _BV (5);                        // toggle pin 13
}
TCCR2B = clockSelect;                     // start timer clock with required prescaler
TCNT2 = 0;                                // reset timer counter
EIMSK &= notIntNum;                       // disable intPin interrupt
EIFR = intNum;                            // reset pending intPin interrupt
}

void stabilizerInit() {
const float clockResolution = 1000000.0 / F_CPU;
unsigned long timerCycles, prescaledCycles;
word prescaler;

intNum = digitalPinToInterrupt(intPin) + 1; // get interrupt mask
notIntNum = ~intNum;
intSense = (EICRA >> (intNum - 1) * 2) & 3; // get interrupt mode
stableWidth = constrain(stableWidth, 2, 1000000); // 2-1000000µs
timerCycles = (stableWidth / clockResolution) - 1;
TCCR2A = 0;
TCCR2B = 0;
TCNT2  = 0; // reset counter
extendedCounter = 0; // reset extended counter
TCCR2A |= (1 << WGM21) | (1 << COM2A0); // CTC mode | toggle OC2A on compare match
if (timerCycles < 2048) { // 1-128µs, 0.5µs resolution
TCCR2B |= (0 << CS22) | (1 << CS21) | (0 << CS20);
clockSelect = 2;
prescaler = 8;
prescaledCycles = timerCycles / prescaler;
OCR2A = prescaledCycles;
} else if (timerCycles < 16384) { // 129-1024µs, 4µs resolution
TCCR2B |= (1 << CS22) | (0 << CS21) | (0 << CS20);
clockSelect = 4;
prescaler = 64;
prescaledCycles = timerCycles / prescaler;
OCR2A = prescaledCycles;
} else if (timerCycles < 65536) { // 1025-4096µs, 16µs resolution
TCCR2B |= (1 << CS22) | (1 << CS21) | (0 << CS20);
clockSelect = 6;
prescaler = 256;
prescaledCycles = timerCycles / prescaler;
OCR2A = prescaledCycles;
} else if (timerCycles < 262144) { // 4097-16384µs, 64µs resolution
TCCR2B |= (1 << CS22) | (1 << CS21) | (1 << CS20);
clockSelect = 7;
prescaler = 1024;
prescaledCycles = timerCycles / prescaler;
OCR2A = prescaledCycles;
} else if (timerCycles < 1048576) {  // 16385-65536µs, 256µs resolution
TCCR2B |= (1 << CS22) | (1 << CS21) | (1 << CS20);
clockSelect = 7;
prescaler = 1024;
prescaledCycles = timerCycles / prescaler;
OCR2A = 3;
extendedCompare = prescaledCycles >> 2;
} else if (timerCycles < 4194304) { // 65537-262144µs, 1024µs resolution
TCCR2B |= (1 << CS22) | (1 << CS21) | (1 << CS20);
clockSelect = 7;
prescaler = 1024;
prescaledCycles = timerCycles / prescaler;
OCR2A = 15;
extendedCompare = prescaledCycles >> 4;
} else { // 262145-1000000µs, 4096µs resolution
TCCR2B |= (1 << CS22) | (1 << CS21) | (1 << CS20);
clockSelect = 7;
prescaler = 1024;
prescaledCycles = timerCycles / prescaler;
OCR2A = 63;
extendedCompare = prescaledCycles >> 6;
}
TIMSK2 |= (1 << OCIE2A); // enable timer compare interrupt
}

#### dlloyd

#48
##### Apr 21, 2016, 12:46 amLast Edit: Apr 22, 2016, 07:46 pm by dlloyd
Analog signal connected to input test: PWM (490.5 Hz) with 50%  duty, RC filter = 1K/0.1µF.
Software set to FALLING mode, 400 µs stableWidth.

Note - can use: stableWidth (µs) = 200,000 / 490

Note: the trigger level on the analyzer does not match the input pin trigger level.

Input zoomed in on each edge to reveal transients:

Output pin 13 zoomed:

#### dlloyd

#49
##### Apr 28, 2016, 03:32 am
This is an attempt to see what the top end input frequency could be for debouncing CHANGE mode interrupts.

In the previous code, I focused more on expanding the range of the 8-bit timer, providing automatic pin and mode detection and on providing debouncing for all modes. The maximum input frequency was 25kHz with 3.6µs latency.

To find the top end frequency, I've stripped out all conditional logic and bit shifting. Discovered an improved way to work with the timer - starting and stopping the clock rather than enabling and disabling the timer2 compare match interrupt.

Clean signal for testing highest input frequency and measuring latency:

Input signal with 22 transitions per cycle having "bouncing" on leading and trailing edge of signal:

Input signal with 34 transitions per cycle having "bouncing" on leading and trailing edge and also during high and low states of the signal:

This exceeded my expectations ... 53kHz input frequency with about 3.2µs latency. Incredibly messy signal completely recovered!

Note: timer0 interrupt was disabled. When enabled, could still get 53kHz with the odd dropout of a pulse, or around 42kHz without any dropout when the timer0 interrupt fires.

Pattern Generator:
Code: [Select]
#include <SPI.h>
//byte pattern[] = {B01010000, B00000010, B10010110, B10111111, B11110101, B11111111, B11110101, B01010101, B01000000, B00000000}; // 34 transitions
//byte pattern[] = {B00000000, B00000010, B10010110, B10111111, B11111111, B11111111, B11111111, B01010101, B01000000, B00000000}; // 22 transitions
byte pattern[] = {B00000000, B00000000, B11111111, B11111111, B11111111, B11111111, B11111111, B00000000, B00000000, B00000000};   // 2 transitions

void setup() {
SPI.begin();
SPI.setClockDivider(SPI_CLOCK_DIV2);
SPI.setDataMode(SPI_MODE1);
}

void loop() {
for (int i = 0; i < 10; i++) {
SPI.transfer(pattern[i]);
}
}

Debouncer Code:
Code: [Select]
const byte intPin = 2;
byte stableWidth = 3;  // 2-128µs interval

void setup()
{
pinMode(intPin, INPUT_PULLUP);
pinMode (LED_BUILTIN, OUTPUT);
attachInterrupt(digitalPinToInterrupt(intPin), inputPin_ISR, CHANGE);
stabilizerInit();
}

void loop()
{
}

ISR(TIMER2_COMPA_vect)
{
TCCR2B = 0;        // stop timer counter
TCNT2 = 0;         // clear timer counter
EIFR = 1;          // clear pending inputPin interrupt
EIMSK |= 1;        // enable inputPin interrupt
}

void inputPin_ISR()
{
PINB |= _BV (5);   // toggle pin 13
// required code
TCCR2B = 2;        // start timer counter with prescaler = 8
TCNT2 = 0;         // clear timer counter
EIMSK &= 0;        // disable inputPin interrupt
}

void stabilizerInit() {
const float clockResolution = 1000000.0 / F_CPU;
unsigned long timerCycles, prescaledCycles;
byte prescaler;
TIMSK0 = 0; // turn off timer0 (optional)
stableWidth = constrain(stableWidth, 2, 128);
timerCycles = (stableWidth / clockResolution) - 1;
TCCR2A = 0;
TCCR2B = 0;
TCNT2  = 0; // reset counter
TCCR2A |= (1 << WGM21); // turn on CTC mode
TCCR2B |= (0 << CS22) | (1 << CS21) | (0 << CS20);
prescaler = 8;
prescaledCycles = timerCycles / prescaler;
OCR2A = prescaledCycles;
TIMSK2 |= (1 << OCIE2A); // enable timer compare interrupt
}

#### dlloyd

#50
##### Apr 29, 2016, 12:27 amLast Edit: Apr 29, 2016, 12:32 am by dlloyd
Code and waveforms for post 47 have been updated.

Updated performance: Up to 38kHz external interrupt signal with severe noise can be fully recovered. Works for all modes (CHANGE, FALLING, RISING) and INT0 or INT1. Only 3.6µs latency. Debouncing done in hardware (uses timer2) and ISRs, main loop is empty.

To test, use stableWidth = 200000/Maximum Input Hz (µs)

Go Up