.include "m32def.inc"


.def temp1=r16
.def temp2=r17
.def temp3=r18
.def temp4=r19
;benutze r22-r25 in der shuffle funktion als zähler(counter) für programmabläufe deshalb nit mehr benutzen


.equ	MMC_Write	=PORTB		;//Port an der die MMC/SD-Karte angeschlossen ist also des SPI 
.equ 	MMC_Read	=PINB
.equ	MMC_Dir		=DDRB	
	
.equ	SPI_DI		=6		;//Port Pin an dem Data Output der MMC/SD-Karte angeschlossen ist 
.equ	SPI_DO		=5		;//Port Pin an dem Data Input der MMC/SD-Karte angeschlossen ist
.equ	SPI_Clock	=7		;//Port Pin an dem die Clock der MMC/SD-Karte angeschlossen ist (clk)
.equ	MMC_Chip_Select	=4		;//Port Pin an dem Chip Select der MMC/SD-Karte angeschlossen ist


.equ CLOCK = 16000000
.equ BAUD = 9600
.equ UBRRVAL = CLOCK/(BAUD*16)-1


ldi temp1, 0x00
sts vorspulabfrage, temp1


ldi temp1, 0x00
out DDRA, temp1

ldi temp1, 0x00
sts Volume_set, temp1					;TDA steht am anfang nach TWI_init auf 0db !!!

ldi temp1, 0x04
ldi temp2, 0x04

sts BASS_set, temp1							;anfangsweerte der bass geschichte
sts TREBBLE_set, temp2

ldi temp1, 0x01
sts GAIN_set, temp1



	   ldi temp1, LOW(RAMEND)      ; LOW-Byte der obersten RAM-Adresse
           out SPL, temp1
           ldi temp1, HIGH(RAMEND)     ; HIGH-Byte der obersten RAM-Adresse
           out SPH, temp1




start:

					; Baudrate einstellen
        ldi temp1, LOW(UBRRVAL)
        out UBRRL, temp1
        ldi temp1, HIGH(UBRRVAL)
        out UBRRH, temp1

        ; Frame-Format: 8 Bit
        ldi temp1, (1<<URSEL)|(3<<UCSZ0)
        out UCSRC, temp1

        sbi UCSRB,TXEN 			;usart an

	




		call lcd_init
		call FUBU_font
		call TWI_init
		



MP3_song_start:

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;





;-----------------------------------------------------------------
;Mainbootrecord lesen
;------------------------------------------------------------------	
	ldi temp1, 0x00
	sts addresse, temp1
	sts addresse+1, temp1
	sts addresse+2, temp1
	sts addresse+3, temp1


	call VS1002_init

	call spi_init
	call mmc_init
	
	call Read_Block_MMC	;liest das cluster 0 von der MMc karte


	ldi ZL, LOW(cluster*2)
	ldi ZH, HIGH(cluster*2)
	adiw ZH:ZL, 0x3F
	adiw ZH:ZL, 0x3F
	adiw ZH:ZL, 0x3F
	adiw ZH:ZL, 0x3F
	adiw ZH:ZL, 0x3F
	adiw ZH:ZL, 0x3F
	adiw ZH:ZL, 0x3F
	adiw ZH:ZL, 0x0D		;ergibt zusammen 0x1C6, das offset von VBR(partition1)
	
	ld temp1, Z+
	ld temp2, Z+			;addressen müsen noch in bytes für mmc addressierung umgewandelt
	ld temp3, Z+	;werden(x512), deswegen acht nullen auf lsb setzen und lsl einmal
	ld temp4, Z+

	ldi r20, 0x00

	lsl temp4
	lsl temp3
	adc temp4, r20
	lsl temp2
	adc temp3, r20
	lsl temp1
	adc temp2, r20

	sts VBR_start+3, r20
	sts VBR_start+2, temp1
	sts VBR_start+1, temp2
	sts VBR_start, temp3


;----------------------------------------------------
;Volumebootrecord lesen
;----------------------------------------------------
		
	lds temp1, VBR_start
	sts addresse, temp1
	lds temp1, VBR_start+1
	sts addresse+1, temp1
	lds temp1, VBR_start+2
	sts addresse+2, temp1
	lds temp1, VBR_start+3
	sts addresse+3, temp1

lds r15, VBR_start
lds r14, VBR_start+1
lds r13, VBR_start+2
lds r12, VBR_start+3


	
	call Read_Block_MMC	;liest das VBR von der MMc karte


ldi ZL, LOW(cluster*2)
	ldi ZH, HIGH(cluster*2)
	adiw ZH:ZL, 0x0D			;Sektoren pro Cluster
	ld temp1, Z+
	sts sectors_per_cluster, temp1

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
	ldi temp2, 0x04
	mul temp1, temp2
	mov r20, r0
	ldi r21, 0x01
	
	clr temp1
	clr temp2
	clr temp3
	ldi temp4, 0x80

sectors_rechnung:

	add temp1, temp4
	adc temp2, temp3

	sub r20, r21
	cp r20, temp3
	breq VBR_weiter
	rjmp sectors_rechnung

VBR_weiter:

	sts sectors_per_cluster_end, temp2
	sts sectors_per_cluster_end+1, temp1
	
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;



ldi ZL, LOW(cluster*2)
	ldi ZH, HIGH(cluster*2)
	adiw ZH:ZL, 0x0E			;FAT anfang errechnen
	ld r20, Z+
	ld r21, Z+
	ldi r22, 0x00
	ldi r23, 0x00

	lsl r21
	adc r22, r23
	lsl r20
	adc r21, r23
	
	
sts VBR_start, r15
sts VBR_start+1, r14
sts VBR_start+2, r13	
sts VBR_start+3, r12



	lds temp1, VBR_start
	lds temp2, VBR_start+1
	lds temp3, VBR_start+2
	lds temp4, VBR_start+3

add temp4, r23
adc temp3, r20
adc temp2, r21
adc temp1, r22

sts FAT_start, temp1
sts FAT_start+1, temp2
sts FAT_start+2, temp3
sts FAT_start+3, temp4			
	


ldi ZL, LOW(cluster*2)
	ldi ZH, HIGH(cluster*2)
	adiw ZH:ZL, 0x16				;ROOT directory anfang errechnen
	ld r20, Z+
	ld r21, Z+
	ldi r22, 0x00
	ldi r23, 0x00

ldi r24, 0x00


	lsl r21
	adc r22, r23
	lsl r20
	adc r21, r23


	

	ldi ZL, LOW(cluster*2)
	ldi ZH,HIGH(cluster*2)
	adiw ZH:ZL, 0x10
	ld temp1, Z+					;2te byte egal da immer "2"

	mov r15, temp1




rechnung_root:
			lds temp1, FAT_start
			lds temp2, FAT_start+1
			lds temp3, FAT_start+2
			lds temp4, FAT_start+3

fattable_2:
			add temp4, r23
			adc temp3, r20
			adc temp2, r21
			adc temp1, r22

			sts ROOT_start, temp1
			sts ROOT_start+1, temp2
			sts ROOT_start+2, temp3
			sts ROOT_start+3, temp4


			ldi r25, 0x01
			dec r15
			cp r15, r25		;wenn 2 fat tabellen nochmal addieren
			breq fattable_2
				



;datenbereich ermitteln
;muss nicht berechnet werden da bei fat16 32 sektoren

lds temp1, ROOT_start
lds temp2, ROOT_start+1
lds temp3, ROOT_start+2
lds temp4, ROOT_start+3

ldi r20, 0x20
ldi r21, 0x00

lsl r20

add temp4, r21
adc temp3, r20
adc temp2, r21
adc temp1, r21

sts DATA_start, temp1
sts DATA_start+1, temp2
sts DATA_start+2, temp3
sts DATA_start+3, temp4


rjmp ROOT_read




;-----------------------------------------------------------------
;Verzeichnisseinträge lesen, erster sektor und eventuell folgende
;-----------------------------------------------------------------
ROOT_read:


	lds temp1, ROOT_start
	sts addresse, temp1
	lds temp1, ROOT_start+1
	sts addresse+1, temp1
	lds temp1, ROOT_start+2
	sts addresse+2 ,temp1
	lds temp1, ROOT_start+3
	sts addresse+3, temp1

	
	call Read_Block_MMC	;liest die Verzeichnisseinträge von der MMc karte


	ldi r23, 0x20			;zähler für das ende der ROOT directory !!!!!!!	
	ldi r24, 0x00

	ldi YL, LOW(ROOT_ram*2)		;setzen des Y pointers auf die Anfangsadresse von ROOT_ram
	ldi YH, HIGH(ROOT_ram*2)

	sts root_counter_ende, r24		;zähler für die anzahl der lieder
	sts root_counter_anfang,r24	;
	

root_show:	
				
	ldi r24, 0x00			;zähler bis 16 damit man weiss wo 512 byte enden
					
	ldi ZL, LOW(cluster*2)	;setzen des Z pointers auf die Anfangsadresse von cluster
	ldi ZH, HIGH(cluster*2)

root_show1:

			ld temp1, Z+
			cpi temp1, 0xE0			;gucken ob erstes byte grösser als 0xE0, bedeutet eintrag leer
			brsh jump_32byte1
			cpi temp1, 0x00
			breq root_ende				;falls 0x00, letzter eintrag danach alle leer
			rjmp root_save

root_ende:
			rjmp root_ausgelesen

jump_32byte1:
			rjmp jump_32byte		;verlängerung des sprunges






root_am_ende1:
			rjmp root_am_ende
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


;__________________________________________________________________________________
;----------------------------------------------------------------------------------
;___________________________________________________________________________________
;-------------------------------------------------------------------------------------;-----------------------------------------------------------------------------------

;muss alles geändert werden wegen anderem LCD!!!!!!!!!!!!

;-------------------------------------------

lcd_show:		
			
				ldi ZL, LOW(ROOT_ram*2)		;setzen des Z pointers auf die Anfangsadresse von ROOT_ram
				ldi ZH, HIGH(ROOT_ram*2)

				lds temp1, root_counter_anfang
				lds temp2, root_counter_ende
				cp temp1, temp2
				breq root_am_ende1

		root_suche:
				cpi temp1, 0x00
				breq root_find
				adiw ZH:ZL, 0x0E
				dec temp1
				rjmp root_suche

		root_find:
				
			
				call lcd_clear

				ldi temp1, 0xB9
				call lcd_command_left
				ldi temp1, 0x41
				call lcd_command_left

				

				
				ld temp1, Z+
				call alphabet_search_left	
				ld temp1, Z+
				call alphabet_search_left
				ld temp1, Z+
				call alphabet_search_left
				ld temp1, Z+
				call alphabet_search_left
				ld temp1, Z+
				call alphabet_search_left
				ld temp1, Z+
				call alphabet_search_left
				ld temp1, Z+
				call alphabet_search_left
				ld temp1, Z+
				call alphabet_search_left
;___________________________________________________________________________________
;---------------------------------------------------------------------------------
;____________________________________________________________________________________
;------------------------------------------------------------------------------------


			
				ld temp1, Z+
				sts first_DATA_cluster+1, temp1
			
				ld temp1, Z+
				sts first_DATA_cluster, temp1

				ld temp1, Z+
				sts MP3_data_length+3,temp1
				sts MP3_data_length_end+3, temp1
				ld temp1, Z+
				sts MP3_data_length+2, temp1
				sts MP3_data_length_end+2, temp1
				ld temp1, Z+
				sts MP3_data_length+1, temp1
				sts MP3_data_length_end+1, temp1
				ld temp1, Z+
				sts MP3_data_length, temp1
				sts MP3_data_length_end, temp1

				call FRAMEHEADER


				call ID3_TAG

				rcall FAT_read

				lds temp1, root_counter_anfang
				inc temp1
				sts root_counter_anfang, temp1


				rjmp lcd_show

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


jump_32byte:
				inc r24
				cpi r24, 0x10			;gucken ob 512byte counter schon erreicht ost
				breq jump_next_sector

				ldi ZL, LOW(cluster*2)
				ldi ZH,HIGH(cluster*2)

				mov temp1, r24

			still_jump:

					adiw ZH:ZL, 0x20
					dec temp1
					cpi temp1, 0x00
					brne still_jump

					rjmp root_show1




root_ausgelesen1:
				rjmp root_ausgelesen



jump_next_sector:
				dec r23
				cpi r23, 0x00
				breq root_ausgelesen1


				lds temp1, ROOT_start
				lds temp2, ROOT_start+1
				lds temp3, ROOT_start+2
				lds temp4, ROOT_start+3
				
				ldi r21, 0x00
				mov r14, r21
				ldi r21, 0x02			;setzen der addierungsrgister für 512 byte erhöhung
				mov r15, r21
				
				mov r22, r23	;sichern des ROOT zählers in r22				
jump_512byte:
				add temp3, r15
				adc temp2, r14
				adc temp1, r14			;erhöhung um 512 byte

				inc r22
				cpi r22, 0x20			;solange springen bis zähler wieder 32(0x20)
				brne jump_512byte

				sts addresse, temp1
				sts addresse+1, temp2		;speichern der neuen addressen
				sts addresse+2, temp3
				sts addresse+3, temp4

	
				rcall Read_Block_MMC	;liest die Verzeichnisseinträge von der MMc karte
				rjmp root_show




root_save:
				st Y+, temp1	;erste byte iss ja schon in temp1 geladen !!!!!!!
				ld temp1, Z+	
				st Y+, temp1	
				ld temp1, Z+
				st Y+, temp1
				ld temp1, Z+
				st Y+, temp1
				ld temp1, Z+
				st Y+, temp1
				ld temp1, Z+
				st Y+, temp1
				ld temp1, Z+
				st Y+, temp1
				ld temp1, Z+
				st Y+, temp1
;___________________________________________________________________________________
;---------------------------------------------------------------------------------
;____________________________________________________________________________________
;------------------------------------------------------------------------------------


				adiw ZH:ZL, 0x12
				ld temp1, Z+
				st Y+, temp1			;das ist first_data_cluster+1
				ld temp1, Z+
				st Y+, temp1			;das ist first_data_cluster

				ld temp1, Z+
				st Y+, temp1				;das ist MP3_data_length+3
									;das ist MP3_data_length_end+3
				ld temp1, Z+
				st Y+, temp1				;das ist MP3_data_length+2
									;das ist MP3_data_length_end+2
				ld temp1, Z+
				st Y+, temp1				;das ist MP3_data_length+1
									;das ist MP3_data_length_end+1
				ld temp1, Z+	
				st Y+, temp1				;das ist MP3_data_length
									;das ist MP3_data_length_end
	

				lds temp1, root_counter_ende
				inc temp1
				sts root_counter_ende, temp1

				rjmp root_show_berechnung



jump_next_sector1:
				rjmp jump_next_sector


root_show_berechnung:
				lds temp1, ROOT_start		;ursprüngliche addresse wiederherstellen vor dem verlassen zur FAT_read!!
				lds temp2, ROOT_start+1
				lds temp3, ROOT_start+2
				lds temp4, ROOT_start+3

				mov r22, r23

last_address1:

	
				cpi r22, 0x00
				breq root_ausgelesen			;gucken ob fat-ende

									;gucken ob sich mehr als 512byte verändert haben
				cpi r22, 0x20
				breq last_address2

				inc r22					;falls keine 512byte rum weiter in der root und vorher um 32byte erhöhen
				ldi r20, 0x02
				ldi r21, 0x00
				add temp3, r20
				adc temp2, r21
				adc temp1, r21
				rjmp last_address1

last_address2:
			
				sts addresse, temp1
				sts addresse+1, temp2
				sts addresse+2, temp3
				sts addresse+3, temp4

				rcall Read_Block_MMC


				ldi ZL, LOW(cluster*2)	;setzen des Z pointers auf die Anfangsadresse von cluster
				ldi ZH, HIGH(cluster*2)

				mov temp1, r24		;sichern für still_32byte !!!

				inc r24			;inkrementieren da wir gleich auf die nächsten 32byte der letzten addresse zeigen
				cpi r24, 0x10			;gucken ob 512byte counter schon erreicht ist
				breq jump_next_sector1

still_32byte:

				adiw ZH:ZL, 0x20		;solange um 32byte erhöhen bis nächste stelle erreicht
				cpi temp1, 0x00
				breq ROOT_ok
				dec temp1
				rjmp still_32byte

ROOT_ok:
	
				rjmp root_show1





root_ausgelesen:
		rjmp lcd_show

root_am_ende:
		rjmp REGISTER


;--------------------------
;FAT lesen, erster sektor und folgende
;--------------------------
FAT_read0:

	lds temp1, next_DATA_cluster
	lds temp2, next_DATA_cluster+1

		cpi temp1, 0xFF			;prüfen ob letztes cluster teil1
		breq finish
		rjmp FAT_ok

finish:
		cpi temp2, 0xF0		;prüfen ob letztes cluster teil2
		brsh finish1
		rjmp FAT_ok
finish1:
		ret

FAT_ok:
	sts first_DATA_cluster, temp1
	sts first_DATA_cluster+1, temp2




FAT_read:


	
	lds temp1, first_DATA_cluster		; temp1 gibt an wieviel sektoren inder ROOT gesprungen werden muss
	lds temp2, first_DATA_cluster+1		; da hier nur 256 einträge gespeichert werden können überlauf
										; bei 256(0xFF) zu first_DATA_cluster !!!!!
	
	cpi temp1, 0x00
	breq FAT0
	rjmp FATx


FAT0:
	
	lds temp1, FAT_start
	sts addresse, temp1
	lds temp1, FAT_start+1
	sts addresse+1, temp1
	lds temp1, FAT_start+2
	sts addresse+2, temp1
	lds temp1, FAT_start+3
	sts addresse+3, temp1
	rjmp FAT_show


FATx:

	mov r20, temp1			;sichern des first_DATA_cluster in r20
	ldi temp1, 0x02			;register einstellen für addition mit 512
	mov r21, temp1
	ldi temp1, 0x00				
	mov r22, temp1

	lds temp1, FAT_start
	lds temp2, FAT_start+1
	lds temp3, FAT_start+2
	lds temp4, FAT_start+3

FATx_1:

	add temp3, r21
	adc temp2, r22
	adc temp1, r22
	dec r20
	cpi r20, 0x00
	brne FATx_1
	
	sts addresse, temp1
	sts addresse+1, temp2
	sts addresse+2, temp3
	sts addresse+3, temp4


FAT_show:
	
	rcall Read_Block_MMC	;liest das fat aus

	ldi ZL, LOW(cluster*2)	;setzen des Z pointers auf die Anfangsadresse von cluster
	ldi ZH, HIGH(cluster*2)
	
	ldi temp1, 0x00
	lds temp2, first_DATA_cluster+1
	ldi r21, 0x00
	lsl temp2					; x2 nehmen, da immer 2byte ein fat eintrag ist
	adc temp1, r21

	add ZL, temp2
	adc ZH, temp1

	ld temp2, Z+
	sts next_DATA_cluster+1, temp2
	ld temp1, Z+
	sts next_DATA_cluster, temp1
	
	rjmp DATA_read


;------------------------------
;Datencluster lesen
;------------------------------
DATA_read:


	lds r20, first_DATA_cluster
	lds r21, first_DATA_cluster+1
	
	
	mov ZH, r20
	mov ZL, r21
	sbiw ZH:ZL, 0x02			;berechnung für das datencluster, da immer 2 werte kleiner als fat wert
	
	ldi r20, 0x00
	mov r9, r20
	mov r20, ZL
	mov r21, ZH					;register für 512 byte addierung
	ldi r22, 0x00

				lds r25, sectors_per_cluster
greater_cluster:
	
				lsl r22
				lsl r21
				adc r22, r9			;auf 512byte umrechnen
				lsl r20
				adc r21, r9


	lds temp1, DATA_start
	lds temp2, DATA_start+1
	lds temp3, DATA_start+2
	lds temp4, DATA_start+3


greater_cluster1:

				add temp3, r20
				adc temp2, r21					;addresse des clusters berechnen 
				adc temp1, r22
	
				dec r25
				cpi r25, 0x00
				brne greater_cluster1	;wenn grösser als 512 muss wiederholt werden, da grössere cluster

	sts addresse, temp1
	sts addresse+1, temp2
	sts addresse+2, temp3
	sts addresse+3, temp4

	lds r22, sectors_per_cluster	;counter damit man weiss wieviel sektoren ein cluster hat!!!


greater_DATA:

	rcall vorspulabfrage_2

	lds temp1, vorspulabfrage	;falls am vorspulen, keine daten an VLSI senden
	cpi temp1, 0xFF
	breq no_VS1002_SDI

	rcall Read_Block_MMC	;liest cluster von der fat der MMc karte
	
	rcall VS1002_SDI


