  ; Hlavicka

; V_mode_pre	; Algoritmy, ktere se musi spustit alespon 1x pred spustenim
  ; tohoto modu, jsou prave tady
; V_mode	; Jadro "Voltage modu"
  ; V_mode_calc	; Soucast "V_mode" - ma predevsim na starost vypocty

; V_mode_Show_progress_bar	; Zobrazi jednoduchy progress bar. Bere
  ; 10bitove cisla, ulozena v R1(H) a R0(L) a podle toho vykresli "pozici"
  ; Jako dalsi parametr slouzi registr "data", ktery urcuje Xovou souradnici
  ; na prave strane LCD. Dale pouziva odkladaci registr "tmp"
; wait_for_int_AD

V_mode_pre:
  ; Nutne nastaveni pri kazdem spusteni
	SBI control_port_LCD,Sleep_mode	; Zapne usporny rezim (vypne externi
  ; AD prevodnik, zastavi hodiny na bufferu a AD prevodniku).

  ; Zapnuti a nastaveni interniho A/D prevodniku v ATmega32
    ; Nastaveni multiplexeru a reference
	LDI tmp,(0<<REFS1)|(0<<REFS0)|(0<<ADLAR)|(0<<MUX4)|(0<<MUX3)|(1<<MUX2)|(1<<MUX1)|(0<<MUX0)
	OUT ADMUX,tmp	; A nahrani do spravneho registru
  ; MUX[4:0] - nastavuji jednotlive piny
  ; Trigger napeti (PA7): MUX[0111]
  ; Uin (PA6): MUX[0110]

  ; Nastaveni triggrovani (nechame bezet v "free running mode" - na nic nebude
  ; cekat)
.EQU ADTS2 = 7
.EQU ADTS1 = 6
.EQU ADATE = 5
.EQU ADTS0 = 5	; Pozn. nevim proc, ale v inc souboru toto nebylo, namisto
  ; toho byly jine nazvy
	LDI tmp,(0<<ADTS2)|(0<<ADTS1)|(0<<ADTS0)
	OUT SFIOR,tmp


  ; Nastaveni ADCSRA
	LDI tmp,(1<<ADEN)|(1<<ADSC)|(0<<ADATE)|(0<<ADIF)|(0<<ADIE)|(1<<ADPS2)|(1<<ADPS1)|(1<<ADPS0)
	OUT ADCSR,tmp
  ; ADEN - zapne A/D
  ; ADSC - spusti konverzi
  ; ADATE - autotrigger (0 vyple) - budeme si spoustet sami
  ; ADIF - priznak preruseni - nebudeme (snad) potrebovat
  ; ADIE - zapne/vypne preruseni od A/D - snad nebude potreba
  ; ADPS[2:0] - preddelicka pro A/D prevodnik - vzhledem k tomu, ze provod trva
      ; 13 cyklu (mimo prvniho) a zapisn na LCD trva mnohem dele, je vyhodne
      ; snizit rychlost A/D a zvysit tak odolnost vuci sumu. Na celkovou
      ; rychlost to nebude mit prakticky zadny vliv


	RCALL wait_for_int_AD	; A pockame, az bude prevod kompletni
  ; A prvni nactenou hodnotou vyplnime misto v SRAM urcene pro vzorky
  ; Z poslednich 127 hodnot se pak bude vypocitavat prumer,
  ; minimalni a maximalni hodnota
  ; 127 hodnot proto, protoze cislo je desetibitove -> musi se pouzit dva bajty

	LDI XH,HIGH(Samples_begin_SRAM)
	LDI XL,LOW(Samples_begin_SRAM)

  ; Stahne si data z A/D prevodniku
	IN R1,ADCH
	IN R0,ADCL

	CLR R2	; pomocny registr

  ; Korekce
	LDI tmp,Vol_mode_AD_correction	; Do tmp se ulozi korekcni hodnota
  ; Jsou dve moznosti, budto je cislo kladne, nebo zaporne
	SBRC tmp,7	; Zkontroluje se MSB bit
	RJMP V_mode_pre_correction_negative	; Pokud bude bit nastaven ->
  ; -> zaporne cislo -> provede se tato procedura
V_mode_pre_correction_positive:
	ADD R0,tmp	; Pricte se k LSB
	ADC R1,R2
	RJMP V_mode_pre_fill_samples_memory_pre

