#define F_CPU 16000000L
			#define __DELAY_BACKWARD_COMPATIBLE__
			//---------------------------//
			//		Define part		 //
			//--------------------------//
			#include <string.h>
			#include <inttypes.h>
			#include <avr/io.h>
			#include <avr/interrupt.h>
			#include <avr/pgmspace.h>
			#include <util/delay.h>
			#include <math.h>
			#include "stdio.h"
			#include "stdlib.h"
			#define SPI_PORT			PORTB
			#define SPI_SS_PIN 		PORTB2
			#define SPI_SCK_PIN 		PORTB5
			#define SPI_MOSI_PIN 		PORTB3
			#define SPI_MISO_PIN 		PORTB4
			
			// SPI clock modes
			#define SPI_MODE_0 			0x00 	// Sample(Rising) Setup(Falling) CPOL=0,CPHA=0
			#define SPI_MODE_1 			0x01 	// Setup (Rising) Sample(Falling)CPOL=0,CPHA=1
			#define SPI_MODE_2 			0x02 	// Sample(Falling)Setup(Rising)  CPOL=1,CPHA=0
			#define SPI_MODE_3 			0x03 	// Setup (Falling)Sample(Rising) CPOL=1,CPHA=1
			
			// data direction
			#define SPI_LSB 			1 		// send least significant bit (bit 0) first
			#define SPI_MSB 			0 		// send most significant bit (bit 7) first
			
			// ----------------------------------------------------------------------------
			// whether to raise interrupt when data received (SPIF bit received)
			#define SPI_NO_INTERRUPT 	0
			#define SPI_INTERRUPT 		1
			
			// ----------------------------------------------------------------------------
			// slave or master with clock diviser
			#define SPI_SLAVE 			0xF0
			#define SPI_MSTR_CLK4 		0x00 	// chip clock/4
			#define SPI_MSTR_CLK16 		0x01 	// chip clock/16
			#define SPI_MSTR_CLK64 		0x02 	// chip clock/64
			#define SPI_MSTR_CLK128 	0x03 	// chip clock/128
			#define SPI_MSTR_CLK2 		0x04 	// chip clock/2
			#define SPI_MSTR_CLK8 		0x05 	// chip clock/8
			#define SPI_MSTR_CLK32 		0x06 	// chip clock/32
			
			// setup spi ------------------------------------------------------------------
			void setup_spi(uint8_t mode,   		// timing mode SPI_MODE[0-4]
			int dord,           	// data direction SPI_LSB|SPI_MSB
			int interrupt,      	// whether to raise interrupt on recieve
			uint8_t clock); 		// clock diviser

			// disable spi ----------------------------------------------------------------
			void disable_spi(void);

			// send and receive a byte of data (master mode)
			uint8_t spiWrite(uint8_t out);

			// receive the byte of data waiting on the SPI buffer and
			// set the next byte to transfer - for use in slave mode
			// when interrupts are enabled.
			uint8_t spiRead(uint8_t out);

			// ----------------------------------------------------------------------------
			// DAC chip : MCP4821 = 12bit spi DAC
			// bit  =  15          14   13(=don't care)     12(1=enable)    11  ...  0
			//         1=DAC1/DAC0  x  gain (2xVrefxD/4096  output control  MSB ...LSB
			// ----------------------------------------------------------------------------
			#define	DAC4821_E		PORTD 	 &= ~_BV(PORTD3)
			#define	DAC4821_D		PORTD 	 |= _BV(PORTD3)
			#define	DAC_SHDN		0x10		// 0 --> no out put signal
			#define	DAC_CHA			0x00
			#define	DAC_CHB			0x80
			#define	DACGAIN1X		0x20		// Vout = Vref x D / 4096
			#define	DACGAIN2X		0x00		// Vout = 2 x Vref x D / 4096
			#define	SPI_CS_E		SPI_PORT &= ~_BV(SPI_SS_PIN)
			#define	SPI_CS_D		SPI_PORT |= _BV(SPI_SS_PIN)
			#define	SPI_CS_E2		SPI_PORT &= ~_BV(SPI_SS_PIN2)
			#define	SPI_CS_D2		SPI_PORT |= _BV(SPI_SS_PIN2)

			// ----------------------------------------------------------------------------
			void setup_spi(uint8_t mode, int dord, int interrupt, uint8_t clock){

				// specify pin directions for SPI pins on port B for MASTER mode

				DDRB |= (1<<SPI_MOSI_PIN); 			// output
				DDRB &= ~(1<<SPI_MISO_PIN); 		// input
				DDRB |= (1<<SPI_SCK_PIN);			// output
				DDRB |= (1<<SPI_SS_PIN);			// output
				SPCR = ((interrupt ? 1 : 0)<<SPIE) 	// interrupt enabled
				| (1<<SPE) // enable SPI
				| (dord<<DORD) // LSB or MSB
				| (((clock != SPI_SLAVE) ? 1 : 0) <<MSTR) // Slave or Master
				| (((mode & 0x02) == 2) << CPOL) 	// clock timing mode CPOL
				| (((mode & 0x01)) << CPHA) 		// clock timing mode CPHA
				| (((clock & 0x02) == 2) << SPR1) 	// cpu clock divisor SPR1
				| ((clock & 0x01) << SPR0); 		// cpu clock divisor SPR0
				SPSR = (((clock & 0x04) == 4) << SPI2X);// clock divisor SPI2X
			}

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

			void disable_spi(void){
				SPCR = 0;
			}

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

			uint8_t spiWrite(uint8_t out){

				SPDR = out;
				while (!(SPSR & (1<<SPIF)));
				return SPDR;
			}
			// ----------------------------------------------------------------------------
			uint8_t spiRead(uint8_t data){
				SPDR = data;
				return SPDR;
			}

			//통신 관련 선언부

			void  Usart0_Tx(char send_data);
			char  Usart0_Rx();
			void Usart0_Init(void);
			void send_str(char *str);
			double read_Resistance(void);
			double read_temperature(void);

			//mesure 부분
			void SWV();
			void CV();
			void Ampero();
			void Rtemperature();
			void sodium();
			void potassium();
			void caliNa1();
			void caliNa2();
			void caliK1();
			void caliK2();
			void caliglu1();
			void caliglu2();
			void calilac1();
			void calilac2();
			void glu();
			void lac();
			void concentrationofNa();
			void concentrationofK();
			void concentrationofglu();
			void concentrationoflac();
			//변수 선언부
			uint16_t adc_val;
			uint16_t AdcTemp[200]={0};
			uint16_t AdcTemp0[200]={0};
			uint16_t AdcTemp1[200]={0};	
			uint16_t trash;
			uint16_t dac_out;
			uint16_t dac_out2;
			float Max_adc=0.0;
			uint8_t spidata=0;
			float raw;
			double Rtemp;
			int Vin;
			float Vout;
			float Veq;
			float R1;
			float R2;
			float gluadc;
			float gluv;
			float gluia;
			double gluiu;
			double lacadc;
			double lacv;
			double lacia;
			double laciu;
			
			
			
			float buffer;
			double midadcsodium1,midadcsodium2,midadcsodium3,midadcpotassium1,midadcpotassium2,midadcpotassium3;
			double midadcglu1,midadcglu2,midadcglu3,midadclac1,midadclac2,midadclac3;
			double vsodium1,vsodium2,vsodium3, vpotassium1,vpotassium2,vpotassium3;
			double vglu1,vglu2,vglu3,vlac1,vlac2,vlac3;
			double iglu1,iglu2,iglu3,ilac1,ilac2,ilac3;
			int adcsodium1[7]={0};
			int adcsodium2[7]={0};
			int adcsodium3[7]={0};
			int adcpotassium1[7]={0};
			int adcpotassium2[7]={0};
			int adcpotassium3[7]={0};
			int adcglu1[7]={0};
			int adcglu2[7]={0};
			int adcglu3[7]={0};
			int adclac1[7]={0};
			int adclac2[7]={0};
			int adclac3[7]={0};
			char str_data[128]={0};
			uint8_t cnt = 0;
			uint8_t i, j, k, l;
			char mesure;
			uint16_t adc_read(int);
			void init_ADC0();

			//----------------------------//
			//		Main Part		  //
			//---------------------------//
			int main(void)
			{
				// SFR 초기화
				Usart0_Init();
				init_ADC0();
				_delay_ms(200);
				DDRD = 0xff;						// PORTG3 high for output
				setup_spi(SPI_MODE_0, SPI_MSB, SPI_NO_INTERRUPT, SPI_MSTR_CLK128);
				SPI_CS_D;
				DAC4821_D;
				_delay_ms(10);
				for(i=0;i<20;i++)
				{
					trash = adc_read(0);
					trash = adc_read(1);
					trash = adc_read(2);
					trash = adc_read(3);
					trash = adc_read(4);
					_delay_ms(10);
				}
				while(1)

				{
					
					while(!(UCSR0A & 0x80));
					mesure=UDR0;
						if(mesure=='n')
						{
							caliNa1();
						}
						if(mesure=='m')
						{
							caliNa2();
						}
						if(mesure=='k')
						{
							caliK1();
						}
						if(mesure=='c')
						{
							caliK2();
						}
						if(mesure=='g')
						{
							caliglu1();
						}
						if(mesure=='h')
						{
							caliglu2();
						}
						if(mesure=='l')
						{
							calilac1();
						}if(mesure=='j')
						{
							calilac2();
						}
						
				
					if(mesure=='1')
						{
							concentrationofglu();
						}
					if(mesure=='2')
						{
							lac();
						}
					if(mesure=='3')
						{
							sodium();
						}
						if(mesure=='4')
						{
							potassium();
						}
						if(mesure=='5')
						{
							Rtemperature();
						}
				
	
				}
				return 0;
				}

 
			//---------------------------//
			//	      Initial part		//
			//--------------------------//
			void init_ADC0()
			{
				ADMUX = 0x40;                     // External AREF = 5V, ADC0
				ADCSRA = 0x87;                    // ADC enable, 8MHz/128 = 62.5KHz
				_delay_ms(10);
			}
		//---------------------------//
		//	      Measure part		//
		//--------------------------//
		uint16_t adc_read(int n)
		{
			if (n==0)
			ADMUX = 0x40;
			_delay_us(1);
			if (n==1)
			ADMUX = 0x41;
			_delay_us(1);
			if (n==2)
			ADMUX = 0x42;
			_delay_us(1);
			if (n==3)
			ADMUX = 0x43;
			_delay_us(1);
			if (n==4)
			ADMUX = 0x44;
			_delay_us(1);
			ADCSRA |= 0x40;
			while((ADCSRA & 0x10) != 0x10);
			return(ADCL + ADCH*256);
		}

