/**********************************************************************\
* Kurzbeschreibung:
*ATMega8a: 
*
*
* Datum:            Autor:                  Grund der Aenderung:
* 17.07.2016        Tobias Kärner           Neuerstellung
*
\**********************************************************************/


/*--- #defines -------------------------------------------------------*/
#define F_CPU 1000000UL				//Taktfrequenz
#define BAUD 9600					//Badrate für UART
#define UART_ANGEHAENGT '\n'		//wird an jeden gesendeten string angehängt
#define UART_FOLGEZEICHEN ','		//
#define SLAVES_ANGESCHLOSSEN (8*1)	//Anzahl der Slave Geräte zum zünden

/*--- #includes ------------------------------------------------------*/
#include <avr/io.h>             //Standardregister
#include <avr/interrupt.h>      //Interupts
#include <util/delay.h>         //warte_Funktion
#include <util/setbaud.h>		//für UART

/*--- typedef-Datentypen ---------------------------------------------*/

/*--- Funktionen -----------------------------------------------------*/
void init_uart(void);
uint8_t uart_getc(void);
void uart_gets( char* Buffer, uint8_t MaxLen );
uint16_t uart_getdata(void);
void uart_putc(char c);
void uart_puts(char* string);

/*--------------------------------------------------------------------*/

int main(void)
{
	/*--- Variablen ---*/
	uint16_t zeiten[SLAVES_ANGESCHLOSSEN] = {0};
	uint16_t test;
	int zaehler1;	
	int zaehler2;
	
	init_uart();
	while(1)	//das ist jetzt nur um auszuprobieren ob UART überhaupt noch funktioniert, eigendlich läuft andere while Schleife
		uart_puts("test ");
	/*while(1)
	{
		uart_puts("\nBitte Eingabe: ");
		
		zaehler2 = 0;
		for (test = uart_getdata(); test != 0; test = uart_getdata())
		{
			zeiten[zaehler2++] = test;
			uart_putc('\n');
		}
		uart_putc('\n');
		for(zaehler1 = 0; zaehler1 < SLAVES_ANGESCHLOSSEN; zaehler1++)
		{	
			for (zaehler2 = 5; zaehler2 > 0; zaehler2--)
			{
				uart_putc((zeiten[zaehler1] % 10) + 48);
				zeiten[zaehler1] /= 10;
			}
			uart_puts(", ");
		}
		uart_puts("\n\n");
	}*/
	
	return 0;
}

////////////////////////////////////////////////////////////////////////////////////////
/************************************ UART ********************************************/
////////////////////////////////////////////////////////////////////////////////////////
/*** UART initialisieren ***/
void init_uart(void)
{
	UBRRH = UBRRH_VALUE;
	UBRRL = UBRRL_VALUE;		// evtl. verkuerzt falls Register aufeinanderfolgen (vgl. Datenblatt) UBRR = UBRR_VALUE;
	#if USE_2X
		UCSRA |= (1 << U2X);	// U2X-Modus erforderlich
	#else
		UCSRA &= ~(1 << U2X);	// U2X-Modus nicht erforderlich
	#endif
	UCSRB = (1<<TXEN)|(1<<RXEN);  // UART TX/RX einschalten
	UCSRC = (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0);  // Asynchron 8N1
}

/*** UART empfangen ***/
uint8_t uart_getc(void)	//UART Zeichen empfangen
{
	while (!(UCSRA & (1<<RXC)));   // warten bis Zeichen verfuegbar
	
	return UDR;                   // Zeichen aus UDR an Aufrufer zurueckgeben
}

void uart_gets( char* Buffer, uint8_t MaxLen )	//UART String empfangen
{
	uint8_t NextChar;
	uint8_t StringLen = 0;
	
	NextChar = uart_getc();         // Warte auf und empfange das nächste Zeichen
	// Sammle solange Zeichen, bis:
	// * entweder das String Ende Zeichen kam
	// * oder das aufnehmende Array voll ist
	while( NextChar != UART_ANGEHAENGT && StringLen < MaxLen - 1 )
	{
		*Buffer++ = NextChar;
		StringLen++;
		NextChar = uart_getc();
	}
	
	// Noch ein '\0' anhängen um einen Standard
	// C-String daraus zu machen
	*Buffer = '\0';	
}

uint16_t uart_getdata(void)	//UART String empfangen
{
	uint16_t ausgabezahl = 0;	//!!!einzulesende Zahl [0, 65535]
	char eingabe;
	
	while (!(UCSRA & (1<<RXC)));	// warten bis Zeichen verfuegbar; Zeichen ist dann in UDR enthalten
	eingabe = UDR;					//speichert den eingelesen Wert in Variable
	
	while ( (eingabe != UART_ANGEHAENGT) && (eingabe != UART_FOLGEZEICHEN) )
	{
		uart_putc('N');
		uart_putc(eingabe);
		ausgabezahl *= 10;
		ausgabezahl += eingabe - 48;
		while (!(UCSRA & (1<<RXC)));   // warten bis Zeichen verfuegbar; Zeichen ist dann in UDR enthalten
		eingabe = UDR;
	}
	return ausgabezahl;                   // Zeichen aus UDR an Aufrufer zurueckgeben
}

/*** UART senden ***/
void uart_putc(char c)
{
	while (!(UCSRA & (1 << UDRE)));			// Warten bis Buffer bereit ...
	UDR = c;								// Senden...
}

void uart_puts(char* string)
{
	unsigned char i;

	for (i=0;i<255;i++)				// Maximal 255 Zeichen ausgeben ...
	{
		if (string[i] != 0)
			uart_putc(string[i]);
		else
			break;					// Ende des Strings erreicht
	}
	//uart_putc(UART_ANGEHAENGT);
}