#include <Arduino.h>

#include <stdint.h>
#include <avr/interrupt.h>

uint8_t get_key_press( uint8_t key_mask );
uint8_t get_key_rpt( uint8_t key_mask );
uint8_t get_key_state( uint8_t key_mask );
uint8_t get_key_short( uint8_t key_mask );
uint8_t get_key_long( uint8_t key_mask );
void init_entprell(void);

#define KEY_DDR         DDRB
#define KEY_PORT        PORTB
#define KEY_PIN         PINB
#define KEY0            0
#define KEY1            1
#define KEY2            2
#define ALL_KEYS        (1<<KEY0 | 1<<KEY1 | 1<<KEY2)

#define REPEAT_MASK     (1<<KEY1 | 1<<KEY2)       // repeat: key1, key2
#define REPEAT_START    50                        // after 500ms
#define REPEAT_NEXT     20                        // every 200ms
#define F_TIMER1        100                       // Timer 1 frequency /Hz

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

extern volatile uint8_t key_rpt;      // key long press and repeat

#define LED_DDR         DDRC
#define LED_PORT        PORTC
#define LED0            0
#define LED1            1
#define LED2            2

void setup(void) 
{
  LED_PORT  = 0;            // LED outputs
  LED_DDR   = 0xFF;

  init_entprell();
} //Ende setup

void loop(void) 
{
 if ( get_key_short( 1<<KEY0 )) LED_PORT ^= 1<<LED0;   // reaction on key release
  if ( get_key_long( 1<<KEY1 ))  LED_PORT ^= 1<<LED1;   // reaction after REPEAT_START ms

  // single press and repeat, running light
  if( get_key_press( 1<<KEY2 )){                        // reaction on key press
    uint8_t i = LED_PORT;
    i = (i & 0x03) | ((i & ~0x03) << 1);
    if( (i & ~0x03) == 0 ) i |= (1<<LED2);
    LED_PORT = i;
  }     


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

volatile uint8_t key_rpt;       // key long press and repeat

ISR( TIMER1_COMPA_vect ) {                        // every 10ms
  static uint8_t ct0 = 0xFF, ct1 = 0xFF, rpt;
  uint8_t i;

  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;
  }
}

void init_entprell(void) {
  KEY_DDR  &= ~ALL_KEYS;    // configure key port for input
  KEY_PORT |= ALL_KEYS;     // and turn on pull up resistors
  
    // Timer 1, CTC mode 4, prescaler 256  
  TCCR1A  = 0;
  TCCR1B  = (1<<WGM12) | (1<<CS12);
  OCR1A   = (F_CPU / (256L * F_TIMER1))-1;
  TIMSK1 |= (1<<OCIE1A);                   // enable timer interrupt
}

/*
 * check if a key has been pressed. Each pressed key is reported
 * only once
 */

uint8_t get_key_press( uint8_t 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;
}

/*
 * check if a key has been pressed long enough such that the
 * key repeat functionality kicks in. After a small setup delay
 * the key is reported being pressed in subsequent calls
 * to this function. This simulates the user repeatedly
 * pressing and releasing the key.
 */

uint8_t get_key_rpt( uint8_t 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;
}

/*
 * check if a key is pressed right now
 */
 
uint8_t get_key_state( uint8_t key_mask ) {
  key_mask &= key_state;
  return key_mask;
}

/*
 * Get short key press
 */
 
uint8_t get_key_short( uint8_t key_mask ) {
  cli();                    // read key state and key press atomic !
  return get_key_press( ~key_state & key_mask );
  sei();
}

/*
 * Get long key press
 */

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

} //Ende Loop ***