#include <avr/io.h>
#include <avr/eeprom.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <stdint.h>
#include <inttypes.h>
#include <ctype.h>
#include <stdarg.h>
#include <ctype.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>



// Globale Variablen

volatile unsigned int L;
 short int tp0=0;
unsigned int eep1 __attribute__((section(".eeprom")));
unsigned int eep2 __attribute__((section(".eeprom")));
unsigned int eep3 __attribute__((section(".eeprom")));
unsigned int eep4 __attribute__((section(".eeprom")));
unsigned int eep5 __attribute__((section(".eeprom")));
unsigned int eep6 __attribute__((section(".eeprom")));
unsigned int eep7 __attribute__((section(".eeprom")));
unsigned int eep8 __attribute__((section(".eeprom")));

int *peep1=(int*)(12345);
int *peep2=(int*)(54321);

	
//------------------------------------------------------------------------------------------
//Initialisierung
void init(void)							//Initialisierung
{
    DDRA = 0xFF; 						//Alle A Pins = Ausgänge
	DDRA &=~ (1<<PA5);
	DDRA &=~ (1<<PA6);
	DDRA &=~ (1<<PA7);
	PORTA = 0b11111111;
	DDRB = 0x00;						//Alle B Pins = Eingänge
	DDRC = 0x00; 						//Alle C Pins = Eingänge
	DDRD = 0xE0;    					//Portleitung D.7 D.6 und D.5 als Ausgang
	PORTC = 0b11111111;					//Ports auf Low schalten
	PORTA = 0x00;						//Ports auf Low schalten
	PORTD = 0x00;				  		//Ports auf LOW schalten
	piep();								//Piep zum Programmstart
	//UCR |= (1<<TXEN);					//Nur fuer alte Controller
	UCSRB |= (1<<TXEN)|(1<< RXEN);		// UART TX und RX einschalten
	UCSRC |= (1<<URSEL)|(3<<UCSZ0);	// Asynchron 8N1 
	UBRRH = (uint8_t)( UART_UBRR_CALC( UART_BAUD_RATE, F_CPU ) >> 8 );
    UBRRL = (uint8_t)UART_UBRR_CALC( UART_BAUD_RATE, F_CPU );
	//alternativ bei der avr-libc "direkt 16bit" : 
    //UBRR = UART_UBRR_CALC( UART_BAUD_RATE, F_CPU );
//------------------------------------------------------------------------------------------
//Teachprogramm
void teach()
{
	//Eingabe der Pulse für Positionen 1-9  in die Variablen tp1 - tp8
	//Eingabe geschieht über die Tasten WASD. Die Schritte werden in den 
	//Variablen tp gespeichert.
	char dummy[2],ch,ch2;
	unsigned int i,z,zsp;
	
	zsp=0;
	PORTA |=(1<<PA2);
	_delay_ms(200);
	
	sendSTR("\n\r===================================================\n\r");	
	sendSTR("\n\r Zum uebernehmen des Punktes bitte Enter druecken! \n\r");
	sendSTR("\n\r===================================================\n\r");	
	do
	{
    	if((ch=receiveBYTE()))	//Abfrage der Tastatur, ob eine der 4 Tasten gedrückt)
		{
			switch (ch) 
			{
				case ta:{
						//Positiver Ausgang 1000 Schritte
						for (z=0;z<10;z++)
						{
							for (i=0;i<100;i++)
							{
								PORTA |=(1<<PA0);	//Pulse
								_delay_ms(0.05);	//Wartezeit zum erzeugen von Takten
								PORTA &=~(1<<PA0);	//Pulse
								_delay_ms(0.05);
							}
							i=0;
						}
						L=L+1;
						zsp=L;
						}
					break;
					
				case td: {
						//negativer Ausgang 1000 Schritte
						PORTA |= (1<<PA1);
						for (z=0;z<10;z++)	
						{
							for (i=0;i<100;i++)
							{
								PORTA |=(1<<PA0);	//Pulse
								_delay_ms(0.05);	//Wartezeit zum erzeugen von Takten
								PORTA &=~(1<<PA0);	//Pulse
								_delay_ms(0.05);
							}
							i=0;
						}
						L=L-1;
						zsp=L;
						PORTA &=~ (1<<PA1);}	//ausschalten des Richtungsports
					break;
					
				case tw:{
						//Positiver Ausgang 10000 Schritte						
						for (z=0;z<100;z++)
						{
							for (i=0;i<100;i++)
							{
								PORTA |=(1<<PA0);	//Pulse
								_delay_ms(0.05);	//Wartezeit zum erzeugen von Takten
								PORTA &=~(1<<PA0);	//Pulse
								_delay_ms(0.05);
							}
							i=0;
						}
						L=L+10;
						zsp=L;
						}
					break;
					
				case ts:{
						//Negativer Ausgang 10000 Schritte
						PORTA |= (1<<PA1);
						for (z=0;z<100;z++)	
						{
							for (i=0;i<100;i++)
							{
								PORTA |=(1<<PA0);	//Pulse
								_delay_ms(0.05);	//Wartezeit zum erzeugen von Takten
								PORTA &=~(1<<PA0);	//Pulse
								_delay_ms(0.05);
							}
							i=0;
						}
						L=L-10;
						zsp=L;
						PORTA &=~ (1<<PA1);}	//ausschalten des Richtungsports
						
					break;
					
				case CR : goto eins;			//bei Enter - zum abspeichern springen
				case ESC: { ende();				//bei ESC abbrechen
							PORTA &=~(1<<PA2);
							goto zwei;			//verlassen des Teachprogramms
						}
				default  : 	sendSTR("unknown command");
				}
			}
			dummy[0]=ch;		//senden der Eingabe
			dummy[1]='\0';
			sendSTR(dummy);
	} while(1);  
eins:
	
	frage2();	
	PORTA &=~(1<<PA2);
	do
	{
		if((ch2=receiveBYTE()))	//Abfragen der Tasten 1 bis 9 zum auswählen der Speicherpunkte
		{
			switch (ch2)
			{
				case Sp1:{			
						frage();
						do{
						if((ch=receiveBYTE()));
						switch(ch){
						case CR:
								
								eeprom_write(*peep1, zsp);
								
								
								/*
								eep1=0x0A;
								EECR |= (1<<EEMWE);
								_delay_ms(500);
								eeprom_write_word(&eep1,zsp);
								_delay_ms(500);*/
								zsp=0;
								goto zwei;
								break;
						case ESC:
								ende();
								goto drei;
								break;
						}
						}while(1);}	
					break;		
				case Sp2:{			
						frage();
						do{
						if((ch=receiveBYTE()));
						switch(ch){
						case CR:
								
								eeprom_write(*peep2,zsp);
								/*eep2=0x14;
								EECR |= (1<<EEMWE);
								_delay_ms(500);
								eeprom_write_word(&eep2,zsp);
								_delay_ms(500);
								*/
								zsp=0;
								goto zwei;
								break;
						case ESC:
								ende();
								goto drei;
								break;
						}
						}while(1);}	
					break;
...
//-----------------------------------------------------------------------------------
//Verfahren --- die Variable Schritt muss übergeben werden
void fahren(int wegf)
{	
	volatile short int mitte,t,v,Tmax,Tmin;
	volatile short int xb,xv,xbl,i;
	volatile unsigned int z;
	volatile unsigned int P;
	//Bestimmung von Variablen
	
	/*
	if(tp0==0)
	{
		sendSTR(" tp0 ");
	}
	else
	{
		sendSTR(" tp0 !=0 ");
	}*/
	
	for(z=0;z<(tp0+1);z++)
	{
		sendSTR(" tp0 ");
	}
	P=0;
	//P = (unsigned int) eeprom_read_word (&eep1);
	P= eeprom_read(*peep1);
	for(z=0;z<(P);z++)
	{
		sendSTR(" tp1 ");
	}
	P=0;
	//P = (unsigned int) eeprom_read_word (&eep2);
	P= eeprom_read(*peep2);	
	for(z=0;z<(P);z++)
	{
		sendSTR(" tp2 ");
	}
	P=0;


//------------------------------------------------------------------------------------------
void manuell()
{
	volatile int weg;
	volatile unsigned int P;
	sendSTR("Punkte werden zu Testzwecken angefahren\n\r");
	sendSTR("\n\r Punkt 0 \n\r");
	
	weg= tp0 - L;	//Weg 1
	fahren(weg);
	_delay_ms(2000);
	
	P=0;
	//P = (unsigned int) eeprom_read_word (&eep1);
	P= eeprom_read(*peep1);
	sendSTR("\n\r Punkt 1 \n\r");
	weg = P - L;	//Weg 1
	fahren(weg);
	_delay_ms(2000);
	
	sendSTR("\n\r Punkt 2 \n\r");
	P=0;
	//P = (unsigned int) eeprom_read_word (&eep2);
	P= eeprom_read(*peep2);
	weg = P - L;
	fahren(weg);
}
//------------------------------------------------------------------------------------------
/*Schnittstellen beschreibung 		    */
/*input : Speicheradress-Stelle, Daten */


void eeprom_write (unsigned short address, unsigned char data) {
  cli ();
  while (EECR & (1<<EEWE));
  EEAR = address;
  EEDR = data;
  EECR |= (1<<EEMWE);
  EECR |= (1<<EEWE);
  sei();
}

//------------------------------------------------------------------------------------------
/*Schnittstellen beschreibung 			*/
/*input : Speicheradress-Stelle			*/
/*output: Rückgabewert: als charakter	*/

int eeprom_read (unsigned short address) 
{
  while(EECR & (1<<EEWE));
    EEAR = address;
  EECR |= (1<<EERE);
  return EEDR;
}