// ==================================================================									
// Include C Libriaries									
// ==================================================================									
									
#include <avr/io.h>									
#include <util/delay.h>									
#include <stdio.h>									
#include <avr/interrupt.h>									
									
// ==================================================================									
// Definition der Segmente pro Ziffer									
// ==================================================================									
									
#define zifferNull		PORTA = (1<<PA0) | (1<<PA1); PORTD = (1<<PD2) | (1<<PD3) | (1<<PD4) | (1<<PD5)							
#define zifferEins		PORTD = (1<<PD3) | (1<<PD4); PORTA = 0;							
#define zifferZwei		PORTD = (1<<PD5) | (1<<PD4) | (1<<PD2) | (1<<PD1); PORTA = (1<<PA0)							
#define zifferDrei		PORTD = (1<<PD5) | (1<<PD4) | (1<<PD3) | (1<<PD2) | (1<<PD1); PORTA = 0;							
#define zifferVier		PORTD = (1<<PD4) | (1<<PD3) | (1<<PD1); PORTA = (1<<PA1)							
#define zifferFuenf		PORTD = (1<<PD5) | (1<<PD3) | (1<<PD2) | (1<<PD1); PORTA = (1<<PA1)							
#define zifferSechs		PORTD = (1<<PD5) | (1<<PD3) | (1<<PD2) | (1<<PD1); PORTA = (1<<PA1) | (1<<PA0)							
#define zifferSieben	PORTD = (1<<PD3) | (1<<PD4) | (1<<PD5); PORTA = 0;								
#define zifferAcht		PORTD = (1<<PD1) | (1<<PD2) | (1<<PD3) | (1<<PD4) | (1<<PD5); PORTA = (1<<PA0) | (1<<PA1)							
#define zifferNeun		PORTD = (1<<PD1) | (1<<PD2) | (1<<PD3) | (1<<PD4) | (1<<PD5); PORTA = (1<<PA1)							
#define zifferAus		PORTA = 0; PORTD = 0							
									
// ==================================================================									
// Timerdefinitionen									
// ==================================================================									
									
// Phasenkorrekter PWM / Vorteiler 1 / Compare-Wert = 55									
// Berechnung: 4 MHz / (2*50) = 40 kHz (40.000 Interrupts und LED-Toogle pro Sekunde)									
#define timer_config_start TCCR0A=(1<<WGM00);TCCR0B=(1<<WGM02)|(1<<CS00);OCR0A=55;TCNT0=0									
									
// Timer anhalten									
#define timer_stop TCCR0A=0;TCCR0B=0;OCR0A=0;TCNT0=0									
									
// ==================================================================									
// NEC Code: Dauer der Puls- und Pausephasen [Anzahl der Interrupts pro Bit/Phase]									
// ==================================================================									
									
// später ergänzen									
									
// Zaehler fuer Anzahl Interrupts (= Anzahl LED-Impulse)									
volatile uint16_t interrupt_count;									
volatile uint8_t counts_pro_phase_puffer;							// Anzahl Counts pro Pulse-Phase		
volatile uint8_t signal_changed;							// Flag bei Signaländerung IR Empfänger		
									
// ==================================================================									
// Funktionsprototypen									
// ==================================================================									
									
void displayZahl(uint16_t zahl, uint16_t dauer);									
void aktiviereSegmente(uint8_t ziffer);									
									
