#define F_CPU3686400
#include <avr\io.h>
#include <stdio.h>
#include <stdlib.h>

int16_t einlesen (int16_t istwert); //Einlesefunktion der Ausgangsspannung am Filter

int16_t pidsense;

/////////////////////////////Funktionen dienen ausschliesslich dem PRINT-Befehl/////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//----------------------------------------------------------------------
void initUART()
{
	UBRRL = 23;       		//9600Baud siehe Baudratentabelle
	UCSRB = 8 + 16;         //Sender enable, Empfänger enable
}
//----------------------------------------------------------------------

char getChar()
{
	char data=0;
	//warte bis RX-complete RXC UCSRA / USR bei z.B.: AT090S2313
	while (!(UCSRA&128));
	//empfangen
	data=UDR;
	return data;
}
//----------------------------------------------------------------------

void putChar(char data)
{
	//warte bis UDR leer ist UCSRA / USR bei z.B.: 2313
	while (!(UCSRA&32));
	//sende
	UDR=data;
}
void print(char buffer[])
{
	for (int i=0;buffer[i]!=0;i++)
		putChar(buffer[i]);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

int main (void)
{
	//Hauptprogramm

	//Initialisierung der Hardware

	TCCR1A=(1<<WGM11)|(1<<WGM10)|(1<<COM1A1);//PWM setzten, WGM10 und 11 heisst 10 Bit Auflösung, COM1A1 nicht invertiert
	TCCR1B=(1<<DDB1); //PWM Timer auf default stellen, keine Teilung
	DDRB|=(1<<DDB1);//Setze Port B1 auf Ausgang
	DDRC&=~(1<<DDC1); // Setze Port C1 auf Eingang
	DDRC&=~(1<<DDC0);

	//Ende der Initialisierung der Hardware

	initUART();

	//Initialisierung der Variablen//

	char buffer[10];
	char zeichen;
	int16_t pidsetpoint=0;
	float help=0;
	float pidoutput=0;
	float err_0=0;
	float err_1=0;
	float err_2=0;
	float P=0;
	float I=0;
	float D=0;
	uint8_t index;

	pidsetpoint=einlesen(0);
	sprintf(buffer,"PID-Setpoint--->%d<----",pidsetpoint);	//Bestätigung für Eingabe
	print(buffer);

	print("P Anteil\n");
	zeichen=getChar();	//Wert einlesen
	putChar(zeichen);	//Funktion aufrufen
	sprintf(buffer,"K_p--->%d<----",zeichen);	//Bestätigung für Eingabe
	print(buffer);	
	atoi(&zeichen);		//Rückgabewert in integer wandeln
	P=zeichen;	

	print("I Anteil\n");
	zeichen=getChar();	//Wert einlesen
	putChar(zeichen);	//Funktion aufrufen
	sprintf(buffer,"K_i--->%d<----",zeichen);	//Bestätigung für Eingabe
	print(buffer);	
	atoi(&zeichen);		//Rückgabewert in integer wandeln
	I=zeichen;			//Wert in i-Glied speichern

	print("D Anteil\n");
	zeichen=getChar();	//Wert einlesen
	putChar(zeichen);	//Funktion aufrufen
	sprintf(buffer,"K_d--->%d<----",zeichen);	//Bestätigung für Eingabe
	print(buffer);	
	atoi(&zeichen);		//Rückgabewert in integer wandeln
	D=zeichen;			//Wert in D-Glied speichern
	//Ende der Initialisierung der Variablen//

	while(1)  //<-----Do While Schleife für Timer

	{
		pidsetpoint=einlesen(0);
		pidsense=einlesen(1);

		err_2=err_1;
		err_1=err_0;		
		err_0=pidsetpoint-pidsense; 

		pidoutput=pidoutput+P*(err_0-err_1);
		pidoutput=pidoutput+I*(err_1);
		pidoutput=pidoutput+D*(err_0-2*err_1+err_2);

		help=pidoutput/65;

		if (help>1023)	//Signalbegrenzung Start
		{
			help=1023; //Vergleichwert für PWM
		}
		else if (help<1)	//Signalbegrenzung Start
		{
			help=1; //Vergleichwert für PWM
		}
	else
		{
			help=help; //Vergleichwert für PWM

		}

		OCR1A=help;

		if(pidsense==pidsetpoint)
		{
			sprintf(buffer, "\n------>%d<-------", index);

			print(buffer);
		}
	else
		{
			sprintf(buffer, "\n%d", pidsense);

			print(buffer);		
		}
	}
	return 0;
	//Ende der Whileschleife

}
// Ende es Hauptprogramms

//Anfang einlesen 

int16_t einlesen (int16_t istwert)

{
	int index;
	int ergebnis;
	ADCSRA=(1<<ADEN)|(1<<ADPS2)|(1<<ADPS0);
	ADMUX= istwert;
	ADMUX|=(1<<REFS1)|(1<<REFS0); //Beide auf 1 gesetzt, damit gilt interne Referenzspannung
	ADCSRA|=(1<<ADSC);

	while (ADCSRA & (1<<ADSC))
	{
		; //wartet bis Wandlung abgeschlossen ist
	}

	for (index=0;index<10;index++)
	{
		//Anfang For-Schleife

		ADCSRA|=(1<<ADSC);
		while (ADCSRA &(1<<ADSC))
		{
			;
		}
		ergebnis+=ADCW;

	}
	//Ende For-Schleife

	ADCSRA &=~(1<<ADEN);  //ADC auf Low setzten, ADC kann wieder als I/O genutzt werden
	ergebnis /=10;
	return ergebnis;
}

//Ende einlesen