AVR Freaks

I note that neither you nor OP has embraced my "horizontal counters". Twisted Evil

Hey, Lee! I was really serious when I said that a link to the "button debounce shootout thread" would make a great contribution to this thread. And jokes/teasing aside, I think you will find it much faster than I could..

IOSCAN:   ; GET AND DEBOUNCE STATE OF PORT C SWITCHES (6)
   MOV   TMPB,PCX2   ; GET 3x PENDING CHANGES
   MOV   PCX2,PCX1   ; GET 2x PENDING CHANGES
   IN   PCX1,PINC   ; GET ACTUAL PORT C INPUTS
   LDI   TMPC, PCMASK   ; LOAD THE INVERT MASK--ACTIVE LOW
   EOR   PCX1,TMPC   ; INVERT SELECTED INPUTS
   EOR   PCX1,PCS   ; GET CHANGES ONLY
   AND   TMPB,PCX1   ; AND 3X WITH 1X
   AND   TMPB,PCX2   ; AND RESULT WITH 2X
   EOR   PCS,TMPB   ; MAKE 3X CHANGES
   EOR   PCX1,TMPB   ; REMOVE 3X CHANGES FROM PENDING
   EOR   PCX2,TMPB   ; REMOVE 3X CHANGES
   AND   TMPB,PCS   ; GET ON STATE CHANGES ONLY
   OR   PCE,TMPB   ; SET ACTIVE EDGE TRIGGERS 

unsigned int				key_debounce		(unsigned int switches)
{
unsigned int	work;
unsigned int	prev;	// calculate the falling edges

	prev = key_current;			// save for calculating falling edges

	work = key_bounce3;			// move prior states closer to validated
	key_bounce3 = key_bounce2;
	key_bounce2 = key_bounce1;
	key_bounce1 = switches;		// get the new strobe data

	key_bounce1 ^= key_current;	// only concerned with changes from current
	work &= key_bounce1;		// make sure there are no bounces
	work &= key_bounce2;
	work &= key_bounce3;
	key_current ^= work;		// make validated changes to current
	key_bounce1 ^= work;		//  and remove from pending stages
	key_bounce2 ^= work;
	key_bounce3 ^= work;

	key_edge = work & key_current;		// only want "on" transitions
									// Note that edges are NOT saved from one
									// call of this routine to the next --
									// "Use it or lose it."  [Change "=" to "|="
									// to save the edges until explicitly cleared.]
    service_needed_key = (key_edge != 0);	// set the new keypress flag

// Calculate the falling edges.  These will be bits that changed to 0 from the "prev"
//	pass of affirmed 1 bits in key_current, to the current pass.
	key_falling = (key_current ^ prev) & prev;

	return (key_edge);			// new debounced edges are 1 bits
}

// **************************************************************************
// *
// *		S I G N A L _ D E B O U N C E
// *
// **************************************************************************
//
//	Input a set of up to 8 bit values as "value".
//	Enter the parameter value into a multiple-debounce sequence based on
//	the define NUM_IN_A_ROW, which represents the number of consecutive
//	signal states to signify a new "1" or a new "0".
//
//	Based on the sequence used for debouncing switch inputs.
//
//	1)	Save penultimate value to "work"
//	2)	Promote each value less than penultimate to next higher index
//	3)	First entry receives new "value"
//	4)	Get changes from current, debounced state:
//			first entry ^= ultimate entry
//	5)	Propogate any bounces:  for each entry from first to penultimate,
//			work &= entry
//	6)	Propogate valid changes:  for all entries,
//			entry ^= work
//
//	The ultimate entry is returned as the value.
//
unsigned char				signal_debounce		(unsigned char value,
												unsigned char *table)
{
unsigned char	work;
unsigned char	loop;	// loop counter

// 1)
	work = *(table + (NUM_IN_A_ROW - 1));	// move prior states closer to validated
// 2)
	for (loop = NUM_IN_A_ROW - 1; loop > 0; loop--)
		{
		*(table + loop) = *(table + loop - 1);
		}
// 3)
	*table = value;							// get the new strobe data
// 4)
	*table ^= *(table + NUM_IN_A_ROW);		// only concerned with changes from current
// 5)
											// make sure there are no bounces
	for (loop = 0; loop < NUM_IN_A_ROW; loop++)
		{
		work &= *(table + loop);
		}
// 6)
											// make validated changes to current
	*(table + NUM_IN_A_ROW) ^= work;
											//  and remove from pending stages
	for (loop = 0; loop < NUM_IN_A_ROW; loop++)
		{
		*(table + loop) ^= work;
		}

	return (*(table + NUM_IN_A_ROW));		// return the multi-debounced value
}

