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

#include <stdint.h>
#include <avr/io.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 XTAL  16e6    // 16MHz

#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_A  ( 1<<2 )  // Hand-Encoder Spur B
#define KEY3      3
#define H_ENCODER_SPUR_B  ( 1<<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

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

static   int h_encoder_alt;
volatile char h_encoder_delta;  // -128 ... 127
         int h_encoder_neu;
         int h_encoder_diff;
/////////////////////////////////////////////////////////////////////
//
// setup
//
////////////////////////////////////////////////////////////////////
void setup(void) 
{
  Serial.begin( 9600 );
  LED_PORT  = 0x00;     
  LED_DDR   = 0xFF;  // LED outputs

  init_entprell ( );
  init_h_encoder( );
   
} //Ende setup

/////////////////////////////////////////////////////////////////////
//
// loop
//
////////////////////////////////////////////////////////////////////
void loop(void)
{
  static char h_encoder_delta_neu = 0;
  
  if( h_encoder_delta != h_encoder_delta_neu ) {

//Serial.print  ( "  h_encoder_delta     = "  );
//Serial.println(    h_encoder_delta, DEC     );

    h_encoder_delta_neu = h_encoder_delta;

//Serial.print  ( "  h_encoder_delta_neu = "  );
//Serial.println(    h_encoder_delta_neu, DEC );
//Serial.println( );
    
    byte wert;
    wert += h_encoder_read( 4 );   // 4 Wechsel pro Rastung
    
  //if( key_press )  {
Serial.print  ( "  wert                = " );
Serial.println(    wert, DEC   );

//Serial.print  ( "  h_encoder_alt    = " );
//Serial.println(    h_encoder_alt, BIN   );

//Serial.print  ( "  h_encoder_neu    = " );
//Serial.println(    h_encoder_neu, BIN   );

//Serial.print  ( "  h_encoder_diff   = " );
//Serial.println(    h_encoder_diff, DEC  );

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;
  }
////////////////////////////////////////////////////////////////////////////////
// Hand-Encoder abfragen
//
  int h_encoder_neu, h_encoder_diff, h_encoder_pin;
  
  h_encoder_pin = KEY_PIN;
  h_encoder_neu = 0;
  
  if( h_encoder_pin & H_ENCODER_SPUR_A ) h_encoder_neu  = 3;
  if( h_encoder_pin & H_ENCODER_SPUR_B ) h_encoder_neu ^= 1;
  
  h_encoder_diff = h_encoder_alt - h_encoder_neu;
  
  if( h_encoder_diff & 1)  {
    h_encoder_alt    = h_encoder_neu;
    h_encoder_delta  += ( h_encoder_diff & 2 ) -1;
  }
} // Ende ISR( TIMER1_COMPA_vect )
/////////////////////////////////////////////////////////////
// Hand-Encoder initialisieren
//
void init_h_encoder ( void )
{
  int h_encoder_neu, tmp;
  tmp = KEY_PIN;
  h_encoder_neu = 0;
  if( tmp & H_ENCODER_SPUR_A ) h_encoder_neu  = 3;
  if( tmp & H_ENCODER_SPUR_B ) h_encoder_neu ^= 1;
  h_encoder_alt = h_encoder_neu;
  h_encoder_delta = 0;
}
/////////////////////////////////////////////////////////////
// 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
}
////////////////////////////////////////////////////////////////////////////////
// Hand-Encoder 1,2, oder 4 Signalwechsel pro Rastpunkt
//
byte h_encoder_read( byte wechsel )
{
  byte wert;

  cli( ); // Atomarer Zugriff auf h_encoder_delta
  wert = h_encoder_delta;
  switch( wechsel ) {
    case  2: h_encoder_delta = wert & 1; wert >>= 1; break;
    case  4: h_encoder_delta = wert & 3; wert >>= 2; break;
    default: h_encoder_delta = 0; break;
  }
  sei( );
  return wert;
}

/////////////////////////////////////////////////////////////////////////
//
// 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 );
Serial.println( );
  
  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 ));
}