;	 Hlavicka
; Vyuziva promenne: CNT, CNT2, CNT3, tmp, data
; load_data_from_buffer - pro nahrani dat z bufferu do SRAM
; Draw_points - hlavni funkce - pouziva: number,number2,CNT,CNT2,CNT3,data,
; Draw_num_L - podprogram pro Draw_graphic
; Draw_num_R - podprogram pro Draw_graphic
; Draw_num_L_vector
; Draw_num_R_vector

; *-----------------------------------------*
load_data_from_buffer:
  ; Nastavime num_port na vstupni (budeme prvne cist data)
	CLR tmp	; ulozi do tmp 0b0000 0000 ($00)
	OUT IO_num,tmp
  ; nastaveno na vstup...
	OUT num_port,tmp	; musime smazat puvodni informace ulozene
  ; na tomto portu - bez tohohle mi pak nefungovly vsechny piny (je to tim,
  ; ze pokud tam "zustala" nejaka jednicka, pak se nastavi pull-up rezistory)
  ; a pri vysokych kmitoctech to dela problemy.
	CLR data

	RCALL select_X_both	; Zacneme vykreslovat od pocatku displeje
  ; Jak na leve, tak prave strane. Po kazdem zapisu si LCD posune X o 1
 
	CLR CNT 	; do promenne CNT budeme ukladat cislo vzorku.
  ; Po stazeni vzorku do SRAM vyuzijeme tento registr na to, abychom
  ; vykreslili 100 vzorku na LCD, ne vic, ne min

  ; A nyni si stahneme data z bufferu sem

    ; Nastavime si pocatek pameti (od teto adresy se sem bude zapisovat)
	LDI XH,HIGH(Samples_begin_SRAM)
	LDI XL,LOW(Samples_begin_SRAM)
    ; Zjistime si pocet vzorku
	LDS number2,number_of_samples_SRAM

    ; Kontrola, zda pocet vzorku nastaveny v main_uC a bufferu jsou stejne.
  ; Je to proto, ze pokud zmenime pocet vzorku v dobe, kdyz buffer shromazduje
  ; data, doslo by k desynchronizaci a musel by se provest reset
Wait_for_check_number_of_samples:
	RCALL wait_for_buffer
	SBI control_port_ADC,main_ready
	nop
	CBI control_port_ADC,main_ready

	IN number,num_port_in
	CP number,number2	; "number" - data poslana bufferem
  ; "number2" - lokalni data
	BRSH Still_receive	; pokud se bude pocet vzorku v bufferu stejny,
  ; nebo vetsi, pak to neni na skodu. V opacnem pripade je to problem
	RCALL Number_of_samples_not_match
	RJMP Wait_for_sync
	
Still_receive:
	RCALL wait_for_buffer	; spusti podprogram, ktery kontroluje, zda
  ; je buffer pripraven - podprogram je v "main_uC.asm" !!!
	SBI control_port_ADC,main_ready	; "pripraven" nastavime do "1"
	NOP	; Dame Bufferu cas na to, aby nahral na vystupy cislo
  ; neni potreba, buffer si nahraje data jeste predtim, ale pro vsechny pripady
	IN number,num_port_in		; a data na num_port ulozime do number
	CBI control_port_ADC,main_ready	; "pripraven" nastavime do "0"

  ; KOREKCE offsetu
	LDI tmp,Corr_OSC_mode	; Dosazeni konstanty
	ADD number,tmp	; Vypocet

	ST X+,number	; a data si ulozime do pameti
	INC CNT
	CP CNT,number2	; a porovname soucasny vzorek (jeho poradi) s celkovym
  ; poctem vzorku
	BRNE Still_receive	; pokud si nejsou rovny, pak skok na
  ; Still_receive

  ; A nastavit promennou, ktera rekne, ze data jsou validni
	CLR tmp
	STS Rx_data_buffer_not_valid_SRAM,tmp


  ; Synchronizacni kody - sync_code_1, sync_code_2, sync_code_3
