// Festlegung der Quarzfrequenz

#ifndef F_CPU						// optional definieren
#define F_CPU 18432000UL			// MEXLEclock mit 18,432 MHz Quarz
#endif

// Deklarationen
// ============================================================================

#include <avr/io.h>					// Header-Dateien zum ATmega88
#include <stdbool.h> 				// Header-Datei fuer Bit-Berechnung
#include <avr/interrupt.h>			// Header-Datei fuer Interrupts
#include <util/delay.h>				// Header-Datei fuer Wartezeit
#include "lcd_lib_de.h"				// Header-Datei fuer LCD-Anzeige
#include <stdint.h> 

// Konstanten
#define ASC_NULL            0x30	// Das Zeichen '0' in ASCII
#define ASC_FULL_STOP       0x2E	// Das Zeichen ':' in ASCII

#define VORTEILER_WERT      90
#define HUNDERTSTEL_WERT    10
#define ZEHNTEL_WERT		10

// Variable

unsigned char   vorteiler   = VORTEILER_WERT;       // Zaehlvariable Vorteiler
unsigned char   hundertstel = HUNDERTSTEL_WERT;
unsigned char   zehntel =     ZEHNTEL_WERT;

unsigned int    adcValue    = 0;	// Variable fuer den AD-Wandlungswert
unsigned int	switchnr    = 0;
int			    LuxValue    = 0;

//unsigned int	index	    = 0;

bool            takt10ms;			// Bit-Botschaft alle 10 ms
bool            takt100ms;			// Bit-Botschaft alle 100 ms
bool            takt1s;				// Bit-Botschaft alle 1s

bool sw1 = 0;                       // Bitspeicher fuer Taste 1
bool sw2 = 0;                       // Bitspeicher fuer Taste 2
bool sw3 = 0;                       // Bitspeicher fuer Taste 3
bool sw4 = 0;                       // Bitspeicher fuer Taste 4

//Funktionsprototypen

void initTimer0 (void);
void initAdc (void);
void initDisplay (void);
void initSwitch (void);
void doAdc (void);
void calculateLux (void);
void Anzeige(void);
void readButtons(void);             // Einlesen der Tastenwerte

//void refreshDisplay (void);
//void refreshDisplayTemp(int tempValue, char line, char pos);

// Hauptprogrammschleife __________________________________________________

int main ()
{	
	initDisplay();				// Initialisierung LCD-Anzeige
	initAdc();                  // Initialisierung des AD-Wandlers
	initTimer0();               // Initialisierung von Timer0
	initSwitch();				// Initialisierung des Taster

	sei();						// generell Interrupts einschalten
		
	while(1)					// unendliche Warteschleife mit Aufruf der
	{
		if(takt100ms)           // Durchfuehrung der Funktion einmal pro 100ms
		{
			takt100ms = 0;      // Taktbotschaft zuruecksetzen
			doAdc();            // Ausfuehrung des Modules der A/D-Wandlung
			calculateLux();		// Ausfuehrung des Modules der Umrechnung
			readButtons();
		}
		        
		if(takt1s)              // Durchfuehrung der Anzeige einmal pro 1s
		{
			takt1s = 0;         // Taktbotschaft zuruecksetzen
			Anzeige();			// Ausfuehrung des Modules der Anzeige
		}
	}
}

// Timer Initialisierung ==============================================================
//
// Initialisierung des Timer0 zur Erzeugung eines getakteten Interrupts.
// Er dient dazu, die benoetigten Taktbotschaften zu erzeugen.
void initTimer0()
{
	TCCR0A  |= (0<<WGM00)
			|  (0<<WGM01);		// Timer 0 auf "Normal Mode" schalten
	TCCR0B  |= (0<<WGM02)
			|  (1<<CS01 );		// mit Prescaler /8 betreiben
	TIMSK0  |= (1<<TOIE0);		// Overflow-Interrupt aktivieren
}

// ADC-Initialisierung ==============================================================
//
// Initialisierung des A/D-Wandlers:
// Vorteiler = 128 => interner Takt = 96 kHz
// Abfrage des ADC0 (NTC-Spannungsteiler)
// Referenzspannung = analoge Versorgung Avcc
void initAdc()
{
	ADMUX   |= (1<<REFS0);				// Vref =AVCC; ADC0
	
	ADCSRA  |= (1<<ADPS0)
			|  (1<<ADPS1)
			|  (1<<ADPS2)
			|  (1<<ADEN);				// Teiler 128; ADC ON
	(void) ADCH;						// erster Wert ist "wegzuwerfen"
}

ISR (TIMER0_OVF_vect)
{
	--vorteiler;                        // Vorteiler dekrementieren
	if (vorteiler==0)                   // wenn 0 erreicht: 10ms abgelaufen
	{
		vorteiler = VORTEILER_WERT;     // Vorteiler auf Startwert
		takt10ms = true;                // Botschaft 10ms senden
		--hundertstel;                  // Hundertstelzaehler dekrementieren
		
		if (hundertstel==0)             // wenn 0 erreicht: 100ms abgelaufen
		{
			hundertstel = HUNDERTSTEL_WERT; // Teiler auf Startwert
			takt100ms = true;           // Botschaft 100ms senden
			--zehntel;
			
			if (zehntel==0)             // Zehntelzaehler dekrementieren
			{
				zehntel = ZEHNTEL_WERT; // Teiler auf Startwert
				takt1s = true;          // Botschaft 1s senden
			}
		}
	}
}

