/*
  IDE 1.8.19
  auf Arduino Mega2560 getestet
  für Arduino Leonardo ATmega32U4
  23.04.2023
  https://www.mikrocontroller.net/topic/553491#7395414
*/

// Auf ATmega32U4 ist PB6 Arduino Pin 10 //
const uint8_t pinPulsOut    {12};   // OC1B bzw. PB6 invertiert
const uint8_t ANZAHLTASTER   {4};
const uint8_t ANZAHLPULSFORM {ANZAHLTASTER+1}; // wegen Default Dummy Pulsform
const bool DEBUG {false};
const bool DEBUGTASTER {true};

const byte pinTaster [ANZAHLTASTER] {2, 3, 4, 5};

struct TasterDaten {
  uint8_t alt {ANZAHLTASTER};   // Default keine Taste gedrückt
  uint8_t neu {ANZAHLTASTER};   // 
};
TasterDaten taster;

struct TimerDaten {
  uint16_t duty      {0};
  uint16_t periode   {0};  
  uint16_t prescaler {0};
};

TimerDaten pulsForm [ANZAHLPULSFORM] {
  {   16,  1600,  1}, //  2us off, 198us on
  {  320,  1600,  1}, // 40us off, 160us on
  {  125, 12500, 64}, //  1ms off,  99ms on
  { 1600,  1600, 64}, //  Signal Low
  {    0,  1600, 64}, //  Dummy, kein Taster gedrückt Signal High
};

enum T1Status {CHECK, ZERO, WAIT, CONFIG, START};
T1Status timerStatus {CHECK};

void setup (void)
{ 
  Serial.begin(250000);
  Serial.println(F("\nuC Reset ####\n"));
  digitalWrite(pinPulsOut, HIGH);       // OC1B bzw. PB6 invertiert
  pinMode(pinPulsOut, OUTPUT); 
  initTimer1(11);                       // Timer-Mode 11
  changeTimer1(pulsForm[ANZAHLTASTER]); // Default, Dummy, kein Taster gedrückt
  startTimer1(pulsForm[ANZAHLTASTER]);  // Default, Dummy, kein Taster gedrückt
  
  for (auto &p: pinTaster) {
    pinMode(p, INPUT_PULLUP); 
  }
}

void loop (void)
{         
  checkActiveButton(pinTaster);
  stateMaschine();
} 

void stateMaschine (void)
{
  switch(timerStatus)
  {
    case CHECK:   
                if (taster.neu != taster.alt) { 
                  timerStatus = ZERO;
                  if (DEBUGTASTER) { Serial.print(F("Taster ")); Serial.println(taster.neu); }
                  if (DEBUG) { Serial.println("to ZERO"); }
                }
                break;
                
    case ZERO:  
                OCR1B = pulsForm[ANZAHLTASTER].duty;   // Default, Dummyeintrag, kein Taster gedrückt Signal High
                timerStatus = WAIT;
                if (DEBUG) { Serial.println("to WAIT"); }
                break;
                
    case WAIT:  
                if (TCNT1 >= pulsForm[taster.alt].duty) { 
                  stopTimer1(); 
                  timerStatus = CONFIG;
                  if (DEBUG) { Serial.println("to CONFIG"); }
                }  
                break;
                
    case CONFIG: 
                changeTimer1(pulsForm[taster.neu]);
                timerStatus = START;
                if (DEBUG) { Serial.println("to START"); }
                break;
                
    case START:   
                startTimer1(pulsForm[taster.neu]);
                timerStatus = CHECK;
                taster.alt = taster.neu;
                if (DEBUG) { Serial.println("to CHECK"); }
                break; 
                
    default:    if (DEBUG) { Serial.println("Hier ging etwas schief."); } break;            
  }
}

void checkActiveButton (auto pin)
{
  static unsigned long lastMillis {0};
  const unsigned long ms {millis()};
    
  if (ms - lastMillis >= 1) {
    lastMillis = ms;
    taster.neu = ANZAHLTASTER;  // Default, kein Taster gedrückt
    for (byte i=0; i<ANZAHLTASTER; i++) {
      if (!digitalRead(pin[i])) {
        taster.neu = i;         // Welcher Taster wird aktuell gedrückt?
      }
    }
  }  
}

