//-----------------------------------------------------------------------------
#include "typedefs.h"
#include "application.h"
#include "spi_master.h"
#include "ad7719_adc.h"
#include "atmega_adc.h"    
#include "usart.h"
#include "macros.h"
//#include "interpol.h"
//#include "w5100_spi_interface.h"
#include <avr/interrupt.h>
#include <avr/wdt.h>
#include <stdlib.h>
//-----------------------------------------------------------------------------
// definition of some functions:
// these function are implemented in this file, this is not doog coding style.
// sooner or later, they will be moved into more apropriate files.
U08	increase_adc (U08 channel);
U08	increase_ad7719 (U08 channel);
void Set_V_Muxer (U08 channel);
void Set_T_Muxer(U08 channel);
void parse(); 
void check_if_measured_all() ;
void print_ad7719_nicely(bool with_header, bool with_LF) ;
void print_adc_nicely(bool with_header, bool with_LF) ;

void print_invalid_enable_statement();
void print_help() ;  // is not printin help at the moment .... eats up too much RAM
void print_adc_enable_status(bool with_headline);
void print_ad7719_enable_status(bool with_headline) ;

bool check_if_adc_measurement_done();
bool check_if_ad7719_measurement_done();


// end of function definition:
//-----------------------------------------------------------------------------

// Reference resistance
	float r_reference = 6.257;

// MAIN WORKFLOW GLOBAL VARIABLES
	bool verbose;
	bool heartbeat_enable;

// USART global variables
	U08 usart_rx_buffer[USART_RX_BUFFER_SIZE];
	U08 usart_tx_buffer[USART_TX_BUFFER_SIZE];
	U08 usart_received_chars;
	U08 usart_rx_buffer_index = 0;
	U08 usart_tx_buffer_index = 0;
  	U08 usart_last_char; 					// last received char

// USART FLAGS
	bool usart_tx_buffer_overflow = false;	// true if usart_tx_buffer was full.
	bool usart_rx_ready = false;			// EOL was received, parser needs to be called
	
// TIMER global variable
	volatile U32 local_ms = 0;

// AD7719 global variables
	#define TEMP_CHANNELS 16
	#define CHANNEL_BITMAP 2
	#define AD7719_READINGS_UNTIL_SETTLED 3 // bei3:480ms
	U32 ad7719_values[TEMP_CHANNELS];
	U08 ad7719_enables[CHANNEL_BITMAP];
	U08 ad7719_channels_ready[CHANNEL_BITMAP];
	U08 ad7719_readings_since_last_muxing = 0;
	U08 ad7719_current_channel = 0;
	U32 ad7719_current_reading = 0;
	bool ad7719_measured_all = false;
	bool ad7719_values_printed = true;
	bool ad7719_print_endless = false;
	
// ATMEGA ADC global variables
	#define V_CHANNELS 16
	#define V_BITMAP 2
	#define ADC_READINGS_UNTIL_SETTLED 1
	U08 adc_readings_until_mean=250;
	U32 adc_values[V_CHANNELS]; // stores measured voltage in steps of 16mV
	U08 adc_enables[V_BITMAP];
	U08 adc_channels_ready[V_BITMAP];
	U08 adc_readings_since_last_muxing = 0;
	U08 adc_current_channel = 0;
	U16 adc_current_reading = 0;
	bool adc_measured_all = false;
	bool adc_values_printed = true;
	bool adc_print_endless = false;

	bool debug_mode = false;
	
	//U32 hb_counter = 0;

