.NOLIST
.INCLUDE "m8def.inc"
.LIST
; ATmega8
; Verze pro komunikaci s ostatnima periferiema: 0.2

; *-----------------------------------------*
; |               PROMENNE                  |
; *-----------------------------------------*
; Zde se definuje, kam se jednotlive informace o stisknutych tlacitkach
  ; ukladaji (v urcitem registru).
.EQU	plus_time_base = 0
.EQU	minus_time_base = 1
.EQU	menu = 2
.EQU	arrow_left = 3
.EQU	arrow_right = 4
.EQU	OK = 5
.EQU	X = 6
.EQU	run_stop = 7
  ; Dalsi "sada" tlacitek
.EQU	A_button = 0	; Tlacitko "A"
.EQU	B_button = 1	; "B"
.EQU	C_button = 2	; "C"
.EQU	D_button = 3	; ....

.EQU	E_button = 4
.EQU	F_button = 5
.EQU	G_button = 6
.EQU	H_button = 7
  ; tyto promenne musi byt  stejne nastaveny i v "keyboard_control.asm"
  ; v main_uC, jinak dojde k "prehazeni" tlacitek

.EQU	soft_button = 7	; Vysoka citlivost tlacitka (rychle)
.EQU	normal_button = 25
.EQU	wait_for_main_interval = 150	; doba, nebo spis takovy pocet cyklu,
  ; po kterou se ma cekat na "main_uC".
  ; Cim dame vyssi cislo, tim se zvysuje pravdepodobnosti, ze ze data rychleji
  ; dostanou do "main_uC", ale snizime si reakcni rychlost klavesnice a naopak


; Jako port pro klavesnici pouzijeme PortD
  ; Cast bude vstupni a cast bude vystupni
.EQU	keyboard_port = PortD	; pro vystupy
.EQU	keyboard_port_in = PinD	; pro vstupy
.EQU	IO_keyboard = DDRD	; pro nastaveni vstupu/vystupu