/*
		void CV()
		{

			int step;
			int begin;
			int end;
			int srate;
			int filter;
			int adcread1=0;
			//int resistance=0;
			//int rst=0;
			int t=0;
			int y_val=0;
			int a0, a1, a2, a3, a4=0;
			int x_val;
			int d0, d1, d2, d3, d4, d5=0;
			char pstp='r';
			sprintf(str_data,"Start..C.V\n"); send_str(str_data);
			_delay_ms(100);
			sprintf(str_data,"Applied\n"); send_str(str_data);
			_delay_ms(100);
			while(!(UCSR0A & 0x80));
			trash=UDR0;
			while(!(UCSR0A & 0x80));
			trash=UDR0;
			while(!(UCSR0A & 0x80));
			trash=UDR0;
			sprintf(str_data,"b\n"); send_str(str_data);
			_delay_ms(50);
			while(!(UCSR0A & 0x80));
			trash=UDR0;
			while(!(UCSR0A & 0x80));
			trash=UDR0;
			while(!(UCSR0A & 0x80));
			trash=UDR0;
			while(!(UCSR0A & 0x80));
			begin=UDR0;
			sprintf(str_data,"%d\n", begin); send_str(str_data);
			_delay_ms(50);
			sprintf(str_data,"e\n"); send_str(str_data);
			_delay_ms(50);
			while(!(UCSR0A & 0x80));
			trash=UDR0;
			while(!(UCSR0A & 0x80));
			trash=UDR0;
			while(!(UCSR0A & 0x80));
			trash=UDR0;
			while(!(UCSR0A & 0x80));
			end=UDR0;
			sprintf(str_data,"%d\n", end); send_str(str_data);
			_delay_ms(50);
			sprintf(str_data,"p\n"); send_str(str_data);
			_delay_ms(50);
			while(!(UCSR0A & 0x80));
			trash=UDR0;
			while(!(UCSR0A & 0x80));
			trash=UDR0;
			while(!(UCSR0A & 0x80));
			trash=UDR0;
			while(!(UCSR0A & 0x80));
			step=UDR0;
			sprintf(str_data,"%d\n", step); send_str(str_data);
			_delay_ms(50);
			sprintf(str_data,"r\n"); send_str(str_data);
			_delay_ms(50);
			while(!(UCSR0A & 0x80));
			srate=UDR0;
			while(!(UCSR0A & 0x80));
			srate=UDR0;
			while(!(UCSR0A & 0x80));
			srate=UDR0;
			while(!(UCSR0A & 0x80));
			srate=UDR0;
			sprintf(str_data,"%d\n", srate); send_str(str_data);
			_delay_ms(50);
			sprintf(str_data,"F\n"); send_str(str_data);
			_delay_ms(50);
			while(!(UCSR0A & 0x80));
			filter=UDR0;
			while(!(UCSR0A & 0x80));
			filter=UDR0;
			while(!(UCSR0A & 0x80));
			filter=UDR0;
			while(!(UCSR0A & 0x80));
			filter=UDR0;
			_delay_ms(50);
			t=step*1000/srate;
			dac_out=begin*100-3*step;
			dac_out2=2000;
			_delay_ms(50);
			sprintf(str_data,"Measure\n"); send_str(str_data);
			_delay_ms(50);
			SPI_CS_E;
			spidata = ((dac_out2 >> 8) & 0xFF) | DAC_SHDN | DAC_CHB | DACGAIN2X;
			spiWrite(spidata);
			spidata = (uint8_t)(dac_out2 & 0xFF);		// low byte
			spiWrite(spidata);
			SPI_CS_D;
			SPI_CS_E;
			spidata = ((dac_out >> 8) & 0xFF) | DAC_SHDN | DAC_CHA | DACGAIN2X;
			spiWrite(spidata);
			spidata = (uint8_t)(dac_out & 0xFF);		// low byte
			spiWrite(spidata);
			SPI_CS_D;
			DAC4821_E;
			_delay_ms(100);
			for(i=0;i<3;i++)
			{
				if(i==0)
				dac_out=dac_out;
				else
				dac_out=dac_out+step;
				SPI_CS_E;
				spidata = ((dac_out >> 8) & 0xFF) | DAC_SHDN | DAC_CHA | DACGAIN2X;
				spiWrite(spidata);
				spidata = (uint8_t)(dac_out & 0xFF);		// low byte
				spiWrite(spidata);
				SPI_CS_D;
				DAC4821_E;
				_delay_us(1);
				DAC4821_D;
				_delay_ms(t);
				for(j=0;j<filter;j++)
				{
					AdcTemp[j]=adc_read();
					_delay_us(1);
				}
				for(j=0;j<filter;j++)
				{
					for(k=0;k<filter-1-j;k++)
					{
						if(AdcTemp[k]>AdcTemp[k+1])
						{
							trash = AdcTemp[k];
							AdcTemp[k]=AdcTemp[k+1];
							AdcTemp[k+1]=trash;
						}
					}
				}
				adcread1=AdcTemp[filter/2];
			}
			x_val=(begin-20)*100;
			int numofdata=(end-begin)*100/step;
			for(i=0;i<numofdata+1;i++)
			{
				if(UCSR0A & 0x80)			//블루투스 신호를 받았을 때
				{
					pstp=UDR0;			//데이터를 변수에 저장
					if(pstp=='p'){
						while(!(UCSR0A & 0x80));
						pstp=UDR0;
					}
					if(pstp=='s')		//stop일 때
					break;			//나가기
				}
				if(i==0)
				dac_out=begin*100;
				else{
					dac_out=dac_out+step;
					x_val=x_val+step;
				}
				SPI_CS_E;
				spidata = ((dac_out >> 8) & 0xFF) | DAC_SHDN | DAC_CHA | DACGAIN2X;
				spiWrite(spidata);
				spidata = (uint8_t)(dac_out & 0xFF);		// low byte
				spiWrite(spidata);
				SPI_CS_D;
				DAC4821_E;
				_delay_us(1);
				DAC4821_D;
				_delay_ms(t);
				for(j=0;j<filter;j++)
				{
					AdcTemp[j]=adc_read();
					_delay_us(1);
				}
				for(j=0;j<filter;j++)
				{
					for(k=0;k<filter-1-j;k++)
					{

						if(AdcTemp[k]>AdcTemp[k+1])
						{
							trash = AdcTemp[k];
							AdcTemp[k]=AdcTemp[k+1];
							AdcTemp[k+1]=trash;
						}
					}
				}
				adcread1=AdcTemp[filter/2];
				y_val=(adcread1-409)*5;
				d0=2;
				if(y_val>=0)
				d1=0;
				if(y_val<0)
				d1=1;
				d5=abs(y_val)%10;
				d4=(abs(y_val)/10)%10;
				d3=(abs(y_val)/100)%10;
				d2=(abs(y_val)/1000)%10;
				if(x_val>=0)
				a0=0;
				if(x_val<0)
				a0=1;
				a4=abs(x_val)%10;
				a3=(abs(x_val)/10)%10;
				a2=(abs(x_val)/100)%10;
				a1=(abs(x_val)/1000)%10;
				sprintf(str_data,"%d%d%d%d%d%d%d%d%d%d%d\n", a0,a1,a2,a3,a4,d0,d1,d2,d3,d4,d5); send_str(str_data);
			}
			for(i=0;i<numofdata;i++)
			{
				if(pstp=='s')		//stop일 때
				break;			//나가기
				if(UCSR0A & 0x80){
					pstp=UDR0;
					if(pstp=='p'){
						while(!(UCSR0A & 0x80));
						pstp=UDR0;
					}
					if(pstp=='s')
					break;
				}
				dac_out=dac_out-step;
				x_val=x_val-step;
				SPI_CS_E;
				spidata = ((dac_out >> 8) & 0xFF) | DAC_SHDN | DAC_CHA | DACGAIN2X;
				spiWrite(spidata);
				spidata = (uint8_t)(dac_out & 0xFF);		// low byte
				spiWrite(spidata);
				SPI_CS_D;
				DAC4821_E;
				_delay_us(1);
				DAC4821_D;
				_delay_ms(t);
				for(j=0;j<filter;j++)
				{
					AdcTemp[j]=adc_read();
					_delay_us(1);
				}
				for(j=0;j<filter;j++)
				{
					for(k=0;k<filter-1-j;k++)
					{
						if(AdcTemp[k]>AdcTemp[k+1])
						{
							trash = AdcTemp[k];
							AdcTemp[k]=AdcTemp[k+1];
							AdcTemp[k+1]=trash;
						}
					}
				}
				adcread1=AdcTemp[filter/2];
				y_val=(adcread1-409)*5;
				d0=2;
				if(y_val>=0)
				d1=0;
				if(y_val<0)
				d1=1;
				d5=abs(y_val)%10;
				d4=(abs(y_val)/10)%10;
				d3=(abs(y_val)/100)%10;
				d2=(abs(y_val)/1000)%10;
				if(x_val>=0)
				a0=0;
				if(x_val<0)
				a0=1;
				a4=abs(x_val)%10;
				a3=(abs(x_val)/10)%10;
				a2=(abs(x_val)/100)%10;
				a1=(abs(x_val)/1000)%10;
				sprintf(str_data,"%d%d%d%d%d%d%d%d%d%d%d\n", a0,a1,a2,a3,a4,d0,d1,d2,d3,d4,d5); send_str(str_data);
			}
			_delay_ms(100);
			if(pstp=='r'){
				sprintf(str_data,"Measurement finish\n"); send_str(str_data);
				_delay_ms(100);
				sprintf(str_data," \n"); send_str(str_data);
			}
			SPI_CS_E;
			dac_out=2000;
			_delay_ms(50);
			spidata = ((dac_out >> 8) & 0xFF) | DAC_SHDN | DAC_CHA | DACGAIN2X;
			spiWrite(spidata);
			spidata = (uint8_t)(dac_out & 0xFF);		// low byte
			spiWrite(spidata);
			SPI_CS_D;
			DAC4821_E;
			_delay_us(1);
			DAC4821_D;
			_delay_ms(50);
		} */

		/////////////////////////////////////////////////
		void Ampero()
		{

		//	int EV[2];
		//	int interval;
		//	int time[2];
		//	int adcread0=0;
		//	int adcread1=0;
		//	int filter;
		//int resistance=0;
		//int rst=0;
		//	int y_val0=0;
		//	int y_val1=0;
		//	int a0, a1, a2, a3, a4, a5=0;
		//	int x_val;
		//	int d0, d1, d2, d3, d4, d5=0;
		//	char pstp='r';
		//	int c;
		//	int res;
		//res=read_Resistance();
		//	sprintf(str_data, " R: %dΩ\n", res); send_str(str_data);
		//sprintf(str_data, "total R: %dΩ\n", c3); send_str(str_data);
			_delay_ms(50);
	/*		sprintf(str_data,"Start..Amperometry\n"); send_str(str_data);
			_delay_ms(100);
			sprintf(str_data,"Applied\n"); send_str(str_data);
			_delay_ms(100);  */
			while(!(UCSR0A & 0x80));
			trash=UDR0;
			while(!(UCSR0A & 0x80));
			trash=UDR0;
			while(!(UCSR0A & 0x80));
			trash=UDR0;
		/*	sprintf(str_data,"V\n"); send_str(str_data);
			_delay_ms(50);
			while(!(UCSR0A & 0x80));
			trash=UDR0;
			while(!(UCSR0A & 0x80));
			trash=UDR0;
			while(!(UCSR0A & 0x80));
			trash=UDR0;
			while(!(UCSR0A & 0x80));
			EV[0]=UDR0;
			while(!(UCSR0A & 0x80));
			EV[1]=UDR0;
			_delay_ms(50);
			sprintf(str_data,"%d\n %d\n", EV[1], EV[0]); send_str(str_data);
			_delay_ms(50);
			sprintf(str_data,"I\n"); send_str(str_data);
			_delay_ms(50);
			while(!(UCSR0A & 0x80));
			trash=UDR0;
			while(!(UCSR0A & 0x80));
			trash=UDR0;
			while(!(UCSR0A & 0x80));
			trash=UDR0;
			while(!(UCSR0A & 0x80));
			interval=UDR0;
			_delay_ms(50);
			sprintf(str_data,"%d\n", interval); send_str(str_data);
			_delay_ms(50);
			sprintf(str_data,"T\n"); send_str(str_data);
			_delay_ms(50);
			while(!(UCSR0A & 0x80));
			trash=UDR0;
			while(!(UCSR0A & 0x80));
			trash=UDR0;
			while(!(UCSR0A & 0x80));
			trash=UDR0;
			while(!(UCSR0A & 0x80));
			time[0]=UDR0;
			while(!(UCSR0A & 0x80));
			time[1]=UDR0;
			_delay_ms(50);
			sprintf(str_data,"%d\n %d\n", time[1], time[0]); send_str(str_data);
			_delay_ms(50);
			sprintf(str_data,"F\n"); send_str(str_data);
			_delay_ms(50);
			while(!(UCSR0A & 0x80));
			trash=UDR0;
			while(!(UCSR0A & 0x80));
			trash=UDR0;
			while(!(UCSR0A & 0x80));
			trash=UDR0;
			while(!(UCSR0A & 0x80));
			filter=UDR0;
			_delay_ms(50);
			dac_out=(EV[1]*100+EV[0]);
			dac_out2=2000;
			_delay_ms(50);
			sprintf(str_data,"Measure\n"); send_str(str_data);
			_delay_ms(50);
			SPI_CS_E;
			spidata = ((dac_out2 >> 8) & 0xFF) | DAC_SHDN | DAC_CHB | DACGAIN2X;
			spiWrite(spidata);
			spidata = (uint8_t)(dac_out2 & 0xFF);		// low byte
			spiWrite(spidata);
			SPI_CS_D;
			SPI_CS_E;
			spidata = ((dac_out >> 8) & 0xFF) | DAC_SHDN | DAC_CHA | DACGAIN2X;
			spiWrite(spidata);
			spidata = (uint8_t)(dac_out & 0xFF);		// low byte
			spiWrite(spidata);
			SPI_CS_D;
			DAC4821_E;
			_delay_ms(100);                                      */                               
		}
			/*
			for(i=0;i<3;i++)
			{
			SPI_CS_E;
			spidata = ((dac_out >> 8) & 0xFF) | DAC_SHDN | DAC_CHA | DACGAIN2X;
			spiWrite(spidata);
			spidata = (uint8_t)(dac_out & 0xFF);		// low byte
			spiWrite(spidata);
			SPI_CS_D;
			DAC4821_E;
			_delay_ms(100);
			for(j=0;j<filter;j++)
			{
			AdcTemp[j]=adc_read();
			_delay_us(1);
			}
			for(j=0;j<filter;j++)
			{
			for(k=0;k<filter-1-j;k++)
			{
			if(AdcTemp[k]>AdcTemp[k+1])
			{
			trash = AdcTemp[k];
			AdcTemp[k]=AdcTemp[k+1];
			AdcTemp[k+1]=trash;
			}
			}
			}
			adcread1=AdcTemp[filter/2];
			}
			*/
		/*	int numofdata=(int)(time[1]*100+time[0])*10/interval;
			for(i=0;i<numofdata+1;i++)
			{
				if(UCSR0A & 0x80){        //블루투스 신호를 받았을 때
					pstp=UDR0;            //데이터를 변수에 저장
					if(pstp=='p'){
						while(!(UCSR0A & 0x80));
						pstp=UDR0;
					}
					if(pstp=='s')
					break;
				}
				x_val=(i*interval*10);
				_delay_ms(interval*100);
				for(j=0;j<filter;j++)
				{
					AdcTemp0[j]=adc_read(0);
					_delay_us(1);
					AdcTemp1[j]=adc_read(1);
					_delay_us(1);
				}
				for(j=0;j<filter;j++)
				{
					for(k=0;k<filter-1-j;k++)
					{
						if(AdcTemp0[k]>AdcTemp0[k+1])
						{
							trash = AdcTemp0[k];
							AdcTemp0[k]=AdcTemp0[k+1];
							AdcTemp0[k+1]=trash;
						}
					}
				}
				adcread0=AdcTemp0[filter/2];
				adcread1=AdcTemp1[filter/2];
				y_val0=(adcread0-409)*5;
				y_val1=adcread1;
				d0=2;
				if(y_val0>=0)
				d1=0;
				if(y_val0<0)
				d1=1;
				d5=abs(y_val0)%10;
				d4=(abs(y_val0)/10)%10;
				d3=(abs(y_val0)/100)%10;
				d2=(abs(y_val0)/1000)%10;
				if(x_val>=0)
				a0=0;
				if(x_val<0)
				a0=1;
				//a6=abs(x_val)%10;
				a5=abs(x_val)%10;
				a4=(abs(x_val)/10)%10;
				a3=(abs(x_val)/100)%10;
				a2=(abs(x_val)/1000)%10;
				a1=(abs(x_val)/10000)%10;
				c=0;
				sprintf(str_data,"%d%d%d%d%d%d%d%d%d%d%d%d%d\n", c, a0,a1,a2,a3,a4,a5,d0,d1,d2,d3,d4,d5); send_str(str_data);
				d0=2;
				if(y_val1>=0)
				d1=0;
				if(y_val1<0)
				d1=1;
				d5=abs(y_val1)%10;
				d4=(abs(y_val1)/10)%10;
				d3=(abs(y_val1)/100)%10;
				d2=(abs(y_val1)/1000)%10;
				if(x_val>=0)
				a0=0;
				if(x_val<0)
				a0=1;
				//a6=abs(x_val)%10;
				a5=abs(x_val)%10;
				a4=(abs(x_val)/10)%10;
				a3=(abs(x_val)/100)%10;
				a2=(abs(x_val)/1000)%10;
				a1=(abs(x_val)/10000)%10;
				c=1;
				sprintf(str_data,"%d%d%d%d%d%d%d%d%d%d%d%d%d\n", c, a0,a1,a2,a3,a4,a5,d0,d1,d2,d3,d4,d5); send_str(str_data);
			}
			_delay_ms(100);
			if(pstp=='r'){
		//		sprintf(str_data,"Measurement finish"); send_str(str_data);
				_delay_ms(100);
				sprintf(str_data," "); send_str(str_data);
			}
			SPI_CS_E;
			dac_out=2000;
			_delay_ms(50);
			spidata = ((dac_out >> 8) & 0xFF) | DAC_SHDN | DAC_CHA | DACGAIN2X;
			spiWrite(spidata);
			spidata = (uint8_t)(dac_out & 0xFF);		// low byte
			spiWrite(spidata);
			SPI_CS_D;
			DAC4821_E;
			_delay_us(1);
			DAC4821_D;
			_delay_ms(50);
		}                                                             */   

		//----------------------------------//
		// 		Communication Part 		//
		//----------------------------------//
		void  Usart0_Tx(char send_data)
		{
			while(!(UCSR0A & 0x20));
			UDR0 = send_data;
		}

		char  Usart0_Rx()
		{
			char receive_data;
			while(!(UCSR0A & 0x80));
			receive_data = UDR0;
			Usart0_Tx(receive_data);
			return (receive_data);
		}
		
		void Usart0_Init(void)
		{
			UBRR0H = 0x00; // 보오레이트 57600bps =>16
			UBRR0L = 103;
			UCSR0A = 0x00;
			UCSR0B = 0x18; //Rx,Tx enable, 8bit
			UCSR0C = 0x06; //no parity, 1 stop bit, 8bit
		}


		void send_str(char *str)
		{
			while(*str != 0) {
				if(*str == '\n') {
					Usart0_Tx(0x0D);
				}
				Usart0_Tx(*str++);
			}
		}