//-----------------------------------------------------------------------------
//   M A I N    ---   M A I N    ---   M A I N    ---   M A I N    ---  M A I N    
//-----------------------------------------------------------------------------
int main(void)
{
	app_init();		  // Setup: Watchdog and I/Os
	usart_init();		// Initialize serial interface   
	spi_init(); 		// Initialize SPI interface as master
	ad7719_init(); 		// Initialize AD7719 ADC as SPI slave 
	atmega_adc_init();

// TIMER2 is used as local clock:
// configure timer 2
	TCCR2 = (1<<WGM21); // CTC Modus
	TCCR2 |= (1<<CS21) | (1<<CS20); // Prescaler 64 --> counts up every 8us
	OCR2 = 125-1; 					// --> output compare interrupt occurs every 125 x 8us = 1ms
	// Compare Interrupt erlauben
	TIMSK |= (1<<OCIE2);

  //  Enable interrupts
  sei();              

  PORTB &= ~(1<<PB2);
  
for ( U08 i=0; i<CHANNEL_BITMAP; ++i ) {
	ad7719_enables[1]=0x00;
	ad7719_enables[0]=0xFF;

//	ad7719_enables[i]=0x00;
	ad7719_channels_ready[i]=0;
	}

for ( U08 i=0; i<V_BITMAP; ++i ) {
	adc_enables[1]=0x33;
	adc_enables[0]=0xFF;
//	adc_enables[i]=0x00;
	adc_channels_ready[i]=0;
}


	static U08 welcome[]="welcome to:\n MSR command interface 1.0 \n build: 29.03.2010\n";
	usart_write_str(welcome);
	print_help();
	print_adc_enable_status(true);
	usart_write_char('\n');
	print_ad7719_enable_status(true);
	usart_write_char('\n');
	usart_write_str((pU08)"time:");
	usart_write_float((float)local_ms/1000 , 1,7);
	usart_write_str((pU08)" sec.\n");

//MAIN LOOP
while (1)
{
	if (check_if_adc_measurement_done()) {
		if(adc_print_endless){
			usart_write_str((pU08)"V|");
			usart_write_float((float)local_ms/1000 , 1,4);
			print_adc_nicely(false,true);
			for ( U08 i=0; i<V_BITMAP; ++i ) {
				adc_channels_ready[i]=0;
			}
		} else 
		if ( !adc_values_printed) {
			adc_values_printed = true;
			print_adc_nicely(true,true);
		}
	} 

	if (check_if_ad7719_measurement_done()) {
		if(ad7719_print_endless){
			usart_write_str((pU08)"R|");
			usart_write_float((float)local_ms/1000 , 1,4);
			print_ad7719_nicely(false,true);
			for ( U08 i=0; i<CHANNEL_BITMAP; ++i ) {
				ad7719_channels_ready[i]=0;
			}
		} else 
		if ( !ad7719_values_printed) {
			ad7719_values_printed = true;
			print_ad7719_nicely(true,true);
		}
	} 

//----------------------------------------------------------------------------

	if (heartbeat_enable) {
		PORTA ^= (1<<PA4); // toggle PA4 --> heartbeat
	
		// warte 100.000 heartbeats und schreibe die Zeit raus
		//hb_counter++;
		//if (hb_counter == 100000){
		//	hb_counter = 0;
		//	usart_write_float((float)local_ms/1000 , 1,7);
		//	usart_write_str((pU08)" sec.\n");
		//}
	}
		
//----------------------------------------------------------------------------
	//IF we need to send away one byte, and ready to send

	if ( (usart_tx_buffer_index > 0) && (UCSRA & (1<<UDRE)) ) { 
		UDR = usart_tx_buffer[0];
		// THis is shit
		for (U08 i=0 ; i < USART_TX_BUFFER_SIZE; ++i) {
			usart_tx_buffer[i] = usart_tx_buffer[i+1];
		}
		usart_tx_buffer_index--;
	}
//----------------------------------------------------------------------------

	//IF we just received one byte
	if ( UCSRA & (1<<RXC) )
	{
		usart_last_char = UDR;  // read the byte from ATmega internal buffer
								// what are we going to do with this byte?
		if (usart_rx_buffer_index < USART_RX_BUFFER_SIZE ) // if space in the buffer ... we store it.
		{
			usart_rx_buffer[usart_rx_buffer_index] = usart_last_char;
			usart_rx_buffer_index++;
			if (usart_last_char == '\n'){ // if EOL was received
				usart_rx_buffer_index--;
				usart_rx_buffer[usart_rx_buffer_index] = 0;
				usart_rx_ready = true;
			}
		} else {													// if no space in buffer ... we try to parse()
			usart_write_str((pU08)"receive buffer overflow ... parsing now\n");
			usart_rx_ready = true;
		}
	} 

//----------------------------------------------------------------------------

	//IF USART DOR bit is set, PC is sending data to fast!!!
	if ( UCSRA & (1<<DOR) ){
		usart_write_str((pU08)"PC sending to fast!\n");
		usart_last_char = UDR;
		// flush TX_buffer and write warning message in
		// maybe even switch off every measurement. ?
	}
//----------------------------------------------------------------------------

	//IF TX_BUFFER was overrun.	
	if (usart_tx_buffer_overflow) {
		// flash TX_buffer and write warning message in
		// maybe even switch off every measurement. ?
		//
		// this should only happen, in verbose mode and with low baudrates.
	}
//----------------------------------------------------------------------------
	
	//IF one command was received. 
	//	-It is not allowed to send more than one command between two '\n'
	if (usart_rx_ready){ 
		parse();
		usart_rx_ready = false;
		for ( U08 i =0 ; i < USART_RX_BUFFER_SIZE; i++){
			usart_rx_buffer[i]=0;
		}
		usart_rx_buffer_index = 0;
		
	}
//----------------------------------------------------------------------------

	//IF ATmega internal ADC did finish a conversion --every 200us
	if ( (ADCSRA & (1<<ADIF)) && !adc_measured_all) {
		adc_current_reading = (U16)ADCL;
		adc_current_reading += (U16)ADCH<<8;
		if (adc_readings_since_last_muxing == ADC_READINGS_UNTIL_SETTLED+adc_readings_until_mean-1) {
			adc_channels_ready[adc_current_channel/8] |= (1<<(adc_current_channel%8));
			adc_current_channel = increase_adc (adc_current_channel);
			adc_values[adc_current_channel] = 0;
			Set_V_Muxer(adc_current_channel);
			adc_readings_since_last_muxing = 0;
			_delay_ms(10);
		}
		else if (adc_readings_since_last_muxing >= ADC_READINGS_UNTIL_SETTLED-1) {
			adc_values[adc_current_channel] += adc_current_reading;
			++adc_readings_since_last_muxing;
		}
		else  {
			++adc_readings_since_last_muxing;
		}

	}
//----------------------------------------------------------------------------

	//IF AD7719 ADC just finished a conversion -- every 60ms
	
	if (AD7719_IS_READY() && !ad7719_measured_all) {
	

			ad7719_current_reading = read_adc(); // --takes at 4MHz SCLK speed about 6us
		// AD7719 is only read out if settled. saves time.	
		if (ad7719_readings_since_last_muxing == AD7719_READINGS_UNTIL_SETTLED-1) {
			ad7719_values[ad7719_current_channel] = ad7719_current_reading;
			ad7719_readings_since_last_muxing=0;
			if (debug_mode) {
				usart_write_U32_hex(ad7719_current_reading);
				usart_write_char('\n');
				usart_write_char('\n');
			}
			// now prepare the data to be send away via USART.
			
			// note that this channel is ready, now and 
			// proceed to the next enabled channel.
			ad7719_channels_ready[ad7719_current_channel/8] |= (1<<(ad7719_current_channel%8));
			ad7719_current_channel = increase_ad7719 (ad7719_current_channel);
			Set_T_Muxer(ad7719_current_channel);
		} else { // the AD7719 did not settle yet, we discard the reading
			++ad7719_readings_since_last_muxing;
			if (debug_mode) {
				usart_write_U32_hex(ad7719_current_reading);
				usart_write_char('\n'); 
			}

			// current reading is not used for anything else
		}
	}


} // end of MAIN LOOP

} // end of main function
//-----------------------------------------------------------------------------
//    E N D     E N D     E N D     E N D     E N D     E N D     E N D     
//-----------------------------------------------------------------------------


