#include <avr/io.h>
#include <avr/interrupt.h>
#include <stdint.h>
#include <stdio.h>
#include <lcd.h>
/****************************************************************************************
Name; Julian Schild

C-Programm zur programmierung des µCs für die DA von Schild_Stangl (Simply_Off2009/10).

*****************************************************************************************/
//Globale Variablen
 volatile unsigned short int usiMinute=0;

//Funktionsdeklaration (Prototypen)

//ADC Init.
//void vinitADU_8Bit(unsigned short int);
void vinitADU_10Bit(unsigned short int);
//Timer Init.
void vinitTimer_16Bit();

unsigned short int usigetADU_10Bit(unsigned short int);

//******************************************************************************************
void main (void)
{//Variablen Definition
	unsigned char cPuffer[10], ucDurchlauf=0;
	unsigned short int usiPuffer1=0,usiPuffer2=0,usiWait=0,usiWait2=0, iMittelCounter=0;
	unsigned int uiPuffer=0, uiMittelPuffer[4];

 //Deklaration der PORTS --> "Richtung"
	DDRD = 0xff;		//0xff --> Ausgang --> LCD
	DDRC = 0xe0;		//0x00 --> Eingang --> ADU
	DDRB = 0xff;		// Ausgang für Testzwecke --> LEDs
	PORTB = 0x00;


 //Initialisierung des ADCs
	//vinitADU_8Bit(0);
	vinitADU_10Bit(0);
 
 //Initialisierung des Timers
 	vinitTimer_16Bit();


    /* Initialisiere Display, Cursor aus*/
    lcd_init(LCD_DISP_ON);
	
	/* loesche das LCD Display und Cursor auf 1 Zeile, 1 Spalte */
    lcd_clrscr();
        
    /* String auf Display anzeigen */
    lcd_puts("Willkommen");
 
 	for (usiWait;usiWait<1000;usiWait++)
		{
			for (usiWait2;usiWait2<100;usiWait2++);
			usiWait2=0;
		}
		usiWait=0;

	// Hauptschleife	
   while(1) 
   {
    if (usigetADU_10Bit(0)<163)			// Prüfung ob Standby- Betrieb erreicht wurde
		{
			
			if (TCCR1B != 0x05)		// Prüfung ob Timer AUS ist
				{
					TCCR1B = ((1<<CS12)|(1<<CS10));	// Timer durch setzten der PRESCALER aktivieren
				}
			
			//Algorithmus zur Leitungsberechnung
			uiPuffer=20*usigetADU_10Bit(1)-(usigetADU_10Bit(1)*46)/102;

			uiMittelPuffer[iMittelCounter]=uiPuffer;

			iMittelCounter++;					// Darf nur Werte 0-3 annehmen,
												// da Array nicht mehr Elemente hat.
			if (ucDurchlauf<4) ucDurchlauf++;	// Zum Befüllen des Arrays während der ersten 4 Durchläufe
												// danach gleitender Mittelwert.

			// Mittelwertbildung
			if (ucDurchlauf >= 4)
			{
				if (iMittelCounter==4) iMittelCounter=0;

				uiPuffer=(uiMittelPuffer[0]>>2)+(uiMittelPuffer[1]>>2)+(uiMittelPuffer[2]>>2)+(uiMittelPuffer[3]>>2);
			}

			else if (ucDurchlauf==1) uiPuffer=uiMittelPuffer[0];
			else if (ucDurchlauf==2) uiPuffer=(uiMittelPuffer[0]+uiMittelPuffer[1])>>1;
			else if (ucDurchlauf==3) uiPuffer=(uiMittelPuffer[0]+uiMittelPuffer[1]+uiMittelPuffer[2])/3;
			
				usiPuffer1=uiPuffer/1000;			// Ganzzahl in W
				usiPuffer2=((uiPuffer%1000)/10);	// Nachkommastellen

			//Typkonvertierung für "lcd_puts"- Funktion
			sprintf(cPuffer,"%2d.%dW",usiPuffer1,usiPuffer2);

			// Ausgabe am LCD
			lcd_clrscr();				// LC-Display löschen und Kursor auf Pos. 1
			lcd_puts(cPuffer);			// String am Display ausgeben
			

		 	for (usiWait;usiWait<100;usiWait++)
				{
					for (usiWait2;usiWait2<300;usiWait2++);
					usiWait2=0;
				}
				usiWait=0;
		}


	// Prüfen ob 2. Spannungsschwelle >1,2 Volt ist
	else if (usigetADU_10Bit(0)>=245)
		{
			if (TCCR1B == 0x05)			// Prüfung ob PRESCALER- Bits gestezt sind 
				{						// wenn "Ja" --> zurücksetzten --> Timer ausschalten
					TCCR1B = 0x00;		// Timer Ausschalten

					TCNT1H = 0xfc;		// Reload des
					TCNT1L = 0x30;		// Timer- Register
				}
			
			usiMinute=0;				// Minuten Zähler zurücksetzen

			lcd_clrscr();				// LC-Display löschen und Kursor auf Pos. 1
			lcd_puts("Betrieb");		// String "Betrieb" am Display ausgeben

			for (usiWait;usiWait<500;usiWait++);
				usiWait=0;
		}
   }   
}