double read_Resistance(void)
{
	raw = adc_read(0);
	Vin= 5;
	Vout= 0;
	R1= 1000;
	if(raw)
	{
		buffer = raw*Vin;
		Vout  = (buffer)/1023.0;
		Veq = (Vin/Vout)-1;
		R2 = R1 * Veq;
	}
	return R2;
}



void Rtemperature()
{
	Rtemp=read_Resistance();
	sprintf(str_data, " %.2f\n ", Rtemp); send_str(str_data);
	_delay_ms(50);
	while(!(UCSR0A & 0x80));
	trash=UDR0;
	while(!(UCSR0A & 0x80));
	trash=UDR0;
	while(!(UCSR0A & 0x80));
	trash=UDR0;
}

void sodium ()
{
	int u,r;
	for(u=0;u<3;u++)
	{
			adcsodium1[u]=adc_read(2);
			_delay_us(1);
	}
	for(u=0;u<4;u++)
	{
		for(r=0;r<4-u;r++)
		{
			if(adcsodium1[r]>adcsodium1[r+1])
			{
			trash=adcsodium1[r];
			adcsodium1[r]=adcsodium1[r+1];
			adcsodium1[r+1]=trash;
			}
		}
	}
	midadcsodium1=adcsodium1[1];
	vsodium1=(midadcsodium1*5000)/1023;
	sprintf(str_data, " %.2f\n ", vsodium1); send_str(str_data);
	_delay_ms(50);
	while(!(UCSR0A & 0x80));
	trash=UDR0;
	while(!(UCSR0A & 0x80));
	trash=UDR0;
	while(!(UCSR0A & 0x80));
	trash=UDR0;
}


