/*
 * Meric_vykonu.c
 *
 * Created: 18.5.2013 8:58:44
 *  Author: steft
 */ 

#include <avr/io.h>
#include <avr/pgmspace.h>
 #include <stdio.h> 
 #include <stdlib.h> 

 #include <math.h> 

#define F_OSC 16000000

#include "delay.c"
#include "bitove_operace.h"
#include <avr/interrupt.h>												// knihovna pot rebn a pro p reru sen  

#include "ks0108.c"
#include "system_5x8.inc"												// Font pro displej
#include "arial_bold_14.inc"											// Font pro displej



char buffer [10];														//Buffer pro zobrazeni dat na LCD


unsigned int podsviceni=25;


volatile char Vysl_BYTE_0=0;	
volatile char Vysl_BYTE_1=0;
volatile char Vysl_BYTE_2=0;

volatile char Prij_BYTE_0=0;
volatile char Prij_BYTE_1=0;
volatile char Prij_BYTE_2=0;

volatile unsigned char klavesa=0;										//Prvni funkce po inicializaci bude spustena funkce "Konec" 
volatile unsigned char funkce=16;																																															

volatile unsigned char klavesa_kolo=0;
volatile unsigned char kolo=0;

float kolo_0_9=0;


unsigned int desitky_at=0;
unsigned char jednotky_at=0;
unsigned char desetiny_at=0;
unsigned char pozice_at=0;







unsigned int nap_det=0;
unsigned int nap_tep=0;
unsigned int nap_bat=0;

			

unsigned int atenuator=100;
unsigned char kalibrace=0;
unsigned int frekvence_MHz=0;
unsigned int frekvence_kHz=0;
			
float baterie=0;
float teplota=0;
float suma=0;
char mereni=0;
float pom_frekvence=0;
float ext_atenuator=0;											//Skutecna hodnota ext. atenuatoru je 10 krat nizsi 



float frekvence=1000.000;

unsigned int tisice_f=1;
unsigned int stovky_f=0;
unsigned int desitky_f=0;
unsigned char jednotky_f=0;
		float desetiny_f=0;
		float setiny_f=0;
		float tisiciny_f=0;

unsigned char pozice_f=0;


int int_atenuator=15;

float p=0;
float Q=0;
float Kmin=0;
float O=0;
float fm=0;

float vypocet=0;
float vykon=0;
float napeti=0;
int vysledek=0;
float kalibrace_hodnota=0;

unsigned char jednotka=0;

unsigned int prepinani=100;												//Nastaveni promenne ridici prepinani	


unsigned int n=100;





///////////////////////////////_Koeficienty pro vypocet s zarazenym atenuatorem_////////////////////////////////////////////////////////
float p_15dB[12] = {1098,1096,1080,1083,971,961,1495,-122,854,-235,405,3749};
float Q_15dB[12] = {-0.060,-0.056,-0.016,-0.018,0.038,0.042,-0.136,0.326,0.082,0.324,0.196,-0.412};
float Kmin_15dB[12] = {-24.5,-24.3,-24.2,-24.1,-24,-23.95,-24.15,-24.05,-25,-24.9,-24.35,-24.15};
float O_15dB[12] = {-0.0005,-0.0002,-0.0002,-0.0002,-0.0001,0.0004,-0.0002,0.0019,-0.0002,-0.0011,-0.0004,0.0009};

///////////////////////////////_Koeficienty pro vypocet bez atenuatoru_////////////////////////////////////////////////////////
float p_0dB[12] = {722,701,713,713,653,748,706,-36,540,36,-474,-1178};
float Q_0dB[12] = {-0.055,-0.014,-0.026,-0.026,0.004,-0.034,-0.020,0.192,0.048,0.160,0.262,0.390};
float Kmin_0dB[12] = {-24.65,-24.5,-24.3,-24.275,-24.275,-24.2,-24.2,-23.975,-24.8,-24.7,-24.375,-24.3};
float O_0dB[12] = {-0.000375,-0.0004,-0.00005,0,-0.00015,0,-0.00045,0.00165,-0.0002,-0.00065,-0.00015,-0.0022};
//////////////////////////////_Koeficient pro vypocet_///////////////////////////////////////////////////////////////////////////
float fm_0_15_dB[12] = {100,500,1000,1500,2000,2500,3000,3500,4000,4500,5000,5500};