// Keypad debouncing
#define	NUM_IN_A_ROW	4					// number of consecutive values to "trip"
unsigned char	inputs[NUM_IN_A_ROW+1];		// input signals


register unsigned char	input_current;				// returned from signal_debounce
unsigned char	input_prev;					// for calculating rising & falling edges
register unsigned char	input_rising;
unsigned char	input_falling;
...
// ***********
// Switches -- every 10 ms.
// ***********
		// Fetch switch state every 10ms.
		input_prev = input_current;	// for calculating edges

		scratch = key_fetch();		// strobe and process switch inputs
		input_current = signal_debounce(scratch, inputs);		//  and create edge triggers & current state

// Rising & falling edges
//
// Note:  no edges.  If needed:
//	Rising & falling edges = composite_io ^ previous_io;
//	Rising edges = (composite_io ^ previous_io) & composite_io;
//	Falling edges = (composite_io ^ previous_io) & previous_io;
//
//		rising_io = (composite_io ^ previous_io) & composite_io;
//		falling_io = (composite_io ^ previous_io) & previous_io;

		input_rising = (input_current ^ input_prev) & input_current;
		input_falling = (input_current ^ input_prev) & input_prev;

bool KeyPressed( char key )
{
  if ( bit_is_set( PORTD, key ) )   // if key is pressed
  {
    _delay_ms( 35 );   // debounce delay
    if ( bit_is_set( PORTD, key ) )     // if key is still pressed
    {
      return true;    // then we assume key is pressed
    }
  }

  return false;   // key was not pressed
}

   // The current debounced steady state
   // Or, if you like, "which keys ARE pressed right now?"
   // Never write to this variable in your application!
   // This is a state variable for the debouncer.
   // You may read it, though.
   char key_state;

   // The currently pending (i.e. not consumed by your aplication)
   // keys that has transitioned into the pressed steady state.
   // Or, if you like, "Which keys HAVE BEEN pressed?
   // Use this to "detect and consume" key presses, i.e.
   // your main app may both read and write this variable.
   char key_press;  

   // The current state of the I/O pins connected to the switches
   char KEY_INPUT;   

   // Eight two-bit vertical counters, each having it's MSB in
   // ct1, and its LSB in ct0
   char ct1, ct0;

   // A scratchpad variable
   char i;

void ISR(void) 
{ 
  // Determine which pins that at this moment have a state differing 
  // from the debounced steady state.
  // If your switches are "active low" then deal with this right here
  // at the input, by replacing KEY_INPUT with ~KEY_INPUT .
  i = key_state ^ KEY_INPUT;

  // Increment the vertical counter for each pin that differs from the steady state,
  // reset all other vertical counters.
  // These two lines actually implement this increment operation with handling of
  // carry from ct0 to ct1. Read the walkthrough to see this in action!
  ct0 = ~( ct0 & i );
  ct1 = ct0 ^ (ct1 & i);

  // Detect which counters have rolled over - these correspond to the pins that have 
  // seen 4 consecutive
 identical states that are the opposite of the steady state
  i &= ct0 & ct1; 

  // Toggle the steady state of those pins
  key_state ^= i;

  // Mirror the new keys pressed into the variable where the main app can 
  // eventually consume them.
  key_press |= key_state & i;
}

<--for this to be readable the browser must be wide enough for this to show on one line with the arrows-->

Round                                       Statement	                  key_state ct1 ct0   i key_press
=========================================   ============================= ========= === === === =========
Initial values of all variables                                                   0   0   0   0         0
-----------------------------------------
Round 1: Switch open     (KEY_INPUT == 0)   
                                            i = key_state ^ KEY_INPUT;                        0

                                            ct0 = ~( ct0 & i );                           1
                                            ct1 = ct0 ^ (ct1 & i);                    1

                                            i &= ct0 & ct1;                                   0

                                            key_state ^= i;                       0

                                            key_press |= key_state & i;                                 0
-----------------------------------------
Round 2: Switch closed   (KEY_INPUT == 1)   
                                            i = key_state ^ KEY_INPUT;                        1

                                            ct0 = ~( ct0 & i );                           0
                                            ct1 = ct0 ^ (ct1 & i);                    1

                                            i &= ct0 & ct1;                                   0

                                            key_state ^= i;                       0

                                            key_press |= key_state & i;                                 0


-----------------------------------------
Round 3: Switch "bounces open" (KEY_INPUT == 0)
                                            i = key_state ^ KEY_INPUT;                        0

                                            ct0 = ~( ct0 & i );                           1
                                            ct1 = ct0 ^ (ct1 & i);                    1

                                            i &= ct0 & ct1;                                   0

                                            key_state ^= i;                       0

                                            key_press |= key_state & i;                                 0

