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

#include <io.h>
#include <interrupt.h>
#include <signal.h>

typedef unsigned char	u8;
typedef signed short	s16;

#define	XTAL		1e6		// 1MHz

#define KEY_PIN		PINB
#define KEY0		0
#define KEY1		1
#define KEY2		2

#define LED_DDR		DDRA
#define LED_PORT	PORTA
#define LED0		0
#define LED1		1
#define LED2		2

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


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

u8 key_rpt;				// key long press and repeat


SIGNAL (SIG_OVERFLOW0)			// every 10ms
{
  static u8 ct0, ct1, rpt;
  u8 i;

  TCNT0 = (u8)(s16)-(XTAL / 1024 * 10e-3 + 0.5);	// preload for 10ms

  i = key_state ^ ~KEY_PIN;		// key changed ?
  ct0 = ~( ct0 & i );			// reset or count ct0
  ct1 = ct0 ^ (ct1 & i);		// reset or count ct1
  i &= ct0 & ct1;			// count until roll over ?
  key_state ^= i;			// then toggle debounced state
  key_press |= key_state & i;		// 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 )
{
  cli();					// read and clear atomic !
  key_mask &= key_press;                        // read key(s)
  key_press ^= key_mask;                        // clear key(s)
  sei();
  return key_mask;
}


u8 get_key_rpt( u8 key_mask )
{
  cli();					// read and clear atomic !
  key_mask &= key_rpt;                        	// read key(s)
  key_rpt ^= key_mask;                        	// clear key(s)
  sei();
  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 )
{
  TCCR0 = 1<<CS02^1<<CS00;			// divide by 1024
  TIMSK = 1<<TOIE0;				// enable timer interrupt

  LED_PORT = 0xFF;
  LED_DDR = 0xFF;
  sei();

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

    if( get_key_press( 1<<KEY0 ))
      LED_PORT ^= 1<<LED0;

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

    if( get_key_short( 1<<KEY1 ))
      LED_PORT ^= 1<<LED1;

    if( get_key_long( 1<<KEY1 ))
      LED_PORT ^= 1<<LED2;

			// single press and repeat

    if( get_key_press( 1<<KEY2 ) || get_key_rpt( 1<<KEY2 )){
      u8 i = LED_PORT;

      i = (i & 0x07) | ((i << 1) & 0xF0);
      if( i < 0xF0 )
        i |= 0x08;
      LED_PORT = i;      
    }
  }
}