///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////_INICIALIZACE_FUNKCE_A/D_PREVODNIKU_S_PREPINANIM_KANALU_////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void INIT_A_D(void)
{
	cbi(DDRA,0);															//Pin pro kanal "0" nastaven jako vstupni
	cbi(DDRA,1);															//Pin pro kanal "1" nastaven jako vstupni
	cbi(DDRA,2);															//Pin pro kanal "2" nastaven jako vstupni


	ADMUX |= (1<<REFS0) | (1<<REFS1);										//Referencni napeti nastaveno na 2,56 V
	ADMUX &=~((1<<MUX0)| (1<<MUX1));										//Nulovani bitu pro vyber kanalu 			
	ADCSRA |= (1<<ADEN) | (1<<ADSC) | (1<<ADPS0) | (1<<ADPS1) | (1<<ADPS2); //Zaputi A/D prevodniku, povoleni prevodu, nastaveni preddelicky na 128
}  

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////_FUNKCE_A/D_PREVODNIKU_S_PREPINANIM_KANALU_/////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
unsigned int mereni_na_kanalu(char kanal)
{
	ADMUX &=~((1<<MUX0)| (1<<MUX1));										//Nulovani bitu pro nastaveni kanalu 
	switch (kanal)	
		{																	
			case 1:															//Vyber prniho kanalu
			ADMUX |= (1<<MUX0)  ;											//Nastaveni kanalu
			break;
	
		case 2:																//Vyber druheho kanalu
			ADMUX |= (1<<MUX1)  ;											//Nastaveni kanalu
			break;
	
		default:															//Vyber nulteho kanalu
			ADMUX &=~((1<<MUX0)| (1<<MUX1));								//Nastaveni kanalu
			break;
		}
	
	delay_ms(1);															//Cekani na dokonceni zapisu (prepnuti) kanalu
	ADCSRA |= (1<<ADSC);													//Spusteni A/D prevodniku

	while(bit_is_set(ADCSRA , ADSC));										//Cekani na dokonceni prevodu
	return(ADCW);															//Vrati zmerenou hodnotu z A/D prevodniku	
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////_INICIALIZACE_FUNKCE_KOMPARATOR_PRO_OSVETLENI_LCD///////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Komparator_Init(void)
{
	sbi(DDRD,6);														// Nastavi PD6 jako vystup
	ACSR = 0x00; 														// Nastavi fci anologoveho komparatoru
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////_FUNKCE_KOMPARATOR_PRO_OSVETLENI_LCD////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Komparator(void)
{
	////Mereni osvetleni pomoci komparatoru////////////////////////////////
	unsigned char temp;													//Promenna pro ulozeni dat z dativeho registru
	temp = ACSR;														// Ulozeni hodnoty z ACSR
	temp &= 0x20;														// Nastaveni potrebne hodnoty 
 
	if(temp & 0x20)														// Testovani, zda je nastaven bit ACO
	{
		podsviceni++;													//Inkrementuje promennou, kdyz ACO = 1		
	}
	else
	{
		podsviceni--;													//Dekrementuje promennou, kdyz ACO = 0
	}

	////Odsraneni blikani podsviceni LCD, pri rychlych zmenach osvetleni
	if (podsviceni>25)													
	{
		sbi(PORTD,6);													//Rozsviti podsviceni LCD
		podsviceni=25;													//Nastaveni koeficientu poctu vzorku pro vyhodnoceni
	} 
	if (podsviceni<5)
	{
		cbi(PORTD,6);													//Zhasne podsviceni LCD
		podsviceni=4;													//Nastaveni koeficientu poctu vzorku pro vyhodnoceni
	}
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////// Inicializace tlacitek//////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Klavesy_SPI_Init(void)
{
	////Nastaveni portu B a D pro SPI komunikaci//////////////////////////           
	sbi(DDRB,4);														//Nastaveni pinu na vstupni neg. SS
	cbi(DDRB,6);														//Nastavei pinu na vstupni MISO
	sbi(DDRB,5);														//Nastaveni pinu na vystupni MOSI 
	sbi(DDRB,7);														//Nastaveni pina na vystupni SCK

	cbi(DDRD,2);														//Nastaveni pinu na vstupni CHANGE 
	cbi(DDRD,3);														//Nastaveni pinu na vstupni DRDY

	////Nastaveni ridiciho registru a preddelicky kmitoctu na fo/32///////
		SPCR = 	 (1<<SPE)													//Aktivace SPI kanálu
			|(1<<MSTR)													//Nastavení MCU jako master		
			|(1<<CPOL)													//Volba polarity hodinového signálu
			|(1<<CPHA)													//Určuje fázi hodin mezi Masterem a  Slave
			|(1<<SPR1);													//Nastaveni preddelisky na fo/32 pro krystal 16 MHz frekvence SPI je 500 kHz

	SPCR &=~(1<<DORD);													//Nastaveni poradi bitu od MSB do LSB	

	////Nastaveni stavoveho registru a preddelicky kmitoctu na fo/32//////
	SPSR=	 (1<<SPI2X);												//Nastavení stavového registru, preddelisky na fo/32 pro krystal 16 MHz frekvence SPI je 500 kHz
}



///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////Prvni komunikace s klavesami, prepsani defaultniho nastaveni////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Klavesy_SPI_prvni(void)
{
	////////Preruseni pro pin DRDY///////////////////////////////
	MCUCR =  (1<<ISC11)													//Nastaveni aktivace nabeznou hranou
			|(1<<ISC10);												//Nastaveni aktivace nabeznou hranou

	GICR = 	 (1<<INT1);													//Zakaz preruseni na pinu INT1

	Vysl_BYTE_0=0b00010011;												//Req=000|Prox on| SLD=kolo| AKS= klavesy 1-4, 5-7, kolo
	Vysl_BYTE_1=0b00010000;												//0| MOD=Free run| DI=6 mereni| LPB=vypnuto| LP MODE=free fun
	Vysl_BYTE_2=0b11011000;												//Resolution= 128 pozic| CalW=on| CalK=on| Cal Key Num= kalibruj vsechny klavesy
}


///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////Bezna komunikace s klavesami////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Klavesy_SPI(void)
{
	if (bit_is_set(PIND, 2))											//Pokud je CHANGE v log. "1" zahaj komunikaci (nova data z klaves)
	{
	Vysl_BYTE_0=0b00010011;												//Req=000|Prox on| SLD=kolo| AKS= klavesy 1-4, 5-7, kolo	
	Vysl_BYTE_1=0b00010000;												//0| MOD=Free run| DI=6 mereni| LPB=vypnuto| LP MODE=free fun				
	Vysl_BYTE_2=0b11000000;												//Resolution= 128 pozic| CalW=off| CalK=off| Cal Key Num= kalibruj vsechny klavesy	
	
	GICR = 	 (1<<INT1);													//Povoleni preruseni na pinu INT1
	}	
}


///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////Informace o kalibraci pro vypis na LCD//////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Kalibrace_info (void)
{
	ks0108SelectFont(System_5x8, ks0108ReadFontData, BLACK);			//Nastaveni fontu			
	if(kalibrace==1)													//Pokud kalibrace probehla
	{
		ks0108FillRect(61, 11, 11, 8, WHITE);							//Mazani hodnoty 	
		ks0108GotoXY(61,11);											//Nastaveni pozice
		ks0108Puts("ANO");												//Vypis retezce
	}
	if(kalibrace==0)													//Pokud kalibrace neprobehla
	{
		ks0108FillRect(63, 11, 6, 8, WHITE);							//Mazani hodnoty 	
		ks0108GotoXY(63,11);											//Nastaveni pozice
		ks0108Puts("NE");												//Vypis retezce
	}
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////Informace o teplote diodoveho detektoru//////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Teplota_info (void)
{
	mereni=0;															//Nulovani promenne
	teplota=0;															//Nulovani promenne
	vysledek=0;															//Nulovani promenne
	suma=0;																//Nulovani promenne
	while (mereni<10)													//Funkce pro opakovani mereni
		{
			nap_tep=mereni_na_kanalu(1);								//Mereni na kanalu 2 A/D prevodniku
			mereni++;													//Inkrementace pocitadla
			teplota=nap_tep;
			teplota=((2560*teplota)/1024);								//Vypocet napeti odpovidajici teplote
			teplota=(teplota+204);										//Kompenzace zatizeni senzoru rezistorem 2 kOhm
			teplota=(teplota-560)/2;									//Vypocet teploty, hodnota 560 mV odpovidajici 0 °C, smernice 2 mV/°C 
			suma=suma+teplota;											//Suma zmerenych hodnot
		}
	teplota=suma/mereni;												//Prumerovani		
	ks0108FillRect(6, 11, 25, 8, WHITE);								//Mazani hodnoty 			
	ks0108GotoXY(15,11);												//Nastaveni pozice
	vysledek=teplota;													//Vypocet celeho cisla hodnoty
	itoa(vysledek,buffer,10);											//Prevadi celociselnou hodnotu na retezec zakoncený hodnotou null
	ks0108Puts(buffer);													//Vypis retezec z bufferu
	ks0108PutChar(' ');													//Vlozeni mezery
	ks0108DrawRect(30, 10,2,2,BLACK);									//Zmena fontu
	ks0108GotoXY(33,11);												//Nastaveni pozice
	ks0108Puts("C");

	while (teplota<0 | teplota>60)
	{
		Komparator();														//Fce pro podsvetleni displeje
		ks0108ClearScreen();												//Mazani LCD
		///Vykrasleni oramovani///////////////////////////////////////////////
		ks0108DrawHoriLine(1, 0, 126, BLACK);								//Vykresleni cerne usecky			
		ks0108DrawHoriLine(1, 63, 126, BLACK);								//Vykresleni cerne usecky		
		ks0108DrawVertLine(127, 0,63, BLACK);								//Vykresleni cerne usecky
		ks0108DrawVertLine(0, 0, 63, BLACK);								//Vykresleni cerne usecky
		
		ks0108SelectFont(System_5x8, ks0108ReadFontData, BLACK);			//Vyber fontu
		ks0108GotoXY(5,15);													//Nastaveni pozice
		ks0108Puts_P(PSTR("Prekrocena maximalni"));							//Zobraz text
		ks0108GotoXY(11,25);												//Nastaveni pozice
		ks0108Puts_P(PSTR("teplota detektoru!"));							//Zobraz text
		ks0108GotoXY(11,40);												//Nastaveni pozice
		ks0108Puts("Ukoncete mereni!!!");									//Zobraz text
	
		for (;;)															//Zacykleni programu
		{
		}
	
	}

}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////Informace o stavu baterie///////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Baterie_info (void)
{		   
	mereni=0;															//Nulovani promenne
	baterie=0;															//Nulovani promenne		    						
	while (mereni<30)													//Funkce pro opakovani mereni
	{
		nap_bat=mereni_na_kanalu(2);									//Mereni na kanalu 2
		baterie=baterie+nap_bat;										//Suma zmerenych hodnot
		mereni++;														//Inkrementace pocitadla
	}

	baterie=baterie/mereni;												//Prumerovani
	baterie=((2560*baterie)/1024);										//Vypocet napeti, 6 je pridano pro zkalibrovani s multimetrem pouzitym pri mereni charakteristik detektoru
	baterie=((baterie-1890)/6.7);
				
	////Vypis informace o stavu baterie///////////////////////////
	ks0108FillRect(97, 11, 20, 8, WHITE);								//Mazani hodnoty 	
			
	////Osetreni posuvu vypisu pri zmene hodnoty stavu baterie 
	if (baterie<100)
	{
		ks0108GotoXY(103,11);											//Nastaveni pozice
	}
	else
	{
		ks0108GotoXY(97,11);											//Nastaveni pozice	
	}			
	itoa(baterie,buffer,10);											//Prevadi celociselnou hodnotu na retezec zakoncený hodnotou null
	ks0108Puts(buffer);													//Vypis retezec z bufferu
	ks0108PutChar(' ');													//Vlozeni mezery
	ks0108PutChar('%');													//Vlozeni znaku
	
	while (baterie<2)
	{
	Komparator();														//Fce pro podsvetleni displeje
	ks0108ClearScreen();												//Mazani LCD
	///Vykrasleni oramovani///////////////////////////////////////////////
	ks0108DrawHoriLine(1, 0, 126, BLACK);								//Vykresleni cerne usecky			
	ks0108DrawHoriLine(1, 63, 126, BLACK);								//Vykresleni cerne usecky		
	ks0108DrawVertLine(127, 0,63, BLACK);								//Vykresleni cerne usecky
	ks0108DrawVertLine(0, 0, 63, BLACK);								//Vykresleni cerne usecky
		
	ks0108SelectFont(System_5x8, ks0108ReadFontData, BLACK);			//Vyber fontu
	ks0108GotoXY(19,15);													//Nastaveni pozice
	ks0108Puts_P(PSTR("Vybita baterie!!"));							//Zobraz text
	ks0108GotoXY(20,30);												//Nastaveni pozice
	ks0108Puts_P(PSTR("Pripojte sitovy"));							//Zobraz text
	ks0108GotoXY(20,40);												//Nastaveni pozice
	ks0108Puts("zdroj 230 V!!!!");									//Zobraz text
	delay_ms(50000);
	}	

}


///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////Inicializace signalizace////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Init_signalizace(void)
{
sbi(DDRD,7);															//Nastaveni pinu LED signalizace prekroceni rozsahu jako vystupni 
sbi(DDRD,5);															//Nastaveni pinu Piezo sireny jako vystupni 
sbi(DDRD,4);															//Nasatveni pinu pro LED kalibraci
sbi(PORTD,7);															//LED signalizace prekroceni rozsahu vypnuta
cbi(PORTD,5);															//Spusteni Piezo sireny vypnuta
sbi(PORTD,4);															//Vypnuti LED kalibrace
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////Singnalizace  kalibrce zapnuta//////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Signalizace_kalibrace_on(void)
{
cbi(PORTD,4);															//LED signalizace kalibrace zapnuta	
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////Singnalizace  kalibrce vypnuta//////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Signalizace_kalibrace_off(void)
{
sbi(PORTD,4);															//LED signalizace kalibrace vypnuta	
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////Singnalizace  prekroceni rozsahu zapnuta///////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Signalizace_prekrocen_rozsah_on(void)
{
cbi(PORTD,7);														//LED signalizace prekroceni rozsahu vypnuta	
sbi(PORTD,5);														//Spusteni Piezo sireny vypnuta	

delay_ms(6);
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////Singnalizace  prekroceni rozsahu vypnuta////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Signalizace_prekrocen_rozsah_off(void)
{
sbi(PORTD,7);														//LED signalizace prekroceni rozsahu vypnuta	
cbi(PORTD,5);														//Spusteni Piezo sireny vypnuta	
}


///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////Inicializace prepinani atenuatoru ochrany vf. vstupu////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Init_prepina_atenuatoru(void)
{
sbi(DDRB,1);														//Nastaveni pinu pro prepinani atenuatoru jako vystupni 
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////Zarazeni utlumu 15 dB v dilu ochrany vf. vstupu ////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Int_atenuator_15_dB (void)
{
sbi(PORTB,1);														//Nastaveni pinu portu pro zarazeni utlumu
int_atenuator=15;													//Zmeni se hodota interniho atenuatoru
delay_ms(20);														//Vlozeni zpozdeni
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////Zarazeni utlumu 0 dB v dilu ochrany vf. vstupu /////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Int_atenuator_0_dB (void)
{
cbi(PORTB,1);														//Nastaveni pinu portu pro vyjmuti utlumu
int_atenuator=0;													//Zmeni se hodota interniho atenuatoru
delay_ms(20);														//Vlozeni zpozdeni	
}



///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////Vyber frekvencniho intervalu ///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Vyber_intervalu_Sn (void)
{
	if (frekvence>=100 & frekvence<=6000)								//Pokud je splnen frekvencni rozsah zvol interval Sn 
	{
		if (frekvence>=100 & frekvence<500)								//Vyber intervalu pro akt. frekvenci
		{
			n=0;		
		}	

		if (frekvence>=500 & frekvence<1000)							//Vyber intervalu pro akt. frekvenci
		{
			n=1;		
		}			
	
		if (frekvence>=1000 & frekvence<1500)							//Vyber intervalu pro akt. frekvenci
		{
			n=2;		
		}
		
		if (frekvence>=1500 & frekvence<2000)							//Vyber intervalu pro akt. frekvenci
		{
			n=3;		
		}	
		
		if (frekvence>=2000 & frekvence<2500)							//Vyber intervalu pro akt. frekvenci
		{
			n=4;		
		}
		
		if (frekvence>=2500 & frekvence<3000)							//Vyber intervalu pro akt. frekvenci
		{
			n=5;		
		}
		
		if (frekvence>=3000 & frekvence<3500)							//Vyber intervalu pro akt. frekvenci
		{
			n=6;		
		}
		
		if (frekvence>=3500 & frekvence<4000)							//Vyber intervalu pro akt. frekvenci
		{
			n=7;		
		}
		
		if (frekvence>=4000 & frekvence<4500)							//Vyber intervalu pro akt. frekvenci
		{
			n=8;		
		}
		
		if (frekvence>=4500 & frekvence<5000)							//Vyber intervalu pro akt. frekvenci
		{
			n=9;		
		}														
	
		if (frekvence>=5000 & frekvence<5500)							//Vyber intervalu pro akt. frekvenci
		{
			n=10;		
		}
		
		if (frekvence>=5500 & frekvence<=6000)							//Vyber intervalu pro akt. frekvenci
		{
			n=11;		
		}			
	Signalizace_prekrocen_rozsah_off();									//Vypnuti signalizace prekroceni rozsahu



	}
}


/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////Mereni vykonu///////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Mereni_vyhodnoceni (void)
{
Kalibrace_info ();											//Vypis informace o provedeni kalibrace
Baterie_info ();											//A/D prevod a vypocet stavu baterie
Teplota_info ();											//A/D prevod a vypocet teploty
Komparator();												//Fce pro osvetleni LCD



if (n>=0 & n<=11)														//Pokud je zvolen vhodny interval
{
	if (int_atenuator==0)												//Vyber koeficientu z Sn pro vypocet pro ochranu vstupu bez utlumu
	{
	p= p_0dB[n];		
	Q=Q_0dB[n];	
	Kmin=Kmin_0dB[n];
	O=O_0dB[n];
	fm=fm_0_15_dB[n];
	} 
	if (int_atenuator==15)												//Vyber koeficientu z Sn pro vypocet pro ochranu vstupu bez utlumu
	{
	p= p_15dB[n];		
	Q=Q_15dB[n];	
	Kmin=Kmin_15dB[n];
	O=O_15dB[n];
	fm=fm_0_15_dB[n];
	}
	

		vypocet=0;
		for (int k=0;k<101;k++)
		{
		nap_det=mereni_na_kanalu(0);
		napeti=nap_det;
		napeti=((napeti*2560)/1024)+6;
		vypocet=vypocet+napeti;	
		}
		napeti=vypocet/100;
	

	vykon=((((napeti)-(p+(Q*frekvence)))/(Kmin-(O*frekvence)+(O*fm)))-kalibrace_hodnota);
	

	vypocet=vykon;
	


		ks0108FillRect(50,45,15,6,WHITE);							//Mazani zaporneho znamenka oblasti pro vypis
		
	
	
	
	
	
	if (int_atenuator==0)												//Pokud je interni atennuator nulovy
	{
		if(ext_atenuator==0 & jednotka==0)
		{
			if (vykon<=-10 & vykon>=-45)									//Povoleni vypisu vhodne zmerene hodnotu vykonu
			{
				if (vykon<(-10))
					{
						
									
						ks0108FillRect(45,48,10,8,WHITE);							//Mazani oblasti pro vypis				
						ks0108GotoXY(45,48);										//Nastaveni pozice	
					}
					else
					{
						
						
						ks0108FillRect(51,48,10,8,WHITE);							//Mazani oblasti pro vypis		
						ks0108GotoXY(51,48);										//Nastaveni pozice	
					}	
				

					vysledek=vykon;
					itoa(vysledek,buffer,10);									//Prevadi celociselnou hodnotu na retezec zakoncený hodnotou null
					ks0108Puts(buffer);											//Vypis retezec z bufferu			
					ks0108PutChar(',');
					vykon=(vykon-vysledek)*(-100);							//Vypocet celeho cisla hodnoty
					vysledek=vykon;
					
					if (vysledek>=10)
					{
						ks0108FillRect(66,48,10,8,WHITE);							//Mazani oblasti pro vypis
						ks0108GotoXY(66,48);										//Nastaveni pozice
					}
					
					if (vysledek<10)
					{
						ks0108FillRect(66,48,10,8,WHITE);							//Mazani oblasti pro vypis
						ks0108GotoXY(66,48);	
						ks0108Puts("0");
						ks0108FillRect(72,48,10,8,WHITE);							//Mazani oblasti pro vypis
						ks0108GotoXY(72,48);										//Nastaveni pozice
					}					
					
					itoa(vysledek,buffer,10);									//Prevadi celociselnou hodnotu na retezec zakoncený hodnotou null
					ks0108Puts(buffer);											//Vypis retezec z bufferu
					ks0108PutChar(' ');											//Vlozeni mezery	 
					ks0108GotoXY(80,48);										//Nastaveni pozice	
					if (jednotka==0)
					{
					ks0108Puts("dBm");											//Vlozeni jednotky
					}
					
					}									
		prepinani=100;													//Nastaveni promenne ridici prepinani
		Signalizace_prekrocen_rozsah_off();								//Signalizace prekroceni rozsahu
		}

	
		if (vypocet<-45)													//Pokud je vykon mensi nez -45 dBm
		{
			ks0108FillRect(5,45,110,15,WHITE);							//Mazani oblasti pro vypis
			ks0108GotoXY(15,45);											//Zmena pozice
			ks0108Puts_P(PSTR("Signal ma prilis"));						//Vypis retezce		
			ks0108GotoXY(20,53);											//Zmena pozice
			ks0108Puts_P(PSTR("malou hodnotu!"));						//Vypis retezce
			prepinani=100;												//Nastaveni promenne ridici prepinani
			Signalizace_prekrocen_rozsah_on();							//Zapnuti signalizace prekroceneho rozsahu
			delay_ms(500);
			ks0108FillRect(5,45,110,15,WHITE);							//Mazani oblasti pro vypis	
		}		
	
	
		if (vypocet>-10)													//Pokud je vykon mimo meritelnou oblast pro int.atenuator= 0 dB prepni atenuator
		{
		prepinani=15;													//Nastaveni promenne pro prepnuti atenuatoru na 15 dB
		}
		
	
	}
	


	if (int_atenuator==15)
	{
		if(ext_atenuator==0 & jednotka==0)
		{
			if (vykon<=5 & vykon>(-10))										//Povoleni vypisu vhodne zmerene hodnotu vykonu
			{
				
				if (vykon<0 & vykon>-1)
					{			
					ks0108FillRect(51,48,10,8,WHITE);							//Mazani oblasti pro vypis		
					ks0108GotoXY(51,48);		
					ks0108PutChar('-');
					
					ks0108FillRect(57,48,10,8,WHITE);							//Mazani oblasti pro vypis		
					ks0108GotoXY(57,48);										//Nastaveni pozice	

					vysledek=vykon+1;
					itoa(vysledek,buffer,10);									//Prevadi celociselnou hodnotu na retezec zakoncený hodnotou null
					ks0108Puts(buffer);											//Vypis retezec z bufferu			
					ks0108PutChar(',');
					vykon=(vykon-vysledek)*(-1);								//Vypocet celeho cisla hodnoty
					vysledek=vykon;
					
					if (vysledek>=10)
					{
						ks0108FillRect(66,48,10,8,WHITE);							//Mazani oblasti pro vypis
						ks0108GotoXY(66,48);										//Nastaveni pozice
					}
					
					if (vysledek<10)
					{
						ks0108FillRect(66,48,10,8,WHITE);							//Mazani oblasti pro vypis
						ks0108GotoXY(66,48);	
						ks0108Puts("0");
						ks0108FillRect(72,48,10,8,WHITE);							//Mazani oblasti pro vypis
						ks0108GotoXY(72,48);										//Nastaveni pozice
					}
					
					
			
					
					itoa(vysledek,buffer,10);									//Prevadi celociselnou hodnotu na retezec zakoncený hodnotou null
					ks0108Puts(buffer);											//Vypis retezec z bufferu
					ks0108PutChar(' ');											//Vlozeni mezery	 
					ks0108GotoXY(80,48);										//Nastaveni pozice	
					if (jednotka==0)
					{
					ks0108Puts("dBm");											//Vlozeni jednotky
					}
				}				
				
				
				
				
				
				
				if (vykon>(-10) & vykon<=-1)
					{
					
					
					ks0108FillRect(51,48,10,8,WHITE);							//Mazani oblasti pro vypis		
					ks0108GotoXY(51,48);										//Nastaveni pozice	

				

						vysledek=vykon;
						itoa(vysledek,buffer,10);									//Prevadi celociselnou hodnotu na retezec zakoncený hodnotou null
						ks0108Puts(buffer);											//Vypis retezec z bufferu			
						ks0108PutChar(',');
						vykon=(vykon-vysledek)*(-100);							//Vypocet celeho cisla hodnoty
						vysledek=vykon;
						
						if (vysledek>=10)
						{
							ks0108FillRect(66,48,10,8,WHITE);							//Mazani oblasti pro vypis
							ks0108GotoXY(66,48);										//Nastaveni pozice
						}
					
						if (vysledek<10)
						{
							ks0108FillRect(66,48,10,8,WHITE);							//Mazani oblasti pro vypis
							ks0108GotoXY(66,48);	
							ks0108Puts("0");
							ks0108FillRect(72,48,10,8,WHITE);							//Mazani oblasti pro vypis
							ks0108GotoXY(72,48);										//Nastaveni pozice
						}

						
						itoa(vysledek,buffer,10);									//Prevadi celociselnou hodnotu na retezec zakoncený hodnotou null
						ks0108Puts(buffer);											//Vypis retezec z bufferu
						ks0108PutChar(' ');											//Vlozeni mezery	 
						ks0108GotoXY(80,48);										//Nastaveni pozice	
						if (jednotka==0)
						{
						ks0108Puts("dBm");											//Vlozeni jednotky
						}
						}					
			
				else
				{
					if (vykon<10 & vykon>0)
					{
						

						ks0108FillRect(57,48,10,8,WHITE);							//Mazani oblasti pro vypis				
						ks0108GotoXY(57,48);										//Nastaveni pozice	
					}

					vysledek=vykon;
					itoa(vysledek,buffer,10);									//Prevadi celociselnou hodnotu na retezec zakoncený hodnotou null
					ks0108Puts(buffer);											//Vypis retezec z bufferu			
					ks0108PutChar(',');
					vykon=(vykon-vysledek)*100;								//Vypocet celeho cisla hodnoty
					vysledek=vykon;
					
					if (vysledek>=10)
					{
						ks0108FillRect(66,48,10,8,WHITE);							//Mazani oblasti pro vypis
						ks0108GotoXY(66,48);										//Nastaveni pozice
					}
					
					if (vysledek<10)
					{
						ks0108FillRect(66,48,10,8,WHITE);							//Mazani oblasti pro vypis
						ks0108GotoXY(66,48);	
						ks0108Puts("0");
						ks0108FillRect(72,48,10,8,WHITE);							//Mazani oblasti pro vypis
						ks0108GotoXY(72,48);										//Nastaveni pozice
					}

					
					
					itoa(vysledek,buffer,10);									//Prevadi celociselnou hodnotu na retezec zakoncený hodnotou null
					ks0108Puts(buffer);											//Vypis retezec z bufferu
					ks0108PutChar(' ');											//Vlozeni mezery	 
					ks0108GotoXY(80,48);										//Nastaveni pozice	
					if (jednotka==0)
					{
					ks0108Puts("dBm");											//Vlozeni jednotky
					}
	
			
			
			}
				}	
				
				

				
				
					
		prepinani=100;		
		Signalizace_prekrocen_rozsah_off();		
		}		
	
	
			if (vypocet>5)
		{
			
			
			ks0108FillRect(5,45,110,15,WHITE);							//Mazani oblasti pro vypis
			ks0108GotoXY(15,45);											//Zmena pozice
			ks0108Puts_P(PSTR("Signal ma prilis"));						//Vypis retezce		
			ks0108GotoXY(20,53);											//Zmena pozice
			ks0108Puts_P(PSTR("velkou hodnotu!"));						//Vypis retezce
			prepinani=100;												//Nastaveni promenne ridici prepinani
			Signalizace_prekrocen_rozsah_on();							//Zapnuti signalizace prekroceneho rozsahu
			delay_ms(500);
			ks0108FillRect(5,45,110,15,WHITE);							//Mazani oblasti pro vypis
		}
		
		
		if (vypocet<=-10)													//Pokud je vykon mimo meritelnou oblast pro int.atenuator= 15 dB prepni atenuator
		{
		prepinani=0;													//Nastaveni promenne pro prepnuti atenuatoru na 0 dB
		}
	
	}		

	
	if (prepinani==0)													//Pokud je nataveno prepnuti
	{
	Int_atenuator_0_dB ();												//Prepni int. ateuator na 0 dB
	}


	if (prepinani==15)													//Pokud je nataveno prepnuti
	{
	Int_atenuator_15_dB ();												//Prepni int. ateuator na 15 dB
	}


	

	if(ext_atenuator>0 & prepinani==100)
	{
		vypocet=vypocet-(ext_atenuator/10);
		vykon=vypocet;
	}	
		
	
	if(ext_atenuator>0 & prepinani==100 & jednotka==0)
	{
	if (vypocet<=-10 & vypocet>=-145)									//Povoleni vypisu vhodne zmerene hodnotu vykonu
		{
			if (vypocet<(-10) & vypocet>(-100) )
				{
					ks0108FillRect(45,48,10,8,WHITE);							//Mazani oblasti pro vypis				
					ks0108GotoXY(45,48);										//Nastaveni pozice	
				}
			if (vypocet>=(-10))
				{
					ks0108FillRect(51,48,10,8,WHITE);							//Mazani oblasti pro vypis		
					ks0108GotoXY(51,48);										//Nastaveni pozice	
				}	
		
			if (vypocet<=(-100))
				{
					ks0108FillRect(39,48,10,8,WHITE);							//Mazani oblasti pro vypis		
					ks0108GotoXY(39,48);										//Nastaveni pozice	
				}					

				vysledek=vypocet;
				itoa(vysledek,buffer,10);									//Prevadi celociselnou hodnotu na retezec zakoncený hodnotou null
				ks0108Puts(buffer);											//Vypis retezec z bufferu			
				ks0108PutChar(',');
				vykon=(vypocet-vysledek)*(-100);							//Vypocet celeho cisla hodnoty
				vysledek=vykon;
				
				
				if (vysledek>=10)
				{
					ks0108FillRect(66,48,10,8,WHITE);							//Mazani oblasti pro vypis
					ks0108GotoXY(66,48);										//Nastaveni pozice
				}
					
				if (vysledek<10)
				{
					ks0108FillRect(66,48,10,8,WHITE);							//Mazani oblasti pro vypis
					ks0108GotoXY(66,48);	
					ks0108Puts("0");
					ks0108FillRect(72,48,10,8,WHITE);							//Mazani oblasti pro vypis
					ks0108GotoXY(72,48);										//Nastaveni pozice
				}
				
			
				
				itoa(vysledek,buffer,10);									//Prevadi celociselnou hodnotu na retezec zakoncený hodnotou null
				ks0108Puts(buffer);											//Vypis retezec z bufferu
				ks0108PutChar(' ');											//Vlozeni mezery	 
				ks0108GotoXY(80,48);										//Nastaveni pozice	
				if (jednotka==0)
				{
				ks0108Puts("dBm");											//Vlozeni jednotky
				}
			}			
		
		if (vypocet<=5 & vypocet>(-10))										//Povoleni vypisu vhodne zmerene hodnotu vykonu
		{
			
			if (vypocet<0 & vypocet>(-1))
					{			
					ks0108FillRect(51,48,10,8,WHITE);							//Mazani oblasti pro vypis		
					ks0108GotoXY(51,48);		
					ks0108PutChar('-');
					
					ks0108FillRect(57,48,10,8,WHITE);							//Mazani oblasti pro vypis		
					ks0108GotoXY(57,48);										//Nastaveni pozice	

					vysledek=vypocet;
					itoa(vysledek,buffer,10);									//Prevadi celociselnou hodnotu na retezec zakoncený hodnotou null
					ks0108Puts(buffer);											//Vypis retezec z bufferu			
					ks0108PutChar(',');
					vykon=(vypocet-vysledek)*(-10);								//Vypocet celeho cisla hodnoty
					vysledek=vykon;
					
					if (vysledek>=10)
					{
						ks0108FillRect(66,48,10,8,WHITE);							//Mazani oblasti pro vypis
						ks0108GotoXY(66,48);										//Nastaveni pozice
					}
					
					if (vysledek<10)
					{
						ks0108FillRect(66,48,10,8,WHITE);							//Mazani oblasti pro vypis
						ks0108GotoXY(66,48);	
						ks0108Puts("0");
						ks0108FillRect(72,48,10,8,WHITE);							//Mazani oblasti pro vypis
						ks0108GotoXY(72,48);										//Nastaveni pozice
					}
					
					
					itoa(vysledek,buffer,10);									//Prevadi celociselnou hodnotu na retezec zakoncený hodnotou null
					ks0108Puts(buffer);											//Vypis retezec z bufferu
					ks0108PutChar(' ');											//Vlozeni mezery	 
					ks0108GotoXY(80,48);										//Nastaveni pozice	
					if (jednotka==0)
					{
					ks0108Puts("dBm");											//Vlozeni jednotky
					}
				}				
			
					if (vypocet<(-1) & vypocet>(-2))
					{			
					ks0108FillRect(51,48,10,8,WHITE);							//Mazani oblasti pro vypis		
					ks0108GotoXY(51,48);		
					ks0108PutChar('-');
					
					ks0108FillRect(57,48,10,8,WHITE);							//Mazani oblasti pro vypis		
					ks0108GotoXY(57,48);										//Nastaveni pozice	

					vysledek=vypocet*(-1);
					itoa(vysledek,buffer,10);									//Prevadi celociselnou hodnotu na retezec zakoncený hodnotou null
					ks0108Puts(buffer);											//Vypis retezec z bufferu			
					ks0108PutChar(',');
					vykon=(vypocet-vysledek)*(-10);								//Vypocet celeho cisla hodnoty
					vysledek=vykon;
					
					if (vysledek>=10)
					{
						ks0108FillRect(66,48,10,8,WHITE);							//Mazani oblasti pro vypis
						ks0108GotoXY(66,48);										//Nastaveni pozice
					}
					
					if (vysledek<10)
					{
						ks0108FillRect(66,48,10,8,WHITE);							//Mazani oblasti pro vypis
						ks0108GotoXY(66,48);	
						ks0108Puts("0");
						ks0108FillRect(72,48,10,8,WHITE);							//Mazani oblasti pro vypis
						ks0108GotoXY(72,48);										//Nastaveni pozice
					}
					

					itoa(vysledek,buffer,10);									//Prevadi celociselnou hodnotu na retezec zakoncený hodnotou null
					ks0108Puts(buffer);											//Vypis retezec z bufferu
					ks0108PutChar(' ');											//Vlozeni mezery	 
					ks0108GotoXY(80,48);										//Nastaveni pozice	
					ks0108Puts("dBm");											//Vlozeni jednotky
					
				}	
			
			
			
			if (vypocet>(-10) & vypocet<=(-2))
				{
				ks0108FillRect(51,48,10,8,WHITE);							//Mazani oblasti pro vypis		
				ks0108GotoXY(51,48);										//Nastaveni pozice	

				

					vysledek=vypocet;
					itoa(vysledek,buffer,10);									//Prevadi celociselnou hodnotu na retezec zakoncený hodnotou null
					ks0108Puts(buffer);											//Vypis retezec z bufferu			
					ks0108PutChar(',');
					vykon=(vypocet-vysledek)*(-100);							//Vypocet celeho cisla hodnoty
					vysledek=vykon;
					
					if (vysledek>=10)
					{
						ks0108FillRect(66,48,10,8,WHITE);							//Mazani oblasti pro vypis
						ks0108GotoXY(66,48);										//Nastaveni pozice
					}
					
					if (vysledek<10)
					{
						ks0108FillRect(66,48,10,8,WHITE);							//Mazani oblasti pro vypis
						ks0108GotoXY(66,48);	
						ks0108Puts("0");
						ks0108FillRect(72,48,10,8,WHITE);							//Mazani oblasti pro vypis
						ks0108GotoXY(72,48);										//Nastaveni pozice
					}
					
					

					
					
					itoa(vysledek,buffer,10);									//Prevadi celociselnou hodnotu na retezec zakoncený hodnotou null
					ks0108Puts(buffer);											//Vypis retezec z bufferu
					ks0108PutChar(' ');											//Vlozeni mezery	 
					ks0108GotoXY(80,48);										//Nastaveni pozice	
					if (jednotka==0)
					{
					ks0108Puts("dBm");											//Vlozeni jednotky
					}
				}					
			
			if (vypocet>=0)
			{
				if (vypocet<10)
				{
					ks0108FillRect(57,48,10,8,WHITE);							//Mazani oblasti pro vypis				
					ks0108GotoXY(57,48);										//Nastaveni pozice	
				}
				else 
				{
					ks0108FillRect(51,48,10,8,WHITE);							//Mazani oblasti pro vypis		
					ks0108GotoXY(51,48);										//Nastaveni pozice	
				}
				vysledek=vypocet;
				itoa(vysledek,buffer,10);									//Prevadi celociselnou hodnotu na retezec zakoncený hodnotou null
				ks0108Puts(buffer);											//Vypis retezec z bufferu			
				ks0108PutChar(',');
				vykon=(vypocet-vysledek)*100;								//Vypocet celeho cisla hodnoty
				vysledek=vykon;
				
				if (vysledek>=10)
				{
					ks0108FillRect(66,48,10,8,WHITE);							//Mazani oblasti pro vypis
					ks0108GotoXY(66,48);										//Nastaveni pozice
				}
					
				if (vysledek<10)
				{
					ks0108FillRect(66,48,10,8,WHITE);							//Mazani oblasti pro vypis
					ks0108GotoXY(66,48);	
					ks0108Puts("0");
					ks0108FillRect(72,48,10,8,WHITE);							//Mazani oblasti pro vypis
					ks0108GotoXY(72,48);										//Nastaveni pozice
				}
				

				itoa(vysledek,buffer,10);									//Prevadi celociselnou hodnotu na retezec zakoncený hodnotou null
				ks0108Puts(buffer);											//Vypis retezec z bufferu
				ks0108PutChar(' ');											//Vlozeni mezery	 
				ks0108GotoXY(80,48);										//Nastaveni pozice	
				if (jednotka==0)
				{
				ks0108Puts("dBm");											//Vlozeni jednotky
				}
	
			}			
			
		}		
	}				




if (jednotka==1 & prepinani==100)
{
double zaklad=10;
double podil=vykon/10;
double power;
power=pow ( zaklad, podil); 	
vypocet=power*1000;
								
				
		
				
				
				if (vypocet>=1000)
				{
					ks0108FillRect(40,48,56,8,WHITE);							//Mazani oblasti pro vypis				
					ks0108GotoXY(40,48);										//Nastaveni pozice	
				}

				if (vypocet<1000 & vypocet>=100)
				{
					ks0108FillRect(46,48,52,8,WHITE);							//Mazani oblasti pro vypis				
					ks0108GotoXY(46,48);										//Nastaveni pozice	
				}


				if (vypocet<100 & vypocet>=10)
				{
					ks0108FillRect(52,48,47,8,WHITE);							//Mazani oblasti pro vypis				
					ks0108GotoXY(52,48);										//Nastaveni pozice	
				}
				
				if (vypocet<10)
				{
					ks0108FillRect(58,48,41,8,WHITE);							//Mazani oblasti pro vypis				
					ks0108GotoXY(58,48);										//Nastaveni pozice	
				}


				vysledek=vypocet;
				itoa(vysledek,buffer,10);									//Prevadi celociselnou hodnotu na retezec zakoncený hodnotou null
				ks0108Puts(buffer);											//Vypis retezec z bufferu			
				ks0108PutChar(',');
				vykon=(vypocet-vysledek)*100;								//Vypocet celeho cisla hodnoty
				vysledek=vykon;
				
								
				if (vysledek>=10)
				{
					ks0108FillRect(67,48,10,8,WHITE);							//Mazani oblasti pro vypis
					ks0108GotoXY(67,48);										//Nastaveni pozice
				}
					
				if (vysledek<10)
				{
					ks0108FillRect(67,48,10,8,WHITE);							//Mazani oblasti pro vypis
					ks0108GotoXY(67,48);	
					ks0108Puts("0");
					ks0108FillRect(72,48,10,8,WHITE);							//Mazani oblasti pro vypis
					ks0108GotoXY(72,48);										//Nastaveni pozice
				}	
	

				itoa(vysledek,buffer,10);									//Prevadi celociselnou hodnotu na retezec zakoncený hodnotou null
				ks0108Puts(buffer);											//Vypis retezec z bufferu
				ks0108PutChar(' ');											//Vlozeni mezery	 
				ks0108GotoXY(80,48);										//Nastaveni pozice	
				ks0108Puts("uW");											//Vlozeni jednotky
				
	
			}			








}	


}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////Kalibrace///////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Kalibrace (void)
{
	kalibrace=1;
	Kalibrace_info ();														//Vypis informace o provedeni kalibrace
	Baterie_info ();														//A/D prevod a vypocet stavu baterie
	Teplota_info ();														//A/D prevod a vypocet teploty
	Komparator();															//Fce pro osvetleni LCD

	if (n>=0 & n<=11)														//Pokud je zvolen vhodny interval
	{
		if (int_atenuator==0)												//Vyber koeficientu z Sn pro vypocet pro ochranu vstupu bez utlumu
		{
		p= p_0dB[n];		
		Q=Q_0dB[n];	
		Kmin=Kmin_0dB[n];
		O=O_0dB[n];
		fm=fm_0_15_dB[n];
		} 
		if (int_atenuator==15)												//Vyber koeficientu z Sn pro vypocet pro ochranu vstupu bez utlumu
		{
		p= p_15dB[n];		
		Q=Q_15dB[n];	
		Kmin=Kmin_15dB[n];
		O=O_15dB[n];
		fm=fm_0_15_dB[n];
		}
	

		vypocet=0;
		for (int k=0;k<101;k++)
		{
		nap_det=mereni_na_kanalu(0);
		napeti=nap_det;
		napeti=((napeti*2560)/1024)+6;
		vypocet=vypocet+napeti;	
		}
		napeti=vypocet/100;

	
		vykon=(((napeti)-(p+(Q*frekvence)))/(Kmin-(O*frekvence)+(O*fm)));
	
		kalibrace_hodnota=vykon;
	
		vypocet=vykon;
		
	
		if (int_atenuator==0)												//Pokud je interni atennuator nulovy
		{
				if (vykon<=-10 & vykon>=-45)									//Povoleni vypisu vhodne zmerene hodnotu vykonu
				{
					prepinani=100;													//Nastaveni promenne ridici prepinani
					Signalizace_prekrocen_rozsah_off();								//Signalizace prekroceni rozsahu
				}

	
				if (vypocet<-45)													//Pokud je vykon mensi nez -45 dBm
				{
					ks0108FillRect(5,45,110,15,WHITE);							//Mazani oblasti pro vypis
					ks0108GotoXY(15,45);											//Zmena pozice
					ks0108Puts_P(PSTR("Signal ma prilis"));						//Vypis retezce		
					ks0108GotoXY(20,53);											//Zmena pozice
					ks0108Puts_P(PSTR("malou hodnotu!"));						//Vypis retezce
					prepinani=100;												//Nastaveni promenne ridici prepinani
					Signalizace_prekrocen_rozsah_on();							//Zapnuti signalizace prekroceneho rozsahu
					delay_ms(500);
					ks0108FillRect(5,45,110,15,WHITE);							//Mazani oblasti pro vypis	
				}		
	
	
				if (vypocet>-10)													//Pokud je vykon mimo meritelnou oblast pro int.atenuator= 0 dB prepni atenuator
				{
					prepinani=15;													//Nastaveni promenne pro prepnuti atenuatoru na 15 dB
				}
		
	
		}
	

		if (int_atenuator==15)
		{
				if (vykon<=5 & vykon>(-10))										//Povoleni vypisu vhodne zmerene hodnotu vykonu
				{						
					prepinani=100;		
					Signalizace_prekrocen_rozsah_off();		
				}		
	
	
				if (vypocet>5)
				{
					ks0108FillRect(5,45,110,15,WHITE);							//Mazani oblasti pro vypis
					ks0108GotoXY(15,45);											//Zmena pozice
					ks0108Puts_P(PSTR("Signal ma prilis"));						//Vypis retezce		
					ks0108GotoXY(20,53);											//Zmena pozice
					ks0108Puts_P(PSTR("velkou hodnotu!"));						//Vypis retezce
					prepinani=100;												//Nastaveni promenne ridici prepinani
					Signalizace_prekrocen_rozsah_on();							//Zapnuti signalizace prekroceneho rozsahu
					delay_ms(500);
					ks0108FillRect(5,45,110,15,WHITE);							//Mazani oblasti pro vypis	
				}
		
		
				if (vypocet<=-10)													//Pokud je vykon mimo meritelnou oblast pro int.atenuator= 15 dB prepni atenuator
				{
				prepinani=0;													//Nastaveni promenne pro prepnuti atenuatoru na 0 dB
				}
	
		}	

	
		if (prepinani==0)													//Pokud je nataveno prepnuti
		{
		Int_atenuator_0_dB ();												//Prepni int. ateuator na 0 dB
		}


		if (prepinani==15)													//Pokud je nataveno prepnuti
		{
		Int_atenuator_15_dB ();												//Prepni int. ateuator na 15 dB
		}

	}	


}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////TELO HLAVNIHO PROGRAMU//////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


int main (void) {

//////////////////// Inicializace pro vsechny fce///////////////////////// 
	Komparator_Init();													//Inicializace displeje
	delay_ms(500);														// Cekani na spusteni LCD
	Klavesy_SPI_Init();													//Inicializace klaves
	ks0108Init(NON_INVERTED);											//Inicializace LCD		
	ks0108ClearScreen();												//Mazani LCD
    Klavesy_SPI_prvni();												//Inicializace kapacitnich tlacitek
	INIT_A_D();															//Inicializace A/D prevodniku			
	Init_prepina_atenuatoru();											//Inicializace prepinani utlumu atenuatoru v dilu ochrany vstupu
	Int_atenuator_15_dB ();												//Nastavi int. atenuator na 0 dB
	Init_signalizace();													//Inicializace signalizace
	Vyber_intervalu_Sn ();												//Vyber koeficientu z Sn pro merenou frekvenci

//////////////////// Uvodni vypis informaci ///////////////////////
	Komparator();														//Fce pro podsvetleni displeje
	ks0108SelectFont(Arial_Bold_14, ks0108ReadFontData, BLACK);			//Vyber fontu
	ks0108GotoXY(5,20);													//Nastaveni pozice
	ks0108Puts_P(PSTR("Vysokofrekvencni"));								//Zobraz text
	ks0108GotoXY(20,35);												//Nastaveni pozice
	ks0108Puts("meric vykonu");											//Zobraz text

	delay_ms(1500);														// Prodleva pro zobrazeni

	ks0108ClearScreen();												//Mazani LCD
	///Vykrasleni oramovani///////////////////////////////////////////////
	ks0108DrawHoriLine(1, 0, 126, BLACK);								//Vykresleni cerne usecky			
	ks0108DrawHoriLine(1, 63, 126, BLACK);								//Vykresleni cerne usecky		
	ks0108DrawVertLine(127, 0,63, BLACK);								//Vykresleni cerne usecky
	ks0108DrawVertLine(0, 0, 63, BLACK);								//Vykresleni cerne usecky
	///Vykrasleni delici cary
	ks0108DrawHoriLine(1, 31, 126, BLACK);								//Vykresleni cerne usecky
	ks0108DrawHoriLine(1, 32, 126, BLACK);								//Vykresleni cerne usecky
	ks0108DrawHoriLine(1, 33, 126, BLACK);								//Vykresleni cerne usecky
	
	ks0108SelectFont(System_5x8, ks0108ReadFontData, BLACK);			//Nataveni fontu
	ks0108GotoXY(17,5);													//Nastaveni pozice
	ks0108Puts("Vykonovy rozsah:");										//Vypsani retezce
	ks0108DrawHoriLine(17, 13, 92, BLACK);								//Podtrzeni nadpisu
	ks0108GotoXY(22,15);												//Nastaveni pozice	
	ks0108Puts("-45 do +5 dBm");										//Vypsani retezce

	ks0108GotoXY(11,38);												//Nastaveni pozice						
	ks0108Puts("Frekvencni rozsah:");									//Vypsani retezce
	ks0108DrawHoriLine(11, 46, 104, BLACK);								//Podtrzeni nadpisu
	ks0108GotoXY(30,48);												//Nastaveni pozice
	ks0108Puts("0,1 do 6 GHz");											//Vypsani retezce

	delay_ms(2000);														// Prodleva pro zobrazeni
	ks0108ClearScreen();


	sei();																//Povoleni globalniho preruseni

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////NEKONECNA SMYCKA////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////	
	while(1)
	{


		Komparator();													//Funkce pro podsviceni displeje
		Klavesy_SPI();													//Funkce pro komunikaci s klavesami
		
		while (funkce==1)												//Po stisku klavesy "Kalibrace" opakuj dokud je podminka splnena	
		{
			Komparator();												//Funkce pro osvetleni LCD	
			Signalizace_prekrocen_rozsah_off();								//Vyputi signalizace prekroceni rozsahu
			////Vykresleni struktury pozadi///////////////////////////////
			ks0108DrawHoriLine(1, 0, 126, BLACK);						//Vykresleni cerne usecky
			ks0108DrawHoriLine(1, 20, 126, BLACK);						//Vykresleni cerne usecky
			ks0108DrawHoriLine(1, 63, 126, BLACK);						//Vykresleni cerne usecky
			ks0108DrawHoriLine(1, 31, 126, BLACK);						//Vykresleni cerne usecky
			ks0108DrawHoriLine(1,32,125, BLACK);						//Vykresleni cerne usecky
			ks0108DrawHoriLine(1, 62,125, BLACK);						//Vykresleni cerne usecky
			ks0108DrawVertLine(127, 0,63, BLACK);						//Vykresleni cerne usecky
			
			ks0108DrawVertLine(42, 1, 19, BLACK);						//Vykresleni cerne usecky
			
			ks0108DrawVertLine(0, 0, 63, BLACK);						//Vykresleni cerne usecky		
			ks0108DrawVertLine(1, 32, 30, BLACK);						//Vykresleni cerne usecky	
			ks0108DrawVertLine(126, 32,30, BLACK);						//Vykresleni cerne usecky
		
			
			ks0108DrawVertLine(96, 1, 19, BLACK);						//Vykresleni cerne usecky
			
			////Vypis nemennych textu/////////////////////////////////////
			ks0108SelectFont(System_5x8, ks0108ReadFontData, WHITE);	//Nastaveni fontu	
			ks0108GotoXY(1,1);											//Nastaveni pozice
			ks0108Puts("Teplota");										//Vypis retezce
			ks0108GotoXY(43,1);											//Nastaveni pozice
			ks0108Puts("Kalibrace");									//Vypis retezce				
			ks0108GotoXY(97,1);											//Nastaveni pozice
			ks0108Puts("Bater");										//Vypis retezce
			ks0108GotoXY(1,22);											//Nastaveni pozice
			ks0108Puts("Frekvence:");									//Vypis retezce
			ks0108SelectFont(System_5x8, ks0108ReadFontData, BLACK);	//Nastaveni fontu
			ks0108GotoXY(14,34);										//Nastaveni pozice
			ks0108Puts("Pripojte na vstup");							//Vypis retezce			
			ks0108GotoXY(4,44);											//Nastaveni pozice			
			ks0108Puts("signal o P=0 dBm pro");							//Vypis retezce				
			ks0108GotoXY(8,54);											//Nastaveni pozice
			ks0108Puts("zvolenou frekvenci.");							//Vypis retezce				

			
			Kalibrace_info ();											//Vypis informace o provedeni kalibrace
			Baterie_info ();											//A/D prevod a vypocet stavu baterie
			Teplota_info ();											//A/D prevod a vypocet teploty

			////Vypis hodnoty nastavene frekvence	    
			frekvence_MHz=frekvence;									//Vypocet celeho cisla hodnoty
			if (frekvence_MHz>=1000)
				{
				ks0108GotoXY(63,22);									//Nastaveni pozice	
				}
			if (frekvence_MHz>=100 & frekvence_MHz<1000)
				{
				ks0108GotoXY(69,22);									//Nastaveni pozice	
				}
			itoa(frekvence_MHz,buffer,10);								//Převádí celočíselnou hodnotu na řetězec zakončený hodnotou null
			ks0108Puts(buffer);											//Vypis retezec z bufferu
			ks0108PutChar(',');											//Vlozeni des. carky								
			frekvence_kHz=(frekvence-frekvence_MHz)*1000;				//Vypocet pro desetinna mista hodnoty
			pom_frekvence=(frekvence-frekvence_MHz)*10000;				//Vypocet pro osetreni chyby deleni
			pom_frekvence=(pom_frekvence-(frekvence_kHz*10));			//Vypocet pro osetreni chyby deleni
			
				//Osetreni chyby deleni zaokrouhlovanim////////////////////
				if (pom_frekvence>=5)
				{
					frekvence_kHz++;									//Zaokrouhli nahoru
				}
			
			ks0108GotoXY(90,22);										//Nastaveni pozice pro vypis stovek kHz
				////Osetreni posuvu vypisu pri zmene hodnoty frekvence 				
				if (frekvence_kHz<100 & frekvence_kHz>=10)				//Nastaveni pozice pro vypis desitek kHz
				{
					ks0108PutChar('0');									//Vypis retezec z bufferu
					ks0108GotoXY(96,22);								//Nastaveni pozice								
				}

			
				if (frekvence_kHz<10)									//Nastaveni pozice pro vypis jednotek kHz
				{
					ks0108Puts("00");									//Vypis retezec z bufferu
					ks0108GotoXY(102,22);								//Nastaveni pozice
				}
		
		

			itoa(frekvence_kHz,buffer,10);								//Převádí celočíselnou hodnotu na řetězec zakončený hodnotou null
			ks0108Puts(buffer);											//Vypis retezec z bufferu
			ks0108PutChar(' ');											//Vlozeni mezery 
			ks0108GotoXY(109,22);										//Nastaveni pozice
			ks0108Puts("MHz");											//Vypis retezce
							
			while (funkce!=64)
			{
				Klavesy_SPI();												//Komunikace s klavesami		
			}
			Signalizace_kalibrace_on();
			Kalibrace();

								
						
		funkce=16;
		}


	
		ks0108ClearScreen();											//Mazani LCD


		while (funkce==2)												//Po stisku klavesy "Ext. atenuator" opakuj dokud je podminka splnena			
		{
			Komparator();												//Funkce pro osvetleni LCD	
			Signalizace_prekrocen_rozsah_off();								//Vyputi signalizace prekroceni rozsahu
			////Vykresleni struktury pozadi///////////////////////////////		
			ks0108DrawHoriLine(1, 0, 126, BLACK);						//Vykresleni cerne usecky
			ks0108DrawHoriLine(1, 20, 126, BLACK);						//Vykresleni cerne usecky
			ks0108DrawHoriLine(1, 63, 126, BLACK);						//Vykresleni cerne usecky
			ks0108DrawHoriLine(1, 31, 126, BLACK);						//Vykresleni cerne usecky
			ks0108DrawHoriLine(1,32,125, BLACK);						//Vykresleni cerne usecky
			ks0108DrawHoriLine(1, 62,125, BLACK);						//Vykresleni cerne usecky
		
			ks0108DrawVertLine(127, 0,63, BLACK);						//Vykresleni cerne usecky
			ks0108DrawVertLine(42, 1, 19, BLACK);						//Vykresleni cerne usecky
			ks0108DrawVertLine(0, 0, 63, BLACK);						//Vykresleni cerne usecky		
			ks0108DrawVertLine(1, 32, 30, BLACK);						//Vykresleni cerne usecky	
			ks0108DrawVertLine(126, 32,30, BLACK);						//Vykresleni cerne usecky
			ks0108DrawVertLine(96, 1, 19, BLACK);						//Vykresleni cerne usecky
			
			////Vypis nemennych textu/////////////////////////////////////
			ks0108SelectFont(System_5x8, ks0108ReadFontData, WHITE);	//Nastaveni fontu	
			ks0108GotoXY(1,1);											//Nastaveni pozice
			ks0108Puts("Teplota");										//Vypis retezce
			ks0108GotoXY(43,1);											//Nastaveni pozice
			ks0108Puts("Kalibrace");									//Vypis retezce				
			ks0108GotoXY(97,1);											//Nastaveni pozice
			ks0108Puts("Bater");										//Vypis retezce
			ks0108GotoXY(2,33);											//Nastaveni pozice
			ks0108Puts("Ext. atenuator:");								//Vypis retezce
			ks0108GotoXY(1,22);											//Nastaveni pozice
			ks0108Puts("Frekvence:");									//Vypis retezce

			Kalibrace_info ();											//Vypis informace o provedeni kalibrace
			Baterie_info ();											//A/D prevod a vypocet stavu baterie
			Teplota_info ();											//A/D prevod a vypocet teploty
			Komparator();												//Funkce pro osvetleni LCD	
					
			////Vypis hodnoty externe pripojeneho atenuatoru//////////////	
			//Osetreni posuvu vypisu pri zmene hodnoty atenuatoru 
			if (ext_atenuator>=100)
				{
					ks0108GotoXY(49,48);								//Nastaveni pozice
				}
			else
				{
					ks0108GotoXY(54,48);								//Nastaveni pozice
				}
			atenuator=ext_atenuator/10;									//Vypocet celeho cisla hodnoty
			itoa(atenuator,buffer,10);									//Prevadi celociselnou hodnotu na retezec zakoncený hodnotou null
			ks0108Puts(buffer);											//Vypis retezec z bufferu
			ks0108PutChar(',');											//Vlozeni des. carky
			vysledek=ext_atenuator-(atenuator*10);						//Vypocet pro desetinna mista hodnoty
			ks0108GotoXY(64,48);										//Nastaveni pozice
			itoa(vysledek,buffer,10);									//Prevadi celociselnou hodnotu na retezec zakoncený hodnotou null
			ks0108Puts(buffer);											//Vypis retezec z bufferu
			ks0108PutChar(' ');											//Vlozeni mezery	 
			ks0108GotoXY(72,48);										//Nastaveni pozice	
			ks0108Puts("dB");											//Vlozeni jednotky

			////Vypis hodnoty nastavene frekvence//////////////////////////	    
			//Osetreni vypisu proti zmene hodnoty frekvence
			frekvence_MHz=frekvence;									//Vypocet celeho cisla hodnoty
			if (frekvence_MHz>=1000)									
				{
					ks0108GotoXY(63,22);								//Nastaveni pozice	
				}
			if (frekvence_MHz>=100 & frekvence_MHz<1000)
				{
					ks0108GotoXY(69,22);								//Nastaveni pozice	
				}

			itoa(frekvence_MHz,buffer,10);								//Prevadi celociselnou hodnotu na retezec zakoncený hodnotou null
			ks0108Puts(buffer);											//Vypis retezec z bufferu
			ks0108PutChar(',');											//Vlozeni des. carky								
			frekvence_kHz=(frekvence-frekvence_MHz)*1000;				//Vypocet pro desetinna mista hodnoty
			pom_frekvence=(frekvence-frekvence_MHz)*10000;				//Vypocet pro osetreni chyby deleni
			pom_frekvence=(pom_frekvence-(frekvence_kHz*10));			//Vypocet pro osetreni chyby deleni
			
			//Osetreni chyby deleni zaokrouhlovanim///////////////////////
			if (pom_frekvence>=5)
				{
					frekvence_kHz++;									//Zaokrouhli nahoru
				}
			ks0108GotoXY(90,22);										//Nastaveni pozice pro vypis stovek kHz
			//Osetreni posuvu vypisu pri zmene hodnoty frekvence 				
			if (frekvence_kHz<100 & frekvence_kHz>=10)					//Nastaveni pozice pro vypis desitek kHz
				{
					ks0108PutChar('0');									//Vypis retezec z bufferu
					ks0108GotoXY(96,22);								//Nastaveni pozice								
				}
			if (frekvence_kHz<10)										//Nastaveni pozice pro vypis jednotek kHz
				{
					ks0108Puts("00");									//Vypis retezec z bufferu
					ks0108GotoXY(102,22);								//Nastaveni pozice
				}
			itoa(frekvence_kHz,buffer,10);								//Prevadi celociselnou hodnotu na retezec zakoncený hodnotou null
			ks0108Puts(buffer);											//Vypis retezec z bufferu
			ks0108PutChar(' ');											//Vlozeni mezery 
			ks0108GotoXY(109,22);										//Nastaveni pozice
			ks0108Puts("MHz");											//Vypis retezce
			
			
			////Zmena hodnoty ext. atenuatoru/////////////////////////////////////
						while (funkce!=16)								//Opakovani dokud neni stiskla klavesa konec 
						{		
							Klavesy_SPI();								//Komunikace s tlacitky
							if (klavesa_kolo==128)						//Pokud byla zmenena hodnota kola (wheel)
								{
									kolo=128-kolo;						//Nastaveni smeru inkrementace kola 
									pozice_at=kolo/42;					//Rozdeli kolo na hodnoty 0-2
									ks0108GotoXY(4,48);					//Nastaveni pozice
									itoa(pozice_at,buffer,10);			//Prevadi celociselnou hodnotu na retezec zakoncený hodnotou null
									ks0108Puts(buffer);					//Vypis retezec z bufferu
									delay_ms(500);							//Zpozdeni
									funkce=klavesa_kolo;					//Zmena promenne nutna pro cykleni smycky
									ks0108FillRect(4, 48, 20, 8, WHITE);	//Mazani hodnoty
									klavesa_kolo=0;							//Nulovani promenne								
									kolo=0;									//Nulovani promenne
									ks0108FillRect(48, 57, 30, 1, WHITE);	//Mazani hodnoty ukazatele na pozici					
								}
				
							switch (pozice_at)							//Prepinani ukazatele na cislo a jeho zmena
							{
								case 0:									//Pozice cisla 
								{
									ks0108DrawHoriLine(48,57,4, BLACK);	//Vykresleni ukazatele
									while (funkce!=64)					//Opakuj dokud neni stikla klavesa "Potvrzeni"
									{
										Klavesy_SPI();					//Komunikace s klavesami
										if (klavesa_kolo==128)			//Pokud byla zmenena hodnota kola (wheel)
										{	
											kolo=128-kolo;				//Nastaveni smeru inkrementace kola 
											desitky_at=kolo/13;			//Rozdeli kolo na hodnoty 0-9
							
											ks0108FillRect(48, 48, 4, 8, WHITE);	//Mazani hodnoty 										
											ks0108GotoXY(48,48);			//Nastaveni pozice
											itoa(desitky_at,buffer,10);		//Prevadi celociselnou hodnotu na retezec zakoncený hodnotou null
											ks0108Puts(buffer);			//Vypis retezec z bufferu
											klavesa_kolo=0;				//Nulovani promenne
											kolo=0;						//Nulovani promenne
										}						
									}
									}
												
								break;
								case 1:											//Pozice cisla 
									{
										ks0108DrawHoriLine(55,57,4, BLACK);		//Vykresleni ukazatele				
										while (funkce!=64)						//Opakuj dokud neni stikla klavesa "Potvrzeni"
									{
										Klavesy_SPI();							//Komunikace s klavesami
										if (klavesa_kolo==128)					//Pokud byla zmenena hodnota kola (wheel)
										{	
											kolo=128-kolo;						//Nastaveni smeru inkrementace kola 
											jednotky_at=kolo/13;				//Rozdeli kolo na hodnoty 0-9
							
											ks0108FillRect(54, 48, 5, 8, WHITE);	//Mazani hodnoty 										
											ks0108GotoXY(55,48);				//Nastaveni pozice
											itoa(jednotky_at,buffer,10);		//Prevadi celociselnou hodnotu na retezec zakoncený hodnotou null
											ks0108Puts(buffer);					//Vypis retezec z bufferu
											klavesa_kolo=0;						//Nulovani promenne
											kolo=0;								//Nulovani promenne				
										}						
									}							
							
							
										}												
								break;
								case 2:											//Pozice cisla 
										{
										ks0108DrawHoriLine(64,57,4, BLACK);		//Vykresleni ukazatele					
									while (funkce!=64)							//Opakuj dokud neni stikla klavesa "Potvrzeni"
									{
										Klavesy_SPI();							//Komunikace s klavesami
										if (klavesa_kolo==128)					//Pokud byla zmenena hodnota kola (wheel)
										{	
											kolo=128-kolo;						//Nastaveni smeru inkrementace kola 
											desetiny_at=kolo/13;				//Rozdeli kolo na hodnoty 0-9
							
											ks0108FillRect(64, 48, 5, 8, WHITE);	//Mazani hodnoty 										
											ks0108GotoXY(64,48);				//Nastaveni pozice
											itoa(desetiny_at,buffer,10);		//Prevadi celociselnou hodnotu na retezec zakoncený hodnotou null
											ks0108Puts(buffer);					//Vypis retezec z bufferu
											klavesa_kolo=0;						//Nulovani promenne
											kolo=0;								//Nulovani promenne				
										}						
									}
								}									
								break;
							}		
							
				ext_atenuator=((desitky_at*100)+(jednotky_at*10)+desetiny_at);	//Vypocet hodnoty noveho nastaveni
		
				Klavesy_SPI();											//Komunikace s klavesami				
				}
	
			Klavesy_SPI();												//Komunikace s klavesami
	}
			
	
		ks0108ClearScreen();											//Mazani LCD

		
////////////Funkce frekvence//////////////////////////////////////////////
		while (funkce==4)
		{

			Signalizace_prekrocen_rozsah_off();								//Vyputi signalizace prekroceni rozsahu
			////Vykresleni struktury pozadi///////////////////////////////
			ks0108DrawHoriLine(1, 0, 126, BLACK);						//Vykresleni cerne usecky
			ks0108DrawHoriLine(1, 20, 126, BLACK);						//Vykresleni cerne usecky
			ks0108DrawHoriLine(1, 63, 126, BLACK);						//Vykresleni cerne usecky
			ks0108DrawHoriLine(1, 31, 126, BLACK);						//Vykresleni cerne usecky
			ks0108DrawHoriLine(1,32,125, BLACK);						//Vykresleni cerne usecky
			ks0108DrawHoriLine(1, 62,125, BLACK);						//Vykresleni cerne usecky
			ks0108DrawVertLine(127, 0,63, BLACK);						//Vykresleni cerne usecky
			
			ks0108DrawVertLine(42, 1, 19, BLACK);						//Vykresleni cerne usecky
			
			ks0108DrawVertLine(0, 0, 63, BLACK);						//Vykresleni cerne usecky		
			ks0108DrawVertLine(1, 32, 30, BLACK);						//Vykresleni cerne usecky	
			ks0108DrawVertLine(126, 32,30, BLACK);						//Vykresleni cerne usecky
		
			
			ks0108DrawVertLine(96, 1, 19, BLACK);						//Vykresleni cerne usecky
			
			////Vypis nemennych textu/////////////////////////////////////
			ks0108SelectFont(System_5x8, ks0108ReadFontData, WHITE);	//Nastaveni fontu	
			ks0108GotoXY(1,1);											//Nastaveni pozice
			ks0108Puts("Teplota");										//Vypis retezce
			ks0108GotoXY(43,1);											//Nastaveni pozice
			ks0108Puts("Kalibrace");									//Vypis retezce				
			ks0108GotoXY(97,1);											//Nastaveni pozice
			ks0108Puts("Bater");										//Vypis retezce
			ks0108GotoXY(1,22);											//Nastaveni pozice
			ks0108Puts("Ext. atenuator:");								//Vypis retezce
			ks0108GotoXY(2,33);											//Nastaveni pozice
			ks0108Puts("Frekvence:");									//Vypis retezce

			Kalibrace_info ();											//Vypis informace o provedeni kalibrace
			Baterie_info ();											//A/D prevod a vypocet stavu baterie
			Teplota_info ();											//A/D prevod a vypocet teploty
	

			////Vypis hodnoty externe pripojeneho atenuatoru//////////////		
			////Osetreni posuvu vypisu pri zmene hodnoty atenuatoru 
				if (ext_atenuator>=100)
				{
					ks0108GotoXY(92,22);								//Nastaveni pozice
				}
				else
				{
					ks0108GotoXY(97,22);								//Nastaveni pozice
				}
			atenuator=ext_atenuator/10;									//Vypocet celeho cisla hodnoty
			itoa(atenuator,buffer,10);									//Prevadi celociselnou hodnotu na retezec zakoncený hodnotou null
			ks0108Puts(buffer);											//Vypis retezec z bufferu
			ks0108PutChar(',');											//Vlozeni des. carky
			vysledek=ext_atenuator-(atenuator*10);						//Vypocet pro desetinna mista hodnoty
			ks0108GotoXY(107,22);										//Nastaveni pozice
			itoa(vysledek,buffer,10);									//Prevadi celociselnou hodnotu na retezec zakoncený hodnotou null
			ks0108Puts(buffer);											//Vypis retezec z bufferu
			ks0108PutChar(' ');											//Vlozeni mezery	 
			ks0108GotoXY(115,22);										//Nastaveni pozice	
			ks0108Puts("dB");											//Vlozeni jednotky

			////Vypis hodnoty nastavene frekvence/////////////////////////	    
			frekvence_MHz=frekvence;									//Vypocet celeho cisla hodnoty
			if (frekvence_MHz>=1000)
				{
				ks0108GotoXY(38,48);										//Nastaveni pozice	
				}
			if (frekvence_MHz>=100 & frekvence_MHz<1000)
				{
				ks0108GotoXY(44,48);										//Nastaveni pozice	
				}
			
			itoa(frekvence_MHz,buffer,10);								//Prevadi celociselnou hodnotu na retezec zakoncený hodnotou null
			ks0108Puts(buffer);											//Vypis retezec z bufferu
			ks0108PutChar(',');											//Vlozeni des. carky								
			frekvence_kHz=(frekvence-frekvence_MHz)*1000;				//Vypocet pro desetinna mista hodnoty
			pom_frekvence=(frekvence-frekvence_MHz)*10000;				//Vypocet pro osetreni chyby deleni
			pom_frekvence=(pom_frekvence-(frekvence_kHz*10));			//Vypocet pro osetreni chyby deleni
			
				//Osetreni chyby deleni zaokrouhlovanim////////////////////
				if (pom_frekvence>=5)
				{
					frekvence_kHz++;									//Zaokrouhli nahoru
				}
			
			ks0108GotoXY(65,48);										//Nastaveni pozice pro vypis stovek kHz
				////Osetreni posuvu vypisu pri zmene hodnoty frekvence 				
				if (frekvence_kHz<100 & frekvence_kHz>=10)				//Nastaveni pozice pro vypis desitek kHz
				{
					ks0108PutChar('0');									//Vypis retezec z bufferu
					ks0108GotoXY(71,48);								//Nastaveni pozice								
				}

			
				if (frekvence_kHz<10)									//Nastaveni pozice pro vypis jednotek kHz
				{
					ks0108Puts("00");									//Vypis retezec z bufferu
					ks0108GotoXY(77,48);								//Nastaveni pozice
				}
		
			itoa(frekvence_kHz,buffer,10);								//Prevadi celociselnou hodnotu na retezec zakonceny hodnotou null
			ks0108Puts(buffer);											//Vypis retezec z bufferu
			ks0108PutChar(' ');											//Vlozeni mezery 
			ks0108GotoXY(84,48);										//Nastaveni pozice
			ks0108Puts("MHz");											//Vypis retezce
					
			Klavesy_SPI();												//Komunikace s klavesami
		
		
			////Zmena hodnoty frekvence///////////////////////////////////
			while (funkce!=16)											//Opakovani dokud neni stiskla klavesa konec 
			{								
				Klavesy_SPI();											//Komunikace s tlacitky
				if (klavesa_kolo==128)									//Pokud byla zmenena hodnota kola (wheel)
					{
						kolo=128-kolo;									//Nastaveni smeru inkrementace kola 
						pozice_f=kolo/18;								//Rozdeli kolo na hodnoty 0-6
						ks0108GotoXY(4,48);								//Nastaveni pozice
						itoa(pozice_f,buffer,10);						//Prevadi celociselnou hodnotu na retezec zakonceny hodnotou null
						ks0108Puts(buffer);								//Vypis retezec z bufferu
						delay_ms(500);									//Zpozdeni
						funkce=klavesa_kolo;							//Zmena promenne nutna pro cykleni smycky
						ks0108FillRect(4, 48, 5, 8, WHITE);				//Mazani hodnoty 	
						klavesa_kolo=0;									//Nulovani promennych
						kolo=0;											//Nulovani promennych
						ks0108FillRect(38, 56, 60, 1, WHITE);			//Mazani hodnoty 
					}
									
				switch (pozice_f)										//Prepinani ukazatele na cislo a jeho zmena
				{
					case 0:												//Pozice cisla 
					{
						
						ks0108DrawHoriLine(38,56,4, BLACK);				//Vykresleni ukazatele
						while (funkce!=64)								//Opakuj dokud neni stikla klavesa "Potvrzeni"
						{
							Klavesy_SPI();								//Komunikace s klavesami
							if (klavesa_kolo==128)
							{	
								kolo=128-kolo;							//Nastaveni smeru inkrementace kola 
								tisice_f=kolo/13;						//Rozdeli kolo na hodnoty 0-9
							
								ks0108FillRect(38, 48, 5, 8, WHITE);	//Mazani hodnoty 										
								ks0108GotoXY(38,48);					//Nastaveni pozice
								itoa(tisice_f,buffer,10);				//Prevadi celociselnou hodnotu na retezec zakonceny hodnotou null
								ks0108Puts(buffer);						//Vypis retezec z bufferu
								klavesa_kolo=0;							//Nulovani promenne
								kolo=0;									//Nulovani promenne
							}						
						}
						}
												
					break;
					case 1:												//Pozice cisla 
						{
						
							ks0108DrawHoriLine(44,56,4, BLACK);			//Vykresleni ukazatele				
							while (funkce!=64)							//Opakuj dokud neni stikla klavesa "Potvrzeni"
						{
							Klavesy_SPI();								//Komunikace s klavesami
							if (klavesa_kolo==128)
							{	
								kolo=128-kolo;							//Nastaveni smeru inkrementace kola 
								stovky_f=kolo/13;						//Rozdeli kolo na hodnoty 0-9
							
								ks0108FillRect(44, 48, 5, 8, WHITE);	//Mazani hodnoty 										
								ks0108GotoXY(44,48);					//Nastaveni pozice
								itoa(stovky_f,buffer,10);				//Prevadi celociselnou hodnotu na retezec zakonceny hodnotou null
								ks0108Puts(buffer);						//Vypis retezec z bufferu
								klavesa_kolo=0;							//Nulovani promenne
								kolo=0;									//Nulovani promenne					
							}						
						}							
							
							
							}												
					break;
					case 2:												//Pozice cisla 
							{
						
							ks0108DrawHoriLine(50,56,4, BLACK);			//Vykresleni ukazatele					
						while (funkce!=64)								//Opakuj dokud neni stikla klavesa "Potvrzeni"
						{
							Klavesy_SPI();								//Komunikace s klavesami
							if (klavesa_kolo==128)
							{	
								kolo=128-kolo;							//Nastaveni smeru inkrementace kola 
								desitky_f=kolo/13;						//Rozdeli kolo na hodnoty 0-9
							
								ks0108FillRect(50, 48, 5, 8, WHITE);	//Mazani hodnoty 										
								ks0108GotoXY(50,48);					//Nastaveni pozice
								itoa(desitky_f,buffer,10);				//Prevadi celociselnou hodnotu na retezec zakonceny hodnotou null
								ks0108Puts(buffer);						//Vypis retezec z bufferu
								klavesa_kolo=0;							//Nulovani promenne
								kolo=0;									//Nulovani promenne				
							}						
						}
							}									
					break;
					case 3:												//Pozice cisla 
							{
						
							ks0108DrawHoriLine(56,56,4, BLACK);			//Vykresleni ukazatele				
						while (funkce!=64)								//Opakuj dokud neni stikla klavesa "Potvrzeni"
						{
							Klavesy_SPI();								//Komunikace s klavesami
							if (klavesa_kolo==128)
							{	
								kolo=128-kolo;							//Nastaveni smeru inkrementace kola 
								jednotky_f=kolo/13;						//Rozdeli kolo na hodnoty 0-9
							
								ks0108FillRect(56, 48, 5, 8, WHITE);	//Mazani hodnoty 										
								ks0108GotoXY(56,48);					//Nastaveni pozice
								itoa(jednotky_f,buffer,10);				//Prevadi celociselnou hodnotu na retezec zakonceny hodnotou null
								ks0108Puts(buffer);						//Vypis retezec z bufferu
								klavesa_kolo=0;							//Nulovani promenne
								kolo=0;									//Nulovani promenne				
							}						
						}
							}									
					break;				
					case 4:												//Pozice cisla 
							{
					
							ks0108DrawHoriLine(65,56,4, BLACK);			//Vykresleni ukazatele					
						while (funkce!=64)								//Opakuj dokud neni stikla klavesa "Potvrzeni"
						{
							Klavesy_SPI();								//Komunikace s klavesami
							if (klavesa_kolo==128)
							{	
								kolo=128-kolo;							//Nastaveni smeru inkrementace kola 
								desetiny_f=kolo/13;						//Rozdeli kolo na hodnoty 0-9
							
								ks0108FillRect(65, 48, 5, 8, WHITE);	//Mazani hodnoty 										
								ks0108GotoXY(65,48);					//Nastaveni pozice
								itoa(desetiny_f,buffer,10);				//Prevadi celociselnou hodnotu na retezec zakonceny hodnotou null
								ks0108Puts(buffer);						//Vypis retezec z bufferu
								klavesa_kolo=0;							//Nulovani promenne
								kolo=0;									//Nulovani promenne				
							}						
						}
							}									
					break;				
					case 5:												//Pozice cisla 
							{
			
							ks0108DrawHoriLine(71,56,4, BLACK);			//Vykresleni ukazatele					
						while (funkce!=64)								//Opakuj dokud neni stikla klavesa "Potvrzeni"
						{
							Klavesy_SPI();								//Komunikace s klavesami
							if (klavesa_kolo==128)
							{	
								kolo=128-kolo;							//Nastaveni smeru inkrementace kola 
								setiny_f=kolo/13;						//Rozdeli kolo na hodnoty 0-9
							
								ks0108FillRect(71, 48, 5, 8, WHITE);	//Mazani hodnoty 										
								ks0108GotoXY(71,48);					//Nastaveni pozice
								itoa(setiny_f,buffer,10);				//Prevadi celociselnou hodnotu na retezec zakonceny hodnotou null
								ks0108Puts(buffer);						//Vypis retezec z bufferu
								klavesa_kolo=0;							//Nulovani promenne
								kolo=0;									//Nulovani promenne			
							}						
						}
							}									
					break;				
					case 6:												//Pozice cisla 
							{
					
							ks0108DrawHoriLine(77,56,4, BLACK);			//Vykresleni ukazatele					
						while (funkce!=64)								//Opakuj dokud neni stikla klavesa "Potvrzeni"
						{
							Klavesy_SPI();								//Komunikace s klavesami
							if (klavesa_kolo==128)
							{	
								kolo=128-kolo;							//Nastaveni smeru inkrementace kola 
								tisiciny_f=kolo/13;						//Rozdeli kolo na hodnoty 0-9
							
								ks0108FillRect(77, 48, 5, 8, WHITE);	//Mazani hodnoty 										
								ks0108GotoXY(77,48);					//Nastaveni pozice
								itoa(tisiciny_f,buffer,10);				//Prevadi celociselnou hodnotu na retezec zakonceny hodnotou null
								ks0108Puts(buffer);						//Vypis retezec z bufferu
								klavesa_kolo=0;							//Nulovani promenne
								kolo=0;									//Nulovani promenne				
							}						
						}
							}									
					break;				
				}	
				Klavesy_SPI();											//Komunikace s klavesami				
							
				}
				frekvence=((tisice_f*1000)+(stovky_f*100)+(desitky_f*10)+(jednotky_f)+(desetiny_f/10)+(setiny_f/100)+(tisiciny_f/1000));	ext_atenuator=((desitky_at*100)+(jednotky_at*10)+desetiny_at);	//Vypocet hodnoty noveho nastaveni
				kalibrace=0;
				kalibrace_hodnota=0;
				
				Vyber_intervalu_Sn ();		//Vyber koeficientu z Sn pro merenou frekvenci
				

				
				
				
				Klavesy_SPI();											//Komunikace s klavesami
			
		
		}
	

	
		ks0108ClearScreen();											//Mazani LCD



////////////Funkce jednotky/////////////////////////////////////////////
		while (funkce==8)
		{
			Komparator();
			Signalizace_prekrocen_rozsah_off();								//Vyputi signalizace prekroceni rozsahu
			///Vykrasleni oramovani/////////////////////////////////////
			ks0108DrawHoriLine(1, 0, 126, BLACK);						//Vykresleni cerne usecky			
			ks0108DrawHoriLine(1, 63, 126, BLACK);						//Vykresleni cerne usecky		
			ks0108DrawVertLine(127, 0,63, BLACK);						//Vykresleni cerne usecky
			ks0108DrawVertLine(0, 0, 63, BLACK);						//Vykresleni cerne usecky
			
			ks0108GotoXY(14,5);											//Nastaveni pozice
			ks0108Puts("Zmenu jednotek je");							//Vypis retezce
			ks0108GotoXY(5,15);											//Nastaveni pozice
			ks0108Puts("mozne provadet pouze");							//Vypis retezce
			
			ks0108GotoXY(15,25);										//Nastaveni pozice
			ks0108Puts("pokud je zvoleno");								//Vypis retezce
			
			ks0108GotoXY(42,35);										//Nastaveni pozice
			ks0108Puts("Mereni!");										//Vypis retezce
			ks0108GotoXY(22,45);											//Nastaveni pozice
			ks0108Puts("Lze volit mezi");								//Vypis retezce
		
			ks0108GotoXY(47,55);										//Nastaveni pozice
			ks0108Puts("dBm/uW!");										//Vypis retezce
		
		
			Klavesy_SPI();												//Komunikace s tlacitky
		
		}		

		ks0108ClearScreen();											//Mazani LCD displeje
		
////////////Funkce konec//////////////////////////////////////////////////
		while (funkce==16 |funkce==64)
		{
			Signalizace_kalibrace_off();

			////Vykresleni struktury pozadi///////////////////////////////
			ks0108DrawHoriLine(1, 0, 126, BLACK);						//Vykresleni cerne usecky
			ks0108DrawHoriLine(1, 20, 126, BLACK);						//Vykresleni cerne usecky
			ks0108DrawHoriLine(1, 63, 126, BLACK);						//Vykresleni cerne usecky
			ks0108DrawHoriLine(1, 31, 126, BLACK);						//Vykresleni cerne usecky
			ks0108DrawHoriLine(1, 42, 126, BLACK);						//Vykresleni cerne usecky
			ks0108DrawVertLine(0, 0, 63, BLACK);						//Vykresleni cerne usecky		
			ks0108DrawVertLine(1, 43, 20, BLACK);						//Vykresleni cerne usecky	
			ks0108DrawVertLine(126, 43,20, BLACK);						//Vykresleni cerne usecky
			ks0108DrawHoriLine(1,43,125, BLACK);						//Vykresleni cerne usecky
			ks0108DrawHoriLine(1, 62,125, BLACK);						//Vykresleni cerne usecky
			ks0108DrawVertLine(127, 0,63, BLACK);						//Vykresleni cerne usecky
			ks0108DrawVertLine(42, 1, 19, BLACK);						//Vykresleni cerne usecky
			ks0108DrawVertLine(96, 1, 19, BLACK);						//Vykresleni cerne usecky
			
			////Vypis nemennych textu/////////////////////////////////////
			ks0108SelectFont(System_5x8, ks0108ReadFontData, WHITE);	//Nastaveni fontu	
			ks0108GotoXY(1,1);											//Nastaveni pozice
			ks0108Puts("Teplota");										//Vypis retezce
			ks0108GotoXY(43,1);											//Nastaveni pozice
			ks0108Puts("Kalibrace");									//Vypis retezce				
			ks0108GotoXY(97,1);											//Nastaveni pozice
			ks0108Puts("Bater");										//Vypis retezce
			ks0108GotoXY(1,33);											//Nastaveni pozice
			ks0108Puts("Ext. atenuator:");								//Vypis retezce
			ks0108GotoXY(1,22);											//Nastaveni pozice
			ks0108Puts("Frekvence:");									//Vypis retezce

			Kalibrace_info ();											//Vypis informace o provedeni kalibrace
			Baterie_info ();											//A/D prevod a vypocet stavu baterie
			Teplota_info ();											//A/D prevod a vypocet teploty//////////////////////////////


			////Vypis hodnoty externe pripojeneho atenuatoru		
			////Osetreni posuvu vypisu pri zmene hodnoty atenuatoru 
				if (ext_atenuator>=100)
				{
					ks0108GotoXY(92,33);									//Nastaveni pozice
				}
				else
				{
					ks0108GotoXY(97,33);									//Nastaveni pozice
				}
			atenuator=ext_atenuator/10;									//Vypocet celeho cisla hodnoty
			itoa(atenuator,buffer,10);									//Převádí celočíselnou hodnotu na řetězec zakončený hodnotou null
			ks0108Puts(buffer);											//Vypis retezec z bufferu
			ks0108PutChar(',');											//Vlozeni des. carky
			vysledek=ext_atenuator-(atenuator*10);						//Vypocet pro desetinna mista hodnoty
			ks0108GotoXY(107,33);										//Nastaveni pozice
			itoa(vysledek,buffer,10);									//Převádí celočíselnou hodnotu na řetězec zakončený hodnotou null
			ks0108Puts(buffer);											//Vypis retezec z bufferu
			ks0108PutChar(' ');											//Vlozeni mezery	 
			ks0108GotoXY(115,33);										//Nastaveni pozice	
			ks0108Puts("dB");											//Vlozeni jednotky

			////Vypis hodnoty nastavene frekvence	    
			frekvence_MHz=frekvence;									//Vypocet celeho cisla hodnoty
			if (frekvence_MHz>=1000)
				{
				ks0108GotoXY(63,22);										//Nastaveni pozice	
				}
			if (frekvence_MHz>=100 & frekvence_MHz<1000)
				{
				ks0108GotoXY(69,22);										//Nastaveni pozice	
				}
			itoa(frekvence_MHz,buffer,10);								//Převádí celočíselnou hodnotu na řetězec zakončený hodnotou null
			ks0108Puts(buffer);											//Vypis retezec z bufferu
			ks0108PutChar(',');											//Vlozeni des. carky								
			frekvence_kHz=(frekvence-frekvence_MHz)*1000;				//Vypocet pro desetinna mista hodnoty
			pom_frekvence=(frekvence-frekvence_MHz)*10000;				//Vypocet pro osetreni chyby deleni
			pom_frekvence=(pom_frekvence-(frekvence_kHz*10));			//Vypocet pro osetreni chyby deleni
			
				//Osetreni chyby deleni zaokrouhlovanim////////////////////
				if (pom_frekvence>=5)
				{
					frekvence_kHz++;									//Zaokrouhli nahoru
				}
			
			ks0108GotoXY(90,22);										//Nastaveni pozice pro vypis stovek kHz
				////Osetreni posuvu vypisu pri zmene hodnoty frekvence 				
				if (frekvence_kHz<100 & frekvence_kHz>=10)				//Nastaveni pozice pro vypis desitek kHz
				{
					ks0108PutChar('0');									//Vypis retezec z bufferu
					ks0108GotoXY(96,22);								//Nastaveni pozice								
				}

			
				if (frekvence_kHz<10)									//Nastaveni pozice pro vypis jednotek kHz
				{
					ks0108Puts("00");									//Vypis retezec z bufferu
					ks0108GotoXY(102,22);								//Nastaveni pozice
				}
		
		

			itoa(frekvence_kHz,buffer,10);								//Převádí celočíselnou hodnotu na řetězec zakončený hodnotou null
			ks0108Puts(buffer);											//Vypis retezec z bufferu
			ks0108PutChar(' ');											//Vlozeni mezery 
			ks0108GotoXY(109,22);										//Nastaveni pozice
			ks0108Puts("MHz");											//Vypis retezce
				
			ks0108SelectFont(System_5x8, ks0108ReadFontData, BLACK);	//Nastaveni fontu
			ks0108GotoXY(25,45);										//Nastaveni pozice
			ks0108Puts("Prosim zvolte");								//Vypis retezce
			ks0108GotoXY(9,53);											//Nastaveni pozice
			ks0108Puts("pozadovanou funkci!");							//Vypis retezce
	
			if (frekvence<100 | frekvence>6000)
				{
					ks0108FillRect(9,45,110,15,WHITE);
					ks0108GotoXY(27,45);
					ks0108Puts_P(PSTR("Frekvence je"));			
					ks0108GotoXY(28,53);
					ks0108Puts_P(PSTR("mimo rozsah!"));	
					Signalizace_prekrocen_rozsah_on();
					n=100;
				}
			else
			{
			Signalizace_prekrocen_rozsah_off();								//Vyputi signalizace prekroceni rozsahu
			Komparator();												//Funkce pro osvetleni LCD		
			}	
		
			Klavesy_SPI();												//Komunikace s klavesami
		}

		ks0108ClearScreen();											//Mazani LCD


////////////Funkce mereni//////////////////////////////////////////////
		while (funkce==32)
		{
			Signalizace_prekrocen_rozsah_off();								//Vyputi signalizace prekroceni rozsahu
			Komparator();												//Funkce pro osvetleni LCD	

			////Vykresleni struktury pozadi///////////////////////////////
			ks0108DrawHoriLine(1, 0, 126, BLACK);						//Vykresleni cerne usecky
			ks0108DrawHoriLine(1, 20, 126, BLACK);						//Vykresleni cerne usecky
			ks0108DrawHoriLine(1, 63, 126, BLACK);						//Vykresleni cerne usecky
			ks0108DrawHoriLine(1, 31, 126, BLACK);						//Vykresleni cerne usecky
			ks0108DrawHoriLine(1,32,125, BLACK);						//Vykresleni cerne usecky
			ks0108DrawHoriLine(1, 62,125, BLACK);						//Vykresleni cerne usecky
			ks0108DrawVertLine(127, 0,63, BLACK);						//Vykresleni cerne usecky
			
			ks0108DrawVertLine(42, 1, 19, BLACK);						//Vykresleni cerne usecky
			
			ks0108DrawVertLine(0, 0, 63, BLACK);						//Vykresleni cerne usecky		
			ks0108DrawVertLine(1, 32, 30, BLACK);						//Vykresleni cerne usecky	
			ks0108DrawVertLine(126, 32,30, BLACK);						//Vykresleni cerne usecky
		
			
			ks0108DrawVertLine(96, 1, 19, BLACK);						//Vykresleni cerne usecky
			
			////Vypis nemennych textu/////////////////////////////////////
			ks0108SelectFont(System_5x8, ks0108ReadFontData, WHITE);	//Nastaveni fontu	
			ks0108GotoXY(1,1);											//Nastaveni pozice
			ks0108Puts("Teplota");										//Vypis retezce
			ks0108GotoXY(43,1);											//Nastaveni pozice
			ks0108Puts("Kalibrace");									//Vypis retezce				
			ks0108GotoXY(97,1);											//Nastaveni pozice
			ks0108Puts("Bater");										//Vypis retezce
			ks0108GotoXY(2,33);											//Nastaveni pozice
			ks0108Puts("Mereny vf. vykon:");								//Vypis retezce
			ks0108GotoXY(1,22);											//Nastaveni pozice
			ks0108Puts("Frekvence:");									//Vypis retezce

			Kalibrace_info ();											//Vypis informace o provedeni kalibrace
			Baterie_info ();											//A/D prevod a vypocet stavu baterie
			Teplota_info ();											//A/D prevod a vypocet teploty

		
			
			////Vypis hodnoty nastavene frekvence	    
			frekvence_MHz=frekvence;									//Vypocet celeho cisla hodnoty
			if (frekvence_MHz>=1000)
				{
				ks0108GotoXY(63,22);										//Nastaveni pozice	
				}
			if (frekvence_MHz>=100 & frekvence_MHz<1000)
				{
				ks0108GotoXY(69,22);										//Nastaveni pozice	
				}
			itoa(frekvence_MHz,buffer,10);								//Převádí celočíselnou hodnotu na řetězec zakončený hodnotou null
			ks0108Puts(buffer);											//Vypis retezec z bufferu
			ks0108PutChar(',');											//Vlozeni des. carky								
			frekvence_kHz=(frekvence-frekvence_MHz)*1000;				//Vypocet pro desetinna mista hodnoty
			pom_frekvence=(frekvence-frekvence_MHz)*10000;				//Vypocet pro osetreni chyby deleni
			pom_frekvence=(pom_frekvence-(frekvence_kHz*10));			//Vypocet pro osetreni chyby deleni
			
				//Osetreni chyby deleni zaokrouhlovanim////////////////////
				if (pom_frekvence>=5)
				{
					frekvence_kHz++;									//Zaokrouhli nahoru
				}
			
			ks0108GotoXY(90,22);										//Nastaveni pozice pro vypis stovek kHz
				////Osetreni posuvu vypisu pri zmene hodnoty frekvence 				
				if (frekvence_kHz<100 & frekvence_kHz>=10)				//Nastaveni pozice pro vypis desitek kHz
				{
					ks0108PutChar('0');									//Vypis retezec z bufferu
					ks0108GotoXY(96,22);								//Nastaveni pozice								
				}

			
				if (frekvence_kHz<10)									//Nastaveni pozice pro vypis jednotek kHz
				{
					ks0108Puts("00");									//Vypis retezec z bufferu
					ks0108GotoXY(102,22);								//Nastaveni pozice
				}
		
		

			itoa(frekvence_kHz,buffer,10);								//Převádí celočíselnou hodnotu na řetězec zakončený hodnotou null
			ks0108Puts(buffer);											//Vypis retezec z bufferu
			ks0108PutChar(' ');											//Vlozeni mezery 
			ks0108GotoXY(109,22);										//Nastaveni pozice
			ks0108Puts("MHz");											//Vypis retezce
			
	
			while (funkce!=16)
			{
			Mereni_vyhodnoceni ();
			
				if (funkce==8)
				{
					if (jednotka==0)
					{
						jednotka=1;
						ks0108FillRect(5,45,110,15,WHITE);							//Mazani oblasti pro vypis	
					} 
					else
					{
						jednotka=0;
						ks0108FillRect(5,45,110,15,WHITE);							//Mazani oblasti pro vypis	
					}
					
				funkce=0;
				}
			
			
			
			Klavesy_SPI();												//Komunikace s klavesami
			}
			
			Klavesy_SPI();												//Komunikace s klavesami
		}
	
		ks0108ClearScreen();											//Mazani LCD
	}
		
}
						




///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////Vektor preruseni////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////	
ISR( INT1_vect )														//Vektor preruseni sledujici signal DDRDY
{
	////Zacatek komunikace////////////////////////////////////////////////
	cbi(PORTB,4); 														//Nastaveni neg. SS do log. "0"
	delay_us(3);														//Nutne zpozdeni pred spustenim hodinoveho signalu 

	////Odeslani a prijem nulty byte//////////////////////////////////////
		SPDR = Vysl_BYTE_0;												//Zapsani dat pro odeslani do dat. registru 
		while(!(SPSR & (1<<SPIF)));										//Cekani na dokonceni prenosu bytu
		Prij_BYTE_0=SPDR;												//Vycteni prijatych dat z dat. registru
		delay_us(30);													//Nutne zpozdeni pro korektni prubeh komuikace 
	////Odeslani a prijem prvni byte//////////////////////////////////////	
		SPDR = Vysl_BYTE_1;												//Zapsani dat pro odeslani do dat. registru 
		while(!(SPSR & (1<<SPIF)));										//Cekani na dokonceni prenosu bytu
		Prij_BYTE_1=SPDR;												//Vycteni prijatych dat z dat. registru
		delay_us(30);													//Nutne zpozdeni pro korektni prubeh komunikace 
	////Odeslani a druhy byte/////////////////////////////////////////////
		SPDR = Vysl_BYTE_2;												//Zapsani dat pro odeslani do dat. registru 
		while(!(SPSR & (1<<SPIF)));										//Cekani na dokonceni prenosu bytu
		Prij_BYTE_2=SPDR;												//Vycteni prijatych dat z dat. registru
		
	////Ukonceni komunikace///////////////////////////////////////////////
	sbi(PORTB,4);														//Nastaveni neg. SS do log. "1"
	cbi(GICR,INT1);														//Zakazani preruseni na pinu INT1
	
	////Vyhodoceni prijatych dat z SPI komunikace//////////////////////////
	if (Prij_BYTE_1>0)													//Odstranuje vyhodnoceni pri oddaleni prstu od klaves
	{
		klavesa=Prij_BYTE_1;											//Ulozi hodnotu stiskle klavesy
		
		if (klavesa==1 | klavesa==2 | klavesa==4 | klavesa==8 | klavesa==16 | klavesa==32| klavesa==64 )									//Rozdeleni klaves na klavesy pro fce a pro nastaveni
		{
			funkce=klavesa;	
		}
		
	
		if (klavesa==128)												//Pri stisku kola ulozi jeho aktualni hodnotu
		{
			klavesa_kolo=klavesa;
			kolo=Prij_BYTE_2;											//Aktualni hodnota kola
		}
	}

}	