V_mode_pre_correction_negative:
	SUB R2,tmp	; R2=0-tmp (kladna hodnota)
	SUB R0,R2	; R0(LSB)=R0-R2(korekce v abs. hodnote)
	
	BRBS 4,V_mode_pre_correction_negative_DEC_MSB	; test na "Sign bit"
  ; Pokud totiz bude nastaven, pak je vysledek zaporny a musi se od MSB bajtu
  ; odecist jednicka
	RJMP V_mode_pre_fill_samples_memory_pre	; V opacnem pripade se nic
  ; nemusi resit

V_mode_pre_correction_negative_DEC_MSB:
	DEC R1	; Snizeni MSB o 1


V_mode_pre_fill_samples_memory_pre:
	LDI CNT,Vol_mode_num_of_sampl	; pocita kroky
V_mode_pre_fill_samples_memory:
	ST X+,R1	; Nejprve se zapise MSB
	ST X+,R0	; a pak LSB bajt
	DEC CNT
	BRNE V_mode_pre_fill_samples_memory


	CLR CNT	; Pocita, kam se ma zapisovat (do SRAM -> vzorky -> vyuzito
  ; jako cyklicka pamet)
	PUSH CNT	; Zaloha do Stacku (bude potreba)

	LDI YH,HIGH(Samples_begin_SRAM)
	LDI YL,LOW(Samples_begin_SRAM)

V_mode:
	RCALL wait_for_int_AD	; Pocka na dokonceni konverze (pokud bude
  ; nutne)

  ; Stahne si data z A/D prevodniku
	IN R2,ADCL
	IN R3,ADCH
  ; Korekce
	CLR R0
	LDI tmp,Vol_mode_AD_correction
	SBRC tmp,7	; Zjisti se znamenko korekce
	RJMP V_mode_correction_negative	; V pripade, ze bude znamenkovy bit
  ; nastaven
V_mode_correction_positive:	; V opacnem pripade neni znamenkovy bit
  ; nastaven a cislo je tedy kladne
	ADD R2,tmp	; Korekce + L
	ADC R3,R0	; 0+C+H
	RJMP V_mode_start_AD_conversion

V_mode_correction_negative:
	SUB R0,tmp	; R0=0-tmp(korekce)=+tmp(korekce bez znamenka)
	SUB R2,R0	; L-korekce

	BRBS 4,V_mode_correction_negative_DEC_MSB	; V pripade, ze dojde
  ; k podteceni, musi se hodnota MSB snizit o 1
	RJMP V_mode_start_AD_conversion	; V opacnem pripade se skoci sem

V_mode_correction_negative_DEC_MSB:
	DEC R3

V_mode_start_AD_conversion:
	SBI ADCSR,ADSC	; Spusti dalsi konverzi

	ST Y+,R3	; Nejprve MSB bajt (lepsi a snadnejsi debug)
	ST Y+,R2	; potom LSB bajt

  ; A preulozeni do SRAM (pak bude potreba u grafickeho ukazatele)
	STS Samples_Actual_value_SRAM,R3
	STS Samples_Actual_value_low_SRAM,R2


	POP CNT	; Obnova CNT
	INC CNT	; A pocitadlo se zvysi o 1
	PUSH CNT	; A opet zaloha CNT

	CPI CNT,Vol_mode_num_of_sampl	; Porovnani s "Vol_mode_num_of_sampl"
	BRNE V_mode_calc	; Pokud jeste nedoslo k "preteceni ukazatele",
   ; pak se pokracuje vypocty

  ; V opacnem pripade se nastavi ukazatel na pocatek

	LDI YH,HIGH(Samples_begin_SRAM)
	LDI YL,LOW(Samples_begin_SRAM)

  ; A pocitadlo se opet nastavi na nulu
	POP CNT
	CLR CNT
	PUSH CNT

V_mode_calc:

