/*
Code auf Basis von Harald Peters: https://www.mikrocontroller.net/topic/134862#postform

Mit folgenden Modifikationen:
https://www.mikrocontroller.net/topic/134862#3991115

Wenn der 328 doppelt so schnell läuft, dann verdoppeln sich auch die Zählerwerte.
Für die Dekodierung von DL braucht man hier nur den Timer0.

 Also bei 16MHz gilt:

 if (TCNT0>160 || TIFR0 ) // 2048us

dann 2x

 OCR0A = 95; // 1536us

und dann

 OCR0A = 127; // 2048us, für Bits1..8 wirksam

Die Werte habe ich hier korrigiert, da ich ursprünglich vergessen hatte, 
daß die resultierende Frequenz bei CTC (f/OCR0A+1) ist. Aber so kritisch 
ist das Ganze nicht.

Den Timer2 verwende ich nur zur Ausfalloffenbarung. Wenn länger als 5s 
keine gültige Daten kommen, gilt das als Ausfall. Da gibt es 1000 
weitere Methoden das zu machen.
Die Initialisierung von Timer0 kann so bleiben, also Vorteiler 1:256.

*/





#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include <avr/wdt.h>
#include <string.h>


volatile uint8_t  tsek, NeuSek;
uint8_t  h10ms, t10ms, Dauer10msMin = 100;
uint8_t  OCRdef = 78;

uint8_t  BitZ, BytZ, DByte, DFert, DAusfall;
uint16_t AnzDLFhl, AnzDLges, DAusfallDauer;


struct tDL // 65Byte
{
/* 00 */ uint16_t Kennung;
/* 02 */ uint8_t  xxx;
/* 03 */ uint8_t  Min, Std, Tag, Mon, Jhr;
/* 08 */ int      Temp[16];
/* 40 */ uint16_t Ausg;
/* 42 */ uint8_t  Drehz[4], WReg, KW100;
/* 48 */ int16_t  KW1;   // max 6553.1KW
/* 50 */ uint8_t  KW1H; // immer 0
/* 51 */ uint16_t KWh, MWh;
/* 55 */ uint32_t KW2, MWh2;
/* 63 */ uint8_t  PSum;
/* 64 */ uint8_t  PSumNeu;
};
/* Temp-Sensoren:
  0: Speicher oben;  1: Warmwasser;   2: Speicher unten; 3: Speicher Mitte
  4: Solarvorlauf;   5: Solarrückl.;  6: WW-Rücklauf;    7: Kollektor Ost
  8: Kollektor West; 9: Außenfühler; 10: Zirkulation;   11: Hz-Vorlauf
 12: Keller;        13: RF I (KS);   14: Vol.-Strom     15: RF II (Wz)
*/
union tDLPuffer
{
 uint8_t b[65];
 struct tDL t;
} DLPuffer, DLWerte;




ISR(TIMER2_COMPA_vect) // 100/sek, 10ms
{
 h10ms++;

 t10ms++;
 if (t10ms==Dauer10msMin) 
 { t10ms = 0;
   tsek++; // Überwachung DL
   NeuSek = 1;
 }  

}



ISR(INT0_vect) // warten auf Startbit DL
{
 if (BytZ==0) // warten auf 16Synchbits
 {
  if (TCNT0>160 || TIFR0 ) // TCNT0=64: 64*32us = 2048us (korrigiert von 80 auf 160 für 16MHz)
  {
   if (BitZ<12) // Synchrahmen noch nicht gefunden
   {
    BitZ = 0;
   }
   else // Start nach >11 Einsbits gefunden
   {
    BitZ = 0;
    OCR0A = 95; // 1536us (korrigiert von 48 auf 95 für 16MHz)
    TIMSK0 |=  (1<<OCIE0A); // Int bei TNCT0=OCR0A
    EIMSK  &= ~(1<<INT0);   // Int0 aus
    DLPuffer.b[64] = 0;
    Serial.println("SYNC");
   }
  } // if (TCNT0>80)
  else
  {
   BitZ++; 
  }
 }
 else // if (BytZ==0)
 { // Startflanke neues Byte aufgetreten:
    BitZ = 0;
    OCR0A = 95; // 1536us -> nur gültig 1.Bit (korrigiert von 48 auf 95 für 16MHz)
    TIMSK0 |=  (1<<OCIE0A); // Int bei TNCT0=OCR0A
    EIMSK  &= ~(1<<INT0);   // Int0 aus
 }

 TCNT0 = 0;
 TIFR0 = 7; // Timerflags löschen
}