int main(void)									
{									
	// Variablen						// 0 = IR empfangen / 1 = Zahl anzeigen		
	uint8_t modus;								
	uint8_t i;						// Schleifenzaehler		
									
	uint8_t zaehler_phasen;						// 10 Phasen (Pulse/Pausen) aufzeichnen, dann ausgeben		
	uint8_t counts_pro_phase[70];						// Anzahl Counts pro Pulse-Phase		
									
	uint16_t zahl;						// anzuzeigende Zahl für Display		
	uint16_t dauer;						// Anzeigedauer einer Zahl		
									
	dauer = 5000;								
									
	// Ports initialisieren								
	DDRB = (1<<PB4) | (1<<PB5) | (1<<PB6) | (1<<PB7);								// Ausgang Ziffern
	DDRA = (1<<PA0) | (1<<PA1);								// Ausgang Segmente
	DDRD = (1<<PD0) | (1<<PD1) | (1<<PD2) | (1<<PD3) | (1<<PD4) | (1<<PD5);								// Ausgang Segmente
	DDRB |= (1<<PB2);								// Ausgang Kontroll-LED
	PORTB = 0b00000101;								// Eingang IR LED / Konroll-LED aus
									
	// Interrupts initialisieren								
	PCMSK = (1<<PCINT0);						// Interrupt bei Signaländerung IR LED		
	GIMSK = (1<<PCIE);								
	TIMSK = (1<<OCIE0A);						// Interrupt zum Zählen der Pulse/Pausen		
	sei();								
									
	// Endlosschleife								
	while(1)								
	{								
		// Modus "IR Signal empfangen"							
		if (modus==0)							
		{							
			if (signal_changed!=0)						
			{						
				cli();					
				zaehler_phasen++;					
				counts_pro_phase[zaehler_phasen]=interrupt_count;					
				signal_changed=0;					
									
				interrupt_count=0;					
				sei();					
			}						
									
			if ((zaehler_phasen>=68))				// Empfang beendet, Ergebnisse in Display anzeigen		
			{						
				modus=1;					
			}						
		}							
									
		// Modus "Zahl auf Display anzeigen"							
		if (modus==1)							
		{							
			cli();						
									
			PORTB&=!(1<<PB2);				// Kontroll-LED an		
			_delay_ms(1000);						
			PORTB|=(1<<PB2);				// Kontroll-LED aus		
			_delay_ms(1000);						
									
			for (i=1;i<=70;i++)						
			{						
				displayZahl(counts_pro_phase[i],dauer);					
				_delay_ms(200);					
			}						
									
			zaehler_phasen=0;						
			interrupt_count=0;						
			modus=0;						
			sei();						
		}							
	}								
}									
									
// ==================================================================									
// Interrupt Service Routinen									
// ==================================================================									
									
ISR(TIMER0_COMPA_vect)									
{									
	interrupt_count++;								
}									
									
ISR(PCINT_vect)									
{									
	signal_changed=1;								
	timer_config_start;								
}									
									
// ==================================================================									
// Helper Funktionen									
// ==================================================================									
									
void displayZahl(uint16_t zahl, uint16_t dauer)									
{									
	// Variablen								
	uint8_t ziffer1;								
	uint8_t ziffer2;								
	uint8_t ziffer3;								
	uint8_t ziffer4;								
									
	uint16_t count;								
									
	// Zahl in Ziffern zerlegen								
									
	// Einser								
	ziffer4 = zahl % 10;								
	zahl = zahl / 10;								
									
	// Zehner								
	if (zahl > 0) {								
	ziffer3 = zahl % 10; }								
	else {								
	ziffer3 = 10; }								
	zahl = zahl / 10;								
									
	// Hunderter								
	if (zahl > 0) {								
	ziffer2 = zahl % 10; }								
	else {								
	ziffer2 = 10; }								
	zahl = zahl / 10;								
									
	// Tausender								
	if (zahl > 0) {								
	ziffer1 = zahl % 10; }								
	else {								
	ziffer1 = 10; }								
	zahl = zahl / 10;								
									
	for (count = 1; count <= dauer; count++)								
	{								
		// alle Ziffern und Segmente ausschalten							
		PORTA = 0;							
		PORTB = 0b00000101;							
		PORTD = 0;							
									
		// Tausender							
		PORTB = 0b00000101;							
		aktiviereSegmente(ziffer1);							
		PORTB |= (1<<7);					// 3 + 4		
									
		_delay_us(200);							
									
		// Hunderter							
		PORTB = 0b00000101;							
		aktiviereSegmente(ziffer2);							
		PORTB |= (1<<6);					// 3 + 3		
									
		_delay_us(200);							
									
		// Zehner							
		PORTB = 0b00000101;							
		aktiviereSegmente(ziffer3);							
		PORTB |= (1<<5);					// 3 + 2		
									
		_delay_us(200);							
									
		// Einser							
		PORTB = 0b00000101;							
		aktiviereSegmente(ziffer4);							
		PORTB |= (1<<4);					// 3 + 1		
									
		_delay_us(200);							
	}								
									
	// alle Ziffern und Segmente ausschalten								
	PORTA = 0;								
	PORTB = 0b00000101;								
	PORTD = 0;								
}									
									
void aktiviereSegmente(uint8_t ziffer)									
{									
	switch (ziffer)								
	{								
		case 0: zifferNull; break;							
		case 1: zifferEins; break;							
		case 2: zifferZwei; break;							
		case 3: zifferDrei; break;							
		case 4: zifferVier; break;							
		case 5: zifferFuenf; break;							
		case 6: zifferSechs; break;							
		case 7: zifferSieben; break;							
		case 8: zifferAcht; break;							
		case 9: zifferNeun; break;							
		case 10: zifferAus; break;							
	}								
}