-----------------------------------------
Round 4: Switch bounces back to closed (KEY_INPUT == 1)  
                                            i = key_state ^ KEY_INPUT;                        1

                                            ct0 = ~( ct0 & i );                           0
                                            ct1 = ct0 ^ (ct1 & i);                    1

                                            i &= ct0 & ct1;                                   0

                                            key_state ^= i;                       0

                                            key_press |= key_state & i;                                 0

-----------------------------------------
Round 5: Switch stays closed (KEY_INPUT == 1)
                                            i = key_state ^ KEY_INPUT;                        1

                                            ct0 = ~( ct0 & i );                           1
                                            ct1 = ct0 ^ (ct1 & i);                    0

                                            i &= ct0 & ct1;                                   0

                                            key_state ^= i;                       0

                                            key_press |= key_state & i;                                 0

-----------------------------------------
Round 6: Switch still closed (KEY_INPUT == 1)
                                            i = key_state ^ KEY_INPUT;                        1

                                            ct0 = ~( ct0 & i );                           0
                                            ct1 = ct0 ^ (ct1 & i);                    0

                                            i &= ct0 & ct1;                                   0

                                            key_state ^= i;                       0

                                            key_press |= key_state & i;                                 0

-----------------------------------------
Round 7:  Switch still closed (KEY_INPUT == 1)
                                            i = key_state ^ KEY_INPUT;                        1

                                            ct0 = ~( ct0 & i );                           1
                                            ct1 = ct0 ^ (ct1 & i);                    1

     A NEW STEADY STATE! >>>                i &= ct0 & ct1;                                   1

                                            key_state ^= i;                       1

                                            key_press |= key_state & i;                                 1

Am I close?

you need four 8-bit byte entries in the array

For the same four-identical-samples requirement Peter needs two bytes.