void changeTimer1 (TimerDaten &puls)  
{         
  TCNT1 = 0;             // wirklich notwendig ??? 
  OCR1A = puls.periode;  // TOP 
  OCR1B = puls.duty;     // Pulsweite, OCR1B <= OCR1A 
}  

void initTimer1 (const uint8_t mode) // Mode x
{
  TCCR1B = 0;    // Reset, stop timer first
  TCCR1A = 0;    // Reset
  TIMSK1 = 0;    // Reset (disable Timer Compare Interrupts)
  TCNT1  = 0;    // initialize counter value to 0
  setTimer1Mode(mode);  // Mode 11
  TCCR1A |= _BV(COM1B1) | _BV(COM1B0); // Compare Output Mode                          
}

void startTimer1 (const unsigned int prescaler)
{ // set new Prescaler Clock Select Bits
  switch (prescaler) {
    case    1 : TCCR1B |= _BV(CS10);              break;
    case    8 : TCCR1B |= _BV(CS11);              break;
    case   64 : TCCR1B |= _BV(CS11) | _BV(CS10);  break;
    case  256 : TCCR1B |= _BV(CS12);              break;
    case 1024 : TCCR1B |= _BV(CS12) | _BV(CS10);  break;
    default   : break;  // otherwise the timer remains unchanged or remains stopped
  }
}

void startTimer1 (TimerDaten &puls)
{ // set new Prescaler Clock Select Bits
  startTimer1(puls.prescaler);
}

void stopTimer1 (void)
{
  TCCR1B &= ~( _BV(CS12) | _BV(CS11) | _BV(CS10) );
}

void deleteTimer1Mode (void)
{
  TCCR1A &= ~( _BV(WGM11) | _BV(WGM10) );
  TCCR1B &= ~( _BV(WGM13) | _BV(WGM12) );
}

void setTimer1Mode (const uint8_t mode)
{
  if ((mode <=15) && (mode != 13)) {
    stopTimer1();
    deleteTimer1Mode();
    switch (mode) {
      case  0 :                                                                     ; break;  // Normal
      case  1 :                                    TCCR1A |=              _BV(WGM10); break;  // PWM, Phase Correct  8-Bit 
      case  2 :                                    TCCR1A |= _BV(WGM11)             ; break;  // PWM, Phase Correct  9-Bit 
      case  3 :                                    TCCR1A |= _BV(WGM11) | _BV(WGM10); break;  // PWM, Phase Correct 10-Bit 
      case  4 : TCCR1B |=              _BV(WGM12);                                  ; break;  // CTC, OCRnA
      case  5 : TCCR1B |=              _BV(WGM12); TCCR1A |=              _BV(WGM10); break;  // Fast PWM  8 Bit
      case  6 : TCCR1B |=              _BV(WGM12); TCCR1A |= _BV(WGM11)             ; break;  // Fast PWM  9 Bit
      case  7 : TCCR1B |=              _BV(WGM12); TCCR1A |= _BV(WGM11) | _BV(WGM10); break;  // Fast PWM 10 Bit
      case  8 : TCCR1B |= _BV(WGM13)             ;                                  ; break;  // PWM, Phase & Frequency Correct, ICRn
      case  9 : TCCR1B |= _BV(WGM13)             ; TCCR1A |=              _BV(WGM10); break;  // PWM, Phase & Frequency Correct, OCRnA
      case 10 : TCCR1B |= _BV(WGM13)             ; TCCR1A |= _BV(WGM11)             ; break;  // PWM, Phase Correct, ICRn
      case 11 : TCCR1B |= _BV(WGM13)             ; TCCR1A |= _BV(WGM11) | _BV(WGM10); break;  // PWM, Phase Correct, OCRnA
      case 12 : TCCR1B |= _BV(WGM13) | _BV(WGM12);                                  ; break;  // CTC, ICRn
      case 13 : break;                                                                        // Reserved
      case 14 : TCCR1B |= _BV(WGM13) | _BV(WGM12); TCCR1A |= _BV(WGM11)             ; break;  // Fast PWM, ICRn
      case 15 : TCCR1B |= _BV(WGM13) | _BV(WGM12); TCCR1A |= _BV(WGM11) | _BV(WGM10); break;  // Fast PWM, OCRnA                                                     
      default : break; // otherwise no change of the configuration
    }
  }  
}