// Devil-Elec
// https://www.mikrocontroller.net/topic/570524?goto=7735213

#include <util/atomic.h>
#include <Streaming.h>  // https://github.com/janelia-arduino/Streaming
Stream &out {Serial};

volatile unsigned long countVolatile;
unsigned long countNonVolatile;

class SimpleTimer
{
  private:
    unsigned long lastMillis;
    const unsigned long intervall;

  public:
    SimpleTimer (unsigned long i) :
      lastMillis {0},
      intervall  {i}
    {}
    
    bool expired (void) {
      bool state {false};
      const unsigned long ms {millis()};
      if (ms - lastMillis >= intervall) {
        lastMillis = ms;
        state = true;
      }
      return state;
    }

    void reset (void) {
      lastMillis = millis();
    }
};

SimpleTimer myTimer {1000};

void setup(void)
{
  Serial.begin(250000);
  Serial.println(F("\nuC Reset ####"));
  resetTimer1();
  changeTimer1Mode(0);
  TIMSK1 = (1<<TOIE1);  // Timer Overflow Interrupt
  startTimer1(1);
}

void loop(void)
{
  if (myTimer.expired()) {
    readOutTimer1(out);
  }
}

void stopTimer1 (void)
{
  // delete Clock Select Bits, Timer is stopped
  TCCR1B &= ~( _BV(CS12) | _BV(CS11) | _BV(CS10) );
}

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 timer remains stopped
  }
}

void changeTimer1Mode (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
    }
  }  
}

void deleteTimer1Mode (void)
{
  // delete all WGM Bits
  TCCR1A &= ~( _BV(WGM11) | _BV(WGM10) );
  TCCR1B &= ~( _BV(WGM13) | _BV(WGM12) );
}

void resetTimer1 (void)
{
  // delete all
  TCCR1B = 0;
  TCCR1A = 0;
  TCCR1C = 0;
  TIMSK1 = 0;
  ICR1   = 0;
  OCR1A  = 0;
  OCR1B  = 0;
}

ISR(TIMER1_OVF_vect)     // Interrupt Service Routine
{  
  countVolatile++;
  countNonVolatile++;
} 

void readOutTimer1 (Stream &out)     
{  
  unsigned long countVol {0};
  unsigned long countNonVol {0};
   
  ATOMIC_BLOCK (ATOMIC_RESTORESTATE) {    
      countVol = countVolatile;
      countNonVol = countNonVolatile;
  }

  out << "volatile     " << countVol    << endl;
  out << "non volatile " << countNonVol << endl;
  out.println();
}