no_VS1002_SDI:


		
	call ZEITZAEHLER
;;;;;;;;;;;;;;;;;;;;;;;;;;;PRÜFUNG OB SCHLUSS

ldi r16, 0x00
ldi r17, 0x00
ldi r18, 0x00
ldi r19, 0x00


lds temp4, MP3_data_length_end+3
lds temp3, MP3_data_length_end+2
lds temp2, MP3_data_length_end+1
lds temp1, MP3_data_length_end

ldi r28, 0x02
ldi r29, 0x00



sub temp3, r28
sbc temp2, r29
sbc temp1, r29


cpi temp1, 0x00
breq data_end0
brmi data_end0

rjmp data_weiter



data_end0:

cpi temp2, 0x00
breq data_end1
brmi data_end1

rjmp data_weiter



data_end1:
cpi temp1, 0xFF
breq data_end2

rjmp data_weiter



data_end2:

rjmp next_FAT

data_weiter:


sts MP3_data_length_end+3, temp4
sts MP3_data_length_end+2, temp3
sts MP3_data_length_end+1, temp2
sts MP3_data_length_end, temp1

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;




dec r22					;sektoren pro cluster um eins erniedrigen
cpi r22, 0x00
breq next_FAT

	lds temp1, addresse
	lds temp2, addresse+1 
	lds temp3, addresse+2 
	lds temp4, addresse+3
	
	ldi r20, 0x02
	ldi r21, 0x00			;um 512 byte addresse erhöhen da sek pro cluster>1

	add temp3, r20
	adc temp2, r21
	adc temp1, r21

	sts addresse, temp1
	sts addresse+1, temp2
	sts addresse+2, temp3
	sts addresse+3, temp4

lds temp1, vorspulabfrage			;abfrage wegen vorspulen, wenn ja keine tastenabfrage
cpi temp1, 0xFF
breq TASTER_ende

rjmp TASTER_anfang

TASTER_ende:

			rjmp greater_DATA



next_FAT:

		rjmp FAT_read0

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

REGISTER:


rjmp start



;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;nach tasten rückkehr;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;müssen id3tag und root wieder;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aufgerufen werden;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;



TASTER_anfang:

			in temp1, PINA
			sbrs temp1, 0
			rjmp taste0
			sbrs temp1, 1
			rjmp taste1
			sbrs temp1, 2
			rjmp taste2
			sbrs temp1, 3
			rjmp taste3

			rjmp TASTER_ende			;zurückkehren zum datentransfer oder sonstwohin vor tastendruck



taste0:

			;:_______________________;
			;zurückspulen			 					 ;
			;taser zurück für menu	 ;
			;________________________;




			rcall tastenwait

			lds temp1, root_counter_anfang
			cpi temp1, 0x00
			breq TASTER_anfang
			dec temp1				;2mal dekrementieren weil lcd_show am ende inkrementiert!!!
			dec temp1
			sts root_counter_anfang, temp1
			
			ret





			


taste1:				


			rcall tastenwait

			rjmp MENUSTEUERUNG				;stop und ab ins MENU







taste2:

			;____________________;
			;bestätigung im menu ;
			;____________________;

			rcall tastenwait

taste2_pause:									;play und pause

			in temp1, PINA
			sbrs temp1, 0
			rjmp taste0
			sbrs temp1, 1
			rjmp taste1
			sbrs temp1, 2
			rjmp TASTER_ende1
			sbrs temp1, 3
			rjmp taste3


			rjmp taste2_pause


TASTER_ende1:

			rcall tastenwait
			rjmp TASTER_ende





taste3:

			;_________________________;
			;vorspulen				  					  ;
			;taster vor im menu	  ;
			;_________________________;
			

			rcall tastenwait

			in temp1, PINA
			sbrs temp1, 3
			rjmp taste3_vorspulen


			ret       				;lcd_show inkrementiert ja schon am schluss
			
taste3_vorspulen:

			ldi temp1, 0xFF
			sts vorspulabfrage, temp1
			rjmp TASTER_ende

vorspulabfrage_2:

			in temp1, PINA
			sbrc temp1, 3
			rjmp vorspulen_ende
			ret

vorspulen_ende:
			
			ldi temp1, 0x00
			sts vorspulabfrage, temp1
			ret








tastenwait:

			;____________________________________
				; warte 7999992 Zyklen:
				          ldi  temp1, $48
				WGLOOP0727:  ldi  temp2, $BC
				WGLOOP1727:  ldi  temp3, $C4
				WGLOOP2727:  dec  temp3
				          brne WGLOOP2727
				          dec  temp2
				          brne WGLOOP1727
				          dec  temp1
				          brne WGLOOP0727
				; ----------------------------- 
				; warte 6 Zyklen:
				          ldi  temp1, $02
				WGLOOP3727:  dec  temp1
				          brne WGLOOP3727
				; ----------------------------- 
				; warte 2 Zyklen:
				          nop
						  nop
				; ============================= 


				ret


MENUSTEUERUNG:

				


					;hier muss das menu hin mit play shuffle, laut-leise, höhen-bässe, playlist
			
					
volume1_schleife:

				call lcd_clear

				ldi temp1, 0xB9
				call lcd_command_left
				ldi temp1, 0x48
				call lcd_command_left

				ldi ZL, LOW(volume1*2)
				ldi ZH, HIGH(volume1*2)

				ldi temp4, 0x00

volume1_schleife1:

				lpm temp1, Z+
				call lcd_data_left

				inc temp4
				cpi temp4, 0x0F
				breq volume2_schleife
				rjmp volume1_schleife1



volume2_schleife:


				ldi temp1, 0xBA
				call lcd_command_left
				ldi temp1, 0x48
				call lcd_command_left

		
				ldi ZL, LOW(volume2*2)
				ldi ZH, HIGH(volume2*2)

				ldi temp4, 0x00

volume2_schleife2:


				lpm temp1, Z+
				call lcd_data_left

				inc temp4
				cpi temp4, 0x0F
				breq bass_trebble_schleife1
				rjmp volume2_schleife2





bass_trebble_schleife1:

				ldi temp1, 0xB9
				call lcd_command_right
				ldi temp1, 0x48
				call lcd_command_right
				ldi ZL, LOW(bass_trebble1*2)
				ldi ZH, HIGH(bass_trebble1*2)

				ldi temp4, 0x00


bass_trebble_loop1:


				lpm temp1, Z+
				call lcd_data_right

				inc temp4
				cpi temp4, 0x0F
				breq bass_trebble_schleife2
				rjmp bass_trebble_loop1




bass_trebble_schleife2:

				ldi temp1, 0xBA
				call lcd_command_right
				ldi temp1, 0x48
				call lcd_command_right

				ldi ZL, LOW(bass_trebble2*2)
				ldi ZH, HIGH(bass_trebble2*2)

				ldi temp4, 0x00


bass_trebble_loop2:


				lpm temp1, Z+
				call lcd_data_right

				inc temp4
				cpi temp4, 0x0F
				breq changes
				rjmp bass_trebble_loop2



changes:
			
			in temp1, PINA
			sbrs temp1, 0
			rjmp MENU_VOLUME_GAIN
			sbrs temp1, 1
			rjmp taste1
			sbrs temp1, 2
			rjmp TASTER_ende1
			sbrs temp1, 3
			rjmp MENU_BASS_TREBBLE

			rjmp changes






MENU_VOLUME_GAIN:

				call tastenwait

				call lcd_clear

				ldi temp1, 0xB9
				call lcd_command_left
				ldi temp1, 0x40
				call lcd_command_left


				ldi temp1, 0xFE 
				call lcd_data_left
				ldi temp1, 0x7C
				call lcd_data_left
				ldi temp1, 0x38
				call lcd_data_left
				ldi temp1, 0x10
				call lcd_data_left
				ldi temp1, 0x7C
				call lcd_data_left
				ldi temp1, 0x00
				call lcd_data_left
				ldi temp1, 0x00
				call lcd_data_left				;zeichen für forward

				ldi temp1, 0x56
				call alphabet_search_left
				ldi temp1, 0x6F
				call alphabet_search_left
				ldi temp1, 0x6C
				call alphabet_search_left
				ldi temp1, 0x75
				call alphabet_search_left
				ldi temp1, 0x6D
				call alphabet_search_left		
				ldi temp1, 0x65
				call alphabet_search_left			;VOLUME


				ldi temp1, 0xBA
				call lcd_command_left
				ldi temp1, 0x40
				call lcd_command_left

				ldi temp1, 0x7C
				call lcd_data_left
				ldi temp1, 0x10
				call lcd_data_left
				ldi temp1, 0x38
				call lcd_data_left
				ldi temp1, 0x7C
				call lcd_data_left
				ldi temp1, 0xFE
				call lcd_data_left
				ldi temp1, 0x00
				call lcd_data_left
				ldi temp1, 0x00
				call lcd_data_left				;zeichen für backward

				ldi temp1, 0x47
				call alphabet_search_left
				ldi temp1, 0x61
				call alphabet_search_left
				ldi temp1, 0x69
				call alphabet_search_left
				ldi temp1, 0x6E
				call alphabet_search_left			;GAIN


VOLUME_OR_GAIN:

				in temp1, PINA
				sbrs temp1, 0
				rjmp MENU_GAIN
				sbrs temp1, 1
				rjmp MENUSTEUERUNG1
				sbrs temp1, 2
				rjmp MENUSTEUERUNG1
				sbrs temp1, 3
				rjmp MENU_laut_leise

				rjmp VOLUME_OR_GAIN




MENU_GAIN:

				rcall tastenwait

				call lcd_clear

				ldi temp1, 0xB9
				call lcd_command_left
				ldi temp1, 0x40
				call lcd_command_left

				ldi temp1, 0x78
				call alphabet_search_left
				lds temp1, GAIN_set
				ldi temp2, 0x30
				add temp1, temp2
				call alphabet_search_left		;derzeitige gainstärke auf display zeigen
	


GAIN_less_more:
				in temp1, PINA
				sbrs temp1, 0
				rjmp less_gain
				sbrs temp1, 1
				rjmp MENUSTEUERUNG1
				sbrs temp1, 2
				rjmp MENUSTEUERUNG1
				sbrs temp1, 3
				rjmp more_gain

				rjmp GAIN_less_more



less_gain:

				rcall tastenwait

				lds temp1, GAIN_set
				cpi temp1, 0x01
				breq GAIN_less_more					;falls schon gain 1 dann zurück menu weil quatsch
				lsr temp1
				sts GAIN_set, temp1


				

				ldi temp1, 0xB9
				call lcd_command_left
				ldi temp1, 0x40
				call lcd_command_left				;bildschirm addresse settzen


				ldi temp1, 0x78
				call alphabet_search_left
				lds temp1, GAIN_set
				ldi temp2, 0x30
				add temp1, temp2
				call alphabet_search_left				;bildschirm anzeige neues gain



				lds temp1, GAIN_set
			
				rcall GAIN_TWI

				rjmp GAIN_less_more
				
				
more_gain:			

				rcall tastenwait

				lds temp1, GAIN_set
				cpi temp1, 0x08
				breq GAIN_less_more					;falls schon volume 8 dann zurück menu weil quatsch
				lsl temp1
				sts GAIN_set, temp1


				

				ldi temp1, 0xB9
				call lcd_command_left
				ldi temp1, 0x40
				call lcd_command_left				;bildschirm addresse settzen


				ldi temp1, 0x78
				call alphabet_search_left
				lds temp1, GAIN_set
				ldi temp2, 0x30
				add temp1, temp2
				call alphabet_search_left				;bildschirm anzeige neues volume

			
				rcall GAIN_TWI

				rjmp GAIN_less_more
								
				
GAIN_TWI:

	ldi temp1, 0xC0 			; Bitrate einstellen
	out TWBR, temp1



	ldi temp1, (1<<TWINT)|(1<<TWSTA)|(1<<TWEN)
	out TWCR, temp1				; Start condition senden

wait19:
	in temp1,TWCR				; Warten bis TWINT Flag gesetzt
	sbrs temp1,TWINT			
	rjmp wait19

	in temp1,TWSR				; TWI Statusregister abfragen 
	andi temp1, 0xF8			; Prescalerbits maskieren
	cpi temp1, 0x08				; Startcondition prüfen (Datenblatt: Tabelle 66)
	brne ERROR139

	ldi temp1, 0x88				; Zieladresse in TWDR laden (RW=0)
	out TWDR, temp1				
	ldi temp1, (1<<TWINT) | (1<<TWEN)	; TWINT löschen um Übertragung zu starten
	out TWCR, temp1

wait29:
	in temp1,TWCR				; Warten bis TWINT Flag gesetzt
	sbrs temp1,TWINT
	rjmp wait29

	in temp1,TWSR				; TWSR Status prüfen
	andi temp1, 0xF8			; Prescalerbits maskieren
	cpi temp1, 0x18				; TWSR mit MT_SLA_ACK vergleichen (Datenblatt: Tabelle 66)
	brne ERROR239

	lds temp1, GAIN_set        ; Daten in TWDR laden
	rcall gain_decide

	out TWDR, temp1				
	ldi temp1, (1<<TWINT) | (1<<TWEN)	; TWINT löschen um Übertragung zu starten
	out TWCR, temp1				

wait39:
	in temp1,TWCR				; Warten bis TWINT Flag gesetzt
	sbrs temp1,TWINT			
	rjmp wait39

	in temp1,TWSR				; TWSR Status prüfen
	andi temp1, 0xF8			; Prescaler maskieren
	cpi temp1, 0x28				; TWSR mit MT_DATA_ACK vergleichen (Datenblatt: Tabelle 66)
	brne ERROR319

	
	ldi temp1, (1<<TWINT)|(1<<TWEN)|(1<<TWSTO)	; Stop condition senden
	out TWCR, temp1

	ldi temp1, 0x00								;TWI shutdown
	out TWCR, temp1				



		ret



gain_decide:

			cpi temp1, 0x01
			breq gain_1
			cpi temp1, 0x02
			breq gain_2
			cpi temp1, 0x04
			breq gain_3
			cpi temp1, 0x08
			breq gain_4

gain_1:

			ldi temp1, 0b01011000
			ret

gain_2:

			ldi temp1, 0b01010000
			ret

gain_3:

			ldi temp1, 0b01001000
			ret

gain_4:

			ldi temp1, 0b01000000
			ret





ERROR319:

	rjmp ERROR338

ERROR239:

	rjmp ERROR238

ERROR139:


	ldi temp1, (1<<TWINT)|(1<<TWEN)|(1<<TWSTO)	; Stop condition senden
	out TWCR, temp1

	ldi temp1, 0x00								;TWI shutdown
	out TWCR, temp1				


	
	call lcd_clear

	ldi temp1, 0xB9
	call lcd_command_left
	ldi temp1, 0x41
	call lcd_command_left 

	ldi temp1, 0x45
	call alphabet_search_left
	ldi temp1, 0x52
	call alphabet_search_left
	ldi temp1, 0x52
	call alphabet_search_left
	ldi temp1, 0x4F
	call alphabet_search_left
	ldi temp1, 0x52
	call alphabet_search_left
	ldi temp1, 0x31
	call alphabet_search_left
	lds temp1, TDA7318_data
	andi temp1, 0xF0
	swap temp1
	ldi temp2, 0x30
	add temp1, temp2
	call alphabet_search_left
	lds temp1, TDA7318_data
	andi temp1, 0x0F
	ldi temp2, 0x30
	add temp1, temp2
	call alphabet_search_left


	rcall tastenwait
	rcall tastenwait

	
	rjmp MENUSTEUERUNG1	
	
			

ERROR238:


	ldi temp1, (1<<TWINT)|(1<<TWEN)|(1<<TWSTO)	; Stop condition senden
	out TWCR, temp1

	ldi temp1, 0x00								;TWI shutdown
	out TWCR, temp1				

	
	
	call lcd_clear

	ldi temp1, 0xB9
	call lcd_command_left
	ldi temp1, 0x41
	call lcd_command_left 

	ldi temp1, 0x45
	call alphabet_search_left
	ldi temp1, 0x52
	call alphabet_search_left
	ldi temp1, 0x52
	call alphabet_search_left
	ldi temp1, 0x4F
	call alphabet_search_left
	ldi temp1, 0x52
	call alphabet_search_left
	ldi temp1, 0x32
	call alphabet_search_left
	lds temp1, TDA7318_data
	andi temp1, 0xF0
	swap temp1
	ldi temp2, 0x30
	add temp1, temp2
	call alphabet_search_left
	lds temp1, TDA7318_data
	andi temp1, 0x0F
	ldi temp2, 0x30
	add temp1, temp2
	call alphabet_search_left


	rcall tastenwait
	rcall tastenwait
	
	rjmp MENUSTEUERUNG1		



		
ERROR338:


	ldi temp1, (1<<TWINT)|(1<<TWEN)|(1<<TWSTO)	; Stop condition senden
	out TWCR, temp1

	ldi temp1, 0x00								;TWI shutdown
	out TWCR, temp1				

	
	
	call lcd_clear

	ldi temp1, 0xB9
	call lcd_command_left
	ldi temp1, 0x41
	call lcd_command_left 

	ldi temp1, 0x45
	call alphabet_search_left
	ldi temp1, 0x52
	call alphabet_search_left
	ldi temp1, 0x52
	call alphabet_search_left
	ldi temp1, 0x4F
	call alphabet_search_left
	ldi temp1, 0x52
	call alphabet_search_left
	ldi temp1, 0x33
	call alphabet_search_left
	lds temp1, TDA7318_data
	andi temp1, 0xF0
	swap temp1
	ldi temp2, 0x30
	add temp1, temp2
	call alphabet_search_left
	lds temp1, TDA7318_data
	andi temp1, 0x0F
	ldi temp2, 0x30
	add temp1, temp2
	call alphabet_search_left


	rcall tastenwait
	rcall tastenwait
				

	rjmp MENUSTEUERUNG1		
				















MENU_laut_leise:

				rcall tastenwait

				call lcd_clear

				ldi temp1, 0xB9
				call lcd_command_left
				ldi temp1, 0x40
				call lcd_command_left

				ldi temp1, 0x2D
				call alphabet_search_left
				lds temp1, Volume_set
				ldi temp2, 0x30
				add temp1, temp2
				call alphabet_search_left		;derzeitige Volumelautstärke auf display zeigen




Leiser_Lauter:

				in temp1, PINA
				sbrs temp1, 0
				rjmp leiser
				sbrs temp1, 1
				rjmp MENUSTEUERUNG1
				sbrs temp1, 2
				rjmp MENUSTEUERUNG1
				sbrs temp1, 3
				rjmp lauter

				rjmp Leiser_Lauter

MENUSTEUERUNG1:

				rcall tastenwait
				rjmp MENUSTEUERUNG



leiser:

				rcall tastenwait

				lds temp1, Volume_set
				cpi temp1, 0x09
				breq Leiser_Lauter					;falls schon volume 0 dann zurück menu weil quatsch
				inc temp1
				sts Volume_set, temp1


				

				ldi temp1, 0xB9
				call lcd_command_left
				ldi temp1, 0x40
				call lcd_command_left				;bildschirm addresse settzen


				ldi temp1, 0x2D
				call alphabet_search_left
				lds temp1, Volume_set
				ldi temp2, 0x30
				add temp1, temp2
				call alphabet_search_left				;bildschirm anzeige neues volume



				lds temp1, Volume_set
			
				rcall Volume_TWI

				rjmp Leiser_Lauter

;hier muss jetzt TWI befejhl hin für TDA zur lautstäärke regelung!!!!!!!!!!!





lauter:			

				rcall tastenwait

				lds temp1, Volume_set
				cpi temp1, 0x00
				breq Leiser_Lauter					;falls schon volume 0 dann zurück menu weil quatsch
				dec temp1
				sts Volume_set, temp1


				

				ldi temp1, 0xB9
				call lcd_command_left
				ldi temp1, 0x40
				call lcd_command_left				;bildschirm addresse settzen


				ldi temp1, 0x2D
				call alphabet_search_left
				lds temp1, Volume_set
				ldi temp2, 0x30
				add temp1, temp2
				call alphabet_search_left				;bildschirm anzeige neues volume

			
				rcall Volume_TWI

				rjmp Leiser_Lauter
				
;hier muss jetzt TWI befejhl hin für TDA zur lautstäärke regelung!!!!!!!!!!!




Volume_TWI:

	
	ldi temp1, 0xC0 			; Bitrate einstellen
	out TWBR, temp1



	ldi temp1, (1<<TWINT)|(1<<TWSTA)|(1<<TWEN)
	out TWCR, temp1				; Start condition senden