V_mode_calc_Actual:	; Vypocte aktualni hodnotu
  ; Ulozi aktualni hodnotu
	CALL Convert_16bit_unsigned_to_float_A	; Prevede data z A/D prevodniku
  ; na float A (aktualni cislo je ulozeno v R3:R2)

  ; Problem je, ze cislo je 10bitove a ne 16bitove -> musi se odecit 512
  ;($02 00 HEX) od aktualniho cisla, abychom dostali znamenkove cislo
	LDI tmp,$02
	MOV R3,tmp
	CLR R2
  ; Nyni mame v R3:R2 ulozeno $02 00 HEX
	CALL Convert_16bit_unsigned_to_float_B

	CALL float_A_minus_B	; A=cislo z prevodniku - 512
  ; A=znamenkove cislo ve float


	CALL Load_10bit_range_LSB_to_Z	; Do ukazatele Z se ulozi "odkaz" na
  ; cislo, ktere predstavuje aktualni rozsah
	CALL Save_Z_to_B	; Rozsah se ulozi do B

	CALL float_A_mul_B	; A=A*B (aktualni hodnota*rozsah)
	CALL Save_A_to_x0	; V x0 nyni mame aktualni hodnotu (x0=A)


V_mode_calc_Min_Max:
  ; Najde maximalni hodnotu

  ; Nastaveni Pocatku vzorku
	LDI XH,HIGH(Samples_begin_SRAM)
	LDI XL,LOW(Samples_begin_SRAM)
	LDI data,Vol_mode_num_of_sampl	; Nastavime pocet "kroku". Cisla jsou
  ; 16. bitove, takze zabizaji 2x mista
	
	CALL find_min_max_in_16bit_samples

  ; Vysledky se ulozi do pameti x1 (maximum), x2 (minimum) jako float
  ; MAXIMUM
	LDS R3,Samples_MAX_value_SRAM
	LDS R2,Samples_MAX_value_low_SRAM
	CALL Convert_16bit_unsigned_to_float_A

  ; -512
	LDI tmp,$02
	MOV R3,tmp
	CLR R2

  ; Save 2 B
	CALL Convert_16bit_unsigned_to_float_B
  ; A-512
	CALL float_A_minus_B

	CALL Load_10bit_range_LSB_to_Z	; Do ukazatele Z se ulozi "odkaz" na
  ; cislo, ktere predstavuje aktualni rozsah
	CALL Save_Z_to_B	; Rozsah se ulozi do B

	CALL float_A_mul_B	; A=A*B (aktualni hodnota*rozsah)
	CALL Save_A_to_x1	; V x1 nyni mame maximalni hodnotu (x1=A)


  ; MINIMUM
	LDS R3,Samples_MIN_value_SRAM
	LDS R2,Samples_MIN_value_low_SRAM
	CALL Convert_16bit_unsigned_to_float_A
  ; -512
	LDI tmp,$02
	MOV R3,tmp
	CLR R2

  ; Save 2 B
	CALL Convert_16bit_unsigned_to_float_B
  ; A-512
	CALL float_A_minus_B
	CALL Load_10bit_range_LSB_to_Z	; Do ukazatele Z se ulozi "odkaz" na
  ; cislo, ktere predstavuje aktualni rozsah
	CALL Save_Z_to_B	; Rozsah se ulozi do B

	CALL float_A_mul_B	; A=A*B (aktualni hodnota*rozsah)
	CALL Save_A_to_x2	; V x2 nyni mame minimalni hodnotu (x2=A)

V_mode_calc_Average:
  ; PRUMER

  ; Vymazeme pracovni registry - cislo muze byt max 18.bitove -> 24bitu
	CLR R2	; M1
	CLR R3	; M2
	CLR R4	; M3

	CLR R0	; pomocny registr pro carry
  ; Nastaveni Pocatku vzorku
	LDI XH,HIGH(Samples_begin_SRAM)
	LDI XL,LOW(Samples_begin_SRAM)
	LDI data,Vol_mode_num_of_sampl	; Nastavime pocet "kroku". Cisla jsou
  ; 16. bitove, takze zabizaji 2x mista

V_m_c_A_for:	; Cyklus, ktery udela soucet. Deleni pak nechame na floatu
	DEC data	; Pocet_kroku=Pocet_kroku-1
	BREQ V_m_c_A_for_end	; Pokud se projde dany pocet vzorku, pak se
  ; provede skok

	LD tmp,X+	; Do "tmp" se nacte hornich 8 bitu, ktere se musi
  ; pricist k celkovemu souctu
	ADD R3,tmp	; Pricte se do R3 (M2)
	ADC R4,R0	; R4 (M3) = R4+R0(0)+C - jde o to C

	LD tmp,X+	; Do tmp se nacte spodnich 8 bitu
	ADD R2,tmp	; Pricte se do R2 (M1)
	ADC R3,R0	; zase se resi jen to C
	ADC R4,R0

	RJMP V_m_c_A_for	; A pokracuje se dal

