/*/AtmegaA-M:

	Bacha: cekej1 zde trvá pouze 400ms.
Porty: B0-B7 D0-D7 CO-C3 jsou katody LED diod
	C4 - společná anoda
	C5- signální vstup výstup, komunikace s Atmegou 5 a dalšími písmenkovými 

Pozice 	0x0100 - 0x0113 - hodnoty zásahů jednotlivých diod (počínaje B0, konče D7)
	0x0131 - 0x0157 (lichá) - indexy jednotlivých diod v pinovém tvaru (00000001), podle toho se pak zvolí a zapíše trefená dioda.
				(sudá) - tam se při impulsu RESET zapíše, kolikrát byla trefená daná dioda  (číslo od 1 do 3).
	0x01FF - číslo aktuálního programu
	0x0200-0x0300 - pozice pro zápis trefených diod, Na sudé místo se zapíše index Portu (1=B, 2=C, 3=D a na liché místo se zapíše index konkrétní diody ve tvaru 11110111)
¨	0x0160 - 62 - 3 pozice pro zapisování 3 registrů, ze kterých se pak čte svícení určitého prstence
Funkce: 
	1. PROGRAM: počká na impuls od Atmegy5 a podle toho zvolí program (normal nebo biatlon)
	Při spuštění biatlonu se do R20 nahraje 7 a pak se rozsvítí prstenec 5
	Při normálním programu se sustí prstenec 0 (R20=2)
	. Zapíše program na pozici x01FF.
	2. START: nabije všechny diody
	3. PINY: Pak se zjišťuje, která dioda byla trefená stylem, že se počká třeba 100us a zjišťuje se jestli se nějaká vybila, pak dalších 100us a znovu… to celé probíhá tolikrát, kolik je kombinace R19 a R20 (např. pokud je R19 = FF a R20 = 2 pak to celé probíhá 512x.
	4. 	Pokud se za celou dobu nic nevybije, znovu se diody nabijí (START)
		NĚKDO_VYSTRELIL: Pokud mezitím přijde impuls od jiné atmegy, zablokuje se přístup k trefení a zkontroluje se jestli to byl impuls střely od jiné atmegy nebo impuls reset od Atmegy5.
NULKA: Pokud to byla jiná střela, zapíše ji do zapisovacích pozic pro střely a vrátí se zpátky na START 
			Pokud to byl impuls RESET (delší než 1ms) , provede vyhodnocení všech střel a podle toho, jestli byly zasaženy 1x 2x nebo 3x a více rozsvítí danou diodu s odpovídající intenzitou. Pak provede restart do pozice zjišťování programu.  
5.	SLOUPECEK_B (a další) : Pokud některá dioda je trefena, otestuje se, která to přesně byla a pošle impulsy do ostatních Atmeg a hlavně do Atmegy5 (400us impulsy za každý zásah +2). Střelu zapíše na další 2 pozice pro střely. Vrátí se na START.


*/




.include "m8def.inc"

.def index = R25
.def sloupec = R24
.def radek = R23
.def osmickar = R22
.def osmickas = R21
 
.org 0x00
	rjmp zac // skok na začátek programu
.org 0x18
	rjmp timer // skok na obsluhu přerušení
.org 0x100

timer: 	
	 reti

////////////////////////////////////////////////////////////
//hlavni program
//////////////////////////////////////////////////////////

zac:  	ldi R16, HIGH(RAMEND) // inicializace STACK POINTERu
		out SPH, R16
		ldi R16, LOW(RAMEND)
		out SPL, R16

		ldi 	R16, 	0xFF	//B - 8 katod - vstupní/výstupní
		out 	DDRB, 	R16
		out 	PORTB, R16
		
		ldi 	R16, 	0b11011111	//C0-3 - 4 katody, C4 - společná anoda 
		out 	DDRC, 	R16		//C5 - vstupní, výstupní - signály od/do Atmegy5
		out		PORTC,	R16   //pull up rezistor na začátku pin C5
		 
		ldi 	R16, 	0xFF	//D - 8 katod
		out 	DDRD, 	R16
		out 	PORTD, R16

				
////vytvoreni tabulky pro počet zasahu konkretni diody////

		ldi R16, 12 			//3 = +1 na pocistadle
		sts 0x0100, R16 //B0
		ldi R16, 10
		sts 0x0101, R16
		sts 0x0102, R16
		ldi R16, 9
		sts 0x0103, R16
		sts 0x0104, R16
		ldi R16, 8
		sts 0x0105, R16
		sts 0x0106, R16
		ldi R16, 7
		sts 0x0107, R16 //B7

		ldi R16, 3
		sts 0x0108, R16 //C0		//C je až nakonec takže většinou je nulové 
		ldi R16, 3
		sts 0x0109, R16
		sts 0x010A, R16
		sts 0x010B, R16 //C3

		ldi R16, 7
		sts 0x010C,	R16 //D0
		ldi R16, 6
		sts 0x010D, R16
		sts 0x010E, R16
		sts 0x010F, R16
		ldi R16, 5
		sts 0x0110, R16
		sts 0x0111, R16
		sts 0x0112, R16
		ldi R16, 4
		sts 0x0113,	R16 // D7			

		ldi R16, 0b00000001
		sts 0x0131, R16
		ldi R16, 0b00000010
		sts 0x0133, R16
		ldi R16, 0b00000100
		sts 0x0135, R16
		ldi R16, 0b00001000
		sts 0x0137, R16
		ldi R16, 0b00010000
		sts 0x0139, R16
		ldi R16, 0b00100000
		sts 0x013B, R16
		ldi R16, 0b01000000
		sts 0x013D, R16
		ldi R16, 0b10000000
		sts 0x013F, R16			//B

		ldi R16, 0b00000001
		sts 0x0141, R16
		ldi R16, 0b00000010
		sts 0x0143, R16
		ldi R16, 0b00000100
		sts 0x0145, R16
		ldi R16, 0b00001000
		sts 0x0147, R16			//C

		ldi R16, 0b00000001
		sts 0x0149, R16
		ldi R16, 0b00000010
		sts 0x014B, R16
		ldi R16, 0b00000100
		sts 0x014D, R16
		ldi R16, 0b00001000
		sts 0x014F, R16
		ldi R16, 0b00010000
		sts 0x0151, R16
		ldi R16, 0b00100000
		sts 0x0153, R16
		ldi R16, 0b01000000
		sts 0x0155, R16
		ldi R16, 0b10000000
		sts 0x0157, R16			//D