Though I did`t notice any line in the code which initializes ct0 and ct1 as ones.

It always amazes me how everyone here are so willing to help and with such extent

I think Peter only need three in a row so there are two intermediate states so it is the same.

i = key_state ^ KEY_INPUT; 
// i is now set if the sample differs from the steady state
.
.
i &= ct0 & ct1;
// i is now set if we've seen four identical samples that differ from the steady state (N.b. the &=)

Can't even debounce his own signature...

C:\c[i386_vc]>cl sim.c
Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 15.00.30729.01 for 80x86
Copyright (C) Microsoft Corporation.  All rights reserved.

sim.c
sim.c(18) : error C2057: expected constant expression
sim.c(18) : error C2466: cannot allocate an array of constant size 0
sim.c(53) : error C2275: 'uint8_t' : illegal use of this type as an expression
        sim.c(7) : see declaration of 'uint8_t'
sim.c(53) : error C2146: syntax error : missing ';' before identifier 'lsb'
sim.c(53) : error C2065: 'lsb' : undeclared identifier
sim.c(54) : error C2065: 'lsb' : undeclared identifier
sim.c(61) : error C2143: syntax error : missing ';' before 'type'
sim.c(62) : error C2065: 'i' : undeclared identifier
sim.c(62) : error C2065: 'i' : undeclared identifier
sim.c(64) : error C2065: 'i' : undeclared identifier
sim.c(65) : error C2065: 'i' : undeclared identifier
sim.c(130) : error C2143: syntax error : missing ';' before 'type'
sim.c(130) : error C2143: syntax error : missing ';' before 'type'
sim.c(130) : error C2143: syntax error : missing ')' before 'type'
sim.c(130) : error C2143: syntax error : missing ';' before 'type'
sim.c(130) : error C2065: 'i' : undeclared identifier
sim.c(130) : warning C4552: '<' : operator has no effect; expected operator with side-effect
sim.c(130) : error C2065: 'i' : undeclared identifier
sim.c(130) : error C2059: syntax error : ')'
sim.c(131) : error C2143: syntax error : missing ';' before '{'
sim.c(132) : error C2065: 'i' : undeclared identifier

C:\c[i386_vc]>ren sim.c sim.cpp

C:\c[i386_vc]>cl sim.cpp
Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 15.00.30729.01 for 80x86
Copyright (C) Microsoft Corporation.  All rights reserved.

sim.cpp
Microsoft (R) Incremental Linker Version 9.00.30729.01
Copyright (C) Microsoft Corporation.  All rights reserved.

/out:sim.exe
sim.obj

C:\Danni>dir
 Volume in drive C has no label.
 Volume Serial Number is 3A54-482A

 Directory of C:\Danni

2011-07-29  16:00              .
2011-07-29  16:00              ..
2011-07-29  15:58             3 715 DanniDebouceSimulator.c
               1 File(s)          3 715 bytes
               2 Dir(s)  45 680 943 104 bytes free

C:\Danni>cl DanniDebouceSimulator.c
Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 15.00.30729.01 for 80x86
Copyright (C) Microsoft Corporation.  All rights reserved.

DanniDebouceSimulator.c
Microsoft (R) Incremental Linker Version 9.00.30729.01
Copyright (C) Microsoft Corporation.  All rights reserved.

/out:DanniDebouceSimulator.exe
DanniDebouceSimulator.obj

C:\Danni>DanniDebouceSimulator 0 1 0 1 1 1 1 1

   STATEMENT                               ct1         ct0           i    keyState    keyPress

ROUND 0 with keyInput == 0
   i = keyState ^ keyInput;                                          0
   ct0 = ~( ct0 & i );                                   1
   ct1 = ct0 ^ (ct1 & i);                    1
   i &= ct0 & ct1;                                                   0
   keyState ^= i;                                                                0
   keyPress |= keyState & i;                                                                 0

ROUND 1 with keyInput == 1
   i = keyState ^ keyInput;                                          1
   ct0 = ~( ct0 & i );                                   0
   ct1 = ct0 ^ (ct1 & i);                    1
   i &= ct0 & ct1;                                                   0
   keyState ^= i;                                                                0
   keyPress |= keyState & i;                                                                 0

ROUND 2 with keyInput == 0
   i = keyState ^ keyInput;                                          0
   ct0 = ~( ct0 & i );                                   1
   ct1 = ct0 ^ (ct1 & i);                    1
   i &= ct0 & ct1;                                                   0
   keyState ^= i;                                                                0
   keyPress |= keyState & i;                                                                 0

ROUND 3 with keyInput == 1
   i = keyState ^ keyInput;                                          1
   ct0 = ~( ct0 & i );                                   0
   ct1 = ct0 ^ (ct1 & i);                    1
   i &= ct0 & ct1;                                                   0
   keyState ^= i;                                                                0
   keyPress |= keyState & i;                                                                 0

ROUND 4 with keyInput == 1
   i = keyState ^ keyInput;                                          1
   ct0 = ~( ct0 & i );                                   1
   ct1 = ct0 ^ (ct1 & i);                    0
   i &= ct0 & ct1;                                                   0
   keyState ^= i;                                                                0
   keyPress |= keyState & i;                                                                 0

ROUND 5 with keyInput == 1
   i = keyState ^ keyInput;                                          1
   ct0 = ~( ct0 & i );                                   0
   ct1 = ct0 ^ (ct1 & i);                    0
   i &= ct0 & ct1;                                                   0
   keyState ^= i;                                                                0
   keyPress |= keyState & i;                                                                 0

ROUND 6 with keyInput == 1
   i = keyState ^ keyInput;                                          1
   ct0 = ~( ct0 & i );                                   1
   ct1 = ct0 ^ (ct1 & i);                    1
   i &= ct0 & ct1;                                                   1
   keyState ^= i;                                                                1
   keyPress |= keyState & i;                                                                 1

ROUND 7 with keyInput == 1
   i = keyState ^ keyInput;                                          0
   ct0 = ~( ct0 & i );                                   1
   ct1 = ct0 ^ (ct1 & i);                    1
   i &= ct0 & ct1;                                                   0
   keyState ^= i;                                                                1
   keyPress |= keyState & i;                                                                 1

C:\Danni>

class Debouncer
{
   ...
public:
   Debounce()
   {
      T i;
      i = steadyState ^ GetPinState();
      .
      .
      .
      switchesMade |= steadyState & i;
   }

protected:
   virtual T GetPinState() = 0;

private:
   T steadyState;
   T switchesMade;

   T ct1, ct0;
}

class MyDebouncer : public Debouncer
{
protected:
   uint8_t GetPinState()
   {
      .
      .
      .
   }
}

void main()
{
   MyDebouncer debouncer;


   while (1)
   {
      if (SysTick::Tick())
      {
         debouncer.Debounce();
      }


      if (debouncer.SwitchMade(1)
      {
         .
         .
         .
      }
   }
}

   scheduler.Register(debouncer, 5);
   scheduler.Register(rtc, 1000);

in C++ "interfaces" are completely abstract classes (i.e. no runnable implementation at all, all methods are pure virtual)

you are free to disagree

Since nothing above is an absolute statement of how C++ is defined, but rather my opinions on how it should be used, you are free to disagree.

That's gross!