wait17:
	in temp1,TWCR				; Warten bis TWINT Flag gesetzt
	sbrs temp1,TWINT			
	rjmp wait17

	in temp1,TWSR				; TWI Statusregister abfragen 
	andi temp1, 0xF8			; Prescalerbits maskieren
	cpi temp1, 0x08				; Startcondition prüfen (Datenblatt: Tabelle 66)
	brne ERROR133

	ldi temp1, 0x88				; Zieladresse in TWDR laden (RW=0)
	out TWDR, temp1				
	ldi temp1, (1<<TWINT) | (1<<TWEN)	; TWINT löschen um Übertragung zu starten
	out TWCR, temp1

wait27:
	in temp1,TWCR				; Warten bis TWINT Flag gesetzt
	sbrs temp1,TWINT
	rjmp wait27

	in temp1,TWSR				; TWSR Status prüfen
	andi temp1, 0xF8			; Prescalerbits maskieren
	cpi temp1, 0x18				; TWSR mit MT_SLA_ACK vergleichen (Datenblatt: Tabelle 66)
	brne ERROR231

	lds temp1, Volume_set        ; Daten in TWDR laden
	lsl temp1
	lsl temp1						; 2mal links schieben , also x4
	out TWDR, temp1				
	ldi temp1, (1<<TWINT) | (1<<TWEN)	; TWINT löschen um Übertragung zu starten
	out TWCR, temp1				

wait37:
	in temp1,TWCR				; Warten bis TWINT Flag gesetzt
	sbrs temp1,TWINT			
	rjmp wait37

	in temp1,TWSR				; TWSR Status prüfen
	andi temp1, 0xF8			; Prescaler maskieren
	cpi temp1, 0x28				; TWSR mit MT_DATA_ACK vergleichen (Datenblatt: Tabelle 66)
	brne ERROR313

	
	ldi temp1, (1<<TWINT)|(1<<TWEN)|(1<<TWSTO)	; Stop condition senden
	out TWCR, temp1

	ldi temp1, 0x00								;TWI shutdown
	out TWCR, temp1				



		ret





ERROR313:

	rjmp ERROR333

ERROR231:

	rjmp ERROR233

ERROR133:


	ldi temp1, (1<<TWINT)|(1<<TWEN)|(1<<TWSTO)	; Stop condition senden
	out TWCR, temp1

	ldi temp1, 0x00								;TWI shutdown
	out TWCR, temp1				


	
	call lcd_clear

	ldi temp1, 0xB9
	call lcd_command_left
	ldi temp1, 0x41
	call lcd_command_left 

	ldi temp1, 0x45
	call alphabet_search_left
	ldi temp1, 0x52
	call alphabet_search_left
	ldi temp1, 0x52
	call alphabet_search_left
	ldi temp1, 0x4F
	call alphabet_search_left
	ldi temp1, 0x52
	call alphabet_search_left
	ldi temp1, 0x31
	call alphabet_search_left
	lds temp1, TDA7318_data
	andi temp1, 0xF0
	swap temp1
	ldi temp2, 0x30
	add temp1, temp2
	call alphabet_search_left
	lds temp1, TDA7318_data
	andi temp1, 0x0F
	ldi temp2, 0x30
	add temp1, temp2
	call alphabet_search_left


	rcall tastenwait
	rcall tastenwait

	
	rjmp MENUSTEUERUNG1	
	
			

ERROR233:


	ldi temp1, (1<<TWINT)|(1<<TWEN)|(1<<TWSTO)	; Stop condition senden
	out TWCR, temp1

	ldi temp1, 0x00								;TWI shutdown
	out TWCR, temp1				

	
	
	call lcd_clear

	ldi temp1, 0xB9
	call lcd_command_left
	ldi temp1, 0x41
	call lcd_command_left 

	ldi temp1, 0x45
	call alphabet_search_left
	ldi temp1, 0x52
	call alphabet_search_left
	ldi temp1, 0x52
	call alphabet_search_left
	ldi temp1, 0x4F
	call alphabet_search_left
	ldi temp1, 0x52
	call alphabet_search_left
	ldi temp1, 0x32
	call alphabet_search_left
	lds temp1, TDA7318_data
	andi temp1, 0xF0
	swap temp1
	ldi temp2, 0x30
	add temp1, temp2
	call alphabet_search_left
	lds temp1, TDA7318_data
	andi temp1, 0x0F
	ldi temp2, 0x30
	add temp1, temp2
	call alphabet_search_left


	rcall tastenwait
	rcall tastenwait
	
	rjmp MENUSTEUERUNG1		



		
ERROR333:


	ldi temp1, (1<<TWINT)|(1<<TWEN)|(1<<TWSTO)	; Stop condition senden
	out TWCR, temp1

	ldi temp1, 0x00								;TWI shutdown
	out TWCR, temp1				

	
	
	call lcd_clear

	ldi temp1, 0xB9
	call lcd_command_left
	ldi temp1, 0x41
	call lcd_command_left 

	ldi temp1, 0x45
	call alphabet_search_left
	ldi temp1, 0x52
	call alphabet_search_left
	ldi temp1, 0x52
	call alphabet_search_left
	ldi temp1, 0x4F
	call alphabet_search_left
	ldi temp1, 0x52
	call alphabet_search_left
	ldi temp1, 0x33
	call alphabet_search_left
	lds temp1, TDA7318_data
	andi temp1, 0xF0
	swap temp1
	ldi temp2, 0x30
	add temp1, temp2
	call alphabet_search_left
	lds temp1, TDA7318_data
	andi temp1, 0x0F
	ldi temp2, 0x30
	add temp1, temp2
	call alphabet_search_left


	rcall tastenwait
	rcall tastenwait
				

	rjmp MENUSTEUERUNG1		
			
				






;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
					

MENU_BASS_TREBBLE:

				call tastenwait

				call lcd_clear

				ldi temp1, 0xB9
				call lcd_command_left
				ldi temp1, 0x40
				call lcd_command_left


				ldi temp1, 0xFE 
				call lcd_data_left
				ldi temp1, 0x7C
				call lcd_data_left
				ldi temp1, 0x38
				call lcd_data_left
				ldi temp1, 0x10
				call lcd_data_left
				ldi temp1, 0x7C
				call lcd_data_left
				ldi temp1, 0x00
				call lcd_data_left
				ldi temp1, 0x00
				call lcd_data_left				;zeichen für forward

				ldi temp1, 0x54
				call alphabet_search_left
				ldi temp1, 0x72
				call alphabet_search_left
				ldi temp1, 0x65
				call alphabet_search_left
				ldi temp1, 0x62
				call alphabet_search_left
				ldi temp1, 0x62
				call alphabet_search_left		
				ldi temp1, 0x6C
				call alphabet_search_left
				ldi temp1, 0x65
				call alphabet_search_left			;TREBBLE



				ldi temp1, 0xBA
				call lcd_command_left
				ldi temp1, 0x40
				call lcd_command_left

				ldi temp1, 0x7C
				call lcd_data_left
				ldi temp1, 0x10
				call lcd_data_left
				ldi temp1, 0x38
				call lcd_data_left
				ldi temp1, 0x7C
				call lcd_data_left
				ldi temp1, 0xFE
				call lcd_data_left
				ldi temp1, 0x00
				call lcd_data_left
				ldi temp1, 0x00
				call lcd_data_left				;zeichen für backward

				ldi temp1, 0x42
				call alphabet_search_left
				ldi temp1, 0x61
				call alphabet_search_left
				ldi temp1, 0x73
				call alphabet_search_left
				ldi temp1, 0x73
				call alphabet_search_left			;BASS
				


BASS_or_TREBBLE:

				in temp1, PINA
				sbrs temp1, 0
				rjmp BASS
				sbrs temp1, 1
				rjmp MENUSTEUERUNG1
				sbrs temp1, 2
				rjmp MENUSTEUERUNG1
				sbrs temp1, 3
				rjmp TREBBLE

				rjmp BASS_or_TREBBLE




TREBBLE:

			rcall tastenwait

			call lcd_clear

			ldi temp1, 0xB9
			call lcd_command_left
			ldi temp1, 0x40
			call lcd_command_left

			lds temp1, TREBBLE_set
			ldi temp2, 0x30
			add temp1, temp2
			call alphabet_search_left


TREBBLE_loop:

				in temp1, PINA
				sbrs temp1, 0
				rjmp lower_TREBBLE
				sbrs temp1, 1
				rjmp MENUSTEUERUNG1
				sbrs temp1, 2
				rjmp MENUSTEUERUNG1
				sbrs temp1, 3
				rjmp higher_TREBBLE

				rjmp TREBBLE_loop


lower_TREBBLE:

				rcall tastenwait

				lds temp1, TREBBLE_set
				cpi temp1, 0x00
				breq TREBBLE_loop
				dec temp1
				sts TREBBLE_set, temp1

				ldi temp1, 0xB9
				call lcd_command_left
				ldi temp1, 0x40
				call lcd_command_left

				lds temp1, TREBBLE_set
			ldi temp2, 0x30
			add temp1, temp2
				call alphabet_search_left 

				rcall TREBBLE_TWI

				rjmp TREBBLE_loop
			

			
higher_TREBBLE:

				rcall tastenwait

				lds temp1, TREBBLE_set
				cpi temp1, 0x08
				breq TREBBLE_loop
				inc temp1
				sts TREBBLE_set, temp1

				ldi temp1, 0xB9
				call lcd_command_left
				ldi temp1, 0x40
				call lcd_command_left

				lds temp1, TREBBLE_set
			ldi temp2, 0x30
			add temp1, temp2
				call alphabet_search_left 

				rcall TREBBLE_TWI

				rjmp TREBBLE_loop



TREBBLE_TWI:


	ldi temp1, 0xC0 			; Bitrate einstellen
	out TWBR, temp1



	ldi temp1, (1<<TWINT)|(1<<TWSTA)|(1<<TWEN)
	out TWCR, temp1				; Start condition senden

wait177:
	in temp1,TWCR				; Warten bis TWINT Flag gesetzt
	sbrs temp1,TWINT			
	rjmp wait177

	in temp1,TWSR				; TWI Statusregister abfragen 
	andi temp1, 0xF8			; Prescalerbits maskieren
	cpi temp1, 0x08				; Startcondition prüfen (Datenblatt: Tabelle 66)
	brne ERROR136

	ldi temp1, 0x88				; Zieladresse in TWDR laden (RW=0)
	out TWDR, temp1				
	ldi temp1, (1<<TWINT) | (1<<TWEN)	; TWINT löschen um Übertragung zu starten
	out TWCR, temp1

wait277:
	in temp1,TWCR				; Warten bis TWINT Flag gesetzt
	sbrs temp1,TWINT
	rjmp wait277

	in temp1,TWSR				; TWSR Status prüfen
	andi temp1, 0xF8			; Prescalerbits maskieren
	cpi temp1, 0x18				; TWSR mit MT_SLA_ACK vergleichen (Datenblatt: Tabelle 66)
	brne ERROR236

	lds temp1, TREBBLE_set
	rcall TREBBLE_decide
								        ; Daten in TWDR laden
	out TWDR, temp1				
	ldi temp1, (1<<TWINT) | (1<<TWEN)	; TWINT löschen um Übertragung zu starten
	out TWCR, temp1				

wait376:
	in temp1,TWCR				; Warten bis TWINT Flag gesetzt
	sbrs temp1,TWINT			
	rjmp wait376

	in temp1,TWSR				; TWSR Status prüfen
	andi temp1, 0xF8			; Prescaler maskieren
	cpi temp1, 0x28				; TWSR mit MT_DATA_ACK vergleichen (Datenblatt: Tabelle 66)
	brne ERROR316

	
	ldi temp1, (1<<TWINT)|(1<<TWEN)|(1<<TWSTO)	; Stop condition senden
	out TWCR, temp1

	ldi temp1, 0x00								;TWI shutdown
	out TWCR, temp1				



		ret





ERROR316:

	rjmp ERROR3336

ERROR236:

	rjmp ERROR2336

ERROR136:


	ldi temp1, (1<<TWINT)|(1<<TWEN)|(1<<TWSTO)	; Stop condition senden
	out TWCR, temp1

	ldi temp1, 0x00								;TWI shutdown
	out TWCR, temp1				


	
	call lcd_clear

	ldi temp1, 0xB9
	call lcd_command_left
	ldi temp1, 0x41
	call lcd_command_left 

	ldi temp1, 0x45
	call alphabet_search_left
	ldi temp1, 0x52
	call alphabet_search_left
	ldi temp1, 0x52
	call alphabet_search_left
	ldi temp1, 0x4F
	call alphabet_search_left
	ldi temp1, 0x52
	call alphabet_search_left
	ldi temp1, 0x31
	call alphabet_search_left
	lds temp1, TDA7318_data
	andi temp1, 0xF0
	swap temp1
	ldi temp2, 0x30
	add temp1, temp2
	call alphabet_search_left
	lds temp1, TDA7318_data
	andi temp1, 0x0F
	ldi temp2, 0x30
	add temp1, temp2
	call alphabet_search_left


	rcall tastenwait
	rcall tastenwait

	
	rjmp MENUSTEUERUNG1	
	
			

ERROR2336:


	ldi temp1, (1<<TWINT)|(1<<TWEN)|(1<<TWSTO)	; Stop condition senden
	out TWCR, temp1

	ldi temp1, 0x00								;TWI shutdown
	out TWCR, temp1				

	
	
	call lcd_clear

	ldi temp1, 0xB9
	call lcd_command_left
	ldi temp1, 0x41
	call lcd_command_left 

	ldi temp1, 0x45
	call alphabet_search_left
	ldi temp1, 0x52
	call alphabet_search_left
	ldi temp1, 0x52
	call alphabet_search_left
	ldi temp1, 0x4F
	call alphabet_search_left
	ldi temp1, 0x52
	call alphabet_search_left
	ldi temp1, 0x32
	call alphabet_search_left
	lds temp1, TDA7318_data
	andi temp1, 0xF0
	swap temp1
	ldi temp2, 0x30
	add temp1, temp2
	call alphabet_search_left
	lds temp1, TDA7318_data
	andi temp1, 0x0F
	ldi temp2, 0x30
	add temp1, temp2
	call alphabet_search_left


	rcall tastenwait
	rcall tastenwait
	
	rjmp MENUSTEUERUNG1		



		
ERROR3336:


	ldi temp1, (1<<TWINT)|(1<<TWEN)|(1<<TWSTO)	; Stop condition senden
	out TWCR, temp1

	ldi temp1, 0x00								;TWI shutdown
	out TWCR, temp1				

	
	
	call lcd_clear

	ldi temp1, 0xB9
	call lcd_command_left
	ldi temp1, 0x41
	call lcd_command_left 

	ldi temp1, 0x45
	call alphabet_search_left
	ldi temp1, 0x52
	call alphabet_search_left
	ldi temp1, 0x52
	call alphabet_search_left
	ldi temp1, 0x4F
	call alphabet_search_left
	ldi temp1, 0x52
	call alphabet_search_left
	ldi temp1, 0x33
	call alphabet_search_left
	lds temp1, TDA7318_data
	andi temp1, 0xF0
	swap temp1
	ldi temp2, 0x30
	add temp1, temp2
	call alphabet_search_left
	lds temp1, TDA7318_data
	andi temp1, 0x0F
	ldi temp2, 0x30
	add temp1, temp2
	call alphabet_search_left


	rcall tastenwait
	rcall tastenwait
				

	rjmp MENUSTEUERUNG1		


;hier muss anzeige und TDA aufruf hin


BASS:  

			rcall tastenwait

			rcall lcd_clear

			ldi temp1, 0xB9
			call lcd_command_left
			ldi temp1, 0x40
			call lcd_command_left

			lds temp1, BASS_set
			ldi temp2, 0x30
			add temp1, temp2
			call alphabet_search_left


BASS_loop:

				in temp1, PINA
				sbrs temp1, 0
				rjmp lower_BASS
				sbrs temp1, 1
				rjmp MENUSTEUERUNG1
				sbrs temp1, 2
				rjmp MENUSTEUERUNG1
				sbrs temp1, 3
				rjmp higher_BASS

				rjmp BASS_loop


lower_BASS:

				rcall tastenwait

				lds temp1, BASS_set
				cpi temp1, 0x00
				breq BASS_loop
				dec temp1
				sts BASS_set, temp1

				ldi temp1, 0xB9
				call lcd_command_left
				ldi temp1, 0x40
				call lcd_command_left

				lds temp1, BASS_set
			ldi temp2, 0x30
			add temp1, temp2
				call alphabet_search_left 

				rcall BASS_TWI

				rjmp BASS_loop
			

			
higher_BASS:

				rcall tastenwait

				lds temp1, BASS_set
				cpi temp1, 0x08
				breq BASS_loop
				inc temp1
				sts BASS_set, temp1

				ldi temp1, 0xB9
				call lcd_command_left
				ldi temp1, 0x40
				call lcd_command_left

				lds temp1, BASS_set
			ldi temp2, 0x30
			add temp1, temp2
				call alphabet_search_left 

				rcall BASS_TWI

				rjmp BASS_loop



BASS_TWI:


	ldi temp1, 0xC0 			; Bitrate einstellen
	out TWBR, temp1



	ldi temp1, (1<<TWINT)|(1<<TWSTA)|(1<<TWEN)
	out TWCR, temp1				; Start condition senden

wait1773:
	in temp1,TWCR				; Warten bis TWINT Flag gesetzt
	sbrs temp1,TWINT			
	rjmp wait1773

	in temp1,TWSR				; TWI Statusregister abfragen 
	andi temp1, 0xF8			; Prescalerbits maskieren
	cpi temp1, 0x08				; Startcondition prüfen (Datenblatt: Tabelle 66)
	brne ERROR1362

	ldi temp1, 0x88				; Zieladresse in TWDR laden (RW=0)
	out TWDR, temp1				
	ldi temp1, (1<<TWINT) | (1<<TWEN)	; TWINT löschen um Übertragung zu starten
	out TWCR, temp1

wait2773:
	in temp1,TWCR				; Warten bis TWINT Flag gesetzt
	sbrs temp1,TWINT
	rjmp wait2773

	in temp1,TWSR				; TWSR Status prüfen
	andi temp1, 0xF8			; Prescalerbits maskieren
	cpi temp1, 0x18				; TWSR mit MT_SLA_ACK vergleichen (Datenblatt: Tabelle 66)
	brne ERROR2362

	lds temp1, BASS_set
	rcall BASS_decide
								        ; Daten in TWDR laden
	out TWDR, temp1				
	ldi temp1, (1<<TWINT) | (1<<TWEN)	; TWINT löschen um Übertragung zu starten
	out TWCR, temp1				

wait3763:
	in temp1,TWCR				; Warten bis TWINT Flag gesetzt
	sbrs temp1,TWINT			
	rjmp wait3763

	in temp1,TWSR				; TWSR Status prüfen
	andi temp1, 0xF8			; Prescaler maskieren
	cpi temp1, 0x28				; TWSR mit MT_DATA_ACK vergleichen (Datenblatt: Tabelle 66)
	brne ERROR3162

	
	ldi temp1, (1<<TWINT)|(1<<TWEN)|(1<<TWSTO)	; Stop condition senden
	out TWCR, temp1

	ldi temp1, 0x00								;TWI shutdown
	out TWCR, temp1				



		ret





ERROR3162:

	rjmp ERROR3332

ERROR2362:

	rjmp ERROR2332

ERROR1362:


	ldi temp1, (1<<TWINT)|(1<<TWEN)|(1<<TWSTO)	; Stop condition senden
	out TWCR, temp1

	ldi temp1, 0x00								;TWI shutdown
	out TWCR, temp1				


	
	rcall lcd_clear

	ldi temp1, 0xB9
	call lcd_command_left
	ldi temp1, 0x41
	call lcd_command_left 

	ldi temp1, 0x45
	call alphabet_search_left
	ldi temp1, 0x52
	call alphabet_search_left
	ldi temp1, 0x52
	call alphabet_search_left
	ldi temp1, 0x4F
	call alphabet_search_left
	ldi temp1, 0x52
	call alphabet_search_left
	ldi temp1, 0x31
	call alphabet_search_left
	lds temp1, TDA7318_data
	andi temp1, 0xF0
	swap temp1
	ldi temp2, 0x30
	add temp1, temp2
	call alphabet_search_left
	lds temp1, TDA7318_data
	andi temp1, 0x0F
	ldi temp2, 0x30
	add temp1, temp2
	call alphabet_search_left


	rcall tastenwait
	rcall tastenwait

	
	rjmp MENUSTEUERUNG1	
	
			