///nulovani registrů a pameti

				
		ldi R16, 0
		ldi R17, 0
		ldi R18, 0
		ldi R19, 0
		ldi R20, 0
		ldi R21, 0
		ldi R22, 0
		ldi R23, 0
		ldi R24, 0
		ldi R25, 0
		
			ldi R17, 200
			ldi ZH, 02
			ldi ZL, 00
nulovani:	st Z+, R16
			dec R17
			brne nulovani
			ldi R17, 0		//všechno vynulováno

			ldi R17, 50
			ldi ZH, 01
			ldi ZL, 0x2F
nulovani2:	inc ZL
			st Z+, R16
			dec R17
			brne nulovani2
			ldi R17, 0		//všechno vynulováno

			rcall cekej1	//synchronizace se zbytkem

	
//////////////////////////////////////////////////////////////////////////////////////////
///////////////ted ceka na impuls programu od Atmegy5//////////////////////////
///////////////////////////////////////////////////////////////////////
impuls:			in 		R16, 	PINC
				andi 	R16, 	0b00100000	//ceka na horni hranu impulsu od atmegy5
				cpi 	R16, 	0b00100000
				brne impuls
				rcall cekejkontrola
				in 		R16, 	PINC
				andi 	R16, 	0b00100000
				cpi 	R16, 	0b00100000	//overi, jestli impuls trva aspoň 
				brne impuls					//60 mikrosekund

plus:			inc R19			//za každý impuls se přičte 1
				ldi R18, 0			//pocitani, jestli uz dlouho nebyl impuls		
plusceka:		in 		R16, 	PINC		
				andi 	R16, 	0b00100000
				cpi 	R16, 	0b00000000	//overi, že impuls ustal
				brne plusceka
				rcall cekejkontrola
				in 		R16, 	PINC		
				andi 	R16, 	0b00100000
				cpi 	R16, 	0b00000000	//pro jistotku 2x
				brne plusceka
plus_uz:		inc R18			//timto pocitadlem se zjisti jestli uz neuplynulo
				cpi R18, 150		//vice nez 1ms od posledniho impulsu a tedy 
				breq program	//by bylo na case ukoncit prenost a spustit dany program
				in 		R16, 	PINC		
				andi 	R16, 	0b00100000	//
				cpi 	R16, 	0b00100000
				brne plus_uz
				rcall cekejkontrola
				in 		R16, 	PINC		
				andi 	R16, 	0b00100000
				cpi 	R16, 	0b00100000	//pro jistotu dvakrát kvůli šumu
				brne plus_uz
				rjmp plus
//program zjištěn, čekáme na start impuls
	
				
program:		sts 0x01FF, R19	//uložení informace o probihajicim programu
				cpi R19, 1		//podle toho kolik impulsu přišlo
				breq p1			//z řidici atmegy5	
				cpi R19, 2		//se vybere příslušný program 
				breq p1
				cpi R19, 3		
				breq p1
				cpi R19, 4
				breq p1
				cpi R19, 5
				breq p2
				cpi R19, 6
				breq p1
				cpi R19, 7
				breq p1
				cpi R19, 8
				breq p1

				rjmp impuls

p1: rjmp normal
p2: rjmp biatlon

////////////////////////////////////////////////////////////////////////////
///////////příprava na biatlon (rozvícení prstence 6)///////////////////////
////////////////////////////////////////////////////////////////////////////

biatlon:	rcall cekej200
			ldi R20, 7 		//s tímto číslem se porovnává, který prstenec má být rozsvícen (7=5)
			rcall prsten0_zapis
			rjmp start


/////////////////////////////////////////////////////////////////////////////
///////////teď si už v klidku zjišťuje, která dioda byla trefena////////////
////////////////////////////////////////////////////////////////////////////

normal:		rcall cekej200
			ldi R20, 2		//s tímto číslem se porovnává, který prstenec má být rozsvícen (2=0)
			rcall prsten0_zapis

start:  	rcall prsten
			ldi R16, 0xFF		
			out DDRB, R16
			out PORTB, R16
			out DDRD, R16
			out PORTD, R16
			ldi R16, 0b00011111		//na DDRC bacha nemuže být C5 - 1
			out DDRC, R16
			ldi R16, 0b00001111		//0 do anody(C4) - nabití všech diod
			out PORTC, R16			//jednička do všech katod

			ldi R16, 0
			out DDRB, R16
			out PORTB, R16
			out DDRD, R16
			out PORTD, R16
			ldi R17, 0b00010000		//C4  musí zůstav výstupní nula, C5 vstupní (neutralní)
			out DDRC, R17
			out PORTC, R16			//0	všechny katody nastavené jako vstupní
				
			ldi R20, 2	///pokus
			ldi R19, 0xFF			//R19 nastavuje delku 
			rjmp piny
		
			