ISR (TIMER2_COMP_vect)
{
 ++local_ms;
}

U08	increase_adc (U08 channel){
U08 effective_channel;
	for ( U08 increase = 1 ; increase <= V_CHANNELS; increase++)
	{
		effective_channel = (channel + increase) % (V_CHANNELS);
		if (adc_enables[effective_channel/8] & (1<<effective_channel%8))
			return effective_channel;
	}
	return channel;
} // end if increase_adc;

U08	increase_ad7719 (U08 channel){
U08 effective_channel;
	for ( U08 increase = 1 ; increase <= TEMP_CHANNELS; increase++)
	{
		effective_channel = (channel + increase) % (TEMP_CHANNELS);
		if (ad7719_enables[effective_channel/8] & (1<<effective_channel%8))
			return effective_channel;
	}
	return channel;
} // end if increase_adc;

// Sets voltage Muxer to current channel
void Set_V_Muxer (U08 channel){
	PORTC = (PORTC & 0xF0) | (0x0F & channel); 
}

void Set_T_Muxer(U08 channel) {
	PORTA = (PORTA & 0xF0) | (0x0F & channel); // Here the muxer is switched.
}

bool check_if_adc_measurement_done(){
	adc_measured_all = true;
	for ( U08 i=0; i<V_BITMAP; ++i ) {
		if ((adc_enables[i] ^ adc_channels_ready[i]) != 0x00) {
			adc_measured_all = false;
			break;
		}
	}
	return adc_measured_all;
}