V_m_c_A_for_end:

	CALL Convert_24bit_unsigned_to_float_A	; Vysledek se ulozi jako A
  ; Ted se musi cislo vydelit poctem vzorku (Vol_mode_num_of_sampl)
	LDI tmp,Vol_mode_num_of_sampl
	DEC tmp	; Korekce
	CALL Convert_8bit_unsigned_to_float_B	; Pocet vzorku se ulozi jako B

	CALL float_A_div_B	; A=A/B - A - prumerna absolutni hodnota

  ; -512
	LDI tmp,$02
	MOV R3,tmp
	CLR R2

  ; Save 2 B
	CALL Convert_16bit_unsigned_to_float_B
  ; A-512
	CALL float_A_minus_B	; A=A-512
  ; Takze v A je ted ulozena znamenkova hodnota

	CALL Load_10bit_range_LSB_to_Z	; Do ukazatele Z se ulozi "odkaz" na
  ; cislo, ktere predstavuje aktualni rozsah
	CALL Save_Z_to_B	; Rozsah se ulozi do B

	CALL float_A_mul_B	; A=A*B (aktualni hodnota*rozsah)
	CALL Save_A_to_x3	; V x3 nyni mame prumernou hodnotu (x3=A)



V_mode_show_results:
  ; Zobrazi vysledky
	CLT	; Barva pisma na cernou

	CALL wait_50ms
	CALL wait_10ms
	CALL wait_10ms
	CALL Clear_display	; Smaze data na LCD


  ; Aktualni hodnota
	LDI data,Vol_mode_Info_Act_line
	CALL select_line_both	; Radek

	LDI data,Vol_mode_Info_X_pos	; Xova souradnice
	LDI ZH,HIGH(2*VM_Actual)
	LDI ZL,LOW(2*VM_Actual)
	CALL write_text_from_DB	; A zapise text

	CALL Save_x0_to_A	; Do "A" se ulozi informace o aktualni hodnote
	CALL Show_float_numkMG_20	; A nasledne cislo
	LDI ZH,HIGH(2*Big_V)	; A jeste symbol "V"
	LDI ZL,LOW(2*Big_V)
	CALL write_char_from_flash

  ; A ted se zobrazi jeste "posuvnik"
	LDI data,Vol_mode_Info_Status_bar_X	; Xova souradnice
	LDS R1,Samples_Actual_value_SRAM	; High byte
	LDS R0,Samples_Actual_value_low_SRAM	; Low byte
	
	RCALL V_mode_Show_progress_bar

  ; Maximalni hodnota
	LDI data,Vol_mode_Info_Max_line
	CALL select_line_both	; Radek

	LDI data,Vol_mode_Info_X_pos	; Xova souradnice
	LDI ZH,HIGH(2*VM_Max)
	LDI ZL,LOW(2*VM_Max)
	CALL write_text_from_DB

	CALL Save_x1_to_A	; MAX
	CALL Show_float_numkMG_20
	LDI ZH,HIGH(2*Big_V)	; A jeste symbol "V"
	LDI ZL,LOW(2*Big_V)
	CALL write_char_from_flash

  ; A ted se zobrazi jeste "posuvnik"
	LDI data,Vol_mode_Info_Status_bar_X	; Xova souradnice
	LDS R1,Samples_MAX_value_SRAM	; High byte
	LDS R0,Samples_MAX_value_low_SRAM	; Low byte
	
	RCALL V_mode_Show_progress_bar

  ; Minimalni hodnota
	LDI data,Vol_mode_Info_Min_line
	CALL select_line_both

	LDI data,Vol_mode_Info_X_pos	; Xova souradnice
	LDI ZH,HIGH(2*VM_Min)
	LDI ZL,LOW(2*VM_Min)
	CALL write_text_from_DB

	CALL Save_x2_to_A
	CALL Show_float_numkMG_20
	LDI ZH,HIGH(2*Big_V)	; A jeste symbol "V"
	LDI ZL,LOW(2*Big_V)
	CALL write_char_from_flash

  ; A ted se zobrazi jeste "posuvnik"
	LDI data,Vol_mode_Info_Status_bar_X	; Xova souradnice
	LDS R1,Samples_MIN_value_SRAM	; High byte
	LDS R0,Samples_MIN_value_low_SRAM	; Low byte
	
	RCALL V_mode_Show_progress_bar

  ; Prumerna hodnota
	LDI data,Vol_mode_Info_Avg_line
	CALL select_line_both

	LDI data,Vol_mode_Info_X_pos	; Xova souradnice
	LDI ZH,HIGH(2*VM_Average)
	LDI ZL,LOW(2*VM_Average)
	CALL write_text_from_DB

	CALL Save_x3_to_A
	CALL Show_float_numkMG_20
	LDI ZH,HIGH(2*Big_V)	; A jeste symbol "V"
	LDI ZL,LOW(2*Big_V)
	CALL write_char_from_flash

  ; Informace o rozsahu
	LDI ZH,HIGH(2*VM_Range)	; text
	LDI ZL,LOW(2*VM_Range)

	LDI data,Vol_mode_Info_Range_line	; Radek
	CALL select_line_both

	LDI data,Vol_mode_Info_X_pos	; Xova souradnice
	CALL write_text_from_DB	; A vypise "Rozsah"

  ; Dal se musi zjistit, jaka je vlastne hodnota rozsahu...
	LDS tmp,range_SRAM	; Rozsah se nahraje do "tmp" a podle toho,
  ; jaky je aktualni rozsah, tak podle toho se nastavi Z pointer na dane cislo