/////////////////////////////////////////////////////////////////////////////////////////
/////////kontrola vybití diody (na všech portech)///////////////////////////////
////////////////////////////////////////////////////////////////////////////////

Piny:		in R16, PINB			//tady je velmi šikovně nastavená priorita
			in R17, PIND			//nejdříve se zahlasi pin, ktery byl vybit nejdrive
			in R18, PINC			//takze by zjistovani mělo byt presnejsi
			cpi R16, 0b11111111
			brne sloupecekB
			cpi R17, 0b11111111
			brne sloupecekD
			andi R18, 0b00001111
			cpi R18, 0b00001111
			brne sloupecekC			//skoci jenom pokud zjisti, ze se nejaky pin vybil
									//a az pak teprve zjistuje ktery to byl
			in R18, PINC
			andi R18, 	0b00100000
			cpi R18, 	0b00100000	//kdyby už vystrelil nekdo jiny, je to smutne ale 
			breq nekdo_vystrelil		//musim to zaregistrovat a zapsat


			dec R19					//delku zjistovani urcuje cislo v R19
			brne dal_jen_dal	//pokus
			dec R20				//pokus
			breq start			//pokus

dal_jen_dal:rjmp piny
	
nekdo_vystrelil:	rcall cekejkontrola				//zjistí, jestli to nebyla chyba nebo třeba impuls reset	
					cpi R18, 0b00100000
					brne chyba			//pokud by už impuls ustal, byla to nejaka chyba
					rcall cekej04
					in R18, PINC
					andi R18, 0b00100000
					cpi R18, 0b00100000
					brne nulka
					rcall cekej04
					in R18, PINC
					andi R18, 0b00100000
					cpi R18, 0b00100000
					brne nulka			//pokud se vynuluje, byl to impuls od jineho segmentu
										//pokud je to dlouhy impuls je to reset
					rjmp reset

nulka:				rjmp fakt_ze_jo

chyba: rjmp piny

sloupecekB:	rcall SHORT_C		//400us impuls, že bylo něco trefeno
			ldi R19, 1				//index ze bylo zasazeno neco na b, R19= 1
			ldi osmickas, 8
sb:			mov R17, R16				//musim cislo z pinu nechat v nejakem registru 
			ldi ZH, high(radky<<1)	//jinak bych si ho porad prepisoval
			ldi ZL,  low(radky<<1)
			add ZL, osmickas		//indexování konrétní diody
			lpm radek, Z			
			or R17,radek			//maskování pinu

			cp R17, radek
			breq vybito				//pokud je na konkrétním pinu 0
									//skočí na vybito
			dec osmickas
			cpi osmickas, 0			//pokud ne, odečte počítadlo
			brne sb					//a jede znovu
			rjmp piny				//pokud nezjisti nic, skoci zpet na piny

sloupecekD:	rcall SHORT_C		//400us impuls, že bylo něco trefeno
			ldi osmickas, 8
			ldi R19, 3			//bylo zasazeno d, R19= 3
sd:			mov R16, R17
			ldi ZH, high(radky<<1)
			ldi ZL,  low(radky<<1)
			add ZL, osmickas		//indexování konrétní diody
			lpm radek, Z			
			or R16,radek			//maskování pinu

			cp R16, radek
			breq vybito				//pokud je na konkrétním pinu 0
									//skočí na vybito
			dec osmickas
			cpi osmickas, 0			//pokud ne, odečte počítadlo
			brne sd				//a jede znovu
	

			rjmp piny		///pokud nezjisti nic, skoci zpet na piny

sloupecekC: rcall SHORT_C		//400us impuls, že bylo něco trefeno
			ldi osmickas, 4
			ldi R19, 2			//zasazeno c R19 = 2
sc:   		mov R16, R18
			ldi ZH, high(radky<<1)
			ldi ZL,  low(radky<<1)
			add ZL, osmickas		//indexování konrétní diody
			lpm radek, Z			
			or R16,radek			//maskování pinu
			andi radek, 0b00001111	//poze katodove piny
			andi R16, 0b00001111
			cp R16, radek
			breq vybito				//pokud je na konkrétním pinu 0
									//skočí na vybito
			dec osmickas
			cpi osmickas, 0			//pokud ne, odečte počítadlo
			brne sc					//a jede znovu
			ldi osmickas,8

			rjmp piny


///////////////////////////////////////////////////////////////////////////////
/////konec kontroly, navrat do nabijeni////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////

			

vybito: ldi 	R16, 	0xFF	//všechny piny výstupní, anoda katoda budou svítit, 
		out 	DDRB, 	R16		//komunikace bude ven, ale ješte to nezapínám
		out 	DDRD, 	R16
		ldi 	R16,	0b00011111
		out 	DDRC, 	R16
		in 		R16, PINC
		ldi 	R17, 	0b00010000
		or		R16, 	R17	//na anode 1 - je připravena svítit	
		out 	PORTC,  R16

		cpi R19, 1			//rozsviti diodu podle toho, kde byla zasazena
		breq zasahB
		cpi R19, 3
		breq zasahD
		cpi R19, 2
		breq zasahC