void potassium ()
{
	int u,r;
	for(u=0;u<3;u++)
	{
		adcpotassium1[u]=adc_read(3);
		_delay_us(1);
	}
	for(u=0;u<2;u++)
	{
		for(r=0;r<2-u;r++)
		{
			if(adcpotassium1[r]>adcpotassium1[r+1])
			{
				trash=adcpotassium1[r];
				adcpotassium1[r]=adcpotassium1[r+1];
				adcpotassium1[r+1]=trash;
			}
		}
	}
	midadcpotassium1=adcpotassium1[1];
	vpotassium1=(midadcpotassium1*5000)/1023;
	sprintf(str_data, " %.2f\n ", vpotassium1); send_str(str_data);
	_delay_ms(50);
	while(!(UCSR0A & 0x80));
	trash=UDR0;
	while(!(UCSR0A & 0x80));
	trash=UDR0;
	while(!(UCSR0A & 0x80));
	trash=UDR0;
}

void glu()
{
	gluadc=adc_read(0);
	gluv=(gluadc*5)/1023;
	gluiu=gluv/0.33;
	sprintf(str_data, " %.2f\n ", gluiu); send_str(str_data);
	_delay_ms(50);
	while(!(UCSR0A & 0x80));
	trash=UDR0;
	while(!(UCSR0A & 0x80));
	trash=UDR0;
	while(!(UCSR0A & 0x80));
	trash=UDR0;
}
void caliNa1()
{
	int u,r;
	for(u=0;u<3;u++)
	{
		adcsodium1[u]=adc_read(0);
		_delay_us(1);
	}
	for(u=0;u<2;u++)
	{
		for(r=0;r<2-u;r++)
		{
			if(adcsodium1[r]>adcsodium1[r+1])
			{
				trash=adcsodium1[r];
				adcsodium1[r]=adcsodium1[r+1];
				adcsodium1[r+1]=trash;
			}
		}
	}
	midadcsodium1=adcsodium1[1];
	vsodium1=(midadcsodium1*5000)/1023;
	sprintf(str_data, " %.2f\n ", vsodium1); send_str(str_data);
	_delay_ms(50);
	while(!(UCSR0A & 0x80));
	trash=UDR0;
	while(!(UCSR0A & 0x80));
	trash=UDR0;
	while(!(UCSR0A & 0x80));
	trash=UDR0;
}
void caliNa2()
{
	int u,r;
	for(u=0;u<3;u++)
	{
		adcsodium2[u]=adc_read(0);
		_delay_us(1);
	}
	for(u=0;u<2;u++)
	{
		for(r=0;r<2-u;r++)
		{
			if(adcsodium2[r]>adcsodium2[r+1])
			{
				trash=adcsodium2[r];
				adcsodium2[r]=adcsodium2[r+1];
				adcsodium2[r+1]=trash;
			}
		}
	}
	midadcsodium2=adcsodium2[1];
	vsodium2=(midadcsodium2*5000)/1023;
	sprintf(str_data, " %.2f\n ", vsodium2); send_str(str_data);
	_delay_ms(50);
	while(!(UCSR0A & 0x80));
	trash=UDR0;
	while(!(UCSR0A & 0x80));
	trash=UDR0;
	while(!(UCSR0A & 0x80));
	trash=UDR0;
}
void concentrationofNa()
{
	double slopeNa;
	double concentrationlogNa;
	double concentrationNa;
	slopeNa=(vsodium2-vsodium1)/2;
	int u,r;
	for(u=0;u<3;u++)
	{
		adcsodium3[u]=adc_read(0);
		_delay_us(1);
	}
	for(u=0;u<2;u++)
	{
		for(r=0;r<2-u;r++)
		{
			if(adcsodium3[r]>adcsodium3[r+1])
			{
				trash=adcsodium3[r];
				adcsodium3[r]=adcsodium3[r+1];
				adcsodium3[r+1]=trash;
			}
		}
	}
	midadcsodium3=adcsodium3[1];
	vsodium3=(midadcsodium3*5000)/1023;
	concentrationlogNa=(vsodium3-vsodium1)/slopeNa;
	concentrationNa=pow(10.0, concentrationlogNa);
	sprintf(str_data, " %.2f\n ", concentrationNa); send_str(str_data);
	while(!(UCSR0A & 0x80));
	trash=UDR0;
	while(!(UCSR0A & 0x80));
	trash=UDR0;
	while(!(UCSR0A & 0x80));
	trash=UDR0;
	
}
void lac()
{
	lacadc=adc_read(1);
	lacv=(lacadc*5)/1023;
	laciu=lacv/(0.22);
	sprintf(str_data, " %.2f\n ", laciu); send_str(str_data);
	_delay_ms(50);
	while(!(UCSR0A & 0x80));
	trash=UDR0;
	while(!(UCSR0A & 0x80));
	trash=UDR0;
	while(!(UCSR0A & 0x80));
	trash=UDR0;
}
 void caliK1()
 {
	 int u,r;
	 for(u=0;u<3;u++)
	 {
		 adcpotassium1[u]=adc_read(0);
		 _delay_us(1);
	 }
	 for(u=0;u<2;u++)
	 {
		 for(r=0;r<2-u;r++)
		 {
			 if(adcpotassium1[r]>adcpotassium1[r+1])
			 {
				 trash=adcpotassium1[r];
				 adcpotassium1[r]=adcpotassium1[r+1];
				 adcpotassium1[r+1]=trash;
			 }
		 }
	 }
	 midadcpotassium1=adcpotassium1[1];
	 vpotassium1=(midadcpotassium1*5000)/1023;
	 sprintf(str_data, " %.2f\n ", vpotassium1); send_str(str_data);
	 _delay_ms(50);
	 while(!(UCSR0A & 0x80));
	 trash=UDR0;
	 while(!(UCSR0A & 0x80));
	 trash=UDR0;
	 while(!(UCSR0A & 0x80));
	 trash=UDR0;
 }
 void caliK2()
 {
	 int u,r;
	 for(u=0;u<3;u++)
	 {
		 adcpotassium2[u]=adc_read(0);
		 _delay_us(1);
	 }
	 for(u=0;u<2;u++)
	 {
		 for(r=0;r<2-u;r++)
		 {
			 if(adcpotassium2[r]>adcpotassium2[r+1])
			 {
				 trash=adcpotassium2[r];
				 adcpotassium2[r]=adcpotassium2[r+1];
				 adcpotassium2[r+1]=trash;
			 }
		 }
	 }
	 midadcpotassium2=adcpotassium2[1];
	 vpotassium2=(midadcpotassium2*5000)/1023;
	 sprintf(str_data, " %.2f\n ", vpotassium2); send_str(str_data);
	 _delay_ms(50);
	 while(!(UCSR0A & 0x80));
	 trash=UDR0;
	 while(!(UCSR0A & 0x80));
	 trash=UDR0;
	 while(!(UCSR0A & 0x80));
	 trash=UDR0;
 }
 void concentrationofK()
 {
	 double slopek;
	 double concentrationlogk;
	 double concentrationk;
	 slopek=(vpotassium2-vpotassium1)/2;
	 int u,r;
	 for(u=0;u<3;u++)
	 {
		 adcpotassium3[u]=adc_read(0);
		 _delay_us(1);
	 }
	 for(u=0;u<2;u++)
	 {
		 for(r=0;r<2-u;r++)
		 {
			 if(adcpotassium3[r]>adcpotassium3[r+1])
			 {
				 trash=adcpotassium3[r];
				 adcpotassium3[r]=adcpotassium3[r+1];
				 adcpotassium3[r+1]=trash;
			 }
		 }
	 }
	 midadcpotassium3=adcpotassium3[1];
	 vpotassium3=(midadcpotassium3*5000)/1023;
	 concentrationlogk=(vpotassium3-vpotassium1)/slopek;
	 concentrationk=pow(10.0, concentrationlogk);
	 sprintf(str_data, " %.2f\n ", concentrationk); send_str(str_data);
	 while(!(UCSR0A & 0x80));
	 trash=UDR0;
	 while(!(UCSR0A & 0x80));
	 trash=UDR0;
	 while(!(UCSR0A & 0x80));
	 trash=UDR0;
	 
 }
 void caliglu1()
 {
	 int u,r;
	 for(u=0;u<3;u++)
	 {
		 adcglu1[u]=adc_read(0);
		 _delay_us(1);
	 }
	 for(u=0;u<2;u++)
	 {
		 for(r=0;r<2-u;r++)
		 {
			 if(adcglu1[r]>adcglu1[r+1])
			 {
				 trash=adcglu1[r];
				 adcglu1[r]=adcglu1[r+1];
				 adcglu1[r+1]=trash;
			 }
		 }
	 }
	 midadcglu1=adcglu1[1];
	 vglu1=(midadcglu1*5)/1023;
	 iglu1=(vglu1)/(0.33);
	 sprintf(str_data, " %.2f\n ", iglu1); send_str(str_data);
	 _delay_ms(50);
	 while(!(UCSR0A & 0x80));
	 trash=UDR0;
	 while(!(UCSR0A & 0x80));
	 trash=UDR0;
	 while(!(UCSR0A & 0x80));
	 trash=UDR0;
 }
