/************************************************************************/
/*                                                                      */
/*                      Debouncing 8 Keys				*/
/*			Sampling 4 Times				*/
/*			With Repeat Function				*/
/*                                                                      */
/*              Author: Peter Dannegger                                 */
/*                      danni@specs.de                                  */
/*                                                                      */
/************************************************************************/


#include <reg52.h>
#include <stdio.h>
typedef unsigned char	u8;
#define Timer0L 0xCC	 	// 1ms Tick bei 22,118 MHz
#define Timer0H 0xF8		// Dezimal 63692

#define Timer1L 0xFD		// 19200 Baud bei 22,118 MHz
#define Timer1H 0xFD

sbit KEY_PIN=P0^2;
#define KEY0		0
#define KEY1		1
#define KEY2		2

#define REPEAT_MASK	(1<<KEY1^1<<KEY2)	// repeat: key1, key2
#define REPEAT_START	500		// after 500ms
#define REPEAT_NEXT		200		// every 200ms


u8 key_state;				// debounced and inverted key state:
							// bit = 1: key pressed
u8 key_press;				// key press detect

u8 key_rpt;
void timer0() interrupt 1						
{
  static u8 ct0, ct1,rpt;
  u8 j;



  j = key_state ^ ~KEY_PIN;		// key changed ?
  ct0 = ~( ct0 & j );			// reset or count ct0
  ct1 = ct0 ^ (ct1 & j);		// reset or count ct1
  j &= ct0 & ct1;			// count until roll over ?
  key_state ^= j;			// then toggle debounced state
  key_press |= key_state & j;		// 0->1: key press detect

  if( (key_state & REPEAT_MASK) == 0 )	// check repeat function
     rpt = REPEAT_START;		// start delay
  if( --rpt == 0 ){
    rpt = REPEAT_NEXT;			// repeat delay
    key_rpt |= key_state & REPEAT_MASK;
  }

}


u8 get_key_press( u8 key_mask )
{
  TR0=0	;										// Timer anhalten
  key_mask &= key_press;                        // read key(s)
  key_press ^= key_mask;                        // clear key(s)
  TR0=1;										// Timer starten
  return key_mask;
}


u8 get_key_rpt( u8 key_mask )
{
  TR0=0	;										// Timer anhalten
  key_mask &= key_rpt;                        	// read key(s)
  key_rpt ^= key_mask;                        	// clear key(s)
  TR0=1;										// Timer starten
  return key_mask;
}


u8 get_key_short( u8 key_mask )
{
//cli();			// read key state and key press atomic !
  return get_key_press( ~key_state & key_mask );
}


u8 get_key_long( u8 key_mask )
{
  return get_key_press( get_key_rpt( key_mask ));
}






int main( void )
{
	TMOD = 0x21; 				// Timer 1 = 8-Bit-Timer mit Auto-Reload-Modus. 
								// Timer 0 = 16-Bit-Timer. 

 	TL1 = Timer1L;  			// 19200 Baud bei 22,118 MHz
 	TH1 = Timer1H;  			// Nachladewert fuer TL1 
 	TR1 = 1;     				// Timer 1 starten       
 	SCON = 0x52; 				// Freigabe von Sender und Empfaenger; Betriebsart: Modus 1
  
 	TL0 = Timer0L;				// Startwert für Timer0 0x7000
 	TH0 = Timer0H;				// dezimal 28672 => Interrupt alle 20ms
 	ET0 = 1;					// Timer0 Interrupt einschalten
 	EA  = 1;					// Interrupt einschalten
 	TR0 = 1;						// Timer 0 starten

 
  for(;;){					// main loop
			// single press

if( get_key_press( 1<<KEY0 ))
      printf("Taste gedrueckt\n");

			// release after short press: task 1
			// long press: task 2

    if( get_key_short( 1<<KEY1 ))
	      printf("KURZ\n");

    if( get_key_long( 1<<KEY1 ))
      printf("LANG\n");

			// single press and repeat

    if( get_key_press( 1<<KEY2 ) || get_key_rpt( 1<<KEY2 )){
 		printf("wiederholung\n");   
    }

 
  }
}