zasahB:			out PORTB, radek
				ldi R16, 0xFF		//ostatni porty taky nebudou svitit ze?
				out PORTD, R16
				ldi R16, 0b00011111
				out PORTC, R16
				ldi ZH, 0x02		//pozice 0x0200
				ldi ZL, 0x00
				ld	R16, Z
				cpi R16, 0			//pokud tam neni nic napsane, napise to tam
				breq zapis_strely_B	// (index - B/C/D a radek strely)

zabranob:		cpi ZL, 200
				breq dal3 
	
				inc ZL				//pokud tam uz byla zapsana strela
				inc ZL				//prejdu o dve pole dal a zapisu to tam
				ld R16, Z			//kdyz tam neco jde jdu o dalsi dve pole
				
				cpi R16, 0
				brne zabranob
				
zapis_strely_B:	

				ldi R16, 1		//index béčka - 1
				st Z+, R16			//
				st Z, radek		//radek do vedlejsiho registru pameti
				
dal3:			rjmp dale			//jedem dal						

 		

zasahC:			andi radek, 0b00001111
				ori radek, 0b00010000		//porad musi byt zapnuta 
				out PORTC, radek	
				ldi R16, 0xFF
				out PORTB, R16		//ostatni porty taky nebudou svitit ze?
				out PORTD, R16
				ldi ZH, 0x02		//pozice 0x0200
				ldi ZL, 0x00
				ld	R16, Z
				cpi R16, 0			//pokud tam neni nic napsane, napise to tam
				breq zapis_strely_C	// (index - B/C/D a radek strely)

zabranoc:		cpi ZL, 200			//vic jak 100 střel nezapíše
				breq dal2 			

				inc ZL				//pokud tam uz byla zapsana strela
				inc ZL				//prejdu o dve pole dal a zapisu to tam
				ld R16, Z			//kdyz tam neco jde jdu o dalsi dve pole
				
				cpi R16, 0
				brne zabranoc
				
zapis_strely_C:	

				ldi R16, 2		//index cecka - 2
				st Z+, R16			//
				st Z, radek		//radek do vedlejsiho registru pameti
				
dal2:			rjmp dale			//jedem dal	



zasahD:			out PORTD, radek
				ldi R16, 0xFF		//ostatni porty taky nebudou svitit ze?
				out PORTB, R16
				ldi R16, 0b00011111
				out PORTC, R16
				ldi ZH, 0x02		//pozice 0x0200
				ldi ZL, 0x00
				ld	R16, Z
				cpi R16, 0			//pokud tam neni nic napsane, napise to tam
				breq zapis_strely_D	// (index - B/C/D a radek strely)

zabranod:		cpi ZL, 200
				breq dale 		
	
				inc ZL				//pokud tam uz byla zapsana strela
				inc ZL				//prejdu o dve pole dal a zapisu to tam
				ld R16, Z			//kdyz tam neco jde jdu o dalsi dve pole
				
				cpi R16, 0
				brne zabranod
				
zapis_strely_D:	ldi R16, 3		//index decka - 2
				st Z+, R16			//
				st Z, radek		//radek do vedlejsiho registru pameti
				
				rjmp dale			//jedem dal	
			

////////////////tady jsem ještě neopravoval///////////////

dale:		rcall indexik		//index zjistí index diody 
			rcall zasah			// zásah načte počet bodů konkrétní diody z adresy 0x0100+ZL
			rcall biatlon_zmeny 	//pokud je program biatlon ležka, znecitliví kruhy menší než 5 bodů
			rcall posli			//pošle impulsy atmeze5
			
			rcall cekej1		//rozsvícení trefené diody

			rjmp start			//back to start :)


////////////////////////////////////////////////////////////
////Tady je velký a mocný RESET/////////////////////
/////////////////////////////////////////////////
///ukaze trefene diody a vrátí se na uplny zacatek a všechno vynuluje//
////////////////////////////////////////////////////////////////////

reset:		ldi R20, 0	//pocitadlo kolik už jsem prošel
navrat:		ldi ZH, 2
			ldi ZL, 0
			add ZL, R20	//preskoci pozice ktere uz kontroloval
			

seg:		ld R16, Z	//naráni prvního místa pro střely
			cpi R16, 1
			breq segB
			cpi R16, 2
			breq segC
			cpi R16, 3
			breq segD	//ktery segment to je?

			inc ZL
			inc ZL
			inc R20
			inc R20

			cpi ZL, 200
			breq konec_zjistovani
			cpi ZL, 201	//pro jistotu obě nevím jak to funguje.
			breq konec_zjistovani
			
			rjmp seg	//pokud tam není 1 2 nebo 3, posune se na další pozici

konec_zjistovani:
			rjmp vysledek_ukaz

segB:		inc ZL
			ld R16, Z
			ldi ZH, 1
			ldi ZL, 0x30
			cpi R16, 0b11111110
			breq B0
			cpi R16, 0b11111101
			breq B1
			cpi R16, 0b11111011
			breq B2
			cpi R16, 0b11110111
			breq B3
			cpi R16, 0b11101111
			breq B4
			cpi R16, 0b11011111
			breq B5
			cpi R16, 0b10111111
			breq B6
			cpi R16, 0b01111111
			breq B7

segC:		inc ZL
			ld R16, Z
			andi R16, 0b00001111
			ldi ZH, 1
			ldi ZL, 0x40
			cpi R16, 0b00001110
			breq C0
			cpi R16, 0b00001101
			breq C1
			cpi R16, 0b00001011
			breq C2
			cpi R16, 0b00000111
			breq C3

