#include <avr/io.h>
#include <stdlib.h>
#include <avr/delay.h>



/***** M A K R O S *******************************************************/

#define CLOCK 8000000L				//Makro 
#define BAUD 9600L					//Makro

#define UBRR_VAL ((CLOCK+BAUD * 8)/(BAUD*16)-1)		//Runden
#define BAUD_REAL (CLOCK/(16*(UBRR_VAL+1)))			//Reale Baudrate

#define BAUD_ERROR ((BAUD_REAL*1000)/BAUD-1000)		//Fehler in Promille

#if ((BAUD_ERROR>10)||(BAUD_ERROR<-10))
	#error Systematischer Fehler der Baudrate grösser 1% und damit zu hoch! 
#endif



/***** I N I T S *************************************/

void uart_init(void)
{
  UBRRH = UBRR_VAL >> 8;
  UBRRL = UBRR_VAL & 0xFF;

  UCSRB |= (1<<TXEN);  							//UART TX einschalten
  UCSRC = (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0); 	//Asynchron 8N1 
}

void adc_init(void)
{
	uint16_t x;

	ADMUX |= (1<<REFS0);				//AVCC als Referenz   
	ADCSRA |= (1<<ADEN);				// ADC aktivieren		
	ADCSRA |= (1<<ADPS2) | (1<<ADPS0);	// Frequenzvorteiler (auf 250khz da 8MHz/32= 250KHz)
		//ADMUX |= (0<<MUX3) | (0<<MUX2)| (0<<MUX1)| (1<<MUX0);		//ADC-Kanal, in main!!!
		//ADCSRA |= (1<<ADFR);				//Free Running Mode ein, 
	ADCSRA |= (1<<ADSC);                // "Dummy-Readout", eine ADC-Wandlung
		//ADMUX = (1<<ADLAR);				//Ergebnis linksbündig, d.h. (8 Bit in ADCH) 
	while (ADCSRA & (1<<ADSC) ) 		// auf Abschluss der Konvertierung warten
	{         
	}
	x = ADC;	//Ergebnis einmal lesen
}	



/***** U N T E R F U N K T I O N E N ***********************************/

void uart_send_char()
{
    if(UCSRA & (1<<UDRE))    // Senden, wenn UDR frei ist       
    { 
		UDR = 'x';           // schreibt das Zeichen x auf die Schnittstelle 
    }
}



int uart_putc(unsigned char c)// Senden einer Zeichenkette, Aufruf mit uart_puts("Zeichenkette")
{
    while (!(UCSRA & (1<<UDRE)))  // warten bis Senden moeglich
    {
    }                             
	UDR = c;                      // sende Zeichen
    return 0;
}
void uart_puts (char *s)	
{
    while (*s)
    {  
        uart_putc(*s);	 // so lange *s != '\0' also ungleich dem "String-Endezeichen(Terminator)" 
        s++;
    }
}



void uart_send_var() //Variable senden, benötigt uart_putc
{
   char c;

   for (uint8_t i=0; i<=9; ++i) 
   {
      c = i + '0';		
      uart_putc( c );	// verkuerzt: uart_putc( i + '0' );
   }
}



/*  Soll mehr als eine Ziffer ausgegeben werden, bedient man sich zweckmäßigerweise 
vorhandener Funktionen zur Umwandlung von Zahlen in Zeichenketten/Strings. Die Funktion 
der avr-libc zur Umwandlung von vorzeichenbehafteten 16bit-Ganzzahlen (int16_t) in 
Zeichenketten heißt itoa (Integer to ASCII). Man muss der Funktion einen Speicherbereich 
zur Verarbeitung (buffer) mit Platz für alle Ziffern, das String-Endezeichen ('\0') und 
evtl. das Vorzeichen bereitstellen. */ 
void uart_send_int(uint16_t value)  
{
	char s[7];
	uint16_t i = value;
   		//itoa( i, s, 10 ); // 10 fuer radix -> Dezimalsystem, itoa (Integer to ASCII)
		//uart_puts( s );
		// da itoa einen Zeiger auf den Beginn von s zurueckgibt verkuerzt auch:
	uart_puts( itoa( i, s, 10 ) );
}



void uart_send_double()  
{
   char s[8]; // Pufferspeicher ausreichend groß, evtl. Vorzeichen + width + Endezeichen:
   float f = -12.345;
   
   dtostrf( f, 6, 3, s ); 
   uart_puts( s );	// verkürzt: uart_puts( dtostrf( f, 7, 3, s ) );
}



uint16_t adc_read( uint16_t channel )
{
	uint16_t x;	

	ADMUX = (ADMUX & ~(0x1F)) | (channel & 0x1F);
	ADCSRA |= (1<<ADSC);            // eine Wandlung "single conversion"
	while (ADCSRA & (1<<ADSC) ) 	// auf Abschluss der Konvertierung warten
	{   
  	}
	x = ADCL;			
	x += (ADCH<<8); 
	return x;			// ADC auslesen und zurückgeben
}



/*void uart_return_new (uint8_t n, r)
{
	falls n = 1 sende uart_putc ('\n');
	falls 0 oder was anderes mache nüscht

	falls r = 1 sende uart_putc ('\r');
	falls 0 oder was anderes mache nüscht
}*/


/***** M A I N **********************************************************************/

int main (void) 
{
	uart_init();
	adc_init();
	
	uint16_t adcval;

	//DDRC = 0x00;

		while (1)
		{
		_delay_ms(200); 
			//uart_send_char();		//einzelnes Zeichen senden mit 'a'
			//uart_puts ("ADC0:");	//Zeichenfolge senden
			//uart_send_var();		//Variable ausgeben
			//uart_send_int();		//integer Zahl ausgeben
			//uart_send_double();	//double Zahl ausgeben
			//uart_putc ('\n');		//neue Zeile in Terminal, als Argument auch ('\n')?
			//uart_putc ('\r');		//neue Zeile in Terminal, als Argument auch ('\r')?
		uart_puts ("ADC0: ");	//Zeichenfolge senden
		adcval = adc_read(0);	//Aufruf mit Kanalangabe
		uart_send_int(adcval);	//Vorzeichenbehaftete integer Zahl ausgeben
			//uart_return_new(1, 1)
		uart_putc ('\n');		//neue Zeile in Terminal, als Argument auch ('\n')?
		uart_putc ('\r');		//neue Zeile in Terminal, als Argument auch ('\r')?
		uart_puts ("ADC1: ");	//Zeichenfolge senden
		adcval = adc_read(1);	//Aufruf mit Kanalangabe
		uart_send_int(adcval);	//Vorzeichenbehaftete integer Zahl ausgeben
			//uart_putc ('\n');		//"NEW", neue Zeile in Terminal, als Argument auch ('\n')?
		uart_putc ('\r');		//"RETURN", neue Zeile in Terminal, als Argument auch ('\r')?
		}
	return 0;	
}