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

//#define XTAL        8e6         // 8MHz

#define F_TIMER1        100          // Timer 1 frequency /Hz

#define H_ENCODER_PIN   PINC
#define H_ENCODER_PORT PORTC
#define H_ENCODER_DDR   DDRC
#define H_ENCODER_A   ( 1<<PC2 )
#define H_ENCODER_B   ( 1<<PC4 )

#define LEDS_DDR     DDRF
#define LEDS        PORTF   // LEDs against VCC

volatile int8_t h_encoder_delta;
static  uint8_t h_encoder_alt; 
        int32_t rechteckgenerator_wert;
         int8_t h_encoder_wert; 
              
void   rechteckgenerator_init ( void ); // Rechteckgenerator mit OCR3A
int8_t h_encode_read( uint8_t klicks ); // Hand-Encoder
void   h_encoder_init( void );           // Hand-Encoder initialisieren

////////////////////////////////////////////////////////////////////////////////
// void setup()
//
void setup() 
{
  Serial.begin( 9600 );
  LEDS_DDR = 0xFF;            // LED-Port komplett als Ausgang
  h_encoder_init();            // Hand-Encoder initialisieren
  rechteckgenerator_init( );  //Rechtecksignal an OCR3A bzw. PE3 ausgeben
} // Ende void setup() 

////////////////////////////////////////////////////////////////////////////////
// 
// void loop()
//
////////////////////////////////////////////////////////////////////////////////
void loop() 
{  
  int8_t betrag;                      // +/- 1
   
  betrag = encode_read(4);            // 4 Signalaenderungen pro Rastung
  if( betrag != 0 ) {                 // Hand-Encoder gedreht?
    rechteckgenerator_wert += betrag * 100; // Wert aktualisieren
    if( rechteckgenerator_wert > 65535 ) rechteckgenerator_wert = 65535; 
    if( rechteckgenerator_wert <     0 ) rechteckgenerator_wert =     0; 
    OCR3A = 10000;  //rechteckgenerator_wert; // An Rechteckgenerator Wert Uebergeben
    
//Serial.println( );
//Serial.print  ( "betrag = "  );
//Serial.println(  betrag      );
Serial.print  ( "OCR3A      = "  );
Serial.println(  OCR3A           );
Serial.println( );

  }  
  LEDS = rechteckgenerator_wert;
} // Ende void loop()

////////////////////////////////////////////////////////////////////////////////
// Interrupt Service Routine Timer1 Output Compare Match A
// Hand-encoder auswerten
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 (+/-)
  }
} // Ende ISR( TIMER1_COMPA_vect )
////////////////////////////////////////////////////////////////////////////////
// Timer3 Mode 4 CTC mit OCR3A als TOP ohne Vorteilung initialisieren
//
void rechteckgenerator_init ( void )  {
  OCR3A  = 10000;                         // OCR3A bestimmt die Frequenz
         
Serial.print  ( "OCR3A init = "  );
Serial.println(  OCR3A              );
   
  TCCR3A  = 0b01<< COM3A0;                 // OC3A Toggeln
  TCCR3B  = 0b01<< WGM12 | 0b001<< CS10;   // Mode 4 & Vorteiler = 1
    DDRE |= 1<<3;                          // OC3A-Pin als Ausgang konfigurieren
}
////////////////////////////////////////////////////////////////////////////////
// Zaehler an Hand-Encoder-Typ anpassen
// read 1, 2, or 4 step encoders
int8_t 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 und 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);
  OCR1A   = (F_CPU / (256L * F_TIMER1))-1;
  TIMSK1 |= (1<<OCIE1A);
}