Wait_for_sync:
	RCALL wait_for_buffer
	SBI control_port_ADC,main_ready
	nop
	CBI control_port_ADC,main_ready
	IN number,num_port_in
	CPI number,sync_code_1
	BRNE Wait_for_sync
  ; Pokud se opravdu jednalo o sync_code_1, pak musime jeste dal zkontrolovat,
  ; jestli jde opravdu o synchronizacni impulzy, nebo jestli jde jen o data
  ; z AD

	RCALL wait_for_buffer
	SBI control_port_ADC,main_ready
	nop
	CBI control_port_ADC,main_ready
	IN number,num_port_in
	CPI number,sync_code_2
	BRNE Wait_for_sync
  ; a test na posledni kod

	RCALL wait_for_buffer
	SBI control_port_ADC,main_ready
	nop
	CBI control_port_ADC,main_ready
	IN number,num_port_in
	CPI number,sync_code_3
	BRNE Wait_for_sync

	RET
; *-----------------------------------------*
Number_of_samples_not_match:
  ; V "number" mame ulozeny pocet vzorku, ktery nam nabizi buffer. Jedina
  ; moznost je prijmout data, ale nikam je neukladat
	RCALL wait_for_buffer
	SBI control_port_ADC,main_ready
	nop
	CBI control_port_ADC,main_ready
	INC CNT
	CP CNT,number
	BRNE Number_of_samples_not_match

  ; Zapiseme informaci o tom, ze vzorky nesedely. Toto neni chyba, je to
  ; normalni chovani pristroje. Pokud bychom pote nepockali na synchronizacni
  ; kody, tak by se komunikace "rozjela" a dusledkem by bylo "zamrznuti"
  ; pristroje

  ; Pokud jsme se ale dostali sem, pak nebudeme chtit tyto "spatne" informace
  ; zobrazit -> zapiseme do dane promenne, ze vysledek se nebude zobrazovat
	LDI tmp,1
	STS Rx_data_buffer_not_valid_SRAM,tmp

  ; Kontrola, zda toto uz nepresahuje cislo 9.999. Pokud ano, pak se
  ; nevynuluje citani,ale skonci na hodnote 9.999 a zobrazovaci algoritmy se
  ; postaraji o to, aby se zobrazilo "Critical", nebo tak neco

	LDS number,Num_of_sampl_error_1_SRAM	; data z SRAM si stahneme do
  ; "number". Toto jsou ty nizsi bity
	CPI number,$99	; data jsou zapsana dekadicky na kaze 4 bity. Tzv.
  ; packed BCD.
	BREQ Number_of_samples_not_match_Test_for_critical

Number_of_samples_not_match_Not_critical:
	CALL Packed_BCD2DEC	; data z "number" rozdeli do "units" a "tens"
	CALL INC_packed_BCD_with_carry	; pricte 1 k units a pripadne prejde
  ; do vyssiho radu. Pokud bude presahnuta hodnota 99, pak prida i carry bit

  ; Ted si zapiseme data do SRAM
	STS Num_of_sampl_error_1_SRAM,number


	BRCS Number_of_samples_not_match_Carry	; Pokud nebude nastaven carry,
  ; pak nemusime resit dalsi rady...
	RET

Number_of_samples_not_match_Carry:
  ; V opacnem pripade se pokracuje tady

	LDS number,Num_of_sampl_error_2_SRAM	; nacteme stovky a tisice
	CALL Packed_BCD2DEC
	CALL INC_packed_BCD_with_carry	; to same jako vyse v blede modrem

	STS Num_of_sampl_error_2_SRAM,number	; a zapis do SRAM

	RET
  ; Prechod do vyssiho radu nemusime resit, vzhledem k tomu, ze cislo 9.999
  ; diky pocatecni podmince, nebude nikdy presahnuto. Pocatecni podminka je tu
  ; proto, ze kdybychom spolehali pouze na carry bit, tak bychom ho museli
  ; nekolikrat zalohovat, prave kvuli tomu, ze se castou pouziva testovacich
  ; sekvencich a my bychom vlastne tuto informaci nekolikrat museli presouvat.
  ; Proto je pocatecni podminka jednodussi a efektivnejsi reseni