bool check_if_ad7719_measurement_done(){
	ad7719_measured_all = true;
	for ( U08 i=0; i<CHANNEL_BITMAP; ++i ) {
		if ((ad7719_enables[i] ^ ad7719_channels_ready[i]) != 0x00) {
			ad7719_measured_all = false;
			break;
		}
	}
	return ad7719_measured_all;
}

void print_ad7719_nicely(bool with_header, bool with_LF) {
	float value_in_ohms;
	if (with_header) {

		usart_write_str((pU08)"\n resistance(Ohm)\n (note: only enabled channels are printed):\n");

		// Überschrift alles in einer Zeile, hoffentlich sieht das gut aus.
		for (U08 i=0; i< TEMP_CHANNELS;++i) {
			usart_write_str((pU08)"|R");						// 1 letter -- R
			usart_write_U08(i, 2);							// 2 letters  -- the channel number 
			usart_write_str((pU08)"   ");  				// 5 spaces
		}
		usart_write_str((pU08)"|\n");
	}
		
	// Jetzt die Werte, auch alle in einer Zeile
	usart_write_char('|');
	for (U08 i=0; i< TEMP_CHANNELS;++i) {
		
		if (ad7719_enables[i/8] & (1<<i%8))
		{
			value_in_ohms = (r_reference * 1024 * ad7719_values[i]) / ((U32)1 << 25);
			if (value_in_ohms < 1000.0)
				usart_write_char(' ');
			if (value_in_ohms < 100.0)
				usart_write_char(' ');
			if (value_in_ohms < 10.0)
				usart_write_char(' ');
			usart_write_float(value_in_ohms, 1, 5);  	// 6 letters .. 1002.4 ohm .. this is 6 letter .. the dot . is also a letter
			usart_write_char('|');				// 2 spaces	
		} else {
			usart_write_str((pU08)"      |");			// or 8 spaces	
		}
	}
	if (with_LF)
		usart_write_char('\n');
}

void print_adc_nicely(bool with_header, bool with_LF) {

	if (with_header) {
		usart_write_str((pU08)"Voltage(mV),  Humidity(mV)  &  Pressure(mV):\n");

		for (U08 i=0; i < 8; ++i) {
			usart_write_str((pU08)"| V");
			usart_write_U08(i, 1); //data
			usart_write_str((pU08)"   ");
		}

		for (U08 i=0; i < 4; ++i) {
			usart_write_str((pU08)"| H");
			usart_write_U08(i, 1); //data
			usart_write_str((pU08)"   ");
		}
		for (U08 i=0; i < 4; ++i) {
			usart_write_str((pU08)"| P");
			usart_write_U08(i, 1); //data
			usart_write_str((pU08)"   ");
		}
		usart_write_str((pU08)"|\n");
	}

	// Jetzt die gemessenen Werte und zwar nur die Spannungen
	for (U08 i=0; i < 16; ++i) {
		usart_write_char('|');
		if (adc_enables[i/8] & (1<<i%8))
			usart_write_U32( ( ( adc_values[i] * 4 + 2 ) / adc_readings_until_mean ) , 6 );
		else
			usart_write_str((pU08)"      "); 
	}
	usart_write_char('|');

	if (with_LF)
		usart_write_char('\n');
}