; Definice jednotlivych jmen pinu na klavesnici
.EQU	R0 = 0	; Bude na keyboard_port, 0. bit -> PD0 (pokud je pro
  ; klavesnici definovany PortD
.EQU	R1 = 1
.EQU	R2 = 2
.EQU	R3 = 3
.EQU	PWR0 = 4
.EQU	PWR1 = 5
.EQU	PWR2 = 6
.EQU	PWR3 = 7



; Jako datovy port bude pouzit PortB (6. bitovy - kdyz nepocitam krystal)
.EQU	data_port = PortB	; pro vystupy
.EQU	data_port_in = PinB	; pro vstupy
.EQU	IO_data = DDRB		; pro nastaveni vstupu/vystupu


.EQU	trigger = 0		; sem se bude privadet informace o tom, zda
  ; je zvolena synchronizace interni, nebo externi. 0 - interni ; 1 - externi
.EQU	AC_DC_coupling = 1		; informace o vazbe - AC stridava, DC ss.

.EQU	serial_data_out = 5	; rekneme, ze PB5 bude port pro vystup dat
.EQU	ready = 4		; sem se bude ukladat informace o tom, jestli
  ; main uC je pripraven prijimat data

; Jako port pro zjistovani aktualniho rozsahu pristroje bude pouzit PortC
;.EQU	range_port = PortC	; pro vystupy - nema smysl, bude vstupni
.EQU	range_port_in = PinC	; pro vstupy
.EQU	IO_range = DDRC		; pro nastaveni vstupu a vystupu

.EQU	SW1 = 0		; první poloha - na pinu PC0
.EQU	SW2 = 1		; druha poloha - PC1
.EQU	SW3 = 2
.EQU	SW4 = 3
.EQU	SW5 = 4
.EQU	SW6 = 5		; a sesta poloha - PC6
;----- interni poznamka
; rozsahy:
; SW1 - 0.1V/div (+-0.3V celkem)
; SW2 - 0.2V/div
; SW3 - 0.5V/div
; SW4 - 1V/div
; SW5 - 2V/div
; SW6 - 5V/div

; *-----------------------------------------*
; |           POJMENOVANI REGISTRU          |
; *-----------------------------------------*
.DEF tmp = R16
.DEF keyboard_data_1_to_8 = R17	; do tohoto registru se budou ukladat
  ; informace o stisknuti/nestisknuti prvnich 8. tlacitek
.DEF keyboard_data_9_to_16 = R18	; info o tlacitkach 9 az 18
.DEF range = R19	; sem se bude ukladat info o nastavenem
  ; rozsahu (1 z 6 moznosti -> budou se posilat jen 3 bity -> zatim neni
  ; potreba 
.DEF CNT = R20	; pro nejake cykly atd..
.DEF CNT2 = R21


  ; Registry pro cas (podprogramy v wait_XMhz.asm)
.DEF time1 = R22
.DEF time2 = R23
.DEF time3 = R24


.DEF parity = R25	; registr urceny pro vypocet parity

; *-----------------------------------------*
; |            ADRESY V SRAM                |
; *-----------------------------------------*
.EQU trigger_SRAM = $0060	; sem se bude ukladat informace o tom, jestli
  ; je zvolena synchronizace interni, nebo externi
.EQU AC_DC_coupling_SRAM = trigger_SRAM+1	; info o vazbe
; *-----------------------------------------*
; |              INICIALIZACE               |
; *-----------------------------------------*
	LDI tmp,LOW(RAMEND)
	OUT SPL,tmp
	LDI tmp,HIGH(RAMEND)
	OUT SPH,tmp

; Nastavime vstupy/vystupy
  ; "1" - OUT	; "0" - IN

  ;	KLAVESNICE
	CBI IO_keyboard,R0
	CBI IO_keyboard,R1
	CBI IO_keyboard,R2
	CBI IO_keyboard,R3
      ; Rx budou vstupni

;	SBI IO_keyboard,PWR0
;	SBI IO_keyboard,PWR1
;	SBI IO_keyboard,PWR2
;	SBI IO_keyboard,PWR3
      ; PWRx budou vystupni	-> ale v prubehu programu se to meni -> proto
  ; zakomentovane -> nema smysl to definovat, kdyz se to bude dokola menit

  ;	DATOVY PORT
	SBI IO_data,serial_data_out	; vystupni
	CBI IO_data,ready	; vstupni
	CBI IO_data,trigger	; vstupni
	CBI IO_data,AC_DC_coupling	; vstupni

	CLR keyboard_data_1_to_8
	CLR keyboard_data_9_to_16

  ;	ROZSAH PORT
	LDI tmp,$00
	OUT IO_range,tmp	; bude vstupni cely

; *-----------------------------------------*
; |            Hlavni program               |
; *-----------------------------------------*
Start:
	CLR CNT	; bude pocitat pocet pokusu
	CLR CNT2	; na jeden registr to proste nestaci :D
  ; Je to kvuli tomu, ze kdyz podrzime tlacitko delsi dobu, tak uzivatel
  ; naznaci, ze jakoby stisk tlacitko vicekrat. A jedina moznost, jak
  ; informovat "main_uC" ze je tlacitko stiskle vicektrat, je vicekrat odelsat
  ; data -> zetsit "okenko" pro prenos dat
Is_main_ready:
	SBIC data_port_in,ready	; kontrola, zda je main uC pripraven prijimat
  ; data z klavesnice -> pokud je zde "0", pak neni pripraven a tento uC
	RJMP Main_is_ready	; pokud je pripraven...
  ; Pokud neni pripraven, pak se probedou nasledujici prikazy
	INC CNT
	CPI CNT,wait_for_main_interval
	BRNE Is_main_ready

	INC CNT2
	CPI CNT2,wait_for_main_interval	; porovna s hodnotou
  ; "wait_for_main_interval"
	BREQ Load_all_data	; a pokud se dosahne limitu, skok na
  ; "Load_all_data"

	RJMP Is_main_ready	; v opacnem pripade se bude dal cekat

Main_is_ready:
	RCALL send_data	; pokud byla na vstupu "1"
  ; po odeslani dat, se automaticky registry "keyboard_data_1_to_8"
  ; a "keyboard_data_9_to_16" smazou

  ; a pokracuje se na "Load_all_data"
Load_all_data:
	RCALL load_data_from_keyboard	; pak se pokracuje tady...

	RCALL load_range_SW	; zjisti, jaky je zvoleny rozsah
	RCALL load_trigger_SW	; zjisti, jestli je zvolena interni, nebo
  ; externi synchronizace
	RCALL load_AC_DC_coupling_SW	; Zjisti vazbu na vstupu
RJMP Start	; a znova se testuje. Musime skocit na Start, aby se smazal
  ; citac "pokusu"


; *-----------------------------------------*
; |          Podprogram na odesilani dat    |
; *-----------------------------------------*

send_data:
	LDI parity,0	; tato informace musi byt stejna i v prijimaci!
  ; V podstate rozhoduje pouze LSB

  ; Dlouhy pulz - "1" (4us) ; Kratky pulz - "0" (2us)
  ; Prvne posleme dlouhy start bit (10us)
	SBI data_port,serial_data_out	; nastavime vystup do "1"
	RCALL wait_2us	; pocka 2us (pro 4Mhz to je 8 taktu)
	RCALL wait_2us
	RCALL wait_2us
	RCALL wait_2us
	RCALL wait_2us
	CBI data_port,serial_data_out	; nastavime vystup do "0"

	RCALL wait_2us	; mezera - za tuto dobu si musi prijimac zpracovat
  ; predesla data

Bit_0:
  ; Nyni posleme nulty bit (+time base)
	SBI data_port,serial_data_out	; nastavime vystup do "1"
	RCALL wait_2us
	SBRC keyboard_data_1_to_8,plus_time_base	; nacte se bit
  ; z registru keyboard_data_1_to_8 -> bit plus_time_base (0 - LSB). Pokud zde
  ;  bude 0, provede se skok. Pokud zde bude "1", pokracuje se na dalsi radek
	RCALL wait_2us
	CBI data_port,serial_data_out

	SBRC keyboard_data_1_to_8,plus_time_base	; a pokud bylo stiskle
  ; tlacitko "plus_time_base", pak se zmeni i hodnota parity
	INC parity

	RCALL wait_2us
  ; a posila se dalsi bit...
Bit_1:	; -time base
	SBI data_port,serial_data_out
	RCALL wait_2us
	SBRC keyboard_data_1_to_8,minus_time_base
	RCALL wait_2us
	CBI data_port,serial_data_out

	SBRC keyboard_data_1_to_8,minus_time_base
	INC parity
	RCALL wait_2us
Bit_2:	; menu
	SBI data_port,serial_data_out
	RCALL wait_2us
	SBRC keyboard_data_1_to_8,menu
	RCALL wait_2us
	CBI data_port,serial_data_out

	SBRC keyboard_data_1_to_8,menu
	INC parity
	RCALL wait_2us
Bit_3:	; <-
	SBI data_port,serial_data_out
	RCALL wait_2us
	SBRC keyboard_data_1_to_8,arrow_left
	RCALL wait_2us
	CBI data_port,serial_data_out

	SBRC keyboard_data_1_to_8,arrow_left
	INC parity
	RCALL wait_2us
Bit_4:	; ->
	SBI data_port,serial_data_out
	RCALL wait_2us
	SBRC keyboard_data_1_to_8,arrow_right
	RCALL wait_2us
	CBI data_port,serial_data_out

	SBRC keyboard_data_1_to_8,arrow_right
	INC parity
	RCALL wait_2us
Bit_5:	; OK
	SBI data_port,serial_data_out
	RCALL wait_2us
	SBRC keyboard_data_1_to_8,OK
	RCALL wait_2us
	CBI data_port,serial_data_out

	SBRC keyboard_data_1_to_8,OK
	INC parity
	RCALL wait_2us
Bit_6:	; X
	SBI data_port,serial_data_out
	RCALL wait_2us
	SBRC keyboard_data_1_to_8,X
	RCALL wait_2us
	CBI data_port,serial_data_out

	SBRC keyboard_data_1_to_8,X
	INC parity
	RCALL wait_2us
Bit_7:	; Run/Stop
	SBI data_port,serial_data_out
	RCALL wait_2us
	SBRC keyboard_data_1_to_8,run_stop
	RCALL wait_2us
	CBI data_port,serial_data_out

	SBRC keyboard_data_1_to_8,run_stop
	INC parity
	RCALL wait_2us
Bit_8:
	SBI data_port,serial_data_out
	RCALL wait_2us
	SBRC keyboard_data_9_to_16,0
	RCALL wait_2us
	CBI data_port,serial_data_out

	SBRC keyboard_data_9_to_16,0
	INC parity
	RCALL wait_2us
Bit_9:
	SBI data_port,serial_data_out
	RCALL wait_2us
	SBRC keyboard_data_9_to_16,1
	RCALL wait_2us
	CBI data_port,serial_data_out

	SBRC keyboard_data_9_to_16,1
	INC parity
	RCALL wait_2us
Bit_10:
	SBI data_port,serial_data_out
	RCALL wait_2us
	SBRC keyboard_data_9_to_16,2
	RCALL wait_2us
	CBI data_port,serial_data_out

	SBRC keyboard_data_9_to_16,2
	INC parity
	RCALL wait_2us
Bit_11:
	SBI data_port,serial_data_out
	RCALL wait_2us
	SBRC keyboard_data_9_to_16,3
	RCALL wait_2us
	CBI data_port,serial_data_out

	SBRC keyboard_data_9_to_16,3
	INC parity
	RCALL wait_2us
Bit_12:
	SBI data_port,serial_data_out
	RCALL wait_2us
	SBRC keyboard_data_9_to_16,4
	RCALL wait_2us
	CBI data_port,serial_data_out

	SBRC keyboard_data_9_to_16,4
	INC parity
	RCALL wait_2us
Bit_13:
	SBI data_port,serial_data_out
	RCALL wait_2us
	SBRC keyboard_data_9_to_16,5
	RCALL wait_2us
	CBI data_port,serial_data_out

	SBRC keyboard_data_9_to_16,5
	INC parity
	RCALL wait_2us
Bit_14:
	SBI data_port,serial_data_out
	RCALL wait_2us
	SBRC keyboard_data_9_to_16,6
	RCALL wait_2us
	CBI data_port,serial_data_out

	SBRC keyboard_data_9_to_16,6
	INC parity
	RCALL wait_2us
Bit_15:
	SBI data_port,serial_data_out
	RCALL wait_2us
	SBRC keyboard_data_9_to_16,7
	RCALL wait_2us
	CBI data_port,serial_data_out

	SBRC keyboard_data_9_to_16,7
	INC parity
	RCALL wait_2us

; Nyni odesleme informace o tom, jaky je zvoleny rozsah - staci 3 bity
; protoze mame jen 6 moznosti
Bit_16:
	SBI data_port,serial_data_out
	RCALL wait_2us
	SBRC range,0	; odesleme LSB
	RCALL wait_2us
	CBI data_port,serial_data_out

	SBRC range,0
	INC parity
	RCALL wait_2us

Bit_17:
	SBI data_port,serial_data_out
	RCALL wait_2us
	SBRC range,1	; odesleme dalsi bit
	RCALL wait_2us
	CBI data_port,serial_data_out

	SBRC range,1
	INC parity
	RCALL wait_2us

Bit_18:
	SBI data_port,serial_data_out
	RCALL wait_2us
	SBRC range,2	; odesleme posledni
	RCALL wait_2us
	CBI data_port,serial_data_out

	SBRC range,2
	INC parity
	RCALL wait_2us
  ; Dal se odesle informace o triggeru (interni/externi)
  ; Nejdriv si ale musime informaci stahnout do nejakeho registru. A vzhledem
  ; k tomu, ze data z registru "range" jsme uz poslali,tak muzeme pouzit treba
  ; ten
	LDS range,trigger_SRAM
Bit_19:
	SBI data_port,serial_data_out
	RCALL wait_2us
	SBRC range,0	; odesleme LSB (zde je ulozena informace)
	RCALL wait_2us
	CBI data_port,serial_data_out

	SBRC range,0
	INC parity
	RCALL wait_2us


	LDS range,AC_DC_coupling_SRAM
bit_20:
	SBI data_port,serial_data_out
	RCALL wait_2us
	SBRC range,0	; odesle se LSB (zde je ulozena informace)
	RCALL wait_2us
	CBI data_port,serial_data_out

	SBRC range,0
	INC parity
	RCALL wait_2us


	MOV range,parity
Bit_parity:
	SBI data_port,serial_data_out
	RCALL wait_2us
	SBRC range,0	; odesle se LSB
	RCALL wait_2us
	CBI data_port,serial_data_out

	RCALL wait_2us

Bit_parity2:
  ; to same, ale musi se odeslat invertovana hodnota
	SBI data_port,serial_data_out
	RCALL wait_2us
	SBRS range,0	; pouzito SBRS misto SBRC -> odesle se inverovana
  ; hodnota
	RCALL wait_2us
	CBI data_port,serial_data_out


; Nyni jsme odeslali veskera data. Tak smazeme data, ktera jsou ulozena
  ; v keyboard_data_1_to_8 a keyboard_data_9_to_16
	CLR keyboard_data_1_to_8
	CLR keyboard_data_9_to_16

 ; a nezapomenout na range, pokud bychom sem následující řádek nedali, tak
  ; by osciloskop pri prepinani rozsahu ukazoval posledni nastavenou hodnotu
  ; a ne otaznik, ktery znaci, ze zde neni nastaveny zadny rozsah
	CLR range

	RET

; *-----------------------------------------*
; |                                         |
; *-----------------------------------------*

load_data_from_keyboard:
	SET	; nastavime T bit na "1"
	LDI tmp,normal_button	; pro urceni toho, jak dlouho muze byt
  ; stisknuto tlacitko, nez bude vyhodnoceno jako ze je stisknuto vicekrat
  ; - nakonec u nekterych tlacitek definovano zvlast

; Nejdrive otestujeme, zda neni stisknute nejake tlacitko na PWR0
Test_PWR0:
  ; To znamena, ze PWR0 bude vystupni ale ostatni PWRx se musi nastavit jako
  ; vstupni -> budou mit nastaveny velky vstupni odpor -> kdyz stiskneme dve
  ; tlacitka vedle sebe (ve dvou ruznych sloupcich), pak by nastal zkrat!
  ; uC tim sice teoreticky neznicime (ma ruzne ochrany), ale dochazelo by
  ; ke spatnemu vyhodnoceni o stisknutych tlacitek na klavesnici a poklesu
  ; napajeciho napeti, pokud by nebyl pouzit dostatecne tvrdy zdroj
	SBI IO_keyboard,PWR0
	CBI IO_keyboard,PWR1
	CBI IO_keyboard,PWR2
	CBI IO_keyboard,PWR3
	NOP


	SBI keyboard_port,PWR0	; Nastavime prvni sloupec jako aktivni
	NOP	; Je potreba dat uC chvilinku na to, aby si nastavil vystupy
  ; na "1", protoze ihned potom kontrolujeme vstupy (bez tohoto prikazu mi
  ; klavesnice "blbla")
Button_PWR0_R0:
	LDI CNT,soft_button		; bude pocitat dobu, po kterou je
  ; stisknuto tlacitko. Pokud bude tato doba prekrocena, bereme, ze uzivatel
  ; chce aby tlacitko bylo jakoby vicekrat stisknuto

	SBIC keyboard_port_in,R0	; kontrolujeme, zda neni stisknuto
  ; tlacitko o souradnicich PWR0,R0 ; "0" -> skok ; "1" dalsi radek
	BLD keyboard_data_1_to_8,arrow_left	; na toto misto se ulozi
  ; informace stitklem tlacitku - zde se ulozi informace, ze je stiskle
  ; tlacitko "<-"
PWR0_R0_release:
	SBIS keyboard_port_in,R0	; kontrola, zda bylo tlacitko pusteno
	RJMP Button_PWR0_R1	; pokud ano, pokracuje se dal
  ; jinak pockame urcitou dobu
	RCALL wait_10ms	; pockame 
	DEC CNT	; odecteme pokus
	BRNE PWR0_R0_release	; a znova testujeme, zda uzivatel nepustil
; tlacitko


Button_PWR0_R1:
	MOV CNT,tmp	; nevime, zda uzivatel pustil tlacitko v intervalu, nebo
  ; zda byla prekrocena doba cekani -> proto znovu nahrajeme hodnotu

	SBIC keyboard_port_in,R1
	BLD keyboard_data_1_to_8,OK	; tlacitko OK
PWR0_R1_release:
	SBIS keyboard_port_in,R1
	RJMP Button_PWR0_R2
	RCALL wait_10ms
	DEC CNT
	BRNE PWR0_R1_release


Button_PWR0_R2:
	MOV CNT,tmp
	SBIC keyboard_port_in,R2
	BLD keyboard_data_9_to_16,A_button
PWR0_R2_release:
	SBIS keyboard_port_in,R2
	RJMP Button_PWR0_R3
	RCALL wait_10ms
	DEC CNT
	BRNE PWR0_R2_release



Button_PWR0_R3:
	MOV CNT,tmp
	SBIC keyboard_port_in,R3
	BLD keyboard_data_9_to_16,E_button
PWR0_R3_release:
	SBIS keyboard_port_in,R3
	RJMP PWR0_R3_end
	RCALL wait_10ms
	DEC CNT
	BRNE PWR0_R3_release


PWR0_R3_end:
	CBI keyboard_port,PWR0	; deaktivujeme prvni sloupec
	nop	; opet je potreba dat uC chvilinku na to, aby si nastavil
  ; vystupy na "0", jinak by mohl nastat problem se ctenim stavu tlacitek
  ; z klavesnice

Test_PWR1:
	SBI IO_keyboard,PWR1
	CBI IO_keyboard,PWR0
	CBI IO_keyboard,PWR2
	CBI IO_keyboard,PWR3
	nop

	SBI keyboard_port,PWR1
	nop

Button_PWR1_R0:
	MOV CNT,tmp
	SBIC keyboard_port_in,R0
	BLD keyboard_data_1_to_8,minus_time_base
PWR1_R0_release:
	SBIS keyboard_port_in,R0
	RJMP Button_PWR1_R1
	RCALL wait_10ms
	DEC CNT
	BRNE PWR1_R0_release

Button_PWR1_R1:
	MOV CNT,tmp
	SBIC keyboard_port_in,R1
	BLD keyboard_data_1_to_8,run_stop
PWR1_R1_release:
	SBIS keyboard_port_in,R1
	RJMP Button_PWR1_R2
	RCALL wait_10ms
	DEC CNT
	BRNE PWR1_R1_release


Button_PWR1_R2:
	MOV CNT,tmp
	SBIC keyboard_port_in,R2
	BLD keyboard_data_9_to_16,B_button
PWR1_R2_release:
	SBIS keyboard_port_in,R2
	RJMP Button_PWR1_R3
	RCALL wait_10ms
	DEC CNT
	BRNE PWR1_R2_release


Button_PWR1_R3:
	MOV CNT,tmp
	SBIC keyboard_port_in,R3
	BLD keyboard_data_9_to_16,F_button
PWR1_R3_release:
	SBIS keyboard_port_in,R3
	RJMP PWR1_R3_end
	RCALL wait_10ms
	DEC CNT
	BRNE PWR1_R3_release

PWR1_R3_end:
	CBI keyboard_port,PWR1
	nop

Test_PWR2:
	SBI IO_keyboard,PWR2
	CBI IO_keyboard,PWR0
	CBI IO_keyboard,PWR1
	CBI IO_keyboard,PWR3
	nop

	SBI keyboard_port,PWR2
	nop

Button_PWR2_R0:
	MOV CNT,tmp
	SBIC keyboard_port_in,R0
	BLD keyboard_data_1_to_8,plus_time_base
PWR2_R0_release:
	SBIS keyboard_port_in,R0
	RJMP Button_PWR2_R1
	RCALL wait_10ms
	DEC CNT
	BRNE PWR2_R0_release


Button_PWR2_R1:
	MOV CNT,tmp
	SBIC keyboard_port_in,R1
	BLD keyboard_data_1_to_8,menu
PWR2_R1_release:
	SBIS keyboard_port_in,R1
	RJMP Button_PWR2_R2
	RCALL wait_10ms
	DEC CNT
	BRNE PWR2_R1_release

Button_PWR2_R2:
	MOV CNT,tmp
	SBIC keyboard_port_in,R2
	BLD keyboard_data_9_to_16,C_button
PWR2_R2_release:
	SBIS keyboard_port_in,R2
	RJMP Button_PWR2_R3
	RCALL wait_10ms
	DEC CNT
	BRNE PWR2_R2_release


Button_PWR2_R3:
	MOV CNT,tmp
	SBIC keyboard_port_in,R3
	BLD keyboard_data_9_to_16,G_button
PWR2_R3_release:
	SBIS keyboard_port_in,R3
	RJMP PWR2_R3_end
	RCALL wait_10ms
	DEC CNT
	BRNE PWR2_R3_release

PWR2_R3_end:
	CBI keyboard_port,PWR2
	nop

Test_PWR3:
	SBI IO_keyboard,PWR3
	CBI IO_keyboard,PWR0
	CBI IO_keyboard,PWR1
	CBI IO_keyboard,PWR2
	nop

	SBI keyboard_port,PWR3
	nop


Button_PWR3_R0:
	LDI CNT,soft_button
	SBIC keyboard_port_in,R0
	BLD keyboard_data_1_to_8,arrow_right
PWR3_R0_release:
	SBIS keyboard_port_in,R0
	RJMP Button_PWR3_R1
	RCALL wait_10ms
	DEC CNT
	BRNE PWR3_R0_release

Button_PWR3_R1:
	MOV CNT,tmp
	SBIC keyboard_port_in,R1
	BLD keyboard_data_1_to_8,X
PWR3_R1_release:
	SBIS keyboard_port_in,R1
	RJMP Button_PWR3_R2
	RCALL wait_10ms
	DEC CNT
	BRNE PWR3_R1_release


Button_PWR3_R2:
	MOV CNT,tmp
	SBIC keyboard_port_in,R2
	BLD keyboard_data_9_to_16,D_button
PWR3_R2_release:
	SBIS keyboard_port_in,R2
	RJMP Button_PWR3_R3
	RCALL wait_10ms
	DEC CNT
	BRNE PWR3_R2_release


Button_PWR3_R3:
	MOV CNT,tmp
	SBIC keyboard_port_in,R3
	BLD keyboard_data_9_to_16,H_button
PWR3_R3_release:
	SBIS keyboard_port_in,R3
	RJMP PWR3_R3_end
	RCALL wait_10ms
	DEC CNT
	BRNE PWR3_R3_release


PWR3_R3_end:
	CBI keyboard_port,PWR3
;	nop	; Uz neni potreba. RET je na 4 takty

	RET
; *-----------------------------------------*
; |                                         |
; *-----------------------------------------*
load_range_SW:
	SBIC range_port_in,SW1	; testujeme, zda neni zvoleny nejmensi rozsah
	LDI range,1	; pokud byl zvolen nejmensi rozsah, pak je na vstupu
  ; "1" a do registru "range" ulozime hodnotu 1

	SBIC range_port_in,SW2	; test pro dalsi rozah
	LDI range,2	; ulozime 2 atd....

	SBIC range_port_in,SW3
	LDI range,3

	SBIC range_port_in,SW4
	LDI range,4

	SBIC range_port_in,SW5
	LDI range,5

	SBIC range_port_in,SW6
	LDI range,6
; Poznamka: pokud neni na vstupu nikde jednicka, pak se asi nachazime v dobe,
; kdy uzivatel prepina rozsah -> na displeji se pak zobrazi napriklad otaznik

	RET
; *-----------------------------------------*
; |                                         |
; *-----------------------------------------*
load_trigger_SW:
	CLR tmp

	SBIC data_port_in,trigger	; test co je na vstupu
	LDI tmp,0b00000001	; pokud je tam jednicka, pak se ulozi do tmp

	STS trigger_SRAM,tmp	; a vysledek se nahraje do SRAM (uz nejsou
  ; volne registry a na druhou stranu nas to zase tak nezpomali)

	RET
; *-----------------------------------------*
; |                                         |
; *-----------------------------------------*
load_AC_DC_coupling_SW:	; Analogie s vyse uvedenym, ale pro AC/DC vazbu
	CLR tmp
	SBIC data_port_in,AC_DC_coupling
	LDI tmp,1

	STS AC_DC_coupling_SRAM,tmp

	RET
; *-----------------------------------------*
; |                                         |
; *-----------------------------------------*

.INCLUDE "../Main_uC/wait_4Mhz.asm"	; pro snadnejsi praci - staci akorat zmenit
  ; jmeno souboru