segD:		inc ZL
			ld R16, Z
			ldi ZH, 1
			ldi ZL, 0x48
			cpi R16, 0b11111110
			breq D0
			cpi R16, 0b11111101
			breq D1
			cpi R16, 0b11111011
			breq D2
			cpi R16, 0b11110111
			breq D3
			cpi R16, 0b11101111
			breq D4
			cpi R16, 0b11011111
			breq D5
			cpi R16, 0b10111111
			breq D6
			cpi R16, 0b01111111
			breq D7	

b0:	ldi R16, 0
	rjmp zapis_vysledek
b1:	ldi R16, 2
	rjmp zapis_vysledek
b2: ldi R16, 4
	rjmp zapis_vysledek
b3: ldi R16, 6
	rjmp zapis_vysledek
b4: ldi R16, 8
	rjmp zapis_vysledek
b5: ldi R16, 10
	rjmp zapis_vysledek
b6: ldi R16, 12
	rjmp zapis_vysledek
b7: ldi R16, 14
	rjmp zapis_vysledek
C0: ldi R16, 0
	rjmp zapis_vysledek
c1: ldi R16, 2
	rjmp zapis_vysledek
c2: ldi R16, 4
	rjmp zapis_vysledek
c3: ldi R16, 6
	rjmp zapis_vysledek
d0: ldi R16, 0
	rjmp zapis_vysledek
d1: ldi R16, 2
	rjmp zapis_vysledek
d2: ldi R16, 4
	rjmp zapis_vysledek
d3: ldi R16, 6
	rjmp zapis_vysledek
d4: ldi R16, 8
	rjmp zapis_vysledek
d5: ldi R16, 10
	rjmp zapis_vysledek
d6: ldi R16, 12
	rjmp zapis_vysledek
d7: ldi R16, 14
	rjmp zapis_vysledek

zapis_vysledek: add ZL, R16
				ld R17, Z
				cpi R17, 3
				breq tri_a_vice 	//pokud byla nektera dioda zasazena 3 a vice krat
				inc R17				//bude tam vzdycky maximalnne 3
tri_a_vice:		st	Z, R17
				inc R20
				inc R20
				rjmp navrat

////////////////////////////////////////////////////////////////
//////mam zapsane vsechny vystrely a ted tam kde je jednicka budu svitit trosicku
////tam kde je 2 trosku vice 
/////a tam kde je trojka úplně nejvic :)

vysledek_ukaz: 	ldi R17, 0		//tady se bude orovat výsledek
				ldi R18, 0		//2 zasahy
				ldi R19, 0		//3 zasahy
				ldi ZH, 1
				ldi ZL, 0x30
v_becko:		cpi ZL, 0x40
				breq v_cecko_pom
				ld R16, Z
				cpi R16, 1
				breq Bjeden_zasah
				cpi R16, 2
				breq Bdva_zasahy
				cpi R16, 3
				breq Btri_zasahy
				inc ZL
				inc ZL
				rjmp v_becko

v_cecko_pom:	or R17, R18
				or R17, R19
				or R18, R19		// aby se i dvojit zasahy dostali do jednoduchych a tak...
				ldi ZL, 0x1E
				st Z, R17
				ldi ZL, 0x1F
				st Z, R18
				ldi ZL, 0x20
				st Z, R19

				ldi R17, 0		//tady se bude orovat výsledek
				ldi R18, 0		//2 zasahy
				ldi R19, 0		//3 zasahy
				ldi ZL, 0x40 
				rjmp v_cecko

Bjeden_zasah:	inc ZL
				ld R20, Z		// konkretni bit
				or R17, R20		//R17 se pak bude nahravat zpet na port 
				inc ZL
				rjmp v_becko

Bdva_zasahy:	inc ZL
				ld R20, Z		// konkretni bit
				or R18, R20		//R18 se pak bude nahravat zpet na port 
				inc ZL
				rjmp v_becko

Btri_zasahy:	inc ZL
				ld R20, Z		// konkretni bit
				or R19, R20		//R19 se pak bude nahravat zpet na port 
				inc ZL
				rjmp v_becko
///////////////////////////////////////////////////////////////////////////////////úú
//////////napocitani vysledku cecka///////////////////////////
v_cecko:		cpi ZL, 0x48
				breq v_decko_pom
				ld R16, Z
				cpi R16, 1
				breq Cjeden_zasah
				cpi R16, 2
				breq Cdva_zasahy
				cpi R16, 3
				breq Ctri_zasahy
				inc ZL
				inc ZL
				rjmp v_cecko

v_decko_pom:	or R17, R18
				or R17, R19
				or R18, R19		// aby se i dvojit zasahy dostali do jednoduchych a tak...
				ldi ZL, 0x21
				st Z, R17
				ldi ZL, 0x22
				st Z, R18
				ldi ZL, 0x23
				st Z, R19

				ldi R17, 0		//tady se bude orovat výsledek
				ldi R18, 0		//2 zasahy
				ldi R19, 0		//3 zasahy
				
				ldi ZL, 0x48
				rjmp v_decko

Cjeden_zasah:	inc ZL
				ld R20, Z		// konkretni bit
				or R17, R20		//R17 se pak bude nahravat zpet na port 
				inc ZL
				rjmp v_cecko

Cdva_zasahy:	inc ZL
				ld R20, Z		// konkretni bit
				or R18, R20		//R18 se pak bude nahravat zpet na port 
				inc ZL
				rjmp v_cecko

