/*
 * Gondel.c
 *
 * Created: 07.12.2013 17:41:10
 *  Author: Manuel
 */ 
#define F_CPU						1000000UL
#define EEPReadWord(addr)			eeprom_read_word((uint16_t *)addr)
#define EEPWriteWord(addr, val)		eeprom_write_word((uint16_t *)addr, val)

#define Hall1						PA0
#define PotiGesch					PA1
#define PotiStand					PA2
#define LED							PA3
#define PWM							PA6
#define Richtung					PA7
#define Hall2						PB0
#define Anlernen					PB2

#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <avr/wdt.h>
#include <avr/eeprom.h>
	
uint8_t Startsequenz;									//Byte um Startfrequenz festzulegen
uint8_t Lernroutine;									//Byte um Lernroutine festzulegen
uint8_t ADC_Geschwindigkeit;							//Byte für Geschwindigkeitmessung
uint8_t ADC_Standzeit;									//Byte für Standzeitmessung
uint16_t Motorrichtung;									//word zum speichern der Motorrichtung
uint16_t Schritte;										//word für eine Runde
uint16_t Runde;											//word für Rundenzähler
uint16_t SollRunden;									//word für sollrunden
uint8_t Speed = 80;
uint8_t i;												//byte für Wiederholfuntkionen


void ADC_Auslesen(uint8_t ADC_sel)						//Funktion ADC-Auslesen
{
	ADMUX &= ~(1<<MUX1) & ~(1<<MUX0);					//ADC_Channel zurücksetzen
	ADMUX |= 1<<ADC_sel;								//ADC Channel auswählen
	ADCSRA |= 1<<ADSC;									//ADC starten
	while(ADCSRA & (1<<ADSC))							//warten bis Konvertierung fertig
	{}
}

void Warten(uint8_t Standzeit)							//Funktion Warten
{
	for(i = Standzeit+25; i>0; i--)						//Wartezeit von 40 ms solange wiederholen bis ADC-Wert erreicht
	{
		_delay_ms(40);									//0,04 * (25 bis 280) entspricht mindestens 1sek bis ~11,2sek max wartezeit
	}
}

void Speedset(void)
{
	ADC_Auslesen(0);									//ADC1 auswählen und starten
	ADC_Geschwindigkeit = ADCH;							//ADC-High in Variable speichern

	OCR1A = Speed - (ADC_Geschwindigkeit/5);				//Geschiwindigkeit festlegen
}

void StartRampe(void)									//Funktion Start
{	

			Speedset();									//Geschwindigkeit auslesen, festlegen
			OCR1A += 200;								//und verlangsamen

			TCCR1A |= 1<<COM1A0;						//PWM wieder an ausgang schalten
		
			for(i = 100; i>0; i--)						//Wartezeit von 25 ms 100-mal wiederholen
			{
				OCR1A -= 1;								//Geschwindigkeit dabei alle 40 ms erhöhen
				_delay_ms(40);
			}
		
			for(i = 100; i>0; i--)						//Wartezeit von 50 ms 100-mal wiederholen
			{
				OCR1A -= 1;
				_delay_ms(50);							//Geschwindigkeit dabei alle 50 ms erhöhen
			}				
														//bis Anfangsgeschwindigkeit vom ADC-Auslesen erreicht
			
			PCMSK0 |= 1<<PCINT0;						//Interrupt wieder aktivieren
			PCMSK1 |= 1<<PCINT8;						//Interrupt wieder aktivieren
			Startsequenz &= ~(1<<0);					//Startsequenz nicht wiederholen		
}

void EndRampe(void)										//Funktion Enderampe
{
			for(i = 100; i>0; i--)						//Wartezeit von 40 ms solange wiederholen bis ADC-Wert erreicht
			{
				OCR1A += 1;
				_delay_ms(50);
			}
			for(i = 100; i>0; i--)
			{
				OCR1A += 1;
				_delay_ms(40);
			}
}
	
void LED_blink(uint8_t blinkzahl)						//Funktion Status LED blinken
{

	for(i = blinkzahl; i>0; i--)						//So oft blinken wie in Eingabewert vorgesehen
	{
		PORTA |= 1<<LED;
		_delay_ms(200);
		PORTA &= ~(1<<LED);
		_delay_ms(200);
	}	
}