void caliglu2()
{
	int u,r;
	for(u=0;u<3;u++)
	{
		adcglu2[u]=adc_read(0);
		_delay_us(1);
	}
	for(u=0;u<2;u++)
	{
		for(r=0;r<2-u;r++)
		{
			if(adcglu2[r]>adcglu2[r+1])
			{
				trash=adcglu2[r];
				adcglu2[r]=adcglu2[r+1];
				adcglu2[r+1]=trash;
			}
		}
	}
	midadcglu2=adcglu2[1];
	vglu2=(midadcglu2*5)/1023;
	iglu2=(vglu2)/(0.33);
	sprintf(str_data, " %.2f\n ", iglu2); send_str(str_data);
	_delay_ms(50);
	while(!(UCSR0A & 0x80));
	trash=UDR0;
	while(!(UCSR0A & 0x80));
	trash=UDR0;
	while(!(UCSR0A & 0x80));
	trash=UDR0;
}
 void concentrationofglu()
 {
	 double slopeglu;
	 double concentrationglu;
	 slopeglu=(iglu2-iglu1)/200;
	 int u,r;
	 for(u=0;u<3;u++)
	 {
		 adcglu3[u]=adc_read(0);
		 _delay_us(1);
	 }
	 for(u=0;u<2;u++)
	 {
		 for(r=0;r<2-u;r++)
		 {
			 if(adcglu3[r]>adcglu3[r+1])
			 {
				 trash=adcglu3[r];
				 adcglu3[r]=adcglu3[r+1];
				 adcglu3[r+1]=trash;
			 }
		 }
	 }
	 midadcglu3=adcglu3[1];
	 vglu3=(midadcglu3*5)/1023;
	 iglu3=vglu3/0.33;
	 concentrationglu=(iglu3-iglu1)/slopeglu;
	 sprintf(str_data, " %.2f\n ", concentrationglu); send_str(str_data);
	 while(!(UCSR0A & 0x80));
	 trash=UDR0;
	 while(!(UCSR0A & 0x80));
	 trash=UDR0;
	 while(!(UCSR0A & 0x80));
	 trash=UDR0;
	 
 }
 void calilac1()
 {
	 int u,r;
	 for(u=0;u<3;u++)
	 {
		 adclac1[u]=adc_read(0);
		 _delay_us(1);
	 }
	 for(u=0;u<2;u++)
	 {
		 for(r=0;r<2-u;r++)
		 {
			 if(adclac1[r]>adclac1[r+1])
			 {
				 trash=adclac1[r];
				 adclac1[r]=adclac1[r+1];
				 adclac1[r+1]=trash;
			 }
		 }
	 }
	 midadclac1=adclac1[1];
	 vlac1=(midadclac1*5)/1023;
	 ilac1=vlac1/(0.22);
	 sprintf(str_data, " %.2f\n ", ilac1); send_str(str_data);
	 _delay_ms(50);
	 while(!(UCSR0A & 0x80));
	 trash=UDR0;
	 while(!(UCSR0A & 0x80));
	 trash=UDR0;
	 while(!(UCSR0A & 0x80));
	 trash=UDR0;
 }
 void calilac2()
 {
	 int u,r;
	 for(u=0;u<3;u++)
	 {
		 adcpotassium2[u]=adc_read(0);
		 _delay_us(1);
	 }
	 for(u=0;u<2;u++)
	 {
		 for(r=0;r<2-u;r++)
		 {
			 if(adcpotassium2[r]>adcpotassium2[r+1])
			 {
				 trash=adcpotassium2[r];
				 adcpotassium2[r]=adcpotassium2[r+1];
				 adcpotassium2[r+1]=trash;
			 }
		 }
	 }
	 midadcpotassium2=adcpotassium2[1];
	 vpotassium2=(midadcpotassium2*5)/1023;
	 sprintf(str_data, " %.2f\n ", vpotassium2); send_str(str_data);
	 _delay_ms(50);
	 while(!(UCSR0A & 0x80));
	 trash=UDR0;
	 while(!(UCSR0A & 0x80));
	 trash=UDR0;
	 while(!(UCSR0A & 0x80));
	 trash=UDR0;
 }
 void concentrationoflac()
 {
	 double slopelac;
	 double concentrationloglac;
	 double concentrationlac;
	 slopelac=(ilac2-ilac1)/2;
	 int u,r;
	 for(u=0;u<3;u++)
	 {
		 adclac3[u]=adc_read(0);
		 _delay_us(1);
	 }
	 for(u=0;u<2;u++)
	 {
		 for(r=0;r<2-u;r++)
		 {
			 if(adclac3[r]>adclac3[r+1])
			 {
				 trash=adclac3[r];
				 adclac3[r]=adclac3[r+1];
				 adclac3[r+1]=trash;
			 }
		 }
	 }
	 midadclac3=adclac3[1];
	 vlac3=(midadclac3*5)/1023;
	 ilac3=vlac3/(0.22);
	 concentrationloglac=(ilac3-ilac1)/slopelac;
	 concentrationlac=pow(10.0, concentrationloglac);
	 sprintf(str_data, " %.2f\n ", concentrationlac); send_str(str_data);
	 while(!(UCSR0A & 0x80));
	 trash=UDR0;
	 while(!(UCSR0A & 0x80));
	 trash=UDR0;
	 while(!(UCSR0A & 0x80));
	 trash=UDR0;
	 
 }