ERROR2332:


	ldi temp1, (1<<TWINT)|(1<<TWEN)|(1<<TWSTO)	; Stop condition senden
	out TWCR, temp1

	ldi temp1, 0x00								;TWI shutdown
	out TWCR, temp1				

	
	
	rcall lcd_clear

	ldi temp1, 0xB9
	call lcd_command_left
	ldi temp1, 0x41
	call lcd_command_left 

	ldi temp1, 0x45
	call alphabet_search_left
	ldi temp1, 0x52
	call alphabet_search_left
	ldi temp1, 0x52
	call alphabet_search_left
	ldi temp1, 0x4F
	call alphabet_search_left
	ldi temp1, 0x52
	call alphabet_search_left
	ldi temp1, 0x32
	call alphabet_search_left
	lds temp1, TDA7318_data
	andi temp1, 0xF0
	swap temp1
	ldi temp2, 0x30
	add temp1, temp2
	call alphabet_search_left
	lds temp1, TDA7318_data
	andi temp1, 0x0F
	ldi temp2, 0x30
	add temp1, temp2
	call alphabet_search_left


	rcall tastenwait
	rcall tastenwait
	
	rjmp MENUSTEUERUNG1		



		
ERROR3332:


	ldi temp1, (1<<TWINT)|(1<<TWEN)|(1<<TWSTO)	; Stop condition senden
	out TWCR, temp1

	ldi temp1, 0x00								;TWI shutdown
	out TWCR, temp1				

	
	
	rcall lcd_clear

	ldi temp1, 0xB9
	call lcd_command_left
	ldi temp1, 0x41
	call lcd_command_left 

	ldi temp1, 0x45
	call alphabet_search_left
	ldi temp1, 0x52
	call alphabet_search_left
	ldi temp1, 0x52
	call alphabet_search_left
	ldi temp1, 0x4F
	call alphabet_search_left
	ldi temp1, 0x52
	call alphabet_search_left
	ldi temp1, 0x33
	call alphabet_search_left
	lds temp1, TDA7318_data
	andi temp1, 0xF0
	swap temp1
	ldi temp2, 0x30
	add temp1, temp2
	call alphabet_search_left
	lds temp1, TDA7318_data
	andi temp1, 0x0F
	ldi temp2, 0x30
	add temp1, temp2
	call alphabet_search_left


	rcall tastenwait
	rcall tastenwait
				

	rjmp MENUSTEUERUNG1	


;hier muss anzeige und TDA aufruf hin




BASS_decide:

			cpi temp1, 0x00
			breq BASS_0
			cpi temp1, 0x01
			breq BASS_1
			cpi temp1, 0x02
			breq BASS_2
			cpi temp1, 0x03	
			breq BASS_3
			cpi temp1, 0x04
			breq BASS_4
			cpi temp1, 0x05	
			breq BASS_5
			cpi temp1, 0x06
			breq BASS_6
			cpi temp1, 0x07
			breq BASS_7
			cpi temp1, 0x08
			breq BASS_8

BASS_0:

			ldi temp1, 0b01100011
			ret

BASS_1:

			ldi temp1, 0b01100100
			ret

BASS_2:

			ldi temp1, 0b01100101
			ret

BASS_3:

			ldi temp1, 0b01100110
			ret

BASS_4:

			ldi temp1, 0b01101111
			ret

BASS_5:

			ldi temp1, 0b01101110
			ret

BASS_6:

			ldi temp1, 0b01101101
			ret

BASS_7:

			ldi temp1, 0b01101100
			ret


BASS_8:

			ldi temp1, 0b01101011
			ret





TREBBLE_decide:


			cpi temp1, 0x00
			breq TREBBLE_0
			cpi temp1, 0x01
			breq TREBBLE_1
			cpi temp1, 0x02
			breq TREBBLE_2
			cpi temp1, 0x03	
			breq TREBBLE_3
			cpi temp1, 0x04
			breq TREBBLE_4
			cpi temp1, 0x05	
			breq TREBBLE_5
			cpi temp1, 0x06
			breq TREBBLE_6
			cpi temp1, 0x07
			breq TREBBLE_7
			cpi temp1, 0x08
			breq TREBBLE_8

TREBBLE_0:

			ldi temp1, 0b01110011
			ret

TREBBLE_1:

			ldi temp1, 0b01110100
			ret

TREBBLE_2:

			ldi temp1, 0b01110101
			ret

TREBBLE_3:

			ldi temp1, 0b01110110
			ret

TREBBLE_4:

			ldi temp1, 0b01111111
			ret

TREBBLE_5:

			ldi temp1, 0b01111110
			ret

TREBBLE_6:

			ldi temp1, 0b01111101
			ret

TREBBLE_7:

			ldi temp1, 0b01111100
			ret


TREBBLE_8:

			ldi temp1, 0b01111011
			ret
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
volume1:
.db	0xC0, 0xE0, 0xF0, 0xF8, 0xFC, 0xFE, 0xFF, 0xFF, 0x00, 0x30, 0x60, 0xC0, 0x06, 0x0C, 0x38, 0xE0
volume2:
.db	0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x7F, 0xFF, 0xFF, 0x00, 0x0C, 0x06, 0x03, 0x60, 0x30, 0x1C, 0x07


bass_trebble1:
.db	0x00, 0x00, 0x00, 0x83, 0xFF, 0xFF, 0x03, 0x03, 0x03, 0x06, 0x06, 0x06, 0xFE, 0xFE, 0x06, 0x00
bass_trebble2:
.db	0x02, 0x07, 0x07, 0x0F, 0x0F, 0x0F, 0x07, 0x02, 0x20, 0x70, 0x70, 0xF8, 0xFF, 0xFF, 0x70, 0x20






;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;,,
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;,

;___________________________
;USART BEFEHL
;---------------------------------






serout:
        sbis UCSRA,UDRE                   ; Warten bis UDR für das nächste
                                          ; Byte bereit ist
        rjmp serout
        out UDR, temp1
        ret                               ; zurück zum Hauptprogramm


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;





;_____________________________
;INITIALISIERUNG SPI UND MMC
;----------------------------


spi_init:
		
		;//Konfiguration des Ports an der die MMC/SD-Karte angeschlossen wurde	
		cbi	MMC_Dir,	SPI_DI 			;//Setzen von Pin MMC_DI auf Input
		sbi	MMC_Dir,	SPI_Clock 		;//Setzen von Pin MMC_Clock auf Output
		sbi	MMC_Dir,	SPI_DO 			;//Setzen von Pin MMC_DO auf Output
		sbi	MMC_Dir,	MMC_Chip_Select 	;//Setzen von Pin MMC_Chip_Select auf Output	
		sbi	MMC_Write,	MMC_Chip_Select 	;MMC chip select aus
		sbi MMC_DIR,    3					; 
		sbi MMC_DIR,    2
		cbi MMC_DIR,    1
		sbi MMC_DIR,    0
		sbi PORTB,      3
		sbi PORTB,      2



		;//Aktiviren des SPI - Bus, Clock = Idel High
		;ldi	work,	(1<<SPE)|(1<<MSTR)|(1<<SPR0)	;//Enable SPI, SPI in Master Mode
		ldi	temp1,	0x53
		out	SPCR,	temp1
		ldi temp1,  0x00
		out	SPSR,	temp1

		ret



mmc_init:

		;//Initialisiere MMC/SD-Karte in den SPI-Mode
		ldi	temp2,	15
lp1:	ldi	temp1,	0xFF
		rcall	Write_Byte_MMC				;//Sendet min 74+ Clocks an die MMC/SD-Karte
		dec	temp2
		brne	lp1

CMD_0:;//Sendet Commando CMD0 an MMC/SD-Karte
	ldi	temp1, 0x40
	sts CMD,   temp1
	ldi temp1, 0x00
	sts CMD+1, temp1	
	sts CMD+2, temp1
	sts CMD+3, temp1
	sts CMD+4, temp1
	ldi	temp1, 0x95
	sts CMD+5, temp1	;speichert denn CMD0 befehl in hex auf SRAM 40 00 00 00 00 95

	rcall	Write_Command_MMC
	
	rcall send_end
	
	lds temp1, response_save
	sts response_ini+1, temp1
	cpi temp1, 0x01
	breq CMD_1
	rjmp CMD_0



;//Sendet Commando CMD1 an MMC/SD-Karte
	
CMD_1:
	ldi	temp1,0x41		;//Commando 1
	sts CMD, temp1
	ldi temp1, 0x00
	sts CMD+1, temp1
	sts CMD+2, temp1
	sts CMD+3 ,temp1
	sts CMD+4, temp1
	ldi	temp1,0xFF
	sts CMD+5, temp1

	rcall	Write_Command_MMC

	rcall send_end

	lds temp1, response_save
	sts response_ini, temp1
	cpi temp1, 0x00
	breq fertig
	rjmp CMD_1

fertig:

	;schneller machen des spi taktes weil ini erfolgreich und unter 400khz von statten geht
	ldi	temp1,	0x50
	out	SPCR,	temp1
	ldi temp1,  0x01
	out	SPSR,	temp1       ;hier kann die geschwindigkeit au noch verdoppelt werden durch
							;schreiben von 0x01 in das register SPSR
	ret



;____________________
;BEFEHLE STEHEN HIER
;--------------------


;Routine zum beenden nach einer übertragung, z.b. nach einem kommando oder nach 
;dem die 512 byte empfangen wurden ...
send_end:	

	sbi MMC_Write,	MMC_Chip_Select
	ldi temp1, 0xFF
	rcall Write_Byte_MMC
	ret


;//Routine zum Senden eines Bytes zur MMC-Karte (SPI)
Write_Byte_MMC:	

		out	SPDR,	temp1 
lp7:	sbis	SPSR,	SPIF
	  	rjmp	lp7
		ret




;//Routine zun senden eines 6 byte Commandos
Write_Command_MMC:
	
	ldi temp1, 0xFF
	rcall Write_Byte_MMC

	;//sendet 6 Byte Commando
	cbi	MMC_Write,	MMC_Chip_Select		;//set MMC_Chip_Select to low (MMC/SD-Karte Aktiv)

	ldi	temp1,	0xFF
	rcall	Write_Byte_MMC

	lds temp1, CMD				;//sendet 6 Byte Commando zur MMC/SD-Karte
	rcall Write_BYTE_MMC
	lds temp1, CMD+1
	rcall Write_Byte_MMC
	lds temp1, CMD+2
	rcall Write_Byte_MMC
	lds temp1, CMD+3
	rcall Write_Byte_MMC
	lds temp1, CMD+4
	rcall Write_Byte_MMC
	lds temp1, CMD+5
	rcall Write_Byte_MMC

response:

	ldi	temp1,	0xFF
	rcall	Write_Byte_MMC 		;//Wartet auf ein gültige Antwort von der MMC/SD-Karte
	in	temp1,	SPDR
	sts response_save, temp1		;sichern des der antwort(response) von der MMC
	cpi	temp1,	0xFF			; Antwort sollte 0x01 bei CMD0 und ...... sein
	brne	response2
	cpi temp1, 0xFF
	breq	response
	
response2:	
  	
	ret
  						;//Abbruch da die MMC/SD-Karte antwortet





;//Routine zum lesen eines Blocks(512Byte) von der MMC/SD-Karte
Read_Block_MMC:	;
	
	
	;//Commando 17 zum lesen eines Blocks
CMD_17:	
	ldi temp1, 0x51		;//Commando 17
	sts CMD,   temp1
	lds temp1, addresse
	sts CMD+1, temp1
	lds temp1, addresse+1
	sts CMD+2, temp1
	lds temp1, addresse+2
	sts CMD+3, temp1
	lds temp1, addresse+3
	sts CMD+4, temp1
	ldi temp1, 0xFF
	sts CMD+5, temp1

	rcall Write_Command_MMC

	lds temp1, response_save
	sts response_read+1, temp1
	cpi temp1, 0x00
	breq read
	rcall send_end 
	rjmp CMD_17

	
;Wartet auf Start Byte von der MMC/SD-Karte (FEh/Start Byte)
	
read:	

	ldi	temp1,	0xFF
	rcall	Write_Byte_MMC
	in	temp1,	SPDR
	sts 	response_read, temp1
	cpi	temp1,	0xFE			; Antwort sollte 0xFE für lesebstätigung
	breq	read2
	cpi temp1, 0xFE
	brne	read


read2:


	ldi ZL, LOW(cluster*2)               ; Adresse von clusterspeicher in den z pointer laden
        ldi ZH, HIGH(cluster*2)
	ldi temp2, 0xFF
	
read2_1:	
		
		ldi	temp1,	0xFF
		rcall	Write_Byte_MMC
		in	temp1,	SPDR
		st	Z+,	temp1
		cpi temp2, 0x00
		breq read3
		dec temp2
		rjmp read2_1

read3:	
	ldi temp2, 0xFF
read3_1:
		ldi	temp1,	0xFF
		rcall	Write_Byte_MMC
		in	temp1,	SPDR
		st	Z+,	temp1
		cpi temp2, 0x00
		breq read_crc
		dec temp2
		rjmp read3_1
	
read_crc:			 ;nicht wichtig darum auslesen und net speichern
	ldi	temp1,	0xFF
	rcall	Write_Byte_MMC
	ldi	temp1,	0xFF
	rcall	Write_Byte_MMC

	rcall send_end

	ret

	
	


CID_read:
	
		
CMD_10:	
	ldi temp1, 0x4A		;//Commando 10
	sts CMD,   temp1
	lds temp1, 0x00
	sts CMD+1, temp1
	sts CMD+2, temp1
	sts CMD+3, temp1
	sts CMD+4, temp1
	ldi temp1, 0xFF
	sts CMD+5, temp1

	rcall Write_Command_MMC

	lds temp1, response_save
	sts response_read+1, temp1
	cpi temp1, 0x00
	breq read_CID
	rcall send_end 
	rjmp CMD_10

	
;Wartet auf Start Byte von der MMC/SD-Karte (FEh/Start Byte)
	
read_CID:	

	ldi	temp1,	0xFF
	rcall	Write_Byte_MMC
	in	temp1,	SPDR
	sts 	response_read, temp1
	cpi	temp1,	0xFE			; Antwort sollte 0xFE für lesebstätigung
	breq	read_CID2
	cpi temp1, 0xFE
	brne	read_CID


read_CID2:


	ldi ZL, LOW(cluster*2)               ; Adresse von clusterspeicher in den z pointer laden
        ldi ZH, HIGH(cluster*2)
	ldi temp2, 0x10
	
read_CID2_1:	
		ldi	temp1,	0xFF
		rcall	Write_Byte_MMC
		in	temp1,	SPDR
		st	Z+,	temp1
		dec temp2
		cpi temp2, 0x00
		breq read_CID_crc
		rjmp read_CID2_1	
	
	
read_CID_crc:			 ;nicht wichtig darum auslesen und net speichern
	ldi	temp1,	0xFF
	rcall	Write_Byte_MMC
	ldi	temp1,	0xFF
	rcall	Write_Byte_MMC

	rcall send_end

	ret








;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;






;_____________________________________________________________________________________
;-------------------------------------------------------------------------------------
;VS1002 befehlsatz
;-------------------------------------------------------------


VS1002_init:


		;//Konfiguration des Ports an der die MMC/SD-Karte angeschlossen wurde	
		cbi	MMC_Dir,	SPI_DI 			;//Setzen von Pin MMC_DI auf Input
		sbi	MMC_Dir,	SPI_Clock 		;//Setzen von Pin MMC_Clock auf Output
		sbi	MMC_Dir,	SPI_DO 			;//Setzen von Pin MMC_DO auf Output
		sbi	MMC_Dir,	MMC_Chip_Select 	;//Setzen von Pin MMC_Chip_Select auf Output	
		sbi	MMC_Write,	MMC_Chip_Select 	;MMC chip select aus
		sbi MMC_DIR,    3					; 
		sbi MMC_DIR,    2
		cbi MMC_DIR,    1
		sbi MMC_DIR,    0
		sbi PORTB,      3
		sbi PORTB,      2



		;//Aktiviren des SPI - Bus, Clock = Idel High
		;ldi	work,	(1<<SPE)|(1<<MSTR)|(1<<SPR0)	;//Enable SPI, SPI in Master Mode
		ldi	temp1,	0x51
		out	SPCR,	temp1
		ldi temp1,  0x01
		out	SPSR,	temp1





		sbi PORTB, 0
		nop
		nop
		nop
		nop
		nop
		nop
		nop
		nop
		nop
		nop
		cbi PORTB, 0

; ============================= 
;   Warteschleifen-Generator 
;     100 Zyklen:
; ----------------------------- 
; warte 99 Zyklen:
          ldi  R17, $21
WGLOOP0222:  dec  R17
          brne WGLOOP0222
; ----------------------------- 
; warte 1 Zyklus:
          nop
; ============================= 

sbi PORTB, 0


;     65000 Zyklen:
; ----------------------------- 
; warte 64998 Zyklen:
          ldi  R17, $8A
WGLOOP122:  ldi  R18, $9C
WGLOOP222:  dec  R18
          brne WGLOOP222
          dec  R17
          brne WGLOOP122
; ----------------------------- 
; warte 2 Zyklen:
          nop
          nop
; =============================

		in temp1, PINB
		sbrs temp1, 1
		rjmp VS1002_init
		rjmp SCI_MODE


SCI_MODE:

		in temp1, PINB
		sbrs temp1, 1
		rjmp SCI_MODE

		cbi PORTB, 3

		ldi temp1, 0x02
		out	SPDR,	temp1 
lp727:	sbis	SPSR,	SPIF
		rjmp	lp727
		


		ldi temp1, 0x00
		out	SPDR,	temp1 
lp827:	sbis	SPSR,	SPIF
		rjmp	lp827

		
		ldi temp1, 0x08
		out	SPDR,	temp1 
lp927:	sbis	SPSR,	SPIF
		rjmp	lp927


		ldi temp1, 0x00
		out	SPDR,	temp1 
lp1027:	sbis	SPSR,	SPIF
		rjmp	lp1027

		sbi PORTB, 3

	


SCI_CLOCKF:
		
		in temp1, PINB
		sbrs temp1, 1
		rjmp SCI_CLOCKF

		cbi PORTB, 3

		ldi temp1, 0x02
		out	SPDR,	temp1 
lp77:	sbis	SPSR,	SPIF
		rjmp	lp77
		


		ldi temp1, 0x03
		out	SPDR,	temp1 
lp87:	sbis	SPSR,	SPIF
		rjmp	lp87

		
		ldi temp1, 0x98
		out	SPDR,	temp1 
lp97:	sbis	SPSR,	SPIF
		rjmp	lp97


		ldi temp1, 0x00
		out	SPDR,	temp1 
lp107:	sbis	SPSR,	SPIF
		rjmp	lp107

		sbi PORTB, 3



SCI_AUDATA:
		
		in temp1, PINB
		sbrs temp1, 1
		rjmp SCI_AUDATA

		cbi PORTB, 3

		ldi temp1, 0x02
		out	SPDR,	temp1 
lp76:	sbis	SPSR,	SPIF
		rjmp	lp76
		


		ldi temp1, 0x05
		out	SPDR,	temp1 
lp86:	sbis	SPSR,	SPIF
		rjmp	lp86

		
		ldi temp1, 0xAC
		out	SPDR,	temp1 
lp96:	sbis	SPSR,	SPIF
		rjmp	lp96


		ldi temp1, 0x45
		out	SPDR,	temp1 
lp106:	sbis	SPSR,	SPIF
		rjmp	lp106

		sbi PORTB, 3


; ============================= 
;   Warteschleifen-Generator 
;     26000 Zyklen:
; ----------------------------- 
; warte 25992 Zyklen:
          ldi  temp1, $26
WGLOOP099:  ldi  temp2, $E3
WGLOOP199:  dec  temp2
          brne WGLOOP199
          dec  temp1
          brne WGLOOP099
; ----------------------------- 
; warte 6 Zyklen:
          ldi  temp1, $02
WGLOOP299:  dec  temp1
          brne WGLOOP299
; ----------------------------- 
; warte 2 Zyklen:
          nop
          nop
; ============================= 



;//Aktiviren des SPI - Bus, Clock = Idel High
		;ldi	work,	(1<<SPE)|(1<<MSTR)|(1<<SPR0)	;//Enable SPI, SPI in Master Mode
		ldi	temp1,	0x50
		out	SPCR,	temp1
		ldi temp1,  0x01
		out	SPSR,	temp1


		
		ret










VS1002_SDI:


		;//Aktiviren des SPI - Bus, Clock = Idel High
		;ldi	work,	(1<<SPE)|(1<<MSTR)|(1<<SPR0)	;//Enable SPI, SPI in Master Mode
		ldi	temp1,	0x50
		out	SPCR,	temp1
		ldi temp1,  0x00
		out	SPSR,	temp1
		

			ldi ZL, LOW(cluster*2)               ; Adresse von clusterspeicher in den z pointer laden
       		ldi ZH, HIGH(cluster*2)

