#include <avr/io.h>
#include "lcd-routines.h"
#include <stdlib.h>
#include <math.h>
#include <avr/interrupt.h>
#include <util/delay.h>

//Defines für Impulsmessung

#define TRUE 1
#define FALSE 0



volatile unsigned char NumberOverflow1 = 0;  // Anzahl Timer1 Overflows
volatile unsigned int  StartTime1 = 0;        // ICR1-Wert bei 1.High-Flanke speichern
volatile unsigned int  EndTime1 = 0;          // ICR1-Wert bei 2.High-Flanke speichern
volatile unsigned char Update1;               // Flag



//Defines für ADC
#define ADCSTATREG      0x00    // 8bit
#define ADCMODEREG      0x01    // 16bit
#define ADCCONFREG      0x02    // 16bit
#define ADCDATAREG      0x03    // 16bit
#define ADCIDREG        0x04    // 8bit
#define ADCIOREG        0x05    // 8bit
#define ADCOFFREG       0x06    // 16bit
#define ADCFSREG        0x07    // 16bit


void spi_init() {
	
	DDRB = _BV(PB2) | _BV(PB3) | _BV(PB5);		// setze SCK,MOSI,PB0 (SS) als Ausgang
	DDRB &= ~_BV(PB4);							// setze MISO als Eingang
	PORTB = _BV(PB5) | _BV(PB2);				// SCK und PB0 high (ist mit SS am Slave verbunden)
	SPCR = _BV(SPE) | _BV(MSTR) | _BV(SPR0);	//Aktivierung des SPI, Master, Taktrate fck/16
	

}

void SPIWrite8(uint8_t data) {
	
	SPDR = data;
	while(!(SPSR & (1<<SPIF)));	
	
}



uint8_t SPIRead8(void) {

SPDR = 0x00;
while(!(SPSR & (1<<SPIF)));

return SPDR;
}

//Write

uint16_t SPIWrite16(uint16_t Data)
{

uint8_t Data_H;
uint8_t Data_L;


Data_H = ((Data >>8) & 0xFF);
Data_L = Data & 0xFF;

SPDR = Data_H;                /* Start transmission */
while(!(SPSR & (1<<SPIF)));  /* Wait for transmission complete */

SPDR = Data_L;                /* Start transmission */
while(!(SPSR & (1<<SPIF)));          /* Wait for transmission complete */    

return SPDR;
}

//READ

uint16_t SPIRead16(void)
{

uint16_t twobytes;


SPDR = 0x00;                /* Start transmission */
while(!(SPSR & (1<<SPIF)));  /* Wait for transmission complete */
twobytes |= (SPDR << 8);

SPDR = 0x00;                /* Start transmission */
while(!(SPSR & (1<<SPIF)));          /* Wait for transmission complete */    
twobytes |= SPDR;


return twobytes;

}


//ADC
//Reset des ADC

void tempReset(void)
{
PORTB &= ~_BV(PB2);
SPIWrite8(0xFF);
SPIWrite8(0xFF);
SPIWrite8(0xFF);
SPIWrite8(0xFF);
PORTB |= _BV(PB2);
}


void tempSetRegister16(unsigned char reg, unsigned int data)
{
reg = reg << 3;
PORTB &= ~_BV(PB2);
SPIWrite8((0x00 | reg));    // write to status reg
SPIWrite16(data);
PORTB |= _BV(PB2);
}

void tempSetRegister8(unsigned char reg, unsigned char data)
{
reg = reg << 3;
PORTB &= ~_BV(PB2);
SPIWrite8((0x00 | reg));    // write to status reg
SPIWrite8(data);
PORTB |= _BV(PB2);
}

unsigned char tempReadRegister8(unsigned char reg)
{
unsigned char data;

reg = reg << 3;
PORTB &= ~_BV(PB2);
SPIWrite8((0x40 | reg));    // write to status reg
data = SPIRead8();
PORTB |= _BV(PB2);

return data;
}