Ctri_zasahy:	inc ZL
				ld R20, Z		// konkretni bit
				or R19, R20		//R19 se pak bude nahravat zpet na port 
				inc ZL
				rjmp v_cecko


///////////////////////////////////////////////////////////////////////////////////úú
//////////napocitani vysledku decka///////////////////////////
v_decko:		cpi ZL, 0x58
				breq v_konec
				ld R16, Z
				cpi R16, 1
				breq Djeden_zasah
				cpi R16, 2
				breq Ddva_zasahy
				cpi R16, 3
				breq Dtri_zasahy
				inc ZL
				inc ZL
				rjmp v_decko

v_konec:		or R17, R18
				or R17, R19
				or R18, R19		// aby se i dvojit zasahy dostali do jednoduchych a tak...
				ldi ZL, 0x24
				st Z, R17
				ldi ZL, 0x25
				st Z, R18
				ldi ZL, 0x26
				st Z, R19
				rjmp vy_konec

Djeden_zasah:	inc ZL
				ld R20, Z		// konkretni bit
				or R17, R20		//R17 se pak bude nahravat zpet na port 
				inc ZL
				rjmp v_decko

Ddva_zasahy:	inc ZL
				ld R20, Z		// konkretni bit
				or R18, R20		//R18 se pak bude nahravat zpet na port 
				inc ZL
				rjmp v_decko

Dtri_zasahy:	inc ZL
				ld R20, Z		// konkretni bit
				or R19, R20		//R19 se pak bude nahravat zpet na port 
				inc ZL
				rjmp v_decko
///////////////////////////////////////////////////////////////////////úú
////////na pozicich 0x011E - 0126 mám devět čísel, ktere charakterizují ktere diody byly kolikrat trefeny
////////pozice 1E obsahuje diody portu B trefeny 1x
///////pozice 26 obsahuje diody portu D trefeny 3x
/////no a ted bych s temi didoami teda mel svitit

vy_konec: 		ldi R16, 0b00011111
				out DDRC, R16
				ldi R16, 0xFF
				out DDRB, R16
				out DDRD, R16
				ldi R16, 0b00010000
				out PORTC, R16

				ldi R21, 1
diodky_sviti1:	ldi R22, 0	
diodky_sviti:	ldi ZH, 1
				ldi ZL, 0x1E
				ld R17, Z	//becko
				ldi ZL, 0x21
				ld R18, Z	//cecko
				andi R18, 0b00001111
				ldi ZL, 0x24
				ld R19, Z	//decko
				com R17
				com R18
				ori R18, 0b00010000
				com R19
				out PORTB, R17
				out PORTC, R18
				out PORTD, R19

				rcall cekejkontrola		//intenzita jednou trefenych diod
				rcall cekejkontrola

				
				ldi R16, 0xFF
				out PORTD, R16
				out PORTB, R16
				ldi R16, 0b00011111
				out PORTC, R16

				
				
				rcall cekej10

				ldi ZH, 1
				ldi ZL, 0x1F
				ld R17, Z	//becko
				ldi ZL, 0x22
				ld R18, Z	//cecko
				andi R18, 0b00001111
				ldi ZL, 0x25
				ld R19, Z	//decko
				com R17
				com R18
				ori R18, 0b00010000
				com R19
				out PORTB, R17
				out PORTC, R18
				out PORTD, R19

				rcall cekejkontrola		//intenzita dvakrát trefenych diod
				rcall cekejkontrola
				rcall cekejkontrola
				rcall cekejkontrola

				ldi R16, 0xFF
				out PORTD, R16
				out PORTB, R16
				ldi R16, 0b00011111
				out PORTC, R16

				
				rcall cekej10

				ldi ZH, 1
				ldi ZL, 0x20
				ld R17, Z	//becko
				ldi ZL, 0x23
				ld R18, Z	//cecko
				andi R18, 0b00001111
				ldi ZL, 0x26
				ld R19, Z	//decko
				com R17
				com R18
				ori R18, 0b00010000
				com R19
				out PORTB, R17
				out PORTC, R18
				out PORTD, R19

				
				rcall cekej04			//intenzita tříkrát trefenych diod
				rcall cekej04
				rcall cekejkontrola
				

				ldi R16, 0xFF
				out PORTD, R16
				out PORTB, R16
				ldi R16, 0b00011111
				out PORTC, R16

				
				rcall cekej10


				dec R22
				brne diodky_sviti3
				dec R21
				brne diodky_sviti4
			//	rjmp impuls
				rjmp zac



diodky_sviti3:	rjmp diodky_sviti	//pomocne skoky
diodky_sviti4:	rjmp diodky_sviti1



/////////////////////////////////////////////////////////////////
////podprogramy///////////////////////////////////////////
//////////////////////////////////////////////////////////////
//toto neni uplne podprogram////////////////////////////////////////
///zarizuje, zapis strely, kdyz byl zasazeny jiný segment terce/////
/////////////////////////////////////////////////////////////////////

fakt_ze_jo:		ldi R17, 0			//toto bude index strely
				ldi ZH, 0x02		//pozice 0x0200
				ldi ZL, 0x00
				ld	R16, Z
				cpi R16, 0			//pokud tam neni nic napsane, napise to tam
				breq zapis_strely	// (index - B/C/D a radek strely)

zabrano:		cpi ZL, 100
				breq zpet
				
				inc ZL				//pokud tam uz byla zapsana strela
				inc ZL				//prejdu o dve pole dal a zapisu to tam
				ld R16, Z			//kdyz tam neco jde jdu o dalsi dve pole
				
				cpi R16, 0
				brne zabrano
				