V_mode_RNG_1:
	CPI tmp,1	; Porovnani s hodnotou 1
	BRNE V_mode_RNG_2	; Pokud neni rovno, testuje se dalsi

  ; Pokud bylo rovno -> PC se dostane sem
	LDI ZH,HIGH(2*Ran_0p3V)
	LDI ZL,LOW(2*Ran_0p3V)
	RJMP V_mode_RNG_end

V_mode_RNG_2:
	CPI tmp,2
	BRNE V_mode_RNG_3

	LDI ZH,HIGH(2*Ran_0p6V)
	LDI ZL,LOW(2*Ran_0p6V)
	RJMP V_mode_RNG_end

V_mode_RNG_3:
	CPI tmp,3
	BRNE V_mode_RNG_4

	LDI ZH,HIGH(2*Ran_1p5V)
	LDI ZL,LOW(2*Ran_1p5V)
	RJMP V_mode_RNG_end
V_mode_RNG_4:
	CPI tmp,4
	BRNE V_mode_RNG_5

	LDI ZH,HIGH(2*Ran_3V)
	LDI ZL,LOW(2*Ran_3V)
	RJMP V_mode_RNG_end
V_mode_RNG_5:
	CPI tmp,5
	BRNE V_mode_RNG_6

	LDI ZH,HIGH(2*Ran_6V)
	LDI ZL,LOW(2*Ran_6V)
	RJMP V_mode_RNG_end
V_mode_RNG_6:
	CPI tmp,6
	BRNE V_mode_RNG_unknown

	LDI ZH,HIGH(2*Ran_15V)
	LDI ZL,LOW(2*Ran_15V)
	RJMP V_mode_RNG_end
V_mode_RNG_unknown:
	LDI ZH,HIGH(2*Symbol_quest)
	LDI ZL,LOW(2*Symbol_quest)
V_mode_RNG_end:
	CALL write_text_from_DB	; A vypise cislo



  ; Informace o vazbe
	LDI ZH,HIGH(2*VM_Coupling)	; text
	LDI ZL,LOW(2*VM_Coupling)

	LDI data,Vol_mode_Info_Coupling_line
	CALL select_line_both

	LDI data,Vol_mode_Info_X_pos
	CALL write_text_from_DB	; A vypise vazbu

	LDS tmp,AC_DC_coupling_SRAM	; Do "tmp" se ulozi informace o vazbe
	CPI tmp,0	; porovnani s nulou (0 ~ AC ; 1 ~ DC)
	BREQ V_mode_coupling_AC	; Pokud je rovno -> AC vazba