uint16_t tempReadRegister16(unsigned char reg)
{
uint16_t  data;

reg = reg << 3;
PORTB &= ~_BV(PB2);
SPIWrite8((0x40 | reg));    // write to status reg
data = SPIRead16();
PORTB |= _BV(PB2);

return data;
}

void tempInit(void)
{
tempReset();
_delay_ms(50); // Pause

tempSetRegister16(ADCCONFREG, 0x1300);  // Select buffered mode / chanel 1 / unipolar / gain 4
tempSetRegister8(ADCIOREG, 0x02);
tempSetRegister16(ADCMODEREG, 0x0009);  // 50Hz 80dB rejection
_delay_ms(50); // Pause
}

uint16_t tempRead(void)
{
uint16_t temp = 0X0000;

tempSetRegister16(ADCMODEREG, 0x2009);  // 50Hz 80dB rejection and start conversion

PORTB &= ~_BV(PB2);
_delay_ms(500);            // wait for conversion to finish; noch nicht ausgereift, besser abfrage von rdout
PORTB |= _BV(PB2);

temp = (tempReadRegister16(ADCDATAREG)); // read last conversion result and convert

return temp;
}


float tempConvert(uint16_t code) {

float V;
float A = 0.0039083;
float B = -0.0000005775;
float C = -0.000000000004183;
float G = 1000;
float R;
float T;

V= (code * 2.5 ) / (65536 * 4);
R = (V / 0.000210);
T = (((R / G) - 1)  * (-0.0895))/ 0.00385;
//T = (( -A * 1000) + sqrt( (A * 1000) * (A * 1000) + (4 * B * 1000) * (1000 - R))) / (2 * B * 1000);

return T;
}


//Routinen für Impulsmessung

//---------------------------------------------------------------------------------
// Flankenauswertung Timer1 ICP1
ISR( TIMER1_CAPT_vect )
{
 static unsigned char ErsteFlanke1 = TRUE;

 if( Update1)
  return;

 if( ErsteFlanke1 )
 {
  StartTime1 = ICR1;
  NumberOverflow1 = 0;
  ErsteFlanke1 = FALSE;       // Die naechste Flanke ist das Ende der Messung
  }

  else
  {
   EndTime1 = ICR1;
   Update1 = TRUE;         // Eine vollstaendige Messung. Sie kann ausgewertet werden
   ErsteFlanke1 = TRUE;    // Bei der naechsten Flanke beginnt der naechste Messzyklus
  }
}



//----------------------------------------------------------------------------------
// Timer1 Overflows zählen
ISR( TIMER1_OVF_vect )
{
  NumberOverflow1++;
}


int main (void) {

	//Inits
	lcd_init();
	spi_init();
	
	//Deklarationen
	char string[10];
	char text2[16];
	char text[32];
	
	double Erg1 = 0.0;
	char Wert1[8];
	
	DDRB &= ~(1<<PB0); //PB0 als Eingang
	PORTB |= (1<<PB0); //PB0 Pullup nach Vcc


	//Timer1 16bit,
	TCCR1B |= (1<<CS10) | (1<<ICES1); //Kein Prescaling
	TIMSK |= (1<<TICIE1) | (1<<TOIE1); //pos. Flanke, Overflowinterrupt aktivieren


	sei(); //globale Interrupts aktivieren
	
	
	//Schleife
	while(1)	{


	tempInit(); 

	float data2;
	uint16_t data = 0x0000;
	
	data = tempRead(); //Auslesen des ADC
	data2 = tempConvert(data);
	
	sprintf(text2, "%.5f", data2);
	
	lcd_clear();
	lcd_string(text2);
	lcd_string(" Grad");
	
	
	
	if(Update1) //Auf vollständige Messung prüfen
     {

      
      Erg1 = (NumberOverflow1 * 65536) + EndTime1 - StartTime1;
      
      Erg1 = F_CPU / Erg1;

      
      dtostrf( Erg1, 5, 3, Wert1 );
     

	
      Update1 = FALSE;
      
        }
	set_cursor(0,2);
	lcd_string( Wert1 );
	lcd_string(" Hz");

	}
	

	
}