zapis_strely:	ldi R16, 0xFF
				st Z, R16			//terc zasahlo neco jineho, neindexuji nic
				inc ZL
				st Z, R16		//ani strela nema index
				
zpet:			rcall cekej200	
				rjmp start			//pocka 200ms na ustaleni a strilime dal			

/////////////////////////////////////////////////////////////////////////////////////
/////////////na miste 02xx přibyla dalši "prazdna strela"////////////////////
/////////////////////////////////////////////////////////////////////////////


indexik:	cpi R19, 1	//B
			breq i1
			cpi R19, 2
			breq i2
			cpi R19, 3
			breq i3

i1:			ldi R16, 0
			add index, R16
			rjmp i4
i2:			ldi R16, 8
			add index, R16
			rjmp i4
i3:			ldi R16, 12
			add index, R16
		//	rjmp i4
i4:			add index, osmickas		//ted mam v indexu presne identifikovanou trefenou diodu (1-20)
			ret						//pomoci zasah zjistim jake cislo jsem trefil


	
///////////////////////////////////////////////////////////////////////////////
zasah:		dec index		//bez toho nějak haprovalo načítání diod
			ldi ZH, 1
			ldi ZL, 0
			add ZL, index
			ldi index, 0
			ld R19, Z			//ted mam v R19 hodnotu zasahu a můžu jí poslat do Atmegy5
								// ve formě 400us impulsu
			ret
/////////////////////////////////////////////////////////////////////////////////////////////////
biatlon_zmeny:
			ldi ZH, 0x01		//nejdříve zjistím jestli jde o biatlon
			ldi ZL, 0xFF
			ld R16, Z
			cpi R16, 5			//v 0x01FF je uloženo číslo 4 pak je to biatlon ležka
			breq biatlon_lezka
			cpi R16, 4			//biatlon stojka
			breq biatlon_stojka
neni_biatlon: ret				//není to program biatlon - jedeme normálně dále

biatlon_lezka:		//pokud se na adrese nachází číslo menší než 7 (menší než 5 bodů) 
			cpi R19, 7			//pošle v dalším programu impuls 0 bodů
			brcc trefil			//pokud je počet bodů na diodě menší než 5 (R19 = 7) pak ho vynuluji (R19=2)
			ldi R19, 2
			ret	
biatlon_stojka:
trefil:		ldi R19, 3			//trefa zapíše do R19=3, což je jakože zásah 1 - pošle impulsy jako zásah diody s 1 bodem
			ret					

///////////////////////////////////////////////////////////////////////////////////
posli:			//poslání impulsů do atmegy5!!!
			in R16, PINC			//maska C portu
			mov R17, R16			//0bxx1xxxxx - R17
			andi R16, 0b11011111	//0bxx0xxxxx - R16
			ori R17, 0b00100000
			ldi R18, 0b00111111
			out DDRC, R18			//bez toho nemuzu posilat impuly
			
						
smycka1:	out PORTC, R17		//smycka jednoho 400us impulsu
			rcall cekej04
			out PORTC, R16
			rcall cekej04
			dec R19				//zaridi akuratni pocet impulsicku
			cpi R19, 0
			brne smycka1
			
		//	out PORTC, R16
			ldi R16, 0b00011111
			out DDRC, R16
						//dokonceno odesilani, C5 opět vstupni

			
			ret
//////////////////////////////////////////////////////////////////////////////////////		
///////////PRSTEN - má rozsvítit prstenec, kde jsou hodnoty 0///////////////
/////////////////////////////////////////////////////////////////////////////
//////pokud se v adrese diody narazí na 2 (odpovídá nule) pak se rozsvítí///

prsten0_zapis:
			ldi R17, 0xFF		//B
			ldi R18, 0x1F		//C (0b00011111)
			ldi R19, 0xFF		//D
			ldi ZH, 01
			ldi ZL, 0
			rjmp P0_skok2

P0_skok:	inc ZL
P0_skok2:	cpi ZL, 0x14		//zkontrolovány všechny pozice, končí zápis
			breq P0_konec
			ld R16, Z
			cp R16, R20			//porovnání který prstenec má svítit
			breq prstenON
			cpi R16, 12 		// i pro prostřední diodu (10)
			breq prstenON

			rjmp P0_skok

P0_konec: 	ldi ZH, 01		//zapise porty a vrati se
			ldi ZL, 0x60
			st	Z+, R17		//zzapis B
			st  Z+, R18		//zapis C
			st  Z+, R19		//zapis D
			ret		

prstenON:	cpi ZL, 0x00				//tady vždycky projde všemi pozicemi a 
			brne P0_B1				//tam kde je nula, andiuje příslušný registr
			andi R17, 0b11111110
P0_B1:		cpi ZL, 0x01
			brne P0_B2
			andi R17, 0b11111101
P0_B2:		cpi ZL, 0x02
			brne P0_B3
			andi R17, 0b11111011
P0_B3:		cpi ZL, 0x03
			brne P0_B4
			andi R17, 0b11110111
P0_B4:		cpi ZL, 0x04
			brne P0_B5
			andi R17, 0b11101111
P0_B5:		cpi ZL, 0x05
			brne P0_B6
			andi R17, 0b11011111
P0_B6:		cpi ZL, 0x06
			brne P0_B7
			andi R17, 0b10111111
P0_B7:		cpi ZL, 0x07
			brne P0_C0
			andi R17, 0b01111111