V_mode_coupling_DC:	; DC vazba
	LDI ZH,HIGH(2*VM_DC)
	LDI ZL,LOW(2*VM_DC)
	RJMP V_mode_coupling_end

V_mode_coupling_AC:
	LDI ZH,HIGH(2*VM_AC)
	LDI ZL,LOW(2*VM_AC)

V_mode_coupling_end:
	CALL write_text_from_DB


  ; Data z klavesnice

	CALL recive_data_keyboard	; Prijme data z klavesnice
	LDS time1,keyboard_L_SRAM	; nacte si prvnich 8 klaves do time1

	SBRC time1,X	; Kontrola, zda nebylo stisknuto tlacitko "X"
	RJMP V_mode_post	; Pokud ano, skok na "V_mode_post"

	SBRC time1,run_stop	; Test na tlacitko "Run/stop"
	RJMP V_mode_Run_Stop

	RJMP V_mode	; V opacnem pripade se pokzacuje se sberem dat

V_mode_Run_Stop:	; Pokud je stisteno, pak se obraz "zastavi" a ceka se,
  ; az uzivatel stiskne znovu tlacitko "run_stop"

  ; Pred tim se ale vypise na LCD informace o tom, ze byl cely proces	
  ; pozastaven
	SET	; Barva pisma na "bile"

	LDI ZH,HIGH(2*VM_Stopped)	; text
	LDI ZL,LOW(2*VM_Stopped)

	LDI data,Vol_mode_Info_Process_Stopped_line	; Radek
	CALL select_line_both

	LDI data,Vol_mode_Info_X_pos	; Xova souradnice
	CALL write_text_from_DB	; A vypise "Rozsah"

	CLT	; A obnovi se barva pisma na puvodni

V_mode_Run_Stop_1:
	CALL recive_data_keyboard	; Nacteni dat z klavesnice
	LDS time1,keyboard_L_SRAM	; nacte prvnich 8 klaves

	SBRC time1,run_stop	; test na tlacitko "run_stop"
	RJMP V_mode	; Pokud bylo stisteno tlacitko "run_stop"

  ; Pokud nebylo stisknuto, pak se vse provede znovu

	RJMP V_mode_Run_Stop_1