Number_of_samples_not_match_Test_for_critical:
	LDS tmp,Num_of_sampl_error_2_SRAM
	CPI tmp,$99	; otestuji se i horni bity...
	BRNE Number_of_samples_not_match_Not_critical	; pokud nejsou 9.9,
  ; pak se pokracuje normalne. Jinak se navratime z podprogramu

	RET
; *-----------------------------------------*
; |                                         |
; *-----------------------------------------*
Draw_points:
  ; provedeme zakladni nastaveni pro vykreslovani

    ; Ted jsou veskera data pripravena na vykresleni na LCD -> smazeme nynejsi
  ; obsah, abychom mohli aktualizovat stary obsah

; "Vycistime" displej
	RCALL Clear_display	; Musi se smazat cely displej vcetne praveho
  ; ramecku, aby pri zmene zobrazenych informaci se vse zobrazilo korektne
  ; (na displeji by mohly zustat casti predchozich znaku/pismen/cisel)
	RCALL Draw_main_screen	; Podprogram v "graphic.asm"
; Vykreslit ramecek
	RCALL Draw_right_menu
; ----


  ; Ted bychom meli mit vsechny potrebne vzorky v SRAM, zbyva jen vykreslit
	LDS tmp,Samples_offset_SRAM	; do tmp si nahrajeme offset
	CLR CNT

  ; Nastavime pocatek, od ktereho se budou "tahat" data z SRAM
	LDI XH,HIGH(Samples_begin_SRAM)
	LDI XL,LOW(Samples_begin_SRAM)

	ADD XL,tmp	; pricteme spodnich 8 bitu
	ADC XH,CNT	; a pricte se nula plus carry
  ; tim by se mela posunout adresa
  ; Nyni muzeme uz vykreslit 100 bodu na LCD

; Nejprve zacneme levou casti. Az bude vykreslena, tak pote vykreslime pravou
	CLR CNT	; pocita vlastne Xovou souradnici


  ; Jeste je zde jeden hacek. A to je zoom. Pokud je zvolena casovka 208, nebo
  ; 207, musi se jeden bod  vykreslit 2x, nebo 5x
	LDS tmp,TimeBaseSRAM	; zjistime si jaka je zvolena casovka
	CPI tmp,209
	BRLO Draw_points_zoom	; pokud je mensi jak 209, pak skok na
  ; Draw_points_zoom



  ; Nyni se rozhodne, zda je zvoleno bodove, nebo vektorove vykreslovani
  ; Je to zde proto, ze sice neusetrime pamet, ale zrychli se vykreslovani,
  ; coz je v tomto pripade rozhodujici
	LDS tmp,draw_mode_SRAM	; do "tmp" si stahneme informaci o zvolenem
  ; modu vykreslovani. 0 - body ; 1 - vektorove
	CPI tmp,0	; a porovnani s 0
	BREQ num_0_63_L	; pokud bude 0, pak skok na bodove
  ; vykreslovani
num_0_63_L_vector:
  ; V opacnem pripade je tedy zvoleno vektorove vykreslovani

  ; Potrebujeme jen 6 bitu (2^6 = 64 - displej 128x[64] ) takze dva spodni
  ; bity "odstranime"
	LD number,X+
	LSR number	; rotace vpravo -> odtranime ty spodni bit
	LSR number	; opet - odstranme dalsi spodni bit

	MOV number2,CNT	; do "number2" si zkopirujeme Xovou souradnici

	RCALL Draw_num_L_vector	; vykresli bod a prida "vektorovou caru"

	INC CNT
	CPI CNT,64
	BRNE num_0_63_L_vector

  ; pokud se dostaneme sem, pak je potreba vykreslit vektorove i pravou stranu
	CLR CNT	; smazeme pocitadlo
num_0_34_R_vector:
	LD number,X+
	LSR number
	LSR number

	MOV number2,CNT

	RCALL Draw_num_R_vector

	INC CNT

	CPI CNT,35
	BRNE num_0_34_R_vector

	RET	; konec

  ; Bodove vykreslovani
num_0_63_L:
  ; Potrebujeme jen 6 bitu (2^6 = 64 - displej 128x[64] ) takze dva spodni
  ; bity "odstranime"
	LD number,X+
	LSR number	; rotace vpravo -> odtranime ty spodni bit
	LSR number	; opet - odstranme dalsi spodni bit

	MOV number2,CNT	; do "number2" si zkopirujeme Xovou souradnici

	RCALL Draw_num_L	; vykresli bod

	INC CNT	; a posuneme se v ose X

	CPI CNT,64
	BRNE num_0_63_L