ISR(TIMER0_COMPA_vect) // zuerst 1536us, dann alle 2048us 
{
 OCR0A = 127; // 2048us, für Bits1..8 wirksam  (korrigiert von 64 auf 127 für 16MHz)

 if (BitZ<8) // 0..7 Datenbits, LSB zuerst
 {
  if (PIND & (1<<PD2)) DByte |= (1<<BitZ);
 }
 else // if (BitZ==9) // BitZ=8 ist Stopbit
 { // auf nächste Startflanke warten:
  TIMSK0 &= ~(1<<OCIE0A);  // Int bei TNCT0=OCR0A aus
  DLPuffer.b[BytZ] = DByte;
  Serial.print("Byte# ");
  Serial.print(BytZ);
  Serial.print(": 0x");
  Serial.println(DByte, HEX);


  if (BytZ<63) DLPuffer.b[64]  += DByte;
  DByte = 0;
  BytZ++;
  if (BytZ==64) // alle Bytes eingelesen
  { 
   DFert = 1;
  }
  else // Int0 freischalten für neues Startbit
  {
   EIFR   |=  (1<<INTF0);   // evtl. altes Int-Flag löschen 
   EIMSK  |=  (1<<INT0);    // Int0 wieder ein
  }
 }
 BitZ++;
}





// -------------------- MAIN-------------------------------------------

int main(void)
{
 wdt_disable();

 // Timer 0
 EICRA =  (1<<ISC00) | (1<<ISC01); // steigende Flanke Int0
 EIMSK |= (1<<INT0);
 OCR0A = 255;
 TCCR0A  =  (1<<WGM01);  // CTC-Modus
 TCCR0B  =  (1<<CS02); // Start Timer 1:256 -> alle 32us Inkr.
 
 // Timer 2
 OCR2A = OCRdef;
 TCCR2A = (1<<WGM21);
 TCCR2B = (1<<CS22) | (1<<CS21) | (1<<CS20); // Timer2 starten mit 1:1024
 TIMSK2 = (1<<OCIE2A); // Enable Timer2 Output Compare Interrupt

 // ------------ SETUP ------------------------------------------------

 //PORTD |=  (1<<PD2); // Pull Up DL
  pinMode(2, INPUT); // INT0 ist auf D2 bei Arduino (PD2)
 
 Serial.begin(115200); // Debuggen

 DAusfall = 0x00;

 sei();
 //wdt_enable(WDTO_1S);


 // --------------- Hauptschleife ---------------------------
 
 
 for(;;)   // Hauptschleife
 { 
  //wdt_reset();

  if (DFert) // Datensatz eingelesen
  {
    DFert = 0;
    memcpy(&DLWerte,&DLPuffer,sizeof(DLPuffer)); // in DLWerte kopieren
    BytZ = 0;

    OCR0A = 255;
    EIFR   |=  (1<<INTF0);
    EIMSK  |=  (1<<INT0); // damit kann der folgende Rahmen gelesen werden

    if (DLPuffer.b[63]==DLPuffer.b[64]) // Prüfsumme stimmt
    {
     if (DAusfall==0x01) // Ende Ausfall
     {
      DAusfall = 0;
     }
     AnzDLges++;
     tsek = 0; // für TimeOut

      // mach was mit den Daten

    }
    else // Prüfsummenfehler
    {
     AnzDLFhl++;
     Serial.print("AnzDLFhl: ");
     Serial.println(AnzDLFhl);
    }
  }

 
  if (NeuSek) // 1 pro Sekunde
  {
   NeuSek = 0; 

   if (tsek>5) // keine DL-Daten mehr
   {
    tsek = 0; 
    if ( (DAusfall&0x01)==0 ) // Beginn Ausfall
    {
     DAusfall = 0x01;
     DAusfallDauer = 0;
    }
   }

   if (DAusfall) 
   {
    DAusfallDauer++;
   }
  }



 } // for
 return 0;
} // main