/*
 * RS232.cpp
 *
 * Created: 27.02.2013 11:27:43
 *  Author: leuthold
 */ 

#define BAUD 9600
#define F_CPU 16000000

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

#include <util/setbaud.h>


/*******************************************************************************************/
/* RS232 Funktionen */
//Initialisierung
void USART_Init (unsigned int baud)
{
	//set baud rate
	UBRRH = UBRRH_VALUE; //#include <util/setbaud.h> geht besser
	UBRRL = UBRRL_VALUE;
//	UBRRH = (unsigned char)(baud>>8);
//	UBRRL = (unsigned char)baud;

	//enable receiver and transmitter
	UCSRB = (1<<RXEN)|(1<<TXEN);

	//set frame format 8data, 2stop bit
	UCSRC = (1<<URSEL)|(1<<USBS)|(3<<UCSZ0);
}	
//Sende Daten
void USART_Transmit (unsigned char data)
{
	//wait for empty transmit buffer
	while(!(UCSRA & (1<<UDRE)));
	
	UDR = data;
}		
//empfange daten		
unsigned int USART_Receive (void)
{
	//wait for data to be received
	while (!(UCSRA&(1<<RXC)));
	
	return UDR;
}
//flushing the receive buffer
void USART_Flush(void)
{
	unsigned char dummy;
	while (UCSRA & (1<<RXC)) dummy = UDR;
}
/*******************************************************************************************/
/* ADC Funktionen */

/* ADC initialisieren */
void ADC_Init(void) {
 
  uint16_t result;
  ADMUX = (0<<REFS1) | (1<<REFS0);							// AVcc als Referenz benutzen
															// ADMUX = (1<<REFS1) | (1<<REFS0);      // interne Referenzspannung nutzen
															// Bit ADFR ("free running") in ADCSRA steht beim Einschalten
															// schon auf 0, also single conversion
  ADCSRA = (1<<ADPS1) | (1<<ADPS0);							// Frequenzvorteiler
  ADCSRA |= (1<<ADEN);										// ADC aktivieren
 															/* nach Aktivieren des ADC wird ein "Dummy-Readout" empfohlen, man liest
															also einen Wert und verwirft diesen, um den ADC "warmlaufen zu lassen" */
   ADCSRA |= (1<<ADSC);										// eine ADC-Wandlung 
  while (ADCSRA & (1<<ADSC) ) {}							// auf Abschluss der Konvertierung warten
															/* ADCW muss einmal gelesen werden, sonst wird Ergebnis der nächsten
															Wandlung nicht übernommen. */
  result = ADCW;
}
/************************************************************/ 
/* ADC Einzelmessung */
uint16_t ADC_Read( uint8_t channel )
{
															// Kanal waehlen, ohne andere Bits zu beeinflußen
  ADMUX = (ADMUX & ~(0x1F)) | (channel & 0x1F);
  ADCSRA |= (1<<ADSC);										// eine Wandlung "single conversion"
  while (ADCSRA & (1<<ADSC) ) {}							// auf Abschluss der Konvertierung warten
  return ADCW;												// ADC auslesen und zurückgeben
}
/************************************************************/
/* Mittelwertbildung */
uint16_t ADC_Read_Avg( uint8_t channel, uint8_t average )
{
  uint32_t result = 0;
 
  for (uint8_t i = 0; i < average; ++i )					//Summenberechnung von Anzahl average
    result += ADC_Read( channel );
 
  return (uint16_t)( result / average );					//Mittelwertbildung, Berechnung und Rückgabe
}


/*******************************************************************************************/

void channel_(int kanal)
{
	
		USART_Transmit (75);//K
		USART_Transmit (65);//A
		USART_Transmit (78);//N
		USART_Transmit (65);//A
		USART_Transmit (76);//L
		//USART_Transmit (95);//_
		USART_Transmit (kanal + '0');//Kanalnummer
		USART_Transmit (32);//" "
		USART_Transmit (58);//:
		USART_Transmit (32);//" "
		
}			

void einheit_mV(void)
{
	//USART_Transmit (32);//" "
	//USART_Transmit (109);//m
	USART_Transmit (59);//V
	//USART_Transmit (32);//" "
}	

