#ifndef F_CPU							// sicherheitshalber
#define F_CPU 20000000					// Prozessortakt eisnstellen
#endif

// sbi == Set Bit		cbi == clear Bit 
#define sbi(ADDRESS,BIT) ((ADDRESS) |= (1<<(BIT)));
#define cbi(ADDRESS,BIT) ((ADDRESS) &= ~(1<<(BIT)));

#include <avr/io.h>						// Integriert Interrupt service routinen
										// für Makro's verknüpft I-vector's
#include <avr/interrupt.h>
#include <util/delay.h>
#include <stdlib.h>
#include "lcd.h"

#ifndef TRUE							// sicherheitshalber
#define TRUE 1
#define FALSE 0
#endif

//----------------------------------------------------------------------------//

volatile unsigned char overflows=0;    	// Azahl der Überläufe
volatile unsigned int  starttime=0;    	// ICR-Wert 1.High-Flanke
volatile unsigned int  endtime=0;      	// ICR-Wert 2.High-FLanke
volatile unsigned char workflag;  		// WorkFlag Flag
volatile float erg = 0;					// Ergebniss der Rechnung

ISR( TIMER1_CAPT_vect )					// ISR für Timer/Counter1 Capture-Event					
{
     static unsigned char ersteflanke = TRUE;
	 
	 if( workflag )						// IF-Anweisung verzögert die ISR
	 {									// bis die starttime & endtime Variablen
	 	return;							// wieder gefahrlos beschrieben werden
	 }									// können
	 else								// Solange workflag nicht FALSE ist
	 {
	 	;								// (Am Ende des Hauptprogrammes) wird
     }									// diese ISR mit return sofort beendet
	  
     if( ersteflanke )
     {
         starttime=ICR1;				// ICR1-16Bit-Register. TIMER REGISTER
		 								// des TCNT1-16Bit-Counter bei capture. 
         overflows=0;					// Überlauf 0 setzen
         ersteflanke=FALSE;				// erste Flanke = 0
     }
     
     else
     {
         endtime = ICR1;				// ICR1-Wert in endtime
         workflag = TRUE;				// 1 vollständige Messung abgeschlossen
         ersteflanke = TRUE;			// beginn der nächsten Messung möglich
     }
	 
	 if ( workflag )
	 {
	 	erg = (overflows*65536) + endtime - starttime;	// allg. Formel
     	erg = F_CPU / erg;				// f = 1/T
	 }
	 		// Ziel: Zeitdauer zwischen Flanken zu bestimmen.
			// Da endtime und starttime unsigned sind brauch nicht
			// darauf geachtet zu werden das endtime kleiner als starttime sein
			// kann. Dies wird zusätzlich durch den Überlauf erfasst.

}

ISR ( TIMER1_OVF_vect )					// ISR für den Überlauf
{
    overflows++;						// Überlauf wird von Variable gezählt
}



int main()
{
	
	//Variablen Deklarieren & Initialisieren    

	char fqstring[8];					// Endergebnis auf dem Diplay
	uint8_t i;							// Laufvariable für Messschleife
	uint8_t j;							// Anzahl der Messungen							
	float summe = 0;					// Summe der ermittelten T's
	float mittelwert = 0;				// Mittelwert aus j Messungen

	j = 10;								// Anzahl der Messungen
										// j hier ändern		
    
    lcd_init();							// Initialisierung LCD
    
    //TCCR1B = 		(1<<ICES1) | (1<<CS10);
	//TCCR1B:		TIMER COUNTER CONTROL REGISTER B
	//ICES1(BIT6):	INPUT CAPTURE EDGE SELECT
	//CS10(BIT0):	CLOCK SELECT
		
	sbi(TCCR1B,6);						// steigender Flanke
	sbi(TCCR1B,0);						// Kein Prescale

    //TIMSK1 = 			(1<<ICIE1) | (1<<TOIE1);
	//TIMSK1:			TIMER/COUNTER1 INTERRUPT MASK REGISTER
	//ICIE1:(BIT5)		TIMER/COUNTER1 INPUT CAPTURE INTERRUPT ENABLE
	//TOIE1:(BIT0)		TIMER/COUNTER1 OVERFLOW INTERRUPT ENABLE
	
	sbi(TIMSK1,5);						// Interrupts aktivieren
	sbi(TIMSK1,0);						// apture+Overflow

    
    sei();								// Interrupts Global aktivieren
    
    while(1)							// Endlosschleife im Main
    {
			
			for( i=0; i<j; i++)			// Messschleife für j Messungen
			{
				summe += erg;			// Summieren der gemessenen T's					
			}
			
		mittelwert = summe;				// Summe an Mittelwert übergeben
		summe = 0;						// Summe null setzen für neue Messreihe				
		mittelwert /= (j*1000);			// :j(jMessungen) :1000(kHz)
			
			
		dtostrf( mittelwert, 7, 3, fqstring );	// 7Ziffern, 3Nachkommastellen
                 
			
        lcd_goto(1,1);						// Zeile,Spalte
		lcd_string(" f[kHz]= ");			// f[kHz]			
		lcd_goto(1,8);						// Zeile, Spalte
        lcd_string(fqstring);				// f in kHz
		
		_delay_ms(500);						// Zeit vertrödeln 500ms
		
		workflag = FALSE;					// Die Darstellung auf dem Display
											// ist abgeschlossen, es kann eine
											// neue Messreihe gestartet werden				
    }
}