/////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////// P A R S E R /////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////
// this method parses the data, 
// which came in via USART
// later it might as well parse the data from ethernet.
void parse() {

U08 input_number = 0;
bool enable = false;
// look at first byte
// I hope, I can manage to use one byte commands
	usart_rx_buffer[USART_RX_BUFFER_SIZE-1] = 0;
	usart_write_char(' ');
	usart_write_str(usart_rx_buffer);
	usart_write_char('\n');
	//usart_write_str((pU08)"\n received number of bytes:");
	//usart_write_U08(usart_rx_buffer_index,3);

	if (usart_rx_buffer_index >0) {
		switch (usart_rx_buffer[0]) {
			case 'E': 		// user wants to enable/disable something
			case 'e':
				enable = true;
			case 'D':
			case 'd':
			
				if (usart_rx_buffer_index>=1) {  // let's see what.
					if ( 	usart_rx_buffer[1] != 'r'  &&
							usart_rx_buffer[1] != 'v'  &&
							usart_rx_buffer[1] != 'h'  &&
							usart_rx_buffer[1] != 'p' )
						{
							print_invalid_enable_statement();
							break;
						}
				}
				
				input_number = 0;
				if (usart_rx_buffer_index >2) {  // lets check the first digit
					if ( usart_rx_buffer[2] >= '0' && usart_rx_buffer[2] <= '9' ) {
						input_number = usart_rx_buffer[2] - '0';
					} else {
						print_invalid_enable_statement();
						break;
					}
				}
				if (usart_rx_buffer_index >3) {  // lets check the 2nd digit
					if ( usart_rx_buffer[3] >= '0' && usart_rx_buffer[3] <= '9' ) {
						input_number = 10*input_number + usart_rx_buffer[3] - '0';
					} else {
						// okay as well ... if the second digit is missing .. 
						// we might have trailing spaces
						// that's okay .. we just accept the first number.
					}
				}
				if (usart_rx_buffer_index>2) {
					usart_write_str((pU08)"\n I will switch ");
					if (enable) 
						usart_write_str((pU08)"on ");
					else
						usart_write_str((pU08)"off ");
					
					// now we know, what the user wanted ... and we need to do it.
					switch (usart_rx_buffer[1]) {
						case 'r':
							if (enable)
								ad7719_enables[input_number/8] |= (1<<(input_number%8));
							else {
								ad7719_enables[input_number/8] &= ~(1<<(input_number%8));
								ad7719_channels_ready[input_number/8] &= ~(1<<(input_number%8));
								}
							usart_write_str((pU08)" resistance channel ");
							usart_write_U08(input_number,2);
							usart_write_char('\n');
							break;
						case 'v':
							if (enable)
								adc_enables[input_number/8] |= (1<<(input_number%8));
							else {
								adc_enables[input_number/8] &= ~(1<<(input_number%8));
								adc_channels_ready[input_number/8] &= ~(1<<(input_number%8));
								}
							usart_write_str((pU08)" voltage channel ");
							usart_write_U08(input_number,2);
							usart_write_char('\n');
							break;
							
						case 'h':
							if (enable)
								adc_enables[1] |= (1<<(input_number%4));
							else {
								adc_enables[1] &= ~(1<<(input_number%4));
								adc_channels_ready[1] &= ~(1<<(input_number%4));
								}
							usart_write_str((pU08)" humidity channel ");
							usart_write_U08(input_number,2);
							usart_write_char('\n');
							break;
						case 'p':
							if (enable)
								adc_enables[1] |= (1<<((input_number%4) + 4));
							else {
								adc_enables[1] &= ~(1<<((input_number%4) + 4));
								adc_channels_ready[1] &= ~(1<<((input_number%4) + 4));
								}
							usart_write_str((pU08)" pressure channel ");
							usart_write_U08(input_number,2);
							usart_write_char('\n');
							break;
						default:
							usart_write_str((pU08)"\n DAMN! this should never happen"
							"- enable/disable switch-case!\n");
							break;
					}
					
					
					
				}// end of if usart_rx_buffer_index>2  --> this should not be necessary at all
				break;
				
			case 'b':
				usart_write_str((pU08)"\nheartbeat ");
				heartbeat_enable = true;
				if (usart_rx_buffer[1] == '0'){
					heartbeat_enable = false;
					usart_write_str((pU08)"off\n");
				} else {
					usart_write_str((pU08)"on\n");
				}
				break;
			case 'G': 			// GET the Temperature channels, which are enabled
				ad7719_values_printed = false;
				for ( U08 i=0; i<CHANNEL_BITMAP; ++i ) {
					ad7719_channels_ready[i]=0;
				}
				break;
			case 'g':			// GET the voltage/current/humidity channels, which are enabled
				adc_values_printed = false;
				for ( U08 i=0; i<V_BITMAP; ++i ) {
					adc_channels_ready[i]=0;
				}
				break;

			case 'p':
					adc_print_endless = true;
				if (usart_rx_buffer[1] == '0')
					adc_print_endless = false;
				break;		

			case 'P':
					ad7719_print_endless = true;
				if (usart_rx_buffer[1] == '0')
					ad7719_print_endless = false;
				break;		
				

			case 's':			
				print_adc_enable_status(true);
				usart_write_char('\n');

				print_ad7719_enable_status(true);
				usart_write_char('\n');
			
				usart_write_str((pU08)"time:");
				usart_write_float((float)local_ms/1000 , 1,7);
				usart_write_str((pU08)" sec.\n");
				break;	

			case '!':
				usart_write_str((pU08)"\ndebug mode ");
				debug_mode = true;
				if (usart_rx_buffer[1] == '0'){
					debug_mode = false;
					usart_write_str((pU08)"off\n");
				} else {
					usart_write_str((pU08)"on\n");
				}
				break;		
				
			case 'h':
			case 'H':
				print_help();
				break;
		}
	} else
	{
		// zero bytes received
	}
	
	
	for (U08 i=0; i<USART_RX_BUFFER_SIZE; ++i)
		usart_rx_buffer[i] = 0;
}