V_mode_post:	; Pro opusteni tohoto modu
  ; Nutne nastaveni pri opousteni tohoto modu
	LDI tmp,(0<<ADEN)
	OUT ADCSR,tmp	; Vypne interni A/D prevodnik

  ; Nastavime "namerene" hodnoty do vychoziho stavu
	CLR tmp
	STS Samples_MAX_value_SRAM,tmp	; Zatim nemame nic namereno -> vymazat
	STS Samples_MAX_position_SRAM,tmp
	STS Samples_MIN_value_SRAM,tmp
	STS Samples_MIN_position_SRAM,tmp
	STS Samples_PERIOD_value_SRAM,tmp

	LDI tmp,$FF	; Tim rekneme, ze vstupni signal je maly
	STS Samples_PERIOD_position_SRAM,tmp

  ; Nastavime i velikost zjisteneho PEAK napeti na 0
	CLR tmp
	CALL Convert_8bit_unsigned_to_float_A
	LDI XH,HIGH(Samples_PEAK_value_float_SRAM)
	LDI XL,LOW(Samples_PEAK_value_float_SRAM)
	CALL Save_A_to_X	; A tam se ulozi vysledek

	LDI XH,HIGH(Samples_VMAX_value_float_SRAM)
	LDI XL,LOW(Samples_VMAX_value_float_SRAM)
	CALL Save_A_to_X

	POP CNT	; Obnova CNT (aby nedoslo k chybe ve stack)

	CBI control_port_LCD,Sleep_mode	; Vypne usporny rezim (zapne externi
  ; A/D prevodnik a hodiny pro buffer a A/D prevodnik

	RET
; *-----------------------------------------*
; |                                         |
; *-----------------------------------------*
V_mode_Show_progress_bar:
	PUSH data	; Zaloha "data"
  ; Nejdriv nastavi Xovou souradnici (radek musi byt uz nastaven)
	CALL select_X_right

  ; ted se bude vykreslovat "grafika"
	LDI data,0b00001000
	CALL write_right
	CALL write_right
	CALL write_right
	CLR data
	CALL write_right
	LDI data,0b00111111
	CALL write_right


  ; Nyni se musi vypocitat, kde se kurzor nachazi (v ktere casti rozsahu).
  ; Casti je 20. Tzn cislo 1023/20=51 -> V principu vezmeme cislo ulozene
  ; v R0, R1 a budeme tak dlouho odecitat 51, dokud se nedostaneme "pod nulu".
  ; To pozname tak, ze v registru R1 bude hodnota $FF
	PUSH R1	; Zaloha R1 (H)
	PUSH R0	; Zaloha R0 (L)

	PUSH R2	; Pocita kroky

	PUSH R4	; Vypocitane (H)
	PUSH R3	; Vypocitane (L)

	LDI tmp,3	; Posun o 3 - 51*20=1020 - do 1023 chybi 3 -> "oprava/korekce"
  ; (Priklad uveden pro 20 dilku)
	MOV R3,tmp
	CLR R4

	CLR R2	; Pocita kroky cyklu
	DEC R2

	LDI data,34	; Konstanta (1023/N_dilku)
	CLR tmp	; Pomocny registr pro scitani (prazdny)
V_mode_S_p_b_Calc_for:
  ; Postup je mirne netradicni, ale funkcni. Od nuly se cyklicky pricita 51 do
  ; te doby, nez je vysledek vetsi, nebo roven vzoru. Pak se cykl ukonci
	ADD R3,data	; L=L+51
	ADC R4,tmp	; H=H+0+C

	INC R2	; krok=krok+1

  ; Porovnani High bajtu
	CP R4,R1
	BRLO V_mode_S_p_b_Calc_for	; Pokud je nami nalezene cislo mensi,
  ; pak se bude pricitat dal
  	BREQ V_mode_S_p_b_Calc_for_Test_LOW	; Pokud je rovno, pak se musi "otukat"
  ; LSB bajt
    BRSH V_mode_S_p_b_Draw	; A pokud je vetsi, pak neni co resit
V_mode_S_p_b_Calc_for_Test_LOW:
	CP R3,R0
	BRLO V_mode_S_p_b_Calc_for	; To same, ale pro LOW

  ; A pokud "dojede" na konec,

V_mode_S_p_b_Draw:



	CLR tmp	; tmp bude nyni jako citac

V_mode_S_p_b_Draw_for:
	CP tmp,R2	; Porovnani cisla aktualniho kroku a pozici nalezeneho
  ; MSB bitu
	BREQ V_mode_S_p_b_Draw_for_Draw_Cursor	; Pokud se shoduji, tak se ma
  ; vykreslit kurzor, ktery zobrazuji pozici cisla
V_mode_S_p_b_Draw_for_Draw_space:
	PUSH tmp
	LDI data,0b01000001	; Mezera
	CALL write_right	; Zapise data
	POP tmp

V_mode_S_p_b_Draw_for_Test_end:	; Otestovani, zda nema cykl skoncit
	INC tmp
	CPI tmp,31	; Porovnani s mezni hodnotou (N_dilku+1)
	BRNE V_mode_S_p_b_Draw_for


  ; A dokresli se zbytek grafiky
	LDI data,0b01111110
	CALL write_right
	LDI data,$00
	CALL write_right
	LDI data,0b00001000
	CALL write_right
	LDI data,0b00011100
	CALL write_right
	LDI data,0b00001000
	CALL write_right

  ; Obnova pouzitych registru
	POP R3
	POP R4

	POP R2

	POP R0	; Obnova R0
	POP R1
	POP data	; Obnova "data"
	RET


V_mode_S_p_b_Draw_for_Draw_Cursor:
	PUSH tmp
	LDI data,0b01011101	; Kurzor
	CALL write_right	; Zapise data
	POP tmp

	RJMP V_mode_S_p_b_Draw_for_Test_end
; *-----------------------------------------*
; |                                         |
; *-----------------------------------------*
wait_for_int_AD:
  ; Podle datasheetu, pokud bude pri cteni ADSC = 1 -> stale A/D prevadi
  ; (str.216)
	IN tmp,ADCSR	; Stahneme si informaci z controll a status registru
	SBRC tmp,ADSC	; Pokud bude konverze hotova, nasledujici instrukce
  ; se preskoci -> pokracuje RET
	RJMP wait_for_int_AD

	RET