; A nyni se dostavame k prave casti
	CLR CNT
num_0_34_R:
	LD number,X+
	LSR number
	LSR number

	MOV number2,CNT

	RCALL Draw_num_R
	INC CNT

	CPI CNT,35
	BRNE num_0_34_R

	RET


Draw_points_zoom:
	CLR CNT2	; CNT2 pocita zoom

	CPI tmp,208
	BRNE Draw_points_zoom_2	; Kontrola, zda ma byt zoom 2x
	LDI time1,2	; 2x zoom. Do time1 si ulozime informaci, kolikrat
  ; bude zoom
	RJMP num_0_63_zoom_L
Draw_points_zoom_2:
;	CPI tmp,207
;	BRNE Draw_points_zoom_3
	LDI time1,5	; 5x zoom
;	RJMP num_0_63_zoom_L
;Draw_points_zoom_3:
  ; Zakomentovane proto, ze zatim jine moznosti nejsou. V pripade rozsireni
  ; jen odkomentovat a doupravit

num_0_63_zoom_L:
  ; Potrebujeme jen 6 bitu (2^6 = 64 - displej 128x[64] ) takze dva spodni
  ; bity "odstranime"
	LD number,X+
	LSR number	; rotace vpravo -> odtranime ty spodni bit
	LSR number	; opet - odstranme dalsi spodni bit

num_0_63_zoom_L_1:
	PUSH CNT2	; zaloha informace v CNT2 (Draw_num_X pracuje s CNT2)
	MOV number2,CNT
	RCALL Draw_num_L	; vykresli bod
	INC CNT
	POP CNT2	; obnova CNT2
	CPI CNT,64
	BREQ num_0_34_zoom_R_pre1	; neustale musime kontrolovat, zda
  ; uz nejsme na konci leve casti LCD a pokud ano, pak musime "vyskocit"
  ; a pokracovat na prave polovine
	INC CNT2	; CNT2+1

	CP CNT2,time1
	BRNE num_0_63_zoom_L_1

	CLR CNT2	; CNT2 pocita zoom

	CPI CNT,64
	BRNE num_0_63_zoom_L

	RJMP num_0_34_zoom_R_pre	; a pokud vsechno dobre dopadne, skok
  ; na num_0_34_zoom_R_pre

; A nyni se dostavame k prave casti
num_0_34_zoom_R_pre1:
	CLR CNT
	RJMP num_0_34_zoom_R_1	; V pripade, ze se ma dovykreslit zoomovany
  ; pixel
num_0_34_zoom_R_pre:
	CLR CNT

num_0_34_zoom_R:
	LD number,X+
	LSR number
	LSR number

num_0_34_zoom_R_1:
	PUSH CNT2
	MOV number2,CNT
	RCALL Draw_num_R
	INC CNT
	POP CNT2
	CPI CNT,35
	BREQ num_0_34_zoom_R_end

	INC CNT2

	CP CNT2,time1
	BRNE num_0_34_zoom_R_1

	CLR CNT2

	CPI CNT,35
	BRNE num_0_34_zoom_R

num_0_34_zoom_R_end:
	RET

; *-----------------------------------------*
; |                                         |
; *-----------------------------------------*
Draw_num_L:
; pracuje s number,CNT2 a s CNT3
; CNT2 - uklada se info o tom, kam ma byt zapsan bod
; number - hodnota z prevodniku ("obrana" o dva spodni bity)
	MOV CNT2,number

	CPI number,8	; porovname cislo s 8
	BRSH num_8_15_L	; pokud je vetsi, nebo rovno jak 8, pak skoci
	; SUBI CNT2,0
; Musime zjistit na ktery radek se bude zapisovat, abychom vedeli, kterou
  ; pomocnou tecku musime vykreslit znovu - uz vime o jaky radek jde ->
  ; -> ulozime informace o pozici pomocne tecky
	LDI data,7	; zvolime cislo radku
	RJMP show_dot_L	; a skok na kod, ktery uz vykresli bod

