#include <Arduino.h>
/************************************************************************/
/*                                                                      */
/*                      Reading rotary encoder                          */
/*                      one, two and four step encoders supported       */
/*                                                                      */
/*              Author: Peter Dannegger                                 */
/*              target: ATmega16                                        */
/************************************************************************/
#include <stdint.h>
#include <avr/io.h>
#include <avr/interrupt.h>

//#define XTAL        8e6         // 8MHz

#define F_TIMER1        100          // Timer 1 frequency /Hz

////////////////////////////////////////////////////////////////////////////////
// Tastenentprellung
//
#define KEY_DDR   DDRC
#define KEY_PORT  PORTC
#define KEY_PIN   PINC

#define KEY1      1     

#define ALL_KEYS  0xFF
#define REPEAT_MASK     ( 1<<KEY1 | 1<<H_ENCODER_B ) // repeat: key1, key2
#define REPEAT_START    50                  // after 500ms
#define REPEAT_NEXT     20                  // every 200ms

////////////////////////////////////////////////////////////////////////////////
// Hand-Encoder
//
#define H_ENCODER_DDR   DDRC
#define H_ENCODER_PORT PORTC
#define H_ENCODER_PIN   PINC

#define H_ENCODER_TASTER ( 1<<PC0 ) // Hand-Encoder Taster
#define H_ENCODER_B      ( 1<<PC2 ) // Hand-Encoder Spur_B
#define H_ENCODER_A      ( 1<<PC4 ) // Hand-Encoder Spur_A

#define ES_DREHEN_DDR    DDRC
#define ES_DREHEN_PORT  PORTC
#define ES DREHEN_PIN    PINC
#define ES_DREHEN     ( 1<<PC6 ) // Endschalter drehen

////////////////////////////////////////////////////////////////////////////////
// LED-PORT
//
#define LEDS_DDR   DDRF
#define LEDS      PORTF   // LEDs against VCC

////////////////////////////////////////////////////////////////////////////////
// Schrittmotortreiber
//
#define SM_RICHTUNG_DDR    DDRK
#define SM_RICHTUNG_PORT  PORTK
#define SM_RICHTUNG_PIN    PINK
#define SM_RICHTUNG     ( 1<<PK0 ) // 62
#define SM_DREHEN_STOP  ( 1<<PK1 ) // Schrittmotor Drehen stoppen 

#define SM_TAKT_DDR        DDRE
#define SM_TAKT         ( 1<<PE3 )  // 5 OC3A-Pin 

#define SM_MIN  25000               // Schrittmotor Minimumwert 
#define SM_MAX    285               // Schrittmotor Maximumwert

////////////////////////////////////////////////////////////////////////////////
// Tastenentprellung
//
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

////////////////////////////////////////////////////////////////////////////////
// Hand-Encoder
//
volatile int8_t h_encoder_delta;
static  uint8_t h_encoder_alt; 
        int32_t taktgeber_wert;
         int8_t h_encoder_wert; 
        uint8_t flagregister;    // Verschiedene Flags      
////////////////////////////////////////////////////////////////////////////////
// Vorwaertsdeklarationen
//
void    h_encoder_init( void );             // Hand-Encoder initialisieren
void    taktgeber_init( void );    // Rechteckgenerator mit OCR3A
int8_t  h_encode_read( uint8_t klicks );    // Hand-Encoder
void    tasterentprellen_init ( void );     // Tastenentprellen initialisieren
uint8_t get_key_press( uint8_t key_mask );  // Tastergedrueckt Flanke auswerten
uint8_t get_key_short( uint8_t key_mask );  // Endschalter geoeffnet Flanke
uint8_t get_key_state( uint8_t key_mask );  // Endschalter entprellt