void Richtungswahl(void)
{
	if(bit_is_clear(Motorrichtung, 0))
	{
		PORTA |= 1<<Richtung;				//Richtung Motor 0
	}
	if(bit_is_set(Motorrichtung, 0))
	{
		PORTA &= ~(1<<Richtung);			//Richtung Motor 1
	}
}

void Lernfunktion(void)									//Funktion zum Lernen des Abstandes der zwei Hallelemente
{
			LED_blink(5);								//LED blinkt fünfmal um Lernroutinenstart anzuzeigen
			
			Speedset();									//Geschwindigkeit auslesen, festlegen
		
			TCCR1A |= 1<<COM1A0;						//PWM wieder an Ausgang schalten

		do {}
			while (bit_is_clear(Startsequenz, 0));		//warten bis Ende das erste mal erreicht
			{}
				
			LED_blink(2);
			Runde = 0x00;
			Startsequenz &= ~(1<<0);
			
			Richtungswahl();
			
			Speedset();									//Geschwindigkeit auslesen, festlegen
	
			TCCR1A |= 1<<COM1A0;						//PWM wieder an ausgang schalten
			_delay_ms(2000);
			PCMSK0 |= 1<<PCINT0;						//nach 2 sekunden Interrupt wieder aktivieren
			PCMSK1 |= 1<<PCINT8;						//Interrupt wieder aktivieren
	
		do {}
			while (bit_is_clear(Startsequenz, 0));		//wenn Ende das zweite mal erreicht:
			{}
				
			EEPWriteWord(0x20, Runde);					//gezählte Runden in EEPROM speichern
			Runde = 0x00;								//Runden zurücksetzen

			SollRunden = 0x00;
			SollRunden |= EEPReadWord(0x20);			//SollRunden auslesen
			
			EEPWriteWord(0x22, Motorrichtung);			//Motorrichtung speichern
			
			Richtungswahl();

			LED_blink(4);
			Lernroutine &= ~(1<<0);						//Lernroutine nicht wiederholen
			GIMSK &= ~(1<<INT0);						//Interrupt0 wieder aktivieren
}

void initialisieren(void)								//******* Initialisierung *******
{
		
	wdt_disable();										//Watchdog ausschalten
	
	//Ausgänge definieren		
	DDRA |= 1<<PWM | 1<<Richtung | 1<<LED;				//PINA6 Ausgang für PWM; PINA7 für Richtung des Motors; 
														//PINA3 als Status: 3x Blink: Initialisierung abgeschlossen
														//					5x Blink: Lernroutine beginnt
														//					2x Blink: wähernd Lernroutine = Anzeigen das die Gonel das erste mal am Ende steht
														//					4x Blink: Lernroutine beendet
	DDRA &= ~(1<<PotiGesch) & ~(1<<PotiStand);			//PINA1 und PINA2 als Eingänge für ADC1 und ADC2
	DDRA &= ~(1<<Hall1);								//PINA0 für Interrupt Hall1 als Eingang definieren
	DDRB &= ~(1<<Anlernen) & ~(1<<Hall2);				//PINB0 für Interrupt Hall2 //PINB2 für Interrupt der Lernroutine als Eingang definieren
	
	//PWM TIMER1 initialisieren
	TCCR1A |= 1<<WGM10;									//fast PWm einschalten (PA6)
	TCCR1B |= 1<<WGM13 | 1<<CS11 |1<<CS10;				//fast PWM mode einschalten und Prescaler: 64 (1.000.000/64)
	TIMSK1 |= 1<<OCIE1A;								//TIMER1 Interrupt für compare match OCR1A aktivieren (zum Schritte zählen)
			
	//ADC initialisieren
	ADCSRA |= 1<<ADPS1 | 1<<ADPS0 | 1<<ADEN;			//Prescaler: 8 und ADC einschalten
	ADCSRB |= 1<<ADLAR;									//nur obere 8bit-modus
		
	//Interrupt Hall Sensor 1 initialisieren
	GIMSK |= 1<<PCIE0;									//Pin Change Interrupt 0-7 aktivieren
	PCMSK0 |= 1<<PCINT0;								//Pin Change Interrupt 0 auswählen (PA0 - Hall1)

	//Interrupt Hall Sensor 2 initialisieren
	GIMSK |= 1<<PCIE1;									//Pin Change Interrupt 8-11 aktivieren
	PCMSK1 |= 1<<PCINT8;								//Pin Change Interrupt 8 auswählen (PB0 - Hall2)
	
	//Interrupt Taster initialisieren
	MCUCR |= 1<<ISC01;									//Low Level Interrupt an pin PB2 (Anlernen)
	GIMSK |= 1<<INT0;									//Interrupt INT0 aktivieren


	sei();												//Global Interrupts aktivieren	

	//Auf Start vorbereiten		
	Lernroutine &= ~(1<<0);
	Startsequenz &= ~(1<<0);
	Runde = 0x00;
	Schritte = 0x00;
	
	SollRunden = 0x00;
	SollRunden |= EEPReadWord(0x20);					//Rundenwert auslesen und in Variable speichern
	
	Motorrichtung = 0x00;
	Motorrichtung |= EEPReadWord(0x22);					//Motorrichtung auslesen
	Richtungswahl();
	
	TCCR1A |= 1<<COM1A0;								// Nicht mit Lernroutine oder Startsequenz beginnen und PWM an Ausgang PA6 schalten
				
	LED_blink(3);										//LED blinkt dreimal um Abschluss der initalisierung anzuzeigen
}


