// ==================================================================
// 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 signal_changed;											// Flag bei Signaländerung IR Empfänger

// ==================================================================
// Funktionsprototypen
// ==================================================================

void initPortsInterrupts();
void displayZahl(uint16_t zahl, uint16_t dauer);
void aktiviereSegmente(uint8_t ziffer);

int main(void)
{
	// Variablen
	volatile uint8_t modus;															// 0 = IR empfangen / 1 = Zahl anzeigen
	uint8_t i;																// Schleifenzaehler
	uint8_t startbit_ok;
	
	volatile 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 = 2000;
	
	// Initialisierung
	initPortsInterrupts();
	
	modus=0;
	signal_changed=0;
	interrupt_count=0;
	zaehler_phasen=0;
	startbit_ok=0;
	
	// Endlosschleife
	while(1)
	{
		// Modus "IR Signal empfangen"
		if (modus==0)
		{
			cli();
			if ((signal_changed!=0) && (startbit_ok==2)) {
				zaehler_phasen++;
				counts_pro_phase[zaehler_phasen]=interrupt_count;
				signal_changed=0;
			interrupt_count=0;}
			if ((signal_changed==1) && (startbit_ok<=1) && (interrupt_count>=60) && (interrupt_count<=90)){
				startbit_ok=1;
				// TEST >>
				zaehler_phasen++;
				counts_pro_phase[zaehler_phasen]=interrupt_count;
				// << TEST
				signal_changed=0;
				interrupt_count=0;}
			if ((signal_changed==2) && (startbit_ok==1) && (interrupt_count>=20) && (interrupt_count<=50)){
				startbit_ok=2;
				// TEST >>
				zaehler_phasen++;
				counts_pro_phase[zaehler_phasen]=interrupt_count;
				// << TEST
				signal_changed=0;
				interrupt_count=0;}
			sei();

			//if ((zaehler_phasen>=20))
			if ((interrupt_count>=2000) && (startbit_ok==2))
			{
				modus=1;													// Empfang beendet, Ergebnisse in Display anzeigen
			}
		}
		
		// Modus "Zahl auf Display anzeigen"
		if (modus==1)
		{
			cli();

			// Kontroll-LED blinken lassen
			PORTB&=!(1<<PB2);												// Kontroll-LED an
			_delay_ms(1000);
			PORTB|=(1<<PB2);												// Kontroll-LED aus
			_delay_ms(1000);

			// Anzahl der empfangenen Phasen anzeigen
			displayZahl(zaehler_phasen,dauer);
			_delay_ms(2000);

			// Dauer pro Phase anzeigen
			for (i=1;i<=70;i++)
			{
				displayZahl(counts_pro_phase[i],dauer);
				_delay_ms(100);
			}

			// Initialisierung
			initPortsInterrupts();

			modus=0;
			signal_changed=0;
			interrupt_count=0;
			zaehler_phasen=0;
			startbit_ok=0;
		}
	}
}

// ==================================================================
// Interrupt Service Routinen
// ==================================================================

ISR(TIMER0_COMPA_vect)
{
	interrupt_count++;
}

ISR(PCINT_vect)
{
	timer_config_start;
	
	if (PINB &= (1<<PB0)){
		signal_changed=1; }		// Eingang ist High, d. h. kein Empfang am TSOP --> Wechsel An>Aus --> Ende/Dauer Pulse-Phase
	else {
		signal_changed=2; }		// Eingang ist Low, d. h. Empfang am TSOP --> Wechsel Aus>An --> Ende/Dauer Pause-Phase
}

// ==================================================================
// Helper Funktionen
// ==================================================================
void initPortsInterrupts()
{
	// 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();
}

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;
	}
}