////////////////////////////////////////////////////////////////////////////////
// void setup()
//
void setup() 
{
  Serial.begin( 9600 );
  
  LEDS_DDR        = 0xFF;               // LED-Port komplett als Ausgang
  
    
  H_ENCODER_PORT  |=  H_ENCODER_TASTER; // Hand-Encoder-Taster PULL-UP aktivieren

  SM_RICHTUNG_DDR  = 0x00;              //
  SM_RICHTUNG_PORT = 0x00;              //
  SM_RICHTUNG_DDR |=  SM_RICHTUNG;      // Schrittmotor Richtung Ausgang
  SM_RICHTUNG_DDR |=  SM_DREHEN_STOP;   // Schrittmotor Drehen stoppen als Ausgang
  
  ES_DREHEN_DDR    = 0x00;              // PORT zunaechst komplett auf..
  ES_DREHEN_PORT   = 0x00;              // ..hochohmige Eingaenge schalten
  ES_DREHEN_DDR   &= ~ES_DREHEN;        // Endschalter  Drehen als Eingang
  ES_DREHEN_PORT  |=  ES_DREHEN;        // Endschalter  Drehen PULL-UP aktivieren
  
  taktgeber_wert  = SM_MIN;    // Startfrequenz bzw. Drehzahl f. Schrittmotor
  flagregister    = 0x00;      // Alle Flaggen loeschen

  h_encoder_init( );          // Hand-Encoder initialisieren
  taktgeber_init( );  // Rechtecksignal an OCR3A bzw. PE3 ausgeben
  tasterentprellen_init ( );  // Tastenentprellen initialisieren
} // Ende void setup() 

//------------------------------------------------------------------------------
// 
// void loop()
//
//------------------------------------------------------------------------------
void loop() 
{ 
  // Wenn Hand-Encoder-Taster, dann Drehrichtung aendern
  if( get_key_press( H_ENCODER_TASTER )) SM_RICHTUNG_PORT ^= SM_RICHTUNG;
  
  // Wenn Endschalter-Drehen, dann Schrittmotor freilauf  
  if( get_key_short( ES_DREHEN )) SM_RICHTUNG_PORT |= SM_DREHEN_STOP; 

  // Wenn Schrittmotor im Freilauf und Hand-Encoder-Taster, dann Schrittmotor andere Richtung
  if( SM_RICHTUNG_PORT & SM_DREHEN_STOP ) {
    if(( flagregister & SM_RICHTUNG ) != ( SM_RICHTUNG_PORT & SM_RICHTUNG )) {
    OCR3A = SM_MIN;                      // Schrittmotor mit minimaler Geschwindigkeit
    SM_RICHTUNG_PORT &= ~SM_DREHEN_STOP; // Schrittmotor Drehen Freigeben
    flagregister     ^=  SM_RICHTUNG;    // Flag Richtung gleich Schrittmotorrichtung setzen
    }
  }

  int8_t betrag;                            // +/- 1
   
  betrag = h_encode_read(4);                // 4 Signalaenderungen pro Rastung
  if( betrag != 0 ) {                       // Hand-Encoder gedreht?
    taktgeber_wert += betrag * 250;         // Wert aktualisieren
    if( taktgeber_wert  >  SM_MIN ) taktgeber_wert = SM_MIN; 
    if( taktgeber_wert <=  SM_MAX ) taktgeber_wert = SM_MAX; 
    OCR3A = taktgeber_wert;                 // An Taktgeber Wert Uebergeben
  }  
  LEDS = taktgeber_wert;                    // Nur untere 8-Bit
} // Ende void loop()

////////////////////////////////////////////////////////////////////////////////
// Interrupt Service Routine Timer1 Output Compare Match A
// Hand-encoder auswerten und Tastenentprellung
ISR( TIMER1_COMPA_vect ) {           // 1ms for manual movement
  int8_t neu, diff, tmp;

  tmp = H_ENCODER_PIN;
  neu = 0;
  if ( tmp & H_ENCODER_A ) neu  = 3;
  if ( tmp & H_ENCODER_B ) neu ^= 1;    // convert gray to binary
  diff = h_encoder_alt - neu;           // difference last - new
  if( diff & 1 ) {                      // bit 0 = value (1)
    h_encoder_alt    = neu;             // store new as next last
    h_encoder_delta += (diff & 2) - 1;  // bit 1 = direction (+/-)
  }
////////////////////////////////////////////////////////////////////////////////
// Tastenentprellung
//  
  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;
  }
} // Ende ISR( TIMER1_COMPA_vect )