int main(void)
{	
	
	initialisieren();
	
	//********** Hauptprogramm **********
	while(1)
	{
	
	//************************************************** 
	//***********Lernroutine

	if(bit_is_set(Lernroutine, 0))
		{
			Lernfunktion();
		}
		
	//************************************************** 
	//***********Endstation

	if(bit_is_set(Startsequenz, 0))						//Variable für Ende gesetzt?
		{
			Richtungswahl();
				
			EEPWriteWord(0x22, Motorrichtung);			//Motorrichtung speichern
											
			Runde = 0x00;								//Runden zurücksetzen
			
			SollRunden = 0x00;
			SollRunden |= EEPReadWord(0x20);			//Rundenwert auslesen und in Variable speichern
		
			ADC_Auslesen(1);							//ADC2 auswählen und starten
			ADC_Standzeit = ADCH;						//ADC-High in Variable speichern

			Warten(ADC_Standzeit);						//wartezeit aufrufen
		
			StartRampe();								//Startrampe aufrufen
		}
	
	//************************************************** 
	//***********Langsam werden
	
	if(Runde >= SollRunden-8)
		{
			EndRampe();
		do {}
			while (bit_is_clear(Startsequenz, 0));		//warten bis Ende das erste mal erreicht
			{}
		}
	
	
	//************************************************** 
	//***********Standardschleife
	
	if(Runde < SollRunden-8)
		{
			Speedset();
		}
	}
}	
	
ISR(PCINT0_vect)										//Interrupt für Hall1 (UNTEN)
{
	PCMSK0 &= ~(1<<PCINT0);								//PinChange Interrupt deaktivieren	
	TCCR1A &= ~(1<<COM1A0);								//PWM vom ausgang trennen
	Startsequenz |= 1<<0;								//Starsequenzvariable setzen
	Motorrichtung &= ~(1<<0);							//Motorrichtung = 0 (Gondel steht unten)
}

ISR(PCINT1_vect)										//Interrupt für Hall2 (OBEN)
{
	PCMSK1 &= ~(1<<PCINT8);								//PinChange Interrupt deaktivieren
	TCCR1A &= ~(1<<COM1A0);								//PWM vom ausgang trennen
	Startsequenz |= 1<<0;								//Starsequenzvariable setzen
	Motorrichtung |= 1<<0;								//Motorrichtung = 1 (Gondel steht oben)

}

ISR(EXT_INT0_vect)
{
	GIMSK &= ~(1<<INT0);								//PinChange Interrupt deaktivieren
	TCCR1A &= ~(1<<COM1A0);								//PWM vom ausgang trennen
	Lernroutine |= 1<<0;								//Lernroutinevariable setzen
}

ISR(TIM1_COMPA_vect )									//Interrupt zum Zählen einer Runde
{
	Schritte ++;
	if (Schritte == 400)
	{
		Schritte = 0x00;
		Runde ++;
	}
}