void getit_(uint16_t channel)
{
		char c;
		unsigned int a_value[4], t_value, h_value, z_value, e_value;
		uint16_t adcval, value;
		
		//adcval =  ADC_Read(channel);
		adcval = ADC_Read_Avg(channel,10);
		
		value = 5 * adcval / 1,024;
		
		t_value = value / 1000;
		a_value[0]=t_value;
		
		h_value = (value - (t_value*1000))/100;
		a_value[1]=h_value;
		
		z_value = (value - (t_value*1000) - (h_value*100))/10;
		a_value[2]=z_value;
		
		e_value = value - (t_value*1000) - (h_value*100) - (z_value*10);
		a_value[3]=e_value;
		
		//USART_Transmit (13);
	
			//channel_(channel);
						
			for(int i= 0;i<=3;i++)
			{
				if(i==1)
				{
					USART_Transmit (44);
				}				
				c = a_value[i];
				USART_Transmit (c+48);
				//DDRC = a_value[i];
				//_delay_ms(1);
			}
			einheit_mV();				
}

void output_(int r_data)
{
	//PC0 Schalter 1 /******************************************/
	if((r_data & 0x01) == 0x01)//setzen
	{
		DDRC |=(1<<PC0);
	}
	if(!((r_data & 0x01) == 0x01))//löschen
	{
		DDRC &=~(1<<PC0);
	}
	//PC1 Schalter 2 /******************************************/
	if((r_data & 0x02) == 0x02)//setzen
	{
		DDRC |=(1<<PC1);
	}
	if(!((r_data & 0x02) == 0x02))//löschen
	{
		DDRC &=~(1<<PC1);
	}
	//PC2 Schalter 3 /******************************************/
	if((r_data & 0x04) == 0x04)//setzen
	{
		DDRC |=(1<<PC2);
	}
	if(!((r_data & 0x04) == 0x04))//löschen
	{
		DDRC &=~(1<<PC2);
	}
	//PC3 Schalter 4 /******************************************/
	if((r_data & 0x08) == 0x08)//setzen
	{
		DDRC |=(1<<PC3);
	}
	if(!((r_data & 0x08) == 0x08))//löschen
	{
		DDRC &=~(1<<PC3);
	}					
							
}		
	
int main(void)
{	
	//RS232 Initialisierung
	USART_Init (9600);
	//RS232 Initialisierungsende
	
	// ADC Initialisierung	
	ADC_Init();												
	//uint16_t adcval;	// unint16_t da 10Bit AD Wandler
	//ADC Initialisierungsende
	
	unsigned int  r1_data, r2_data, data; //Kommunikationsvariablen
	int i_data;
	bool merker;//Zustandsmerker
	DDRC = 0x0F; //Port C als Ausgang setzen
		
	while(1)
    {
		getit_(0); //Kanal 0 mit getit Funktion senden
		
		//_delay_ms(5);
		
		USART_Transmit (r1_data);
		
		//USART_Transmit (10);
		USART_Transmit (r2_data);
		
		//i_data = DDRC>>4 ;
		//USART_Transmit(i_data+48);
		//USART_Transmit (10);		
		//USART_Transmit (13); //Abschlusszeichen
		
		//_delay_ms(10); //Pause zwischen Senden und Empfangen
		//USART_Receive(); //Einmal Empfangen ohne Verwertung
						 //da Labview scheinbar was mit schickt
						 //halt was Unbekanntes
		
		r1_data = USART_Receive();	//Empfangen
		USART_Flush;
		//USART_Receive();
		r2_data = USART_Receive();
		//USART_Receive();
		//USART_Receive();
		//r1_data = r1_data-48;
		//_delay_ms(1); //Pause zwischen Senden und Empfangen
		//r2_data = r2_data - 48;		//Vorbereiten der Daten auf 0 "setzten"
				
		data = (r1_data-48)*10+(r2_data-48);	//+ (r2_data-48);
		output_(data);			//Übergabe der Werte an die Funktion 
								//output_ um den gewünschten Ausgang zusetzen
		
	}
}

//DDRC |=(1<<PC1); setzten
//DDRC &=~(1<<PC1);löschen
//DDRC ^=(1<<PC1); toggeln