VS1002_SDI2:		

		in temp1, PINB
		sbrs temp1, 1
		rjmp VS1002_SDI2


		cbi PORTB, 2

		ldi temp2, 0x10  ;512byte counter

VS1002_SDI03:
		ldi temp3, 0x20  ;32byte counter


		in temp1, PINB
		sbrs temp1, 1
		rjmp VS1002_SDI03

		
VS1002_SDI3:
		ld temp1, Z+
		out	SPDR,	temp1 
	lp75:	sbis	SPSR,	SPIF
		rjmp	lp75
		dec temp3
		cpi temp3, 0x00
		brne VS1002_SDI3

		dec temp2
		cpi temp2, 0x00
		brne VS1002_SDI03

		sbi PORTB, 2	

		ldi	temp1,	0x50		;SPI verschnellern nach vs1002 auf mmc
		out	SPCR,	temp1
		ldi temp1,  0x01
		out	SPSR,	temp1       ;hier kann die geschwindigkeit au noch verdoppelt werden durch
							;schreiben von 0x01 in das register SPSR
		

		ret





Sinustest:
		
		in temp1, PINB
		sbrs temp1, 1
		rjmp Sinustest

		
Sinustest2:

		nop
		nop

		cbi PORTB, 2


		ldi temp1, 0x53
		out	SPDR,	temp1 
lp753:	sbis	SPSR,	SPIF
		rjmp	lp753
		


		ldi temp1, 0xEF
		out	SPDR,	temp1 
lp853:	sbis	SPSR,	SPIF
		rjmp	lp853

		
		ldi temp1, 0x6E
		out	SPDR,	temp1 
lp953:	sbis	SPSR,	SPIF
		rjmp	lp953


		ldi temp1, 0x44
		out	SPDR,	temp1 
lp1053:	sbis	SPSR,	SPIF
		rjmp	lp1053


		ldi temp1, 0x00
		out	SPDR,	temp1 
lp74:	sbis	SPSR,	SPIF
		rjmp	lp74
		


		ldi temp1, 0x00
		out	SPDR,	temp1 
lp84:	sbis	SPSR,	SPIF
		rjmp	lp84

		
		ldi temp1, 0x00
		out	SPDR,	temp1 
lp94:	sbis	SPSR,	SPIF
		rjmp	lp94


		ldi temp1, 0x00
		out	SPDR,	temp1 
lp104:	sbis	SPSR,	SPIF
		rjmp	lp104


		


; ============================= 
;   Warteschleifen-Generator 
;     8000000 Zyklen:
; ----------------------------- 
; warte 7999992 Zyklen:
          ldi  R17, $48
WGLOOP04:  ldi  R18, $BC
WGLOOP14:  ldi  R19, $C4
WGLOOP24:  dec  R19
          brne WGLOOP24
          dec  R18
          brne WGLOOP14
          dec  R17
          brne WGLOOP04
; ----------------------------- 
; warte 6 Zyklen:
          ldi  R17, $02
WGLOOP34:  dec  R17
          brne WGLOOP34
; ----------------------------- 
; warte 2 Zyklen:
          nop
          nop
; ============================= 
		
		sbi PORTB, 2
		
		nop
		nop
		
		cbi PORTB,2	
			
				
		ldi temp1, 0x45
		out	SPDR,	temp1 
lp73:	sbis	SPSR,	SPIF
		rjmp	lp73
		


		ldi temp1, 0x78
		out	SPDR,	temp1 
lp83:	sbis	SPSR,	SPIF
		rjmp	lp83

		
		ldi temp1, 0x69
		out	SPDR,	temp1 
lp93:	sbis	SPSR,	SPIF
		rjmp	lp93


		ldi temp1, 0x74
		out	SPDR,	temp1 
lp103:	sbis	SPSR,	SPIF
		rjmp	lp103


		ldi temp1, 0x00
		out	SPDR,	temp1 
lp731:	sbis	SPSR,	SPIF
		rjmp	lp731
		


		ldi temp1, 0x00
		out	SPDR,	temp1 
lp831:	sbis	SPSR,	SPIF
		rjmp	lp831

		
		ldi temp1, 0x00
		out	SPDR,	temp1 
lp931:	sbis	SPSR,	SPIF
		rjmp	lp931


		ldi temp1, 0x00
		out	SPDR,	temp1 
lp1031:	sbis	SPSR,	SPIF
		rjmp	lp1031

				
		sbi PORTB, 2
		
; ============================= 
;   Warteschleifen-Generator 
;     8000000 Zyklen:
; ----------------------------- 
; warte 7999992 Zyklen:
          ldi  R17, $48
WGLOOP02:  ldi  R18, $BC
WGLOOP12:  ldi  R19, $C4
WGLOOP22:  dec  R19
          brne WGLOOP22
          dec  R18
          brne WGLOOP12
          dec  R17
          brne WGLOOP02
; ----------------------------- 
; warte 6 Zyklen:
          ldi  R17, $02
WGLOOP32:  dec  R17
          brne WGLOOP32
; ----------------------------- 
; warte 2 Zyklen:
          nop
          nop
; ============================= 



rjmp Sinustest2



;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;






;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;,
;

;ID3 tags

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;nur TPE1,TALB,TCON und TIT2  bislang integriert
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


ID3_TAG:

lds r20, first_DATA_cluster
	lds r21, first_DATA_cluster+1
	
	
	mov ZH, r20
	mov ZL, r21
	sbiw ZH:ZL, 0x02			;berechnung für das datencluster, da immer 2 werte kleiner als fat wert
	
	ldi r20, 0x00
	mov r9, r20
	mov r20, ZL
	mov r21, ZH					;register für 512 byte addierung
	ldi r22, 0x00

				lds r25, sectors_per_cluster
greater_cluster_id:
	
				lsl r22
				lsl r21
				adc r22, r9			;auf 512byte umrechnen
				lsl r20
				adc r21, r9


	lds temp1, DATA_start
	lds temp2, DATA_start+1
	lds temp3, DATA_start+2
	lds temp4, DATA_start+3


greater_cluster1_id:

				add temp3, r20
				adc temp2, r21					;addresse des clusters berechnen 
				adc temp1, r22
	
				dec r25
				cpi r25, 0x00
				brne greater_cluster1_id	;wenn grösser als 512 muss wiederholt werden, da grössere cluster

	sts addresse, temp1
	sts addresse+1, temp2
	sts addresse+2, temp3
	sts addresse+3, temp4 


		rcall Read_Block_MMC	;liest cluster von der fat der MMc karte

		ldi ZL, LOW(cluster*2)	;setzen des Z pointers auf die Anfangsadresse von cluster
		ldi ZH, HIGH(cluster*2)

		ld temp1, Z+
		cpi temp1, 0x49			;PRÜFUNG OB ID3-TAG VORHANDEN
		breq id3_11
		ret
id3_11:
		ld temp1, Z+
		cpi temp1, 0x44
		breq id3_12
		ret
id3_12:
		ld temp1, Z+
		cpi temp1, 0x33
		breq ID3_is_there
		ret

ID3_is_there:

				


ldi r20, 0x00			;addierer 		
ldi r21, 0x00			;zähler für 512bytes dann schluss,
ldi r22, 0x00




		ldi temp1, 0xBB
		rcall lcd_command_left
		ldi temp1, 0x40
		rcall lcd_command_left


		ldi ZL, LOW(cluster*2)	;setzen des Z pointers auf die Anfangsadresse von cluster
		ldi ZH, HIGH(cluster*2)

ID3_0_TIT2:		
		
		ldi temp1, 0x01
		add r20, temp1
		adc r21, r22
		cpi r21, 0x02
		breq ID3_0_TPE11

		ld temp1, Z+
		cpi temp1,0x54
		breq ID3_1_TIT2
		rjmp ID3_0_TIT2

ID3_0_TPE11:

		rjmp ID3_0_TPE1

ID3_1_TIT2:


		ldi temp1, 0x01
		add r20, temp1
		adc r21, r22
		cpi r21, 0x02
		breq ID3_0_TPE111

		ld temp1, Z+
		cpi temp1, 0x49
		breq ID3_2_TIT2

		sbiw ZH:ZL, 0x01
		subi r20, 0x01
		sbc r21, r22

		rjmp ID3_0_TIT2

ID3_2_TIT2:

		ldi temp1, 0x01
		add r20, temp1
		adc r21, r22
		cpi r21, 0x02
		breq ID3_0_TPE1

		ld temp1, Z+
		cpi temp1, 0x54
		breq ID3_3_TIT2

		sbiw ZH:ZL, 0x02
		subi r20, 0x02
		sbc r21, r22

		rjmp ID3_0_TIT2	


ID3_3_TIT2:

		ldi temp1, 0x01
		add r20, temp1
		adc r21, r22
		cpi r21, 0x02
		breq ID3_0_TPE1

		ld temp1, Z+
		cpi temp1, 0x32
		breq lcd_show_ID3_TIT2

		sbiw ZH:ZL, 0x03
		subi r20, 0x03
		sbc r21, r22

		rjmp ID3_0_TIT2	
		

ID3_0_TPE111:

		rjmp ID3_0_TPE1

lcd_show_ID3_TIT2:

		ldi r20, 0xBB
		sts response_save, r20
		mov temp1, r20
		rcall lcd_command_left
		ldi temp1, 0x40
		rcall lcd_command_left

		mov r0, ZL
		mov r1, ZH


		ldi ZL, LOW(Titel_font*2)
		ldi ZH, HIGH(Titel_font*2)

		ldi r20, 0x1E

Titel_font_lcd:

		lpm temp1, Z+
		rcall lcd_data_left
		dec r20
		cpi r20, 0x00
		breq Titel_weiter
		rjmp Titel_font_lcd

Titel_weiter:
		
		ldi temp1, 0b00000000
		rcall lcd_data_left
		ldi temp1, 0b00011000
		rcall lcd_data_left
		ldi temp1, 0b00011000
		rcall lcd_data_left

		mov ZL, r0
		mov ZH, r1
		

		rcall lcd_show_ID3
		rjmp ID3_0_TPE1



Titel_font:										;T									;I									;T									;E									;L

		.db		0x03, 0x03, 0x7F, 0x7F, 0x03, 0x03, 0x00, 0x00, 0x7F, 0x7F, 0x00, 0x00, 0x03, 0x03, 0x7F, 0x7F, 0x03, 0x03, 0x00, 0x7F, 0x7F, 0x6B, 0x6B, 0x63, 0x00, 0x7F, 0x7F, 0x60, 0x60, 0x00

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;




ID3_0_TPE1:


		ldi ZL, LOW(cluster*2)	;setzen des Z pointers auf die Anfangsadresse von cluster
		ldi ZH, HIGH(cluster*2)


ldi r20, 0x00			;addierer 		
ldi r21, 0x00			;zähler für 512bytes dann schluss,
ldi r22, 0x00





		ldi temp1, 0xBC
		rcall lcd_command_left
		ldi temp1, 0x40
		rcall lcd_command_left


ID3_1_TPE1:		
		
		ldi temp1, 0x01
		add r20, temp1
		adc r21, r22
		cpi r21, 0x02
		breq ID3_0_TALB11
			
		ld temp1, Z+
		cpi temp1,0x54
		breq ID3_2_TPE1
		rjmp ID3_1_TPE1


ID3_0_TALB11:

		rjmp ID3_0_TALB

ID3_2_TPE1:

		ldi temp1, 0x01
		add r20, temp1
		adc r21, r22
		cpi r21, 0x02
		breq ID3_0_TALB111

		ld temp1, Z+
		cpi temp1, 0x50
		breq ID3_3_TPE1

		sbiw ZH:ZL, 0x01
		subi r20, 0x01
		sbc r21, r22

		rjmp ID3_1_TPE1
		

ID3_0_TALB111:

	rjmp ID3_0_TALB



ID3_3_TPE1:

		ldi temp1, 0x01
		add r20, temp1
		adc r21, r22
		cpi r21, 0x02
		breq ID3_0_TALB111

		ld temp1, Z+
		cpi temp1, 0x45
		breq ID3_4_TPE1

		sbiw ZH:ZL, 0x02
		subi r20, 0x02
		sbc r21, r22

		rjmp ID3_1_TPE1	


ID3_4_TPE1:

		ldi temp1, 0x01
		add r20, temp1
		adc r21, r22
		cpi r21, 0x02
		breq ID3_0_TALB

		ld temp1, Z+
		cpi temp1, 0x31
		breq lcd_show_ID3_TPE1

		sbiw ZH:ZL, 0x03
		subi r20, 0x03
		sbc r21, r22

		rjmp ID3_1_TPE1	




lcd_show_ID3_TPE1:

		ldi r20, 0xBC
		sts response_save, r20
		mov temp1, r20
		rcall lcd_command_left
		ldi temp1, 0x40
		rcall lcd_command_left

		mov r0, ZL
		mov r1, ZH


		ldi ZL, LOW(BANDS_font*2)
		ldi ZH, HIGH(BANDS_font*2)

		ldi r20, 0x1E

Bands_font_lcd:

		lpm temp1, Z+
		rcall lcd_data_left
		dec r20
		cpi r20, 0x00
		breq Bands_weiter
		rjmp Bands_font_lcd

Bands_weiter:
		
		ldi temp1, 0b00000000
		rcall lcd_data_left
		ldi temp1, 0b00011000
		rcall lcd_data_left
		ldi temp1, 0b00011000
		rcall lcd_data_left

		mov ZL, r0
		mov ZH, r1
		

		rcall lcd_show_ID3
		rjmp ID3_0_TALB






BANDS_font:							      ;B								   ;A									;N									;D									;S

	.db		0x7F, 0x7F, 0x6B, 0x6B, 0x36, 0x00, 0x7C, 0x7E, 0x13, 0x7E, 0x7C, 0x00, 0x7F, 0x7F, 0x0C, 0x18, 0x7F, 0x7F, 0x00, 0x7F, 0x7F, 0x63, 0x63, 0x3E, 0x00, 0x60, 0x66, 0x6F, 0x7B, 0x33


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;





ID3_0_TALB:

		ldi ZL, LOW(cluster*2)	;setzen des Z pointers auf die Anfangsadresse von cluster
		ldi ZH, HIGH(cluster*2)


ldi r20, 0x00			;addierer 		
ldi r21, 0x00			;zähler für 512bytes dann schluss,
ldi r22, 0x00




		ldi temp1, 0xBD
		rcall lcd_command_left
		ldi temp1, 0x40
		rcall lcd_command_left


ID3_1_TALB:	
		
		ldi temp1, 0x01
		add r20, temp1
		adc r21, r22
		cpi r21, 0x02
		breq ID3_0_TCON11
			
		ld temp1, Z+
		cpi temp1,0x54
		breq ID3_2_TALB
		rjmp ID3_1_TALB


ID3_0_TCON11:

		rjmp ID3_0_TCON

ID3_2_TALB:

		ldi temp1, 0x01
		add r20, temp1
		adc r21, r22
		cpi r21, 0x02
		breq ID3_0_TCON111

		ld temp1, Z+
		cpi temp1, 0x41
		breq ID3_3_TALB

		sbiw ZH:ZL, 0x01
		subi r20, 0x01
		sbc r21, r22

		rjmp ID3_1_TALB
		


ID3_0_TCON111:

		rjmp ID3_0_TCON




ID3_3_TALB:

		ldi temp1, 0x01
		add r20, temp1
		adc r21, r22
		cpi r21, 0x02
		breq ID3_0_TCON

		ld temp1, Z+
		cpi temp1, 0x4C
		breq ID3_4_TALB

		sbiw ZH:ZL, 0x02
		subi r20, 0x02
		sbc r21, r22

		rjmp ID3_1_TALB


ID3_4_TALB:

		ldi temp1, 0x01
		add r20, temp1
		adc r21, r22
		cpi r21, 0x02
		breq ID3_0_TCON

		ld temp1, Z+
		cpi temp1, 0x42
		breq lcd_show_ID3_TALB

		sbiw ZH:ZL, 0x03
		subi r20, 0x03
		sbc r21, r22

		rjmp ID3_1_TALB	

lcd_show_ID3_TALB:

		ldi r20, 0xBD
		sts response_save, r20
		mov temp1, r20
		rcall lcd_command_left
		ldi temp1, 0x40
		rcall lcd_command_left

		mov r0, ZL
		mov r1, ZH


		ldi ZL, LOW(ALBUM_font*2)
		ldi ZH, HIGH(ALBUM_font*2)

		ldi r20, 0x1E

ALBUM_font_lcd:

		lpm temp1, Z+
		rcall lcd_data_left
		dec r20
		cpi r20, 0x00
		breq ALBUM_weiter
		rjmp ALBUM_font_lcd

ALBUM_weiter:
		
		ldi temp1, 0b00000000
		rcall lcd_data_left
		ldi temp1, 0b00011000
		rcall lcd_data_left
		ldi temp1, 0b00011000
		rcall lcd_data_left

		mov ZL, r0
		mov ZH, r1


		rcall lcd_show_ID3
		rjmp ID3_0_TCON


ALBUM_font:							        ;A									;L									;B									;U									;M

	.db		0x7C, 0x7E, 0x13, 0x7E, 0x7C, 0x00, 0x7F, 0x7F, 0x60, 0x60, 0x60, 0x00, 0x7F, 0x7F, 0x6B, 0x6B, 0x36, 0x00, 0x7F, 0x7F, 0x60, 0x7F, 0x7F, 0x00, 0x7E, 0x07, 0x1F, 0x06, 0x7F, 0x7F

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;



ID3_0_TCON:

		ldi ZL, LOW(cluster*2)	;setzen des Z pointers auf die Anfangsadresse von cluster
		ldi ZH, HIGH(cluster*2)


ldi r20, 0x00			;addierer 		
ldi r21, 0x00			;zähler für 512bytes dann schluss,
ldi r22, 0x00





		ldi temp1, 0xBE
		rcall lcd_command_left
		ldi temp1, 0x40
		rcall lcd_command_left


ID3_1_TCON:	
		
		ldi temp1, 0x01
		add r20, temp1
		adc r21, r22
		cpi r21, 0x02
		breq ID3_ende2002
			
		ld temp1, Z+
		cpi temp1,0x54
		breq ID3_2_TCON
		rjmp ID3_1_TCON


ID3_ende2002:

		rjmp ID3_ende200

ID3_2_TCON:

		ldi temp1, 0x01
		add r20, temp1
		adc r21, r22
		cpi r21, 0x02
		breq ID3_ende200

		ld temp1, Z+
		cpi temp1, 0x43
		breq ID3_3_TCON

		sbiw ZH:ZL, 0x01
		subi r20, 0x01
		sbc r21, r22

		rjmp ID3_1_TCON
		

ID3_3_TCON:

		ldi temp1, 0x01
		add r20, temp1
		adc r21, r22
		cpi r21, 0x02
		breq ID3_ende200

		ld temp1, Z+
		cpi temp1, 0x4F
		breq ID3_4_TCON

		sbiw ZH:ZL, 0x02
		subi r20, 0x02
		sbc r21, r22

		rjmp ID3_1_TCON


ID3_4_TCON:

		ldi temp1, 0x01
		add r20, temp1
		adc r21, r22
		cpi r21, 0x02
		breq ID3_ende200

		ld temp1, Z+
		cpi temp1, 0x4E
		breq lcd_show_ID3_TCON

		sbiw ZH:ZL, 0x03
		subi r20, 0x03
		sbc r21, r22

		rjmp ID3_1_TCON	


lcd_show_ID3_TCON:

		ldi r20, 0xBE
		sts response_save, r20
		mov temp1, r20
		rcall lcd_command_left
		ldi temp1, 0x40
		rcall lcd_command_left

		mov r0, ZL
		mov r1, ZH


		ldi ZL, LOW(GENRE_font*2)
		ldi ZH, HIGH(GENRE_font*2)

		ldi r20, 0x1E

GENRE_font_lcd:

		lpm temp1, Z+
		rcall lcd_data_left
		dec r20
		cpi r20, 0x00
		breq GENRE_weiter
		rjmp GENRE_font_lcd

GENRE_weiter:
		
		ldi temp1, 0b00000000
		rcall lcd_data_left
		ldi temp1, 0b00011000
		rcall lcd_data_left
		ldi temp1, 0b00011000
		rcall lcd_data_left

		mov ZL, r0
		mov ZH, r1


		rcall lcd_show_ID3

		ret			; RÜCKSPRUNG ZUR ROOTDIRECTORY, DA alle ID3TAGS gelesen





ID3_ende200:

		ret			;RÜCKSPRUNG ZUR ROOTDIRECTORY, DA alle ID3TAGS gelesen