// ADWandlung ==============================================================
//
// Durchfuehrung einer Einzelwandlung der am NTC-Spannungsteiler anstehenden
// Spannung in einen digitalen 10-bit-Wert (einmal pro 100 ms).
void doAdc()
{
	ADCSRA |= (1<<ADSC);				// Wandlung starten
	while (ADCSRA & (1<<ADSC));			// Ende der Wandlung abwarten
	
	adcValue = ADCL + (ADCH<<8);		// 10-Bit-Wert berechnen
}

// Umrechnung ==============================================================
//
// (wird alle 100 ms aufgerufen)
void calculateLux ()
{
	float index;						// Tabellenindex fuer Temperaturtabelle
										// der AD-Werte der Temperaturtabelle
	float factor;						//[switchnr]={25000,2500,250};
		
	if(switchnr==0)
		{ 
			factor = 25000;
		}
		
	if (switchnr==1)
		{
			factor = 2500;
		}
	
	if(switchnr==2)
		{
			factor = 250;
		}

	index   = ((float)adcValue * (float)5)/(float)1024;		// Indexberechnung - ADC-Wert in Volt
	
	LuxValue = index * factor;		
}	

// Anzeigefunktion ==============================================================
//
// Der aktuelle Temperatur und die maximale Temperatur werden ausgegeben

void Anzeige(void)
 {
	lcd_gotoxy(0,0);
		lcd_putc   (LuxValue/100 + ASC_NULL);
		LuxValue = LuxValue%100;
		lcd_putc   (LuxValue/10  + ASC_NULL);  // Zehner ausgeben (°C Einer)
		lcd_putc   (ASC_FULL_STOP);             // Punkt ausgeben
		lcd_putc   (LuxValue%10  + ASC_NULL);  // Einer ausgeben (°C Zehntel)	
 }
 
void readButtons(void)
{
	DDRD = DDRD & 0b11110000;       // Port B auf Eingabe schalten
	PORTD =       0b00001111;       // Pullup-Rs eingeschaltet
	_delay_us(1);                   // Umschalten der Hardware-Signale abwarten
	sw1 = !(PIND & (1 << PD0));       // Tasten invertiert in Bitspeicher einlesen
	sw2 = !(PIND & (1 << PD1));       // somit gedrueckte Taste ="1"
	sw3 = !(PIND & (1 << PD2));       // Tasten invertiert in Bitspeicher einlesen
	sw4 = !(PIND & (1 << PD3));       // somit gedrueckte Taste ="1"
	DDRD = DDRD | 0b00001111;       // Port B auf Eingabe schalten
			
		if (sw1==1)
			{
				PORTB |= (1<<PB1);			//PB1 High
				PORTB &= ~(1 << PB0);		//PB0 Low
				PORTB &= ~(1 << PB2);		//PB2 Low
				switchnr=0;
			}
			
		else if (sw2==1)
			{
				PORTB |= (1<<PB0);			//PB0 High
				PORTB &= ~(1 << PB1);		//PB1 Low
				PORTB &= ~(1 << PB2);		//PB2 Low
				switchnr=1;
			}
			
		else if (sw3==1)
			{
				PORTB |= (1<<PB2);			//PB2 High
				PORTB &= ~(1 << PB0);		//PB0 Low
				PORTB &= ~(1 << PB1);		//PB1 Low
				switchnr=2;
			}
			
		else if (sw4==1)
			{
				PORTB &= ~(1 << PB0);		//PB0 Low
				PORTB &= ~(1 << PB1);		//PB1 Low
				PORTB &= ~(1 << PB2);		//PB2 Low
			}	
}

// Taster initialisieren =======================================================
void initSwitch(void)
{
	DDRB |= (1 << PB0);			// PB0 als Ausgang definieren
	DDRB |= (1 << PB1);			// PB1 als Ausgang definieren
	DDRB |= (1 << PB2);			// PB2 als Ausgang definieren
	
	DDRC = 0x00;
	PORTC = 0x00;
}

// Initialisierung Display-Anzeige ==============================================================
void initDisplay()					// Start der Funktion
{
	lcd_init();						// Initialisierungsroutine aus der lcd_lib
	
	lcd_gotoxy(0,0);		       	// Cursor auf 1. Zeile, 1. Zeichen
	lcd_putstr("Luxmeter");			// Ausgabe Festtext: 8 Zeichen

	lcd_gotoxy(1,0);		       	// Cursor auf 2. Zeile, 1. Zeichen
	lcd_putstr("        ");			// Ausgabe Festtext: 16 Zeichen

	_delay_ms(2000);				// Wartezeit nach Initialisierung

	lcd_gotoxy(0,0);		       	// Cursor auf 1. Zeile, 1. Zeichen
	lcd_putstr("      lx");			 // Ausgabe Festtext: 16 Zeichen

	lcd_gotoxy(1,0);		       	// Cursor auf 2. Zeile, 1. Zeichen
	lcd_putstr("        ");			// Ausgabe Festtext: 8 Zeichen

}									// Ende der Funktion