//////////////////////////////////////////////
// Funktionen								//
//////////////////////////////////////////////


void vinitADU_10Bit(unsigned short int usimux)
{// Eigene Funktion zur ADU Initialisierung damit diese nicht ständig durchgeführt werden muss
int iresult;

ADMUX = usimux; 	// Kanal waehlen
ADMUX |= 0x40; 		// AVCC als Referenzspannung nutzen
ADCSRA |= 0x85; 	// Frequenzvorteiler
					// setzen auf 8 (1) und ADC aktivieren (1)

/* nach Aktivieren des ADC wird ein "Dummy-Readout" empfohlen, man liest
also einen Wert und verwirft diesen, um den ADC "warmlaufen" zu lassen*/

ADCSRA |= (1<<ADSC); // eine ADC-Wandlung

	while(ADCSRA&(1<<ADSC)) 
		{
		 	// auf Abschluss der Konvertierung warten
		}

iresult = ADCH;			// ADCH muss einmal gelesen werden,
						// sonst wird Ergebnis der nächsten Wandlung
						// nicht übernommen.
ADCSRA &= ~(1<<ADEN); 	// ADC deaktivieren

iresult = 0;
}


unsigned short int usigetADU_10Bit(unsigned short int usimux)
{	unsigned short int usiresult;

	ADMUX &= 0xF0;			// Rücksetzten der Kanäle
	ADMUX |= usimux; 		// Kanal waehlen
	ADCSRA |= 0x80; 		// ADC aktivieren (1)


	ADCSRA |= (1<<ADSC); 	// eine Wandlung "single conversion"
		while ( ADCSRA & (1<<ADSC) ) 
			{
				// auf Abschluss der Konvertierung warten
			}

	usiresult = ADCL; 		// Wandlungsergebnisse abholen
	usiresult += (ADCH<<8); // Zusammenfügung zu einer 10Bit Zahl
	ADCSRA &= ~(1<<ADEN); 	// ADC deaktivieren (2)

	return usiresult;
}


// Timer Initialisierung
void vinitTimer_16Bit()
{

TCNT1H = 0xfc;								// Reload des
TCNT1L = 0x30;								// Timer- Register
TCCR1B = (1<<CS12)|(1<<CS10);				// Prescaler 1024 --> CPU/1024
											// 1MHz/1024=7812,5Hz
TIMSK = (1<<TOIE1);							// Overflow Interrupt erlauben
sei();										// Interrupts erlauben
}


// Interrupt bei Timer1 Overflow
ISR(TIMER1_OVF_vect)
{	
	TCNT1H = 0xfc;							// Reload des
	TCNT1L = 0x30;							// Timer- Register

	usiMinute++;							// Merker inkrementieren
	PORTB = ~PORTB;							// Kontrollausgabe ob Timer Überlauf kommt
		if(usiMinute==60)					// Nach 60 Überläufen ca. 1min
		{
			usiMinute=0;					// Merker zurücksetzen
			PORTC = (1<<PC4);				// Abschalt Signal
		}
}