GENRE_font:							        ;G									;E									;N									;R									;E

	.db		0x3E, 0x7F, 0x63, 0x6B, 0x7B, 0x00, 0x7F, 0x7F, 0x6B, 0x6B, 0x63, 0x00, 0x7F, 0x7F, 0x0C, 0x18, 0x7F, 0x7F, 0x00, 0x7F, 0x7F, 0x3D, 0x77, 0x67,	0x00, 0x7F, 0x7F, 0x6B, 0x6B, 0x63
		


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;





lcd_show_ID3:    ;rcall befehl !!!!!!!
				 ;in r20 steht die LCD PAGE für den wechsel auf die rechte seite !!!!!!!!!


		

		ld temp1, Z+
		cpi temp1, 0x20
		brsh lcd_show_ID3_1
		rjmp lcd_show_ID3

lcd_show_ID3_1:

		rcall alphabet_search_left

		ldi XL, LOW(ID3_TAG_zeichen*2)
		ldi XH, HIGH(ID3_TAG_zeichen*2)

		ldi r21, 0x00

lcd_show_ID3_2:

		inc r21
		cpi r21, 0x13
		breq ID3_TAG_ENDE
		ld temp1, Z+
		st X+, temp1
		cpi temp1, 0x20
		brlo ID3_TAG_ENDE
		rjmp lcd_show_ID3_2
		

ID3_TAG_ENDE:	

		ldi XL, LOW(ID3_TAG_zeichen*2)
		ldi XH, HIGH(ID3_TAG_zeichen*2)	
		
		subi r21, 0x05
		ldi r20, 0x04

ID3_TAG_ENDE1:

		cpi r20, 0x00

		ld temp1, X+
		rcall alphabet_search_left
		dec r20
		cpi r20, 0x00
		breq ID3_TAG_ENDE1_rechts
		dec r21
		cpi r21, 0x00
		breq endenenenen
		rjmp ID3_TAG_ENDE1



endenenenen:

		rjmp endenenenen200






ID3_TAG_ENDE1_rechts: ;da noch 4 zeichen auf der linken seite frei, die erst nutzen dann rechts weiter

		lds temp1, response_save
		rcall lcd_command_right
		ldi temp1, 0x40
		rcall lcd_command_right


LAST_signs_right:

		dec r21
		cpi r21, 0x00
		breq endenenenen
		
		
		ld temp1, X+
		rcall alphabet_search_right
		
		rjmp LAST_signs_right




endenenenen200:


		ret



;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;



FRAMEHEADER:
			

			lds r20, sectors_per_cluster
			sts byte_speicher, r20

			lds r20, first_DATA_cluster
			lds r21, first_DATA_cluster+1
	
	
	mov ZH, r20
	mov ZL, r21
	sbiw ZH:ZL, 0x02			;berechnung für das datencluster, da immer 2 werte kleiner als fat wert
	
	ldi r20, 0x00
	mov r9, r20
	mov r20, ZL
	mov r21, ZH					;register für 512 byte addierung
	ldi r22, 0x00

				lds r25, sectors_per_cluster

greater_cluster_id_frameH:
	
				lsl r22
				lsl r21
				adc r22, r9			;auf 512byte umrechnen
				lsl r20
				adc r21, r9


	lds temp1, DATA_start
	lds temp2, DATA_start+1
	lds temp3, DATA_start+2
	lds temp4, DATA_start+3


greater_cluster1_id_frameH:

				add temp3, r20
				adc temp2, r21					;addresse des clusters berechnen 
				adc temp1, r22
	
				dec r25
				cpi r25, 0x00
				brne greater_cluster1_id_frameH	;wenn grösser als 512 muss wiederholt werden, da grössere cluster

	sts addresse, temp1
	sts addresse+1, temp2
	sts addresse+2, temp3
	sts addresse+3, temp4 


		rcall Read_Block_MMC	;liest cluster von der fat der MMc karte

		

frame_search_next_sektor2:

		ldi ZL, LOW(cluster*2)	;setzen des Z pointers auf die Anfangsadresse von cluster
		ldi ZH, HIGH(cluster*2)


		ldi temp2, 0x00
		ldi temp3, 0x00
		ldi temp4, 0x00
		ldi r20  , 0x01
		
frame_search1:

		add temp2, r20
		adc temp3, temp4
		cpi temp3, 0x02				;wenn 512byte erreicht schluss
		breq frame_search_next_sektor1

		ld temp1, Z+
		cpi temp1, 0xFF				;schauen ob erste 8bit gesetzt, weil Frameheader immer erste 11bit gesetzt
		breq frame_search2
		rjmp frame_search1
		
frame_search2:

		add temp2, r20
		adc temp3, temp4
		cpi temp3, 0x02				;wenn 512byte erreicht schluss
		breq frame_search_next_sektor1

		ld temp1, Z+
		cpi temp1, 0xE0				;schauen ob erste 3bit gesetzt, weil Frameheader immer erste 11bit gesetzt
		brsh frame_search_found
		rjmp frame_search1
		
		
		
frame_search_next_sektor1:

				lds temp1, byte_speicher
				dec temp1
				cpi temp1, 0x00
				breq frame_search_finish200
				sts byte_speicher, temp1

				lds temp1, addresse
				lds temp2, addresse+1
				lds temp3, addresse+2
				lds temp4, addresse+3

				ldi r20, 0x00
				mov r9, r20
				ldi r20, 0x02
				add temp3, r20
				adc temp2, r9
				adc temp1, r9

				sts addresse, temp1
				sts addresse+1, temp2
				sts addresse+2, temp3
				sts addresse+3, temp4


				rcall Read_Block_MMC 

				rjmp frame_search_next_sektor2



frame_search_finish200:	
		
				rjmp frame_search_finish

							
				
frame_search_found:				

				ld temp1, Z+
				ldi temp2, 0xF0
				and temp1, temp2
			
				cpi temp1, 0x00
				breq frame_search_finish201
				cpi temp1, 0xF0
				breq frame_search_finish201
				cpi temp1, 0x10
				breq frame_header_0001
				cpi temp1, 0x20
				breq frame_header_0010
				cpi temp1, 0x30
				breq frame_header_0011
				cpi temp1, 0x40
				breq frame_header_0100
				cpi temp1, 0x50
				breq frame_header_0101
				cpi temp1, 0x60
				breq frame_header_0110
				cpi temp1, 0x70
				breq frame_header_0111
				cpi temp1, 0x80
				breq frame_header_1000
				cpi temp1, 0x90
				breq frame_header_1001
				cpi temp1, 0xA0
				breq frame_header_1010
				cpi temp1, 0xB0
				breq frame_header_1011
				cpi temp1, 0xC0
				breq frame_header_1100
				cpi temp1, 0xD0
				breq frame_header_1101
				cpi temp1, 0xE0
				breq frame_header_1110

frame_search_finish201:

			rjmp frame_search_finish

;; da die frames per second in kbit angegeben ist gleich umwandlung in byte !!!!!

frame_header_0001:

				ldi r20, 0x04
				mov r0,r20
				rjmp rechnung_frame

frame_header_0010:

				ldi r20, 0x05
				mov r0,r20
				rjmp rechnung_frame

frame_header_0011:

				ldi r20, 0x06
				mov r0,r20
				rjmp rechnung_frame


frame_header_0100:

				ldi r20, 0x07
				mov r0,r20
				rjmp rechnung_frame

frame_header_0101:

				ldi r20, 0x08
				mov r0,r20
				rjmp rechnung_frame

frame_header_0110:

				ldi r20, 0x0A
				mov r0,r20
				rjmp rechnung_frame

frame_header_0111:

				ldi r20, 0x0C
				mov r0,r20
				rjmp rechnung_frame

frame_header_1000:

				ldi r20, 0x0E
				mov r0,r20
				rjmp rechnung_frame

frame_header_1001:

				ldi r20, 0x10
				mov r0,r20
				rjmp rechnung_frame

frame_header_1010:

				ldi r20, 0x14
				mov r0,r20
				rjmp rechnung_frame

frame_header_1011:

				ldi r20, 0x18
				mov r0,r20
				rjmp rechnung_frame


frame_header_1100:

				ldi r20, 0x1C
				mov r0,r20
				rjmp rechnung_frame

frame_header_1101:

				ldi r20, 0x20
				mov r0,r20
				rjmp rechnung_frame

frame_header_1110:

				ldi r20, 0x28
				mov r0,r20
				rjmp rechnung_frame



rechnung_frame:

			sts FRAMES_per_second, r0

			mov temp1, r0
			ldi temp2, 0x04
			mul temp1, temp2

			
			clr temp1
			clr temp2
			clr temp3
			clr temp4

			ldi r20, 0xFA
			ldi temp2, 0x01


rechnungframe_zeitzaehler:					;hochrechnen auf 1000er wegen zeitzaehler

			add temp4, r20
			adc temp3, temp1

			sub r0, temp2
			cp r0, temp1
			breq end_zeitzaehler_frame
			rjmp rechnungframe_zeitzaehler

end_zeitzaehler_frame:						;ergebnis in temp4-temp3

			sts FRAMES_per_second_end,temp3		
			sts FRAMES_per_second_end+1,temp4
			sts FRAMES_per_second_end+2,temp3		
			sts FRAMES_per_second_end+3,temp4 


;;;;;;
			
			lds temp1, MP3_data_length
			lds temp2, MP3_data_length+1
			lds temp3, MP3_data_length+2
			lds temp4, MP3_data_length+3


			
ldi r20, 0x01
mov r0, r20

ldi r20, 0xC8
mov r1, r20			;200

ldi r20, 0x00
mov r2, r20
mov r3, r20
mov r4, r20




loop:    ;1000 teilen


			sub temp4, r1
			sbc temp3, r20
			sbc temp2, r20
			sbc temp1, r20
			
			sub temp4, r1
			sbc temp3, r20
			sbc temp2, r20
			sbc temp1, r20		
		
			sub temp4, r1
			sbc temp3, r20
			sbc temp2, r20
			sbc temp1, r20
			
			sub temp4, r1
			sbc temp3, r20
			sbc temp2, r20
			sbc temp1, r20		
		
			sub temp4, r1
			sbc temp3, r20
			sbc temp2, r20
			sbc temp1, r20

			add r2, r0
			adc r3, r20
			adc r4, r20

			cpi temp1, 0x00
			breq loop1
			rjmp loop

loop1:

			cpi temp2, 0x00
			breq loop2
			rjmp loop

loop2:


			mov r5, temp3
			ldi r20, 0xFC
			and r5, r20
			ldi r20 ,0x00
			cp r5, r20
			breq weiter
			rjmp loop



weiter:		;geteilt durch frames = titellänge in sek, allerdings in hex


		
ldi r20, 0x01
mov r0, r20

lds r20, FRAMES_per_second
mov r1, r20	
	
ldi r16, 0x00
ldi r17, 0x00
ldi r18, 0x00
ldi r19, 0x00

ldi r20, 0x00
mov r5, r20
mov r6, r20
mov r7, r20




weiter1:

			sub r2, r1
			sbc r3, r20
			sbc r4, r20

			add r16, r0
			adc r17, r20
			adc r18, r20
			
			
			cp r4, r20
			breq weiter2
			brmi weiter2
			rjmp weiter1

weiter2:

			cp r3, r20
			breq weiter3
			brmi weiter3
			rjmp weiter1

weiter3:

			cp r2, r0
			brlo weiter4
			ldi r20, 0xFF
			cp r4, r20
			breq weiter4
			ldi r20, 0x00
			rjmp weiter1




weiter4:
			ldi r20, 0x01
			ldi r21, 0x00
			sub r16, r20
			sbc r17, r21
			sbc r18, r21



;ab hier sind ergebmnisse eigentlich in r16-r18


ldi r20, 0x00
mov r0, r20
mov r1, r20
mov r2, r20
mov r3, r20


ldi r21, 0x01
ldi r20, 0x3C
ldi r28, 0x00



minuten0:

sub temp1, r20
sbc temp2, r28
sbc temp3, r28

add r0, r21
adc r1, r28

cpi temp3, 0x00
breq minuten1
brmi minuten1
rjmp minuten0


minuten1:

cpi temp2, 0x00
breq minuten2
brmi minuten2
rjmp minuten0


minuten2:

cpi temp1, 0x00
breq end_dezi2
brlo end_minuten
ldi r28, 0xFF
cp temp3, r28
breq end_minuten
ldi r28, 0x00
rjmp minuten0


end_dezi2:

		ldi temp1, 0x00
		rjmp end_dezi



end_minuten:

		ldi r20, 0x01
		ldi r21, 0x00

		sub r0, r20
		sbc r1, r21



		ldi r20, 0x3C

		add temp1, r20

		
		; sek in temp1 und minuten in r0

end_dezi:

		ldi r20, 0x00
		mov r1, r20
		mov r2, r20
		mov r3, r20
		ldi r20, 0x64
		ldi r21, 0x01

huni_min:

		sub r0, r20
		brmi zen_min
		add r1, r21
		rjmp huni_min

zen_min:

		add r0, r20
		ldi r20, 0x0A
		ldi r21, 0x01

zen_min1:

		sub r0, r20
		brmi ein_min
		add r2, r21
		rjmp zen_min1

ein_min:

		add r0, r20
		mov r3, r0



zen_sek:

		ldi r20, 0x0A
		ldi r21, 0x01
		ldi temp2, 0x00
		ldi temp3, 0x00

zen_sek1:

		sub temp1, r20
		brmi ein_sek
		add temp2, r21
		rjmp zen_sek1

ein_sek:

		add temp1, r20
		mov temp3, temp1

;ergebnisse jetzt: min. von r1(MSB)-r3 (LSB) und  sek. von temp2(MSB)-temp3(LSB)
		

		;AUSGABE aud LCD
		

		sts minuten_speicher, r1
		sts minuten_speicher+1, r2
		sts minuten_speicher+2, r3

		sts sekunden_speicher, temp2
		sts sekunden_speicher+1, temp3


		ldi r29, 0x30



		ldi temp1, 0xB9
		rcall lcd_command_right
		ldi temp1, 0x40
		rcall lcd_command_right

		;lds temp1, minuten_speicher
		;add temp1, r29
		;rcall alphabet_search_right
		lds temp1, minuten_speicher+1
		add temp1, r29
		rcall alphabet_search_right
		lds temp1, minuten_speicher+2
		add temp1, r29
		rcall alphabet_search_right

		ldi temp1, 0x3A
		rcall alphabet_search_right


		lds temp1, sekunden_speicher
		add temp1, r29
		rcall alphabet_search_right
		lds temp1, sekunden_speicher+1
		add temp1, r29
		rcall alphabet_search_right

			

frame_search_finish:


			ret
			




;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;




TWI_init:


	ldi temp1, 0xC0 			; Bitrate einstellen
	out TWBR, temp1


	ldi temp1, 0b01101111
	sts TDA7318_data, temp1
	rcall TWI_start				;BASS=0db


	ldi temp1, 0b01111111			;TREBLE=0db
	sts TDA7318_data, temp1
	rcall more_TWI_data

	
	ldi temp1, 0b01011000
	sts TDA7318_data, temp1
	rcall more_TWI_data			;AUDIO-switch=Stereo1 
						;und GAIN=0db

	ldi temp1, 0b10000000
	sts TDA7318_data, temp1
	rcall more_TWI_data				;left front=0db


	ldi temp1, 0b10100000
	sts TDA7318_data, temp1
	rcall more_TWI_data				;right front=0db

	ldi temp1, 0b11011111
	sts TDA7318_data, temp1
	rcall more_TWI_data				;left rear=mute

	ldi temp1, 0b11111111
	sts TDA7318_data, temp1
	rcall more_TWI_data				;left rear=mute


	ldi temp1, 0x00
	sts TDA7318_data, temp1
	rcall more_TWI_data				;Volume control=0db




	ldi temp1, (1<<TWINT)|(1<<TWEN)|(1<<TWSTO)	; Stop condition senden
	out TWCR, temp1

	call tastenwait




	ldi temp1, 0x00								;TWI shutdown
	out TWCR, temp1				



		ret




TWI_start:


	ldi temp1, (1<<TWINT)|(1<<TWSTA)|(1<<TWEN)
	out TWCR, temp1				; Start condition senden

wait1:
	in temp1,TWCR				; Warten bis TWINT Flag gesetzt
	sbrs temp1,TWINT			
	rjmp wait1

	in temp1,TWSR				; TWI Statusregister abfragen 
	andi temp1, 0xF8			; Prescalerbits maskieren
	cpi temp1, 0x08				; Startcondition prüfen (Datenblatt: Tabelle 66)
	brne ERROR1

	ldi temp1, 0x88				; Zieladresse in TWDR laden (RW=0)
	out TWDR, temp1				
	ldi temp1, (1<<TWINT) | (1<<TWEN)	; TWINT löschen um Übertragung zu starten
	out TWCR, temp1

wait2:
	in temp1,TWCR				; Warten bis TWINT Flag gesetzt
	sbrs temp1,TWINT
	rjmp wait2

	in temp1,TWSR				; TWSR Status prüfen
	andi temp1, 0xF8			; Prescalerbits maskieren
	cpi temp1, 0x18				; TWSR mit MT_SLA_ACK vergleichen (Datenblatt: Tabelle 66)
	brne ERROR2

more_TWI_data:	lds temp1, TDA7318_data				; Daten in TWDR laden
				out TWDR, temp1				
				ldi temp1, (1<<TWINT) | (1<<TWEN)	; TWINT löschen um Übertragung zu starten
				out TWCR, temp1				

wait3:
	in temp1,TWCR				; Warten bis TWINT Flag gesetzt
	sbrs temp1,TWINT			
	rjmp wait3

	in temp1,TWSR				; TWSR Status prüfen
	andi temp1, 0xF8			; Prescaler maskieren
	cpi temp1, 0x28				; TWSR mit MT_DATA_ACK vergleichen (Datenblatt: Tabelle 66)
	brne ERROR31

	

	ret





ERROR31:

	rjmp ERROR3

ERROR1:


	ldi temp1, (1<<TWINT)|(1<<TWEN)|(1<<TWSTO)	; Stop condition senden
	out TWCR, temp1

	ldi temp1, 0x00								;TWI shutdown
	out TWCR, temp1				


	
	rcall lcd_clear

	ldi temp1, 0xB9
	call lcd_command_left
	ldi temp1, 0x41
	call lcd_command_left 

	ldi temp1, 0x45
	rcall alphabet_search_left
	ldi temp1, 0x52
	rcall alphabet_search_left
	ldi temp1, 0x52
	rcall alphabet_search_left
	ldi temp1, 0x4F
	rcall alphabet_search_left
	ldi temp1, 0x52
	rcall alphabet_search_left
	ldi temp1, 0x31
	rcall alphabet_search_left
	lds temp1, TDA7318_data
	andi temp1, 0xF0
	swap temp1
	ldi temp2, 0x30
	add temp1, temp2
	rcall alphabet_search_left
	lds temp1, TDA7318_data
	andi temp1, 0x0F
	ldi temp2, 0x30
	add temp1, temp2
	rcall alphabet_search_left


	call tastenwait
	call tastenwait

	
	rjmp TWI_init	
	
			

ERROR2:


	ldi temp1, (1<<TWINT)|(1<<TWEN)|(1<<TWSTO)	; Stop condition senden
	out TWCR, temp1

	ldi temp1, 0x00								;TWI shutdown
	out TWCR, temp1				

	
	
	rcall lcd_clear

	ldi temp1, 0xB9
	call lcd_command_left
	ldi temp1, 0x41
	call lcd_command_left 

	ldi temp1, 0x45
	rcall alphabet_search_left
	ldi temp1, 0x52
	rcall alphabet_search_left
	ldi temp1, 0x52
	rcall alphabet_search_left
	ldi temp1, 0x4F
	rcall alphabet_search_left
	ldi temp1, 0x52
	rcall alphabet_search_left
	ldi temp1, 0x32
	rcall alphabet_search_left
	lds temp1, TDA7318_data
	andi temp1, 0xF0
	swap temp1
	ldi temp2, 0x30
	add temp1, temp2
	rcall alphabet_search_left
	lds temp1, TDA7318_data
	andi temp1, 0x0F
	ldi temp2, 0x30
	add temp1, temp2
	rcall alphabet_search_left


	call tastenwait
	call tastenwait
	
	rjmp TWI_init	



		