num_8_15_L:
	CPI number,16
	BRSH num_16_23_L

	SUBI CNT2,8	; CNT2 se muze pohybovat od 0~7 - nutno odecist 8
	LDI data,6
	RJMP show_dot_L

num_16_23_L:
	CPI number,24
	BRSH num_24_31_L

	SUBI CNT2,16
	LDI data,5
	RJMP show_dot_L
num_24_31_L:	; Tady je vyjimka - prepisujeme Xovou pomocnou osu
  ; -> musime zaridit, aby byla stale viditelna
	CPI number,32
	BRSH num_32_39_L

	SUBI CNT2,24
	LDI data,4
	RJMP show_dot_L
num_32_39_L:
	CPI number,40
	BRSH num_40_47_L
	
	SUBI CNT2,32
	LDI data,3
	RJMP show_dot_L
num_40_47_L:
	CPI number,48
	BRSH num_48_55_L

	SUBI CNT2,40
	LDI data,2
	RJMP show_dot_L
num_48_55_L:
	CPI number,56
	BRSH num_56_63_L

	SUBI CNT2,48
	LDI data,1
	RJMP show_dot_L
num_56_63_L:
  ; Uz neni jina moznost -> nemusime overovat
	SUBI CNT2,56
	LDI data,0
; a pokracuje na show_dot_L
; *-----------------------------------------*
show_dot_L:
	RCALL select_line_left	; vybereme spravny radek (proto se pred skokem
  ; sem nastavovala promenna "data" jako cislo radku

normal_point_L_0:
	CPI CNT2,0	; nyni zjistime, kde mame vlastne bod vykreslit
  ; (mame 8 moznosti na jednom radku. Radek je uz zvoleny, takze zbyva
  ; urcit presnou polohu bodu)
	BRNE normal_point_L_1	; pokud nejde o "0", pak skok na
  ; normal_point_L_1 - pak testujeme, zda se nejedna o "1"
	LDI data,0b10000000	; ukaze tecku uplne dole na radku (strance)
	RCALL write_left_with_read	; a zapis dat na LCD
	RET	; bod je jiz zapsan -> konec vykreslovani jednoho bodu
normal_point_L_1:	; testovani jestli jde o "1"
	CPI CNT2,1
	BRNE normal_point_L_2
	LDI data,0b01000000
	RCALL write_left_with_read
	RET
normal_point_L_2:
	CPI CNT2,2
	BRNE normal_point_L_3
	LDI data,0b00100000
	RCALL write_left_with_read
	RET
normal_point_L_3:
	CPI CNT2,3
	BRNE normal_point_L_4
	LDI data,0b00010000
	RCALL write_left_with_read
	RET
normal_point_L_4:
	CPI CNT2,4
	BRNE normal_point_L_5
	LDI data,0b00001000
	RCALL write_left_with_read
	RET
normal_point_L_5:
	CPI CNT2,5
	BRNE normal_point_L_6
	LDI data,0b00000100
	RCALL write_left_with_read
	RET
normal_point_L_6:
	CPI CNT2,6
	BRNE normal_point_L_7
	LDI data,0b00000010
	RCALL write_left_with_read
	RET
normal_point_L_7:
; Uz neni potreba testovat. Uz neni jina moznost -> jasne ze pujde o "7"
  ; Taky pokud nastane nejaky problem pri prenosu dat, tak se zobrazi jako
  ; bod nejniz na displeji
	LDI data,0b00000001
	RCALL write_left_with_read
	RET
; *-----------------------------------------*
; |                                         |
; *-----------------------------------------*
Draw_num_R:
; pracuje s number,CNT2
; CNT2 - uklada se info o tom, kam ma byt zapsan bod
; number - hodnota z prevodniku ("obrana" o dva spodni bity)
	MOV CNT2,number

	CPI number,8	; porovname cislo s 8
	BRSH num_8_15_R	; pokud je vetsi, nebo rovno jak 8, pak skoci
	; SUBI CNT2,0
; Musime zjistit na ktery radek se bude zapisovat, abychom vedeli, kterou
  ; pomocnou tecku musime vykreslit znovu - uz vime o jaky radek jde ->
  ; -> ulozime informace o pozici pomocne tecky
	LDI data,7	; zvolime cislo radku
	RJMP show_dot_R	; a skok na kod, ktery uz vykresli bod

num_8_15_R:
	CPI number,16
	BRSH num_16_23_R

	SUBI CNT2,8	; CNT2 se muze pohybovat od 0~7 - nutno odecist 8
	LDI data,6
	RJMP show_dot_R

num_16_23_R:
	CPI number,24
	BRSH num_24_31_R

	SUBI CNT2,16
	LDI data,5
	RJMP show_dot_R
num_24_31_R:	; Tady je vyjimka - prepisujeme Xovou pomocnou osu
  ; -> musime zaridit, aby byla stale viditelna
	CPI number,32
	BRSH num_32_39_R

	SUBI CNT2,24
	LDI data,4
	RJMP show_dot_R
num_32_39_R:
	CPI number,40
	BRSH num_40_47_R
	
	SUBI CNT2,32
	LDI data,3
	RJMP show_dot_R
num_40_47_R:
	CPI number,48
	BRSH num_48_55_R

	SUBI CNT2,40
	LDI data,2
	RJMP show_dot_R
num_48_55_R:
	CPI number,56
	BRSH num_56_63_R

	SUBI CNT2,48
	LDI data,1
	RJMP show_dot_R
num_56_63_R:
  ; Uz neni jina moznost -> nemusime overovat
	SUBI CNT2,56
	LDI data,0
; a pokracuje na show_dot_R
; *-----------------------------------------*
show_dot_R:
	RCALL select_line_right	; vybereme spravny radek (proto se pred skokem
  ; sem nastavovala promenna "data" jako cislo radku

normal_point_R_0:
	CPI CNT2,0	; nyni zjistime, kde mame vlastne bod vykreslit
  ; (mame 8 moznosti na jednom radku. Radek je uz zvoleny, takze zbyva
  ; urcit presnou polohu bodu)
	BRNE normal_point_R_1	; pokud nejde o "0", pak skok na
  ; normal_point_R_1 - pak testujeme, zda se nejedna o "1"
	LDI data,0b10000000	; ukaze tecku uplne dole na radku (strance)
	RCALL write_right_with_read	; a zapis dat na LCD
	RET	; bod je jiz zapsan -> konec vykreslovani jednoho bodu
normal_point_R_1:	; testovani jestli jde o "1"
	CPI CNT2,1
	BRNE normal_point_R_2
	LDI data,0b01000000
	RCALL write_right_with_read
	RET
normal_point_R_2:
	CPI CNT2,2
	BRNE normal_point_R_3
	LDI data,0b00100000
	RCALL write_right_with_read
	RET
normal_point_R_3:
	CPI CNT2,3
	BRNE normal_point_R_4
	LDI data,0b00010000
	RCALL write_right_with_read
	RET
normal_point_R_4:
	CPI CNT2,4
	BRNE normal_point_R_5
	LDI data,0b00001000
	RCALL write_right_with_read
	RET
normal_point_R_5:
	CPI CNT2,5
	BRNE normal_point_R_6
	LDI data,0b00000100
	RCALL write_right_with_read
	RET
normal_point_R_6:
	CPI CNT2,6
	BRNE normal_point_R_7
	LDI data,0b00000010
	RCALL write_right_with_read
	RET
normal_point_R_7:
; Uz neni potreba testovat. Uz neni jina moznost -> jasne ze pujde o "7"
  ; Taky pokud nastane nejaky problem pri prenosu dat, tak se zobrazi jako
  ; bod nejniz na displeji
	LDI data,0b00000001
	RCALL write_right_with_read
	RET
; *-----------------------------------------*
; |                                         |
; *-----------------------------------------*
Draw_num_L_vector:
  ; nejprve si zjistime, zda nasledujici bod je vetsi, nebo mensi a podle toho
  ; se muzeme rohodnout, zda se bude "vektorova cara" vykreslovat "nahoru",
  ; nebo "dolu"

	LD time2,X	; nacteme nasledujici vzorek do "time2"
  ; (pointer se uz posunul o 1 pri nacitani - LD number,X+ -> pricetl 1
	LSR time2
	LSR time2	; opet odstranime 2 spodni bity
  ; number - aktualni vzorek
  ; time2 - nasledujici vzorek

	RCALL Draw_num_L	; vykreslime aktualni vzorek a pote vykreslime
  ; "vektorovou caru"

	INC number2	; tim se posuneme v Xove souradnici o 1 doprava
  ; "Vektorova cara" se vykresluje jakoby na dalsi pixel


	CPI number2,64	; kontrola, zda bychom uz nepotrebovali zapisovat na
  ; pravy radic LCD
	BRNE Draw_num_L_vector_Write_normally	; pokud ne, skok na navesti
  ; v opacnem pripade zapiseme data na pravou polovinu LCD. Ale musime
  ; nastavit Xovou souradnici a zvolit pravou polovinu
	LDI data,0
	RCALL select_X_right	; vybereme Xovou souradnici
	MOV number2,data	; to same, ale pro podprogram
  ; "Draw_num_R" ale de-facto pro "write_right_with_read"
  ; Ted se musi rozhodnout, zda se bude vykreslovat vektor "dolu", nebo
  ; "nahoru"

  ; nasledujici algoritmy jsou vysvetleny podrobne nize.
	CP time2,number
	BRLO Draw_num_L_vector_down_R
Draw_num_L_vector_up_or_equal_R:
	CP time2,number
	BRNE Draw_num_L_vector_up_R
	RET
Draw_num_L_vector_up_R:
	INC number
	RCALL Draw_num_R
	CP number,time2
	BRNE Draw_num_L_vector_up_R
	RET
Draw_num_L_vector_down_R:
	DEC number
	RCALL Draw_num_R
	CP number,time2
	BRNE Draw_num_L_vector_down_R
	RET


Draw_num_L_vector_Write_normally:
	CP time2,number	; porovname data (nasledujici vzorek) a number
  ; (aktualni vzorek)
	BRLO Draw_num_L_vector_down	; pokud je data (nasledujici) mensi
  ; nez number (aktualni), pak skok na predepsane navesti
  ; V opacnem pripade se bude zapisovat "nahoru"
Draw_num_L_vector_up_or_equal:
	CP time2,number	; jeste muze nastat situace, ze tyto dva vzorky budou
  ; stejne. V tom pripade je zbytecne neco dokreslovat
	BRNE Draw_num_L_vector_up	; pokud si nejsou rovny -> skok na
  ; navesti
  ; pokud si budou rovny, nic nemusime resit
	RET	; konec
Draw_num_L_vector_up:
	INC number
;	MOV number2,CNT

	RCALL Draw_num_L

	CP number,time2	; a bude se pridavat ten jeden bod tak dlouho, dokud
  ; nebude na souradnicich nasledujiciho bodu
	BRNE Draw_num_L_vector_up
	RET

Draw_num_L_vector_down:
	DEC number
	
	RCALL Draw_num_L

	CP number,time2
	BRNE Draw_num_L_vector_down

	RET
; *-----------------------------------------*
Draw_num_R_vector:
  ; Vektorove vykresleni pro pravou polovinu LCD

	LD time2,X
	LSR time2
	LSR time2

	RCALL Draw_num_R

	INC number2

	CPI number2,35	; to same jako vyse, ale musi se prestat vykreslovat
  ; uz na 34. pixelu
	BRNE Draw_num_R_vector_Write_normally
  ; pokud jsme "na konci", pak uz neni kam vykreslovat dalsi pixel
	RET	; jak jednoduche...

Draw_num_R_vector_Write_normally:
	CP time2,number
	BRLO Draw_num_R_vector_down

Draw_num_R_vector_up_or_equal:
	CP time2,number
	BRNE Draw_num_R_vector_up
	RET

Draw_num_R_vector_up:
	INC number
	RCALL Draw_num_R
	CP number,time2
	BRNE Draw_num_R_vector_up
	RET

Draw_num_R_vector_down:
	DEC number
	RCALL Draw_num_R
	CP number,time2
	BRNE Draw_num_R_vector_down
	RET