P0_C0:		cpi ZL, 0x08				
			brne P0_C1			
			andi R18, 0b11111110
P0_C1:		cpi ZL, 0x09
			brne P0_C2
			andi R18, 0b11111101
P0_C2:		cpi ZL, 0x0A
			brne P0_C3
			andi R18, 0b11111011
P0_C3:		cpi ZL, 0x0B
			brne P0_D0
			andi R18, 0b11110111

P0_D0:		cpi ZL, 0x0C				
			brne P0_D1				
			andi R19, 0b11111110
P0_D1:		cpi ZL, 0x0D
			brne P0_D2
			andi R19, 0b11111101
P0_D2:		cpi ZL, 0x0E
			brne P0_D3
			andi R19, 0b11111011
P0_D3:		cpi ZL, 0x0F
			brne P0_D4
			andi R19, 0b11110111
P0_D4:		cpi ZL, 0x10
			brne P0_D5
			andi R19, 0b11101111
P0_D5:		cpi ZL, 0x11
			brne P0_D6
			andi R19, 0b11011111
P0_D6:		cpi ZL, 0x12
			brne P0_D7
			andi R19, 0b10111111
P0_D7:		cpi ZL, 0x13
			brne P0_konec2
			andi R19, 0b01111111
P0_konec2:	rjmp P0_skok	







	


/////////////////////////////////////////////////
//diody s danymi cisly zapsany, budou svitit///
////////PRSTEN rozsviti všechny diody daneho prstence///
////////////////////////////////////////////////

prsten:		ldi R16, 0xFF
			out DDRB, R16
			out PORTB, R16		//nesvítíci katoda je 1
			out DDRD, R16
			out PORTD, R16
			ldi R16, 0b000011111
			out DDRC, R16		//nastavení katod a anody na výstupní
			ldi R16, 0b000011111
			out PORTC, R16		//anoda je 1

			ldi ZH, 01
			ldi ZL, 0x60
			ld R16, Z+
			out PORTB, R16
			ld R16, Z+
			out PORTC, R16
			ld R16, Z
			out PORTD, R16

			rcall cekejkontrola		//nesmí čekat dlouho protože to běží ve chvíli, kdy běží 
									//i program PINY a mohlo by to ohrozit signál z jiné atmegy
			ret


////////////////////////////////////////////////////////////////////////
//////krátký impuls pro to, aby segmenty okamžitě daly vědět ostatním, že
//////byly zasažený//////, provede okamžítě po přijetí střely impuls na C5 

SHORT_C: 	in R19, PINC			//maska C portu
			mov R22, R19			//0bxx1xxxxx - R17
			andi R19, 0b11011111	//0bxx0xxxxx - R16
			ori R22, 0b00100000
			ldi R21, 0b00111111
			out DDRC, R21			//bez toho nemuzu posilat impuly
			
			out PORTC, R22		//smycka jednoho 400us impulsu
			rcall cekej04
			out PORTC, R19
			rcall cekejkontrola	//už není nutné celých 400us páč před další hranou se ještě dělají výpočty
			ret
						

/////////////////////////////////////////////////////////////////////////////
///zpozdeni////////////////////////////////////////
//////////////////////////////////////////////////////////////

cekej1:
			ldi R17, 2		//cca 1s (R17 5)
	n1:		ldi R18, 0
	n2:		ldi R20, 0
	n3:		dec R20
		
			brne n3
			dec R18
			brne n2
			dec R17
			brne n1
	
				ret

cekej200:	ldi R20, 1			//cca 200ms (R17 1)
	m1:		ldi R18, 120
	m2:		ldi R21, 0
	m3:		dec R21
		
			brne m3
			dec R18
			brne m2
			dec R20
			brne m1
				ret

cekej24:
			 						//cca 24mss (R17 neni)
			ldi R18, 60
	h1:		ldi R19, 0
	h2:		dec R19
		
			brne h2
			dec R18
			brne h1
			
		
	
				ret

cekej10:
			 						
			ldi R18, 100
	g1:		ldi R19, 10
	g2:		dec R19
		
			brne g2
			dec R18
			brne g1
			
		
	
				ret

cekej04:		//cca 400us (R19 = 132)
			ldi R20, 132
	w1:		dec R20
			brne w1
			ret





cekej01:
			 						
			ldi R18, 20
	f1:		ldi R19, 1
	f2:		dec R19
		
			brne f2
			dec R18
			brne f1
			ret

cekejkontrola:
			 						//cca 54us (R19 = 18)
			ldi R20, 18
	v1:		dec R20
			brne v1
			ret



nop 
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop //nopy jsou tu proto, že mi přetekal registr 
nop	// ZL na čteni z paměti programu, proto takhle 
nop	// tabulky radky a sloupce posunu o par mist dal
nop
nop
nop
nop
nop
nop
nop		


radky:
//.db 0b00000001,0b00000010,0b00000100,0b00001000,0b00010000,0b00100000,0b01000000,0b10000000
.db 0,0b11111110,0b11111101,0b11111011,0b11110111,0b11101111,0b11011111,0b10111111,0b01111111
sloupce:
.db 0,0b11111110,0b11111101,0b11111011,0b11110111,0b11101111,0b11011111,0b10111111,0b01111111

matice:
.db 1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,3,3,3,3,3,3,3,4,4,4,4,4,4,5,5,5,5,5,6,6,6,6,6,7,7,7,7,7,8,8,8,8,8,9,9,9,9,9,9,9,10,10,10,10,10,10,10