void print_invalid_enable_statement(){
usart_write_str((pU08)"\nerror: invalid 'enable' or 'disable'statement.\n");
usart_write_str((pU08)"usage: [E|e|D|d][r|v|h|p][0..15]\n");
usart_write_str((pU08)"e.g.:  Ev1  --> enable voltage channel 1\n");
usart_write_str((pU08)"e.g.:  dr0  --> disable resistance channel 0\n");
}

void print_help() {

usart_write_str((pU08)
"List of MSR commands:\n29.03.2011\n" 
"E or e      --   enable channel: type e? for detailed help\n" 
"D or d      --  disable channel: type d? for detailed help\n" 
"b0 or b1    --  switch heartbeat PA4 on or off\n" 
"G           --  'get AD7719'       -> measure resistances again\n" 
"g           --  'get ATmega adc'   -> measure voltages    again\n" 
"P           --  get & print AD7719 infinitly \n" 
"p           --  get & print ATmega adc infinitly \n" 
"s           --  print status\n" 
"H or h      --  print this help\n" 
);

}

void print_adc_enable_status(bool with_headline) {

	if (with_headline) {
		usart_write_str((pU08)"adc channels 15 downto 0:\n i.e. left is pressure and humidity ... right is voltage\n");
	}
	usart_write_U08_bin(adc_enables[1]);	
	usart_write_char(' ');
	usart_write_U08_bin(adc_enables[0]);	
	usart_write_char(' ');
	
	usart_write_char('\n');
	usart_write_U08_bin(adc_channels_ready[1]);
	usart_write_char(' ');
	usart_write_U08_bin(adc_channels_ready[0]);
	usart_write_char(' ');
}

void print_ad7719_enable_status(bool with_headline) {

	if (with_headline) {
		usart_write_str((pU08)"ad7719 channels: 15 downto 0:\n");
	}
	usart_write_U08_bin(ad7719_enables[1]);
	usart_write_char(' ');
	usart_write_U08_bin(ad7719_enables[0]);
	usart_write_char(' ');

	usart_write_char('\n');
	usart_write_U08_bin(ad7719_channels_ready[1]);
	usart_write_char(' ');
	usart_write_U08_bin(ad7719_channels_ready[0]);
	
}