////////////////////////////////////////////////////////////////////////////////
// Zaehler an Hand-Encoder-Typ anpassen ( Rueckgabewert 0, 1 oder -1 )
// read 1, 2, or 4 step encoders
int8_t h_encode_read( uint8_t klicks )  { 
  
  // atomic access to enc_delta
  cli( );
  h_encoder_wert = h_encoder_delta;

  switch( klicks ) {
    case  2: h_encoder_delta = h_encoder_wert & 1; h_encoder_wert >>= 1; break;
    case  4: h_encoder_delta = h_encoder_wert & 3; h_encoder_wert >>= 2; break;
    default: h_encoder_delta = 0; break;
  }
  sei( );
  return h_encoder_wert;                   // counts since last call
}
////////////////////////////////////////////////////////////////////////////////
// Hand-Encoder mit Timer1 Output Compare A initialisieren
//
void h_encoder_init( void ) {
  int8_t neu, tmp;

  // init encoder
  tmp = H_ENCODER_PIN;
  neu = 0;
  if( tmp & H_ENCODER_A ) neu  = 3;
  if( tmp & H_ENCODER_B ) neu ^= 1; // convert gray to binary
  h_encoder_alt = neu;              // power on state
  h_encoder_delta = 0;

  // interne Pull Ups einschalten
  H_ENCODER_DDR  &= ~(H_ENCODER_A | H_ENCODER_B);
  H_ENCODER_PORT |=  (H_ENCODER_A | H_ENCODER_B);  
  
  // Timer 1, CTC mode 4, prescaler  64
  TCCR1A  = 0;
  TCCR1B  = (1<<WGM12) | (1<<CS11) | (1<<CS10);
  TIMSK1 |= (1<<OCIE1A);
  OCR1A   = (F_CPU / (256L * F_TIMER1))-1;
}
////////////////////////////////////////////////////////////////////////////////
// Taktgeber initialisieren mit Timer3 Mode 4 CTC mit OCR3A als TOP 
//
void taktgeber_init ( void )  {
  TCCR3A  = 0b01<< COM3A0;                 // OC3A Toggeln
  TCCR3B  = 0b01<< WGM32 | 0b010<< CS30;   // Mode 4 & Vorteiler = 8
  SM_TAKT_DDR |= SM_TAKT;                  // Schrittmotor-Takt als Ausgang konfigurieren
  OCR3A  = SM_MIN;                       // OCR3A bestimmt die Frequenz

Serial.print  ( "OCR3A init = "  );
Serial.println(  OCR3A           );
     
}
////////////////////////////////////////////////////////////////////////////////
// Tastenentprellung initialisiern mit Timer1 Mode 4 CTC mit OCR1A als TOP 
//
void tasterentprellen_init ( void ) {
  // put your setup code here, to run once:
  // Timer 1, CTC mode 4, prescaler  64
  TCCR1A  = 0;
  TCCR1B  = (1<<WGM12) | (1<<CS11) | (1<<CS10);
  TIMSK1 |= (1<<OCIE1A);
  OCR1A   = (F_CPU / (256L * F_TIMER1))-1;
 
  KEY_PORT |= ALL_KEYS;   // Intern PULL-UP aktivieren
}
/////////////////////////////////////////////////////////////////////////
//
// 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( );
  return key_mask;
}
///////////////////////////////////////////////////////////////////
//
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 );
}
///////////////////////////////////////////////////////////////////
//
// check if a key is pressed right now
//
uint8_t get_key_state( uint8_t key_mask ) {
  key_mask &= key_state;
  return key_mask;
}