#include <Arduino.h>
/************************************************************************/
/*                                                                      */
/*                      Debouncing 8 Keys                               */
/*                      Sampling 4 Times                                */
/*                      With Repeat Function                            */
/*                                                                      */
/*              Author: Peter Dannegger                                 */
/*                      danni@specs.de                                  */
/*                                                                      */
/************************************************************************/

#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   DDRC
#define KEY_PORT  PORTC
#define KEY_PIN   PINC

#define H_ENCODER_TASTER 0  // Hand-Encoder Taster
#define KEY1      1     
#define H_ENCODER_SPUR_B 2  // Hand-Encoder Spur B

#define KEY3      3
#define H_ENCODER_SPUR_A 4  // Hand-Encoder Spur A
#define KEY5      5
#define KEY6      6
#define KEY7      7

#define ALL_KEYS  0xFF

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

#define H_ENCODER_MSK   0b00111100  // Hand-Encoder-Maske f. dass Linksschieben

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         DDRF
#define LED_PORT        PORTF
#define LED0            0
#define LED1            1
#define LED2            2
#define LED3            3
#define LED4            4
#define LED5            5
#define LED6            6
#define LED7            7

/////////////////////////////////////////////////////////////////////
//
// setup
//
////////////////////////////////////////////////////////////////////
void setup(void) 
{
  Serial.begin( 9600 );
  LED_PORT  = 0x00;     
  LED_DDR   = 0xFF;  // LED outputs

  init_entprell();
  
} //Ende setup

/////////////////////////////////////////////////////////////////////
//
// loop
//
////////////////////////////////////////////////////////////////////
    
    
void loop(void)
{
  if( key_press )  { 
    static byte tmp;
    tmp = ( H_ENCODER_MSK ) & ( key_press );
    

  Serial.println( );
  Serial.println( );
  Serial.println( );
  Serial.print  ( "key_press       = "   );
  Serial.println(  key_press,    BIN   );


    byte temp = tmp;       // Dient dazu tmp..
    tmp = (temp<<1) | (temp>>7);    //..einmal links zu schieben
 
  //Serial.println( );
  Serial.print  ( "tmp             = "   );
  Serial.println(  tmp,    BIN           );

      if( tmp & (1<<6) ) {
        
  Serial.println( );
  Serial.print  ( "Rechts          = "    );
  Serial.println( tmp, BIN );
  Serial.println( );
      
      tmp = 0;
      }
      if( tmp & (1<<4) )  {
        
  Serial.println( );
  Serial.print  ( "Links           = "    );
  Serial.println( tmp, BIN );
  Serial.println( );

      tmp = 0;
      }
      get_key_press ( key_press );  // key_press loeschen
  }  

} //Ende Loop ***

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

/////////////////////////////////////////////////////////////
// Entprellen initialisieren
//
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 64 
  TCCR1A  = 0;
  TCCR1B  = (1<<WGM12) | (1<<CS11) | (1<<CS10);
  OCR1A   = (F_CPU / (256L * F_TIMER1))-1;
  TIMSK1 |= (1<<OCIE1A);                   // enable timer interrupt
}

/////////////////////////////////////////////////////////////////////////
//
// Alle moeglichen Tastenbetaetigungen abfragen
//
//////////////////////////////////////////////////////////////////////
// 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();

Serial.print  ( "get_key_press   = " );
Serial.println(      key_mask, BIN );
  
  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)
  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 ));
}