ERROR3:


	ldi temp1, (1<<TWINT)|(1<<TWEN)|(1<<TWSTO)	; Stop condition senden
	out TWCR, temp1

	ldi temp1, 0x00								;TWI shutdown
	out TWCR, temp1				

	
	
	rcall lcd_clear

	ldi temp1, 0xB9
	call lcd_command_left
	ldi temp1, 0x41
	call lcd_command_left 

	ldi temp1, 0x45
	call alphabet_search_left
	ldi temp1, 0x52
	call alphabet_search_left
	ldi temp1, 0x52
	call alphabet_search_left
	ldi temp1, 0x4F
	call alphabet_search_left
	ldi temp1, 0x52
	call alphabet_search_left
	ldi temp1, 0x33
	call alphabet_search_left
	lds temp1, TDA7318_data
	andi temp1, 0xF0
	swap temp1
	ldi temp2, 0x30
	add temp1, temp2
	call alphabet_search_left
	lds temp1, TDA7318_data
	andi temp1, 0x0F
	ldi temp2, 0x30
	add temp1, temp2
	call alphabet_search_left


	call tastenwait
	call tastenwait
				

	rjmp TWI_init	

			
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;,,
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;,


;___________________________________________________________________________________
;-------------------------------------------------------------------------------



	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                 LCD-Routinen                ;;
;;                 ============                ;;
;;              (c)andreas-s@web.de            ;;
;;                                             ;;
;; 8bit-Interface                              ;;
;; DB0-DB7:       PC0-PC7 					   ;;
;; RESET:		  PD4                          ;;
;; DI:            PD5                          ;;
;; E1:            PD6						   ;;
;; E2:            PD7			               ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

 
 

lcd_init:

	ldi temp1, 0x00
        out UCSRC, temp1
	cbi UCSRB,TXEN 			;usart aus

	ldi temp1, 0x80
	out MCUCSR, temp1		;jtag aus


	ldi temp1, 0xFF
	out DDRC, temp1
	ldi temp1, 0x00			;Register setzen
	out PORTC, temp1
	ldi temp1, 0xF0
	out DDRD, temp1
	ldi temp1, 0x00
	out PORTD, temp1

	


	
	cbi PORTD, 4			;RESET
	rcall wait_5ms
	sbi PORTD, 4
	rcall wait_5ms
	cbi PORTD, 4
	rcall wait_5ms
	rcall wait_5ms
	rcall wait_5ms
	rcall wait_5ms
	rcall wait_5ms
	rcall wait_5ms
	sbi PORTD, 4
	rcall wait_5ms
	rcall wait_5ms
	rcall wait_5ms
	rcall wait_5ms
	rcall wait_5ms
	

	sbi PORTD, 6
	sbi PORTD, 7

	nop 
	nop
	nop
	nop


ldi ZL, LOW(text_command1*2)
		ldi ZH, HIGH(text_command1*2)
		lpm temp1, Z+
		rcall lcd_command_left

		rcall wait_5ms
		rcall wait_5ms
		rcall wait_5ms

		ldi ZL, LOW(text_command1*2)
		ldi ZH, HIGH(text_command1*2)
		lpm temp1, Z+
		rcall lcd_command_right

		rcall wait_5ms
		rcall wait_5ms
		rcall wait_5ms

		rcall lcd_clear


		ldi ZL, LOW(text_command3*2)
		ldi ZH, HIGH(text_command3*2)
		lpm temp1, Z+
		rcall lcd_command_left

		ldi ZL, LOW(text_command4*2)
		ldi ZH, HIGH(text_command4*2)
		lpm temp1, Z+
		rcall lcd_command_left

		
		ret
		

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


lcd_clear:


ldi temp1, 0xB8
rcall lcd_command_left
ldi temp1, 0x40
rcall lcd_command_left

ldi temp3, 0xB8

loop_00_left0:

ldi temp4, 0x00

loop_00_left:

ldi temp1, 0x00
rcall lcd_data_left
inc temp4
cpi temp4, 0x40
breq loop_00_left_next_page
rjmp loop_00_left

loop_00_left_next_page:

inc temp3
cpi temp3, 0xC0
breq loop_00_right
mov temp1, temp3
rcall lcd_command_left
ldi temp1, 0x40
rcall lcd_command_left

rjmp loop_00_left0




;;;;;;;;;;;;;;;;;;;;;;;;

loop_00_right:

ldi temp1, 0xB8
rcall lcd_command_right
ldi temp1, 0x40
rcall lcd_command_right

ldi temp3, 0xB8

loop_00_right1:

ldi temp4, 0x00

loop_00_right2:

ldi temp1, 0x00
rcall lcd_data_right
inc temp4
cpi temp4, 0x40
breq loop_00_right_next_page
rjmp loop_00_right2


loop_00_right_next_page:

inc temp3
cpi temp3, 0xC0
breq loop_00_end
mov temp1, temp3
rcall lcd_command_right
ldi temp1, 0x40
rcall lcd_command_right

rjmp loop_00_right1



loop_00_end:


		ret


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;



lcd_command_left:
	
	cbi PORTD, 6
	sbi PORTD, 7
	rcall wait_1ms
	cbi PORTD, 5
	rcall wait_5ms

	sbi PORTD, 6
	out PORTC, temp1
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	rcall wait_5ms

	cbi PORTD, 6
	nop
	sbi PORTD, 5
	ldi temp1, 0x00
	out PORTC, temp1
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	rcall wait_5ms

	sbi PORTD, 6
	sbi PORTD, 7
	rcall wait_5ms
	rcall wait_1ms

	
	ret


lcd_command_right:

	sbi PORTD, 6
	cbi PORTD, 7
	rcall wait_1ms
	cbi PORTD, 5
	rcall wait_5ms

	sbi PORTD, 7
	out PORTC, temp1
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	rcall wait_5ms

	cbi PORTD, 7
	nop
	sbi PORTD, 5
	ldi temp1, 0x00
	out PORTC, temp1
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	rcall wait_5ms

	sbi PORTD, 6
	sbi PORTD, 7
	rcall wait_5ms
	rcall wait_1ms

	
	ret





lcd_data_right:

	sbi PORTD, 6
	cbi PORTD, 7
	rcall wait_1ms
	sbi PORTD, 5
	rcall wait_5ms

	
	sbi PORTD, 7
	out PORTC, temp1
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	rcall wait_5ms

	cbi PORTD, 7
	nop
	cbi PORTD, 5
	ldi temp1, 0x00
	out PORTC, temp1
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	rcall wait_5ms

	sbi PORTD, 6
	sbi PORTD, 7
	rcall wait_5ms
	rcall wait_1ms


		ret




lcd_data_left:

	cbi PORTD, 6
	sbi PORTD, 7
	rcall wait_1ms
	sbi PORTD, 5
	rcall wait_5ms

	
	sbi PORTD, 6
	out PORTC, temp1
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	rcall wait_5ms

	cbi PORTD, 6
	nop
	cbi PORTD, 5
	ldi temp1, 0x00
	out PORTC, temp1
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	rcall wait_5ms

	sbi PORTD, 6
	sbi PORTD, 7
	rcall wait_5ms
	rcall wait_1ms

		ret






wait_1ms:
			
; ============================= 
;   Warteschleifen-Generator 
;     16 Zyklen:
; ----------------------------- 
; warte 15 Zyklen:
          ldi  R17, $05
WGLOOP0345:  dec  R17
          brne WGLOOP0345
; ----------------------------- 
; warte 1 Zyklus:
          nop
; ============================= 

		ret



wait_5ms:
		
; ============================= 
;   Warteschleifen-Generator 
;     80 Zyklen:
; ----------------------------- 
; warte 78 Zyklen:
          ldi  R17, $1A
WGLOOP0543:  dec  R17
          brne WGLOOP0543
; ----------------------------- 
; warte 2 Zyklen:
          nop
          nop
; ============================= 

	
		ret	


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


alphabet_search_left:

mov temp4, temp1

ldi temp2, 0xF0
and temp1, temp2

cpi temp1, 0x20
breq alphabet_0x20
cpi temp1, 0x30
breq alphabet_0x30
cpi temp1, 0x40
breq alphabet_0x40
cpi temp1, 0x50
breq alphabet_0x50
cpi temp1, 0x60
breq alphabet_0x60
cpi temp1, 0x70
breq alphabet_0x70



alphabet_0x20:
		
			mov r3, ZH
			mov r2, ZL

			ldi ZL, LOW(alphabet_6x8_0x20_0x2F*2)
			ldi ZH, HIGH(alphabet_6x8_0x20_0x2F*2)

			mov temp1, temp4
			ldi temp2, 0x0F
			and temp1, temp2
			ldi temp2, 0x06
			mul temp1, temp2

			add ZL, r0
			adc ZH, r1
			rjmp alphabet_print


alphabet_0x30:
		
			mov r3, ZH
			mov r2, ZL

			ldi ZL, LOW(alphabet_6x8_0x30_0x3F*2)
			ldi ZH, HIGH(alphabet_6x8_0x30_0x3F*2)

			mov temp1, temp4
			ldi temp2, 0x0F
			and temp1, temp2
			ldi temp2, 0x06
			mul temp1, temp2

			add ZL, r0
			adc ZH, r1
			rjmp alphabet_print


alphabet_0x40:
		
			mov r3, ZH
			mov r2, ZL

			ldi ZL, LOW(alphabet_6x8_0x40_0x4F*2)
			ldi ZH, HIGH(alphabet_6x8_0x40_0x4F*2)

			mov temp1, temp4
			ldi temp2, 0x0F
			and temp1, temp2
			ldi temp2, 0x06
			mul temp1, temp2

			add ZL, r0
			adc ZH, r1
			rjmp alphabet_print

alphabet_0x50:
		
			mov r3, ZH
			mov r2, ZL

			ldi ZL, LOW(alphabet_6x8_0x50_0x5F*2)
			ldi ZH, HIGH(alphabet_6x8_0x50_0x5F*2)

			mov temp1, temp4
			ldi temp2, 0x0F
			and temp1, temp2
			ldi temp2, 0x06
			mul temp1, temp2

			add ZL, r0
			adc ZH, r1
			rjmp alphabet_print



alphabet_0x60:
		
			mov r3, ZH
			mov r2, ZL

			ldi ZL, LOW(alphabet_6x8_0x60_0x6F*2)
			ldi ZH, HIGH(alphabet_6x8_0x60_0x6F*2)

			mov temp1, temp4
			ldi temp2, 0x0F
			and temp1, temp2
			ldi temp2, 0x06
			mul temp1, temp2

			add ZL, r0
			adc ZH, r1
			rjmp alphabet_print



alphabet_0x70:
		
			mov r3, ZH
			mov r2, ZL

			ldi ZL, LOW(alphabet_6x8_0x70_0x7D*2)
			ldi ZH, HIGH(alphabet_6x8_0x70_0x7D*2)

			mov temp1, temp4
			ldi temp2, 0x0F
			and temp1, temp2
			ldi temp2, 0x06
			mul temp1, temp2

			add ZL, r0
			adc ZH, r1
			rjmp alphabet_print




			

alphabet_print:
			
			ldi temp3, 0x06

alphabet_print2:
			
			lpm temp1, Z+
			rcall lcd_data_left
			dec temp3
			cpi temp3, 0x00
			breq alphabet_ende
			rjmp alphabet_print2
			



alphabet_ende:

			mov ZH, r3
			mov ZL, r2

			ret


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


alphabet_search_right:

mov temp4, temp1

ldi temp2, 0xF0
and temp1, temp2

cpi temp1, 0x20
breq alphabet_0x20_right
cpi temp1, 0x30
breq alphabet_0x30_right
cpi temp1, 0x40
breq alphabet_0x40_right
cpi temp1, 0x50
breq alphabet_0x50_right
cpi temp1, 0x60
breq alphabet_0x60_right
cpi temp1, 0x70
breq alphabet_0x70_right



alphabet_0x20_right:
		
			mov r3, ZH
			mov r2, ZL

			ldi ZL, LOW(alphabet_6x8_0x20_0x2F*2)
			ldi ZH, HIGH(alphabet_6x8_0x20_0x2F*2)

			mov temp1, temp4
			ldi temp2, 0x0F
			and temp1, temp2
			ldi temp2, 0x06
			mul temp1, temp2

			add ZL, r0
			adc ZH, r1
			rjmp alphabet_print5


alphabet_0x30_right:
		
			mov r3, ZH
			mov r2, ZL

			ldi ZL, LOW(alphabet_6x8_0x30_0x3F*2)
			ldi ZH, HIGH(alphabet_6x8_0x30_0x3F*2)

			mov temp1, temp4
			ldi temp2, 0x0F
			and temp1, temp2
			ldi temp2, 0x06
			mul temp1, temp2

			add ZL, r0
			adc ZH, r1
			rjmp alphabet_print5


alphabet_0x40_right:
		
			mov r3, ZH
			mov r2, ZL

			ldi ZL, LOW(alphabet_6x8_0x40_0x4F*2)
			ldi ZH, HIGH(alphabet_6x8_0x40_0x4F*2)

			mov temp1, temp4
			ldi temp2, 0x0F
			and temp1, temp2
			ldi temp2, 0x06
			mul temp1, temp2

			add ZL, r0
			adc ZH, r1
			rjmp alphabet_print5

alphabet_0x50_right:
		
			mov r3, ZH
			mov r2, ZL

			ldi ZL, LOW(alphabet_6x8_0x50_0x5F*2)
			ldi ZH, HIGH(alphabet_6x8_0x50_0x5F*2)

			mov temp1, temp4
			ldi temp2, 0x0F
			and temp1, temp2
			ldi temp2, 0x06
			mul temp1, temp2

			add ZL, r0
			adc ZH, r1
			rjmp alphabet_print5



alphabet_0x60_right:
		
			mov r3, ZH
			mov r2, ZL

			ldi ZL, LOW(alphabet_6x8_0x60_0x6F*2)
			ldi ZH, HIGH(alphabet_6x8_0x60_0x6F*2)

			mov temp1, temp4
			ldi temp2, 0x0F
			and temp1, temp2
			ldi temp2, 0x06
			mul temp1, temp2

			add ZL, r0
			adc ZH, r1
			rjmp alphabet_print5



alphabet_0x70_right:
		
			mov r3, ZH
			mov r2, ZL

			ldi ZL, LOW(alphabet_6x8_0x70_0x7D*2)
			ldi ZH, HIGH(alphabet_6x8_0x70_0x7D*2)

			mov temp1, temp4
			ldi temp2, 0x0F
			and temp1, temp2
			ldi temp2, 0x06
			mul temp1, temp2

			add ZL, r0
			adc ZH, r1
			rjmp alphabet_print5




			

alphabet_print5:
			
			ldi temp3, 0x06

alphabet_print4:
			
			lpm temp1, Z+
			rcall lcd_data_right
			dec temp3
			cpi temp3, 0x00
			breq alphabet_ende_right
			rjmp alphabet_print4
			



alphabet_ende_right:

			mov ZH, r3
			mov ZL, r2

			ret








;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


ZEITZAEHLER:


				lds temp1, FRAMES_per_second_end+2
				lds temp2, FRAMES_per_second_end+3

				ldi temp3, 0x02
				ldi temp4, 0x00

				;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
				
				sbc temp1, temp3

				
				brmi one_second_over01
				

				sts FRAMES_per_second_end+2, temp1
				sts FRAMES_per_second_end+3, temp2


				ret


one_second_over01:

				add temp1, temp3

				ldi temp3, 0x02
				ldi temp4, 0x00

				sub temp4, temp2
				sbc temp3, temp1
								
				lds temp2, FRAMES_per_second_end+1
				lds temp1, FRAMES_per_second_end

				sub temp2, temp4
				sbc temp1, temp3				


				sts FRAMES_per_second_end+3, temp2
				sts FRAMES_per_second_end+2, temp1

				rjmp one_second_over2




one_second_over2:

				ldi temp2, 0x01
				lds temp1, sekunden_speicher+1		;um eins reduzieren die einer sek.
				cpi temp1, 0x00
				breq one_second_over3
				sub temp1, temp2
				sts sekunden_speicher+1, temp1
				
				rcall time_write
				ret


one_second_over3:

				ldi temp2, 0x01
				ldi temp1, 0x09
				sts sekunden_speicher+1, temp1		;wieder auffüllen zu 9 bei überlauf

				lds temp1, sekunden_speicher		;um eins reduzieren die zehner sek.
				cpi temp1, 0x00
				breq one_second_over4
				sub temp1, temp2
				sts sekunden_speicher, temp1


				rcall time_write				
				ret


one_second_over4:

				ldi temp2, 0x01
				ldi temp1, 0x05
				sts sekunden_speicher, temp1
				

				lds temp1, minuten_speicher+2		;um eins reduzieren die einer min.
				cpi temp1, 0x00
				breq one_second_over5
				sub temp1, temp2
				sts minuten_speicher+2, temp1
				
				rcall time_write
				ret


one_second_over5:

				ldi temp2, 0x01
				ldi temp1, 0x09
				sts minuten_speicher+2, temp1
				

				lds temp1, minuten_speicher+1		;um eins reduzieren die zehner min.
				cpi temp1, 0x00
				breq one_second_over6
				sub temp1, temp2
				sts minuten_speicher+1, temp1
				
				rcall time_write
				ret



one_second_over6:


				ldi temp2, 0x01
				ldi temp1, 0x09
				sts minuten_speicher+1, temp1
				

				lds temp1, minuten_speicher			;um eins reduzieren die hunni min.
				cpi temp1, 0x00
				breq one_second_over7
				sub temp1, temp2
				sts minuten_speicher, temp1
				
				rcall time_write
				ret


one_second_over7:

			
				
				ret									;Lied ende
		


time_write:


				
				ldi temp1, 0xB9
				rcall lcd_command_right

				ldi temp1, 0x40
				rcall lcd_command_right

				

				ldi r29, 0x30
				;lds temp1, minuten_speicher
				;add temp1, r29
				;rcall alphabet_search_right

				lds temp1, minuten_speicher+1
				add temp1, r29
				rcall alphabet_search_right

				lds temp1, minuten_speicher+2
				add temp1, r29
				rcall alphabet_search_right

				ldi temp1, 0x3A
				rcall alphabet_search_right

				lds temp1, sekunden_speicher
				add temp1, r29
				rcall alphabet_search_right

				lds temp1, sekunden_speicher+1
				add temp1, r29
				rcall alphabet_search_right


					ret



		;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;DAS IST DER ANFANGSFONT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

FUBU_font:

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;linke display hälfte

		ldi ZL, LOW(FUBU_font_F1*2)
		ldi ZH, HIGH(FUBU_font_F1*2)
		
		ldi temp1, 0b10111010
		call lcd_command_left
		ldi temp1, 0b01011101
		call lcd_command_left


		ldi temp4, 0x0E

FUBU_loop_F1:

		lpm temp1, Z+
		call lcd_data_left
		dec temp4
		cpi temp4, 0x00
		brne FUBU_loop_F1




		ldi ZL, LOW(FUBU_font_U1*2)
		ldi ZH, HIGH(FUBU_font_U1*2)

		ldi temp4, 0x14

FUBU_loop_U1:

		lpm temp1, Z+
		call lcd_data_left
		dec temp4
		cpi temp4, 0x00
		brne FUBU_loop_U1


		


		ldi ZL, LOW(FUBU_font_F2*2)
		ldi ZH, HIGH(FUBU_font_F2*2)
		
		ldi temp1, 0b10111011
		call lcd_command_left
		ldi temp1, 0b01011101
		call lcd_command_left

		ldi temp4, 0x0E

FUBU_loop_F2:

		lpm temp1, Z+
		call lcd_data_left
		dec temp4
		cpi temp4, 0x00
		brne FUBU_loop_F2




		ldi ZL, LOW(FUBU_font_U2*2)
		ldi ZH, HIGH(FUBU_font_U2*2)

		ldi temp4, 0x14

FUBU_loop_U2:

		lpm temp1, Z+
		call lcd_data_left
		dec temp4
		cpi temp4, 0x00
		brne FUBU_loop_U2


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;rechte display hälfte


		ldi ZL, LOW(FUBU_font_B1*2)
		ldi ZH, HIGH(FUBU_font_B1*2)
		
		ldi temp1, 0b10111010
		call lcd_command_right
		ldi temp1, 0b01000000
		call lcd_command_right

		ldi temp4, 0x10

FUBU_loop_B1:

		lpm temp1, Z+
		call lcd_data_right
		dec temp4
		cpi temp4, 0x00
		brne FUBU_loop_B1




		ldi ZL, LOW(FUBU_font_U1*2)
		ldi ZH, HIGH(FUBU_font_U1*2)

		ldi temp4, 0x14

FUBU_loop_U1_1:

		lpm temp1, Z+
		call lcd_data_right
		dec temp4
		cpi temp4, 0x00
		brne FUBU_loop_U1_1


		


		ldi ZL, LOW(FUBU_font_B2*2)
		ldi ZH, HIGH(FUBU_font_B2*2)
		
		ldi temp1, 0b10111011
		call lcd_command_right
		ldi temp1, 0b01000000
		call lcd_command_right

		ldi temp4, 0x10

FUBU_loop_B2:

		lpm temp1, Z+
		call lcd_data_right
		dec temp4
		cpi temp4, 0x00
		brne FUBU_loop_B2




		ldi ZL, LOW(FUBU_font_U2*2)
		ldi ZH, HIGH(FUBU_font_U2*2)

		ldi temp4, 0x14

FUBU_loop_U2_2:

		lpm temp1, Z+
		call lcd_data_right
		dec temp4
		cpi temp4, 0x00
		brne FUBU_loop_U2_2


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;nächste PAGE linke display hälfte

		ldi ZL, LOW(FUBU_font_T1*2)
		ldi ZH, HIGH(FUBU_font_T1*2)
		
		ldi temp1, 0b10111100
		rcall lcd_command_left
		ldi temp1, 0b01000001
		rcall lcd_command_left


		ldi temp4, 0x0F

FUBU_loop_T1:

		lpm temp1, Z+
		call lcd_data_left
		dec temp4
		cpi temp4, 0x00
		brne FUBU_loop_T1




		ldi ZL, LOW(FUBU_font_E1*2)
		ldi ZH, HIGH(FUBU_font_E1*2)

		ldi temp4, 0x0F

FUBU_loop_E1:

		lpm temp1, Z+
		call lcd_data_left
		dec temp4
		cpi temp4, 0x00
		brne FUBU_loop_E1




		ldi ZL, LOW(FUBU_font_C1*2)
		ldi ZH, HIGH(FUBU_font_C1*2)

		ldi temp4, 0x0F

FUBU_loop_C1:

		lpm temp1, Z+
		call lcd_data_left
		dec temp4
		cpi temp4, 0x00
		brne FUBU_loop_C1




		ldi ZL, LOW(FUBU_font_H1*2)
		ldi ZH, HIGH(FUBU_font_H1*2)

		ldi temp4, 0x11

FUBU_loop_H1:

		lpm temp1, Z+
		call lcd_data_left
		dec temp4
		cpi temp4, 0x00
		brne FUBU_loop_H1





		ldi ZL, LOW(FUBU_font_T2*2)
		ldi ZH, HIGH(FUBU_font_T2*2)
		
		ldi temp1, 0b10111101
		rcall lcd_command_left
		ldi temp1, 0b01000001
		rcall lcd_command_left


		ldi temp4, 0x0F

FUBU_loop_T2:

		lpm temp1, Z+
		call lcd_data_left
		dec temp4
		cpi temp4, 0x00
		brne FUBU_loop_T2




		ldi ZL, LOW(FUBU_font_E2*2)
		ldi ZH, HIGH(FUBU_font_E2*2)

		ldi temp4, 0x0F

FUBU_loop_E2:

		lpm temp1, Z+
		call lcd_data_left
		dec temp4
		cpi temp4, 0x00
		brne FUBU_loop_E2




		ldi ZL, LOW(FUBU_font_C2*2)
		ldi ZH, HIGH(FUBU_font_C2*2)

		ldi temp4, 0x0F

FUBU_loop_C2:

		lpm temp1, Z+
		call lcd_data_left
		dec temp4
		cpi temp4, 0x00
		brne FUBU_loop_C2




		ldi ZL, LOW(FUBU_font_H2*2)
		ldi ZH, HIGH(FUBU_font_H2*2)

		ldi temp4, 0x11

FUBU_loop_H2:

		lpm temp1, Z+
		call lcd_data_left
		dec temp4
		cpi temp4, 0x00
		brne FUBU_loop_H2


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;nächste PAGE, rechte display hälfte



		ldi ZL, LOW(FUBU_font_N1*2)
		ldi ZH, HIGH(FUBU_font_N1*2)
		
		ldi temp1, 0b10111100
		rcall lcd_command_right
		ldi temp1, 0b01000000
		rcall lcd_command_right


		ldi temp4, 0x11

FUBU_loop_N1:

		lpm temp1, Z+
		call lcd_data_right
		dec temp4
		cpi temp4, 0x00
		brne FUBU_loop_N1




		ldi ZL, LOW(FUBU_font_I1*2)
		ldi ZH, HIGH(FUBU_font_I1*2)

		ldi temp4, 0x08

FUBU_loop_I1:

		lpm temp1, Z+
		call lcd_data_right
		dec temp4
		cpi temp4, 0x00
		brne FUBU_loop_I1




		ldi ZL, LOW(FUBU_font_C1*2)
		ldi ZH, HIGH(FUBU_font_C1*2)

		ldi temp4, 0x0F

FUBU_loop_C1_1:

		lpm temp1, Z+
		call lcd_data_right
		dec temp4
		cpi temp4, 0x00
		brne FUBU_loop_C1_1




		ldi ZL, LOW(FUBU_font_S1*2)
		ldi ZH, HIGH(FUBU_font_S1*2)

		ldi temp4, 0x0F

FUBU_loop_S1:

		lpm temp1, Z+
		call lcd_data_right
		dec temp4
		cpi temp4, 0x00
		brne FUBU_loop_S1





		ldi ZL, LOW(FUBU_font_N2*2)
		ldi ZH, HIGH(FUBU_font_N2*2)
		
		ldi temp1, 0b10111101
		rcall lcd_command_right
		ldi temp1, 0b01000000
		rcall lcd_command_right


		ldi temp4, 0x11

FUBU_loop_N2:

		lpm temp1, Z+
		call lcd_data_right
		dec temp4
		cpi temp4, 0x00
		brne FUBU_loop_N2




		ldi ZL, LOW(FUBU_font_I2*2)
		ldi ZH, HIGH(FUBU_font_I2*2)

		ldi temp4, 0x08

FUBU_loop_I2:

		lpm temp1, Z+
		call lcd_data_right
		dec temp4
		cpi temp4, 0x00
		brne FUBU_loop_I2




		ldi ZL, LOW(FUBU_font_C2*2)
		ldi ZH, HIGH(FUBU_font_C2*2)

		ldi temp4, 0x0F

FUBU_loop_C2_1:

		lpm temp1, Z+
		call lcd_data_right
		dec temp4
		cpi temp4, 0x00
		brne FUBU_loop_C2_1




		ldi ZL, LOW(FUBU_font_S2*2)
		ldi ZH, HIGH(FUBU_font_S2*2)

		ldi temp4, 0x0F

FUBU_loop_S2:

		lpm temp1, Z+
		call lcd_data_right
		dec temp4
		cpi temp4, 0x00
		brne FUBU_loop_S2

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


; ============================= 
;   Warteschleifen-Generator 
;     80000000 Zyklen:
; ----------------------------- 
; warte 49939965 Zyklen:
          ldi  R17, $FF
WGLOOP0:  ldi  R18, $FF
WGLOOP1:  ldi  R19, $FF
WGLOOP2:  dec  R19
          brne WGLOOP2
          dec  R18
          brne WGLOOP1
          dec  R17
          brne WGLOOP0
; ----------------------------- 
; warte 30059760 Zyklen:
          ldi  R17, $FB
WGLOOP3:  ldi  R18, $BF
WGLOOP4:  ldi  R19, $D0
WGLOOP5:  dec  R19
          brne WGLOOP5
          dec  R18
          brne WGLOOP4
          dec  R17
          brne WGLOOP3
; ----------------------------- 
; warte 273 Zyklen:
          ldi  R17, $5B
WGLOOP6:  dec  R17
          brne WGLOOP6
; ----------------------------- 
; warte 2 Zyklen:
          nop
          nop
; ============================= 


	rcall lcd_init
	ret










;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


		    
		    
text_command1:
		.db 0x3F
		
text_command2:
		.db 0xC0
		
text_command3:
		.db 0b10111000
		
text_command4:
		.db 0x40		  
		

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


;--------------------------------
;das ist ein ANSI ZTEICHENSATZ
;--------------------------------

alphabet_6x8_0x20_0x2F:

			.db		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x5F, 0x06, 0x00, 0x00, 0x07, 0x03, 0x00, 0x07, 0x03, 0x00, 0x24, 0x7E, 0x24, 0x7E, 0x24, 0x00, 0x24, 0x2B, 0x6A, 0x12, 0x00, 0x00, 0x63, 0x13, 0x08, 0x64, 0x63, 0x00, 0x36, 0x49, 0x56, 0x20, 0x50, 0x00, 0x00, 0x07, 0x03, 0x00, 0x00, 0x00, 0x00, 0x3E, 0x41, 0x00, 0x00, 0x00, 0x00, 0x41, 0x3E, 0x00, 0x00, 0x00, 0x08, 0x3E, 0x1C, 0x3E, 0x08, 0x00, 0x08, 0x08, 0x3E, 0x08, 0x08, 0x00, 0x00, 0xE0, 0x60, 0x00, 0x00, 0x00, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00, 0x00, 0x60, 0x60, 0x00, 0x00, 0x00, 0x20, 0x10, 0x08, 0x04, 0x02

alphabet_6x8_0x30_0x3F:


			.db		0x00, 0x3E, 0x51, 0x49, 0x45, 0x3E, 0x00, 0x00, 0x42, 0x7F, 0x40, 0x00, 0x00, 0x62, 0x51, 0x49, 0x49, 0x46, 0x00, 0x22, 0x49, 0x49, 0x49, 0x36, 0x00, 0x18, 0x14, 0x12, 0x7F, 0x10, 0x00, 0x2F, 0x49, 0x49, 0x49, 0x31, 0x00, 0x3C, 0x4A, 0x49, 0x49, 0x30, 0x00, 0x01, 0x71, 0x09, 0x05, 0x03, 0x00, 0x36, 0x49, 0x49, 0x49, 0x36, 0x00, 0x06, 0x49, 0x49, 0x29, 0x1E, 0x00, 0x00, 0x6C, 0x6C, 0x00, 0x00, 0x00, 0x00, 0xEC, 0x6C, 0x00, 0x00, 0x00, 0x08, 0x14, 0x22, 0x41, 0x00, 0x00, 0x24, 0x24, 0x24, 0x24, 0x24, 0x00, 0x00, 0x41, 0x22, 0x14, 0x08, 0x00, 0x02, 0x01, 0x59, 0x09, 0x06 
	
alphabet_6x8_0x40_0x4F:	
	
			.db		0x00, 0x3E, 0x41, 0x5D, 0x55, 0x1E, 0x00, 0x7E, 0x09, 0x09, 0x09, 0x7E, 0x00, 0x7F, 0x49, 0x49, 0x49, 0x36, 0x00, 0x3E, 0x41, 0x41, 0x41, 0x22, 0x00, 0x7F, 0x41, 0x41, 0x41, 0x3E, 0x00, 0x7F, 0x49, 0x49, 0x49, 0x41, 0x00, 0x7F, 0x09, 0x09, 0x09, 0x01, 0x00, 0x3E, 0x41, 0x49, 0x49, 0x7A, 0x00, 0x7F, 0x08, 0x08, 0x08, 0x7F, 0x00, 0x00, 0x41, 0x7F, 0x41, 0x00, 0x00, 0x30, 0x40, 0x40, 0x40, 0x3F, 0x00, 0x7F, 0x08, 0x14, 0x22, 0x41, 0x00, 0x7F, 0x40, 0x40, 0x40, 0x40, 0x00, 0x7F, 0x02, 0x04, 0x02, 0x7F, 0x00, 0x7F, 0x02, 0x04, 0x08, 0x7F, 0x00, 0x3E, 0x41, 0x41, 0x41, 0x3E
	
alphabet_6x8_0x50_0x5F:
	
			.db		0x00, 0x7F, 0x09, 0x09, 0x09, 0x06, 0x00, 0x3E, 0x41, 0x51, 0x21, 0x5E, 0x00, 0x7F, 0x09, 0x09, 0x19, 0x66, 0x00, 0x26, 0x49, 0x49, 0x49, 0x32, 0x00, 0x01, 0x01, 0x7F, 0x01, 0x01, 0x00, 0x3F, 0x40, 0x40, 0x40, 0x3F, 0x00, 0x1F, 0x20, 0x40, 0x20, 0x1F, 0x00, 0x3F, 0x40, 0x3C, 0x40, 0x3F, 0x00, 0x63, 0x14, 0x08, 0x14, 0x63, 0x00, 0x07, 0x08, 0x70, 0x08, 0x07, 0x00, 0x71, 0x49, 0x45, 0x43, 0x00, 0x00, 0x00, 0x7F, 0x41, 0x41, 0x00, 0x00, 0x02, 0x04, 0x08, 0x10, 0x20, 0x00, 0x00, 0x41, 0x41, 0x7F, 0x00, 0x00, 0x04, 0x02, 0x01, 0x02, 0x04, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80
	
alphabet_6x8_0x60_0x6F:
	
			.db		0x00, 0x00, 0x03, 0x07, 0x00, 0x00, 0x00, 0x20, 0x54, 0x54, 0x54, 0x78, 0x00, 0x7F, 0x44, 0x44, 0x44, 0x38, 0x00, 0x38, 0x44, 0x44, 0x44, 0x28, 0x00, 0x38, 0x44, 0x44, 0x44, 0x7F, 0x00, 0x38, 0x54, 0x54, 0x54, 0x18, 0x00, 0x08, 0x7E, 0x09, 0x09, 0x00, 0x00, 0x18, 0xA4, 0xA4, 0xA4, 0x7C, 0x00, 0x7F, 0x04, 0x04, 0x78, 0x00, 0x00, 0x00, 0x00, 0x7D, 0x00, 0x00, 0x00, 0x40, 0x80, 0x84, 0x7D, 0x00, 0x00, 0x7F, 0x10, 0x28, 0x44, 0x00, 0x00, 0x00, 0x00, 0x7F, 0x40, 0x00, 0x00, 0x7C, 0x04, 0x18, 0x04, 0x78, 0x00, 0x7C, 0x04, 0x04, 0x78, 0x00, 0x00, 0x38, 0x44, 0x44, 0x44, 0x38
	
alphabet_6x8_0x70_0x7D:

			.db		0x00, 0xFC, 0x44, 0x44, 0x44, 0x38, 0x00, 0x38, 0x44, 0x44, 0x44, 0xFC, 0x00, 0x44, 0x78, 0x44, 0x04, 0x08, 0x00, 0x08, 0x54, 0x54, 0x54, 0x20, 0x00, 0x04, 0x3E, 0x44, 0x24, 0x00, 0x00, 0x3C, 0x40, 0x20, 0x7C, 0x00, 0x00, 0x1C, 0x20, 0x40, 0x20, 0x1C, 0x00, 0x3C, 0x60, 0x30, 0x60, 0x3C, 0x00, 0x6C, 0x10, 0x10, 0x6C, 0x00, 0x00, 0x9C, 0xA0, 0x60, 0x3C, 0x00, 0x00, 0x64, 0x54, 0x54, 0x4C, 0x00, 0x00, 0x08, 0x3E, 0x41, 0x41, 0x00, 0x00, 0x00, 0x00, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x41, 0x41, 0x3E, 0x08, 0x00, 0x02, 0x01, 0x02, 0x01, 0x00
	
	
alphabet_6x8_specials:
	
	
	
	
	.db		0x00, 0xFE, 0xFE, 0x7C, 0x38, 0x10, 0x00, 0xFC, 0xFC, 0x00, 0xFC, 0xFC, 0x00, 0x7C, 0x7C, 0x7C, 0x7C, 0x7C, 0x00, 0xFE, 0x7C, 0x38, 0x10, 0x7C, 0x00, 0x7C, 0x10, 0x38, 0x7C, 0xFE
									  ; "play"							; "pause"							  ; "stop"						   ; "forward"						   ; "backward







;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;------------
;ANFANGSFONT
;------------

FUBU_font_F1:		;14	
		.db		0x00, 0x00, 0x03, 0xE3, 0xFB, 0xFF, 0x7F, 0x63, 0x63, 0x63, 0x03, 0x03, 0x03, 0x03

FUBU_font_F2:		;14
		.db		0x00, 0x10, 0x38, 0x3F, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00




FUBU_font_U1:		;20
		.db		0x00, 0x00, 0xE0, 0xFC, 0x7E, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x80, 0xE0, 0xF0, 0xFC, 0xFE, 0x1E, 0x00, 0x00, 0x00, 0x00

FUBU_font_U2:		;20
		.db		0x00, 0x3E, 0x7F, 0x7F, 0x40, 0x60, 0x30, 0x18, 0x0C, 0x06, 0x03, 0x01, 0x3F, 0x3F, 0x3F, 0x20, 0x20, 0x30, 0x1C, 0x0C




FUBU_font_B1:		;16
		.db		0x00, 0x02, 0x02, 0xC2, 0xFA, 0xFE, 0x8E, 0x86, 0x86, 0x86, 0xC6, 0x4C, 0x7C, 0x38, 0x10, 0x00

FUBU_font_B2:		;16
		.db		0x00, 0x00, 0x39, 0x3F, 0x3F, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x33, 0x1F, 0x1E, 0x0C




FUBU_font_T1:		;15
	.db	0x00, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0xFE, 0xFE, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06

FUBU_font_T2:		;15

	.db	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3E, 0x3F, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00





FUBU_font_E1:		;15
	.db	0x00, 0x00, 0x00, 0xE3, 0xFF, 0xFF, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0x03, 0x03, 0x03, 0x03

FUBU_font_E2:		;15
	.db	0x00, 0x30, 0x3F, 0x3F, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x00





FUBU_font_C1:		;15
	.db	0x00, 0xE0, 0xF0, 0x38, 0x1C, 0x0E, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x00, 0x00

FUBU_font_C2:		;15
	.db	0x00, 0x07, 0x0F, 0x1C, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x38, 0x18






FUBU_font_H1:		;17
	.db	0x00, 0x00, 0x00, 0xC0, 0xF1, 0xFF, 0xCF, 0xC1, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xF1, 0xFF, 0xCF, 0x01


FUBU_font_H2:		;17
	.db	0x00, 0x20, 0x3C, 0x3F, 0x27, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x3C, 0x3F, 0x27, 0x00, 0x00, 0x00






FUBU_font_N1:		;17
	.db	0x00, 0x00, 0x00, 0x83, 0xFF, 0x7F, 0x0F, 0x3E, 0xF8, 0xE0, 0x80, 0x00, 0x00, 0xE0, 0xFF, 0x1F, 0x03

FUBU_font_N2:		;17
	.db	0x00, 0x30, 0x38, 0x3F, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x01, 0x07, 0x0F, 0x1C, 0x3F, 0x3F, 0x00, 0x00






FUBU_font_I1:		;8
	.db	0x00, 0x00, 0x02, 0x86, 0xFE, 0xFE, 0x06, 0x02

FUBU_font_I2:		;8
	.db	0x00, 0x20, 0x30, 0x3F, 0x3F, 0x30, 0x20, 0x00





FUBU_font_S1:		;15
	.db	0x00, 0x00, 0x00, 0x00, 0x1C, 0x3E, 0x7F, 0x63, 0x63, 0xE3, 0xC3, 0xC3, 0x87, 0x86, 0x00


FUBU_font_S2:		;15
	.db	0x00, 0x06, 0x0E, 0x1C,	0x18, 0x38, 0x30, 0x30, 0x30, 0x30, 0x38, 0x19, 0x0F, 0x0F, 0x07











;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;




;_________________________
;HIER SIND SRAM EINTRÄGE
;------------------------

.dseg
sectors_per_cluster:  .byte 1

.dseg 
sectors_per_cluster_end:   .byte 2

.dseg 
first_DATA_cluster:  .byte 2

.dseg
next_DATA_cluster:  .byte 2

.dseg
VBR_start:  .byte 4

.dseg 
FAT_start:  .byte 4

.dseg
ROOT_start:  .byte 4

.dseg 
DATA_start:  .byte 4

.dseg 
addresse:   .byte 4

.dseg
CMD:  .byte 6

.dseg
FRAMES_per_second: .byte 1

.dseg 
FRAMES_per_second_end:   .byte 4

.dseg
response_save:  .byte 1

.dseg 
response_ini:  .byte 2

.dseg
Volume_set:    .byte 1

.dseg
Volume_SCI:     .byte 1

.dseg
TREBBLE_set:    .byte 1

.dseg
BASS_set:    .byte 1

.dseg
GAIN_set:     .byte 1

.dseg
vorspulabfrage:    .byte 1

.dseg
back_taste0:     .byte 1

.dseg
TDA7318_data:      .byte 1

.dseg 
response_read:  .byte 2

.dseg
root_counter_ende:	.byte 1

.dseg 
root_counter_anfang:	.byte 1

.dseg
byte_speicher:  .byte 1

.dseg
minuten_speicher:  .byte 3

.dseg
sekunden_speicher:   .byte 2

.dseg
MP3_data_length:  .byte 4

.dseg 
MP3_data_length_end:   .byte 4

.dseg
ID3_TAG_zeichen:  .byte 20

.dseg
cluster:   .byte 512

.dseg 
ROOT_ram:	.byte 980