Zu beachten sind folgende Punkte bei Aufrufen der Unterprogramme:

-Das Unterprogramm muss am Hauptprogramm nach der Hauptschleife inkludiert werden.
	Dies geht mit dem Befehl .include "StartADConCHANEL0_8Bit.asm"

-Das Aufrufen des Unterprogramms wird mit dem Befehl call / rcall bewerkstelligt.

Spezielle Einstellungen bei ADC Unterprogramme:####################################################################
bevor StartADConChanel0...7 aufgerufen werden kann muss zuerst der Prescaler eingestellt werden, dies geht über
das Register ADCSRA über die 3 niederwertigsten Bits ADPS0 ADPS1 ADPS2
Dann muss das Bit ADEN im ADCSRA auf 1 gesetzt werden, damit der ADC enabled ist.
Man kann den Wert aus dem Register aös 8 Bit Zahl rauslesen: in r16, ADCH

Spezielle Eigenschaften vor dem Schreiben ins EEPROM:##############################################################
ZL und ZL (r30, r31) werden zur Adresierung erwendet, dh bevor man Read oder Write EEPROM aufruft,
muss man die Adresse festlegen von der gelesen werden soll, es gibt 256 Adressen dh 256 Byte,
dh 255 Byte liegen in ZL und 1 liegt in ZH
Bsp:
		mov r25, Schwellwertleft		;da r25 in Write EEPROM zum schreiben der Variable 
										;verwendet wird muss das Register kopiert werden	
		ldi ZH, 0 						;niederwertige Bit der EEPROM Adresse = 0
		ldi ZL, 1						;schreibe EEPROM an adresse 1
rcall	Write_EEPROM					;schreibe Wert in EEPROM


Spezielle Eigenschaften der Division:###############################################################################
r16 = Divident
r17 = Divisor

Ergebnisse: Ergebnis: 	r30
			Rest:		r31
			
es muss auf jedenfall vor Programmaufruf die Registerinhalte r17 und r16 gesichert werden

Bsp:

	push r16
	push r17
		mov r16, Divident
		mov r17, Divisor
		
		call/rcall Division
	pop r17
	pop r16
	
	
	
Wait1:
push r16
push r17
push r18
	ldi r16, 255	
	ldi r17, 255
	ldi r18, 50

Wr: 
	dec r16
	brne Wr

	dec r17
	brne Wr
	
	dec r18
	brne Wr

pop r18
pop r17
pop r16
ret

Wait3:
push r16
push r17
push r18
	ldi r16, 255	
	ldi r17, 255
	ldi r18, 130

Wr12: 
	dec r16
	brne Wr12

	dec r17
	brne Wr12
	
	dec r18
	brne Wr12

pop r18
pop r17
pop r16
ret


Write_EEPROM:
	push r17
Write:
	sbic    EECR, EEWE                  ; prüfe ob der letzte Schreibvorgang beendet ist
    rjmp    Write		                ; wenn nein, nochmal prüfen
 
    out     EEARH, ZH                   ; Adresse schreiben
    out     EEARL, ZL                   ; 
    out     EEDR,r25                   ; Daten  schreiben
    in      r17,SREG              ; SREG sichern
    cli                                 ; Interrupts sperren, die nächsten
                                        ; zwei Befehle dürfen NICHT
                                        ; unterbrochen werden
    sbi     EECR,EEMWE                  ; Schreiben vorbereiten
    sbi     EECR,EEWE                   ; Und los !
    out     SREG, r17             ; SREG wieder herstellen
	pop r17
ret


Read_EEPROM:
	sbic EECR,EEWE                	;prüfe ob ein vorheriger Schreibzugriff
                                   	;beendet ist
    rjmp Read_EEPROM              	;nein, nochmal prüfen
	
	out EEARH, ZH 					;adresse lesen
    out EEARL, ZL    				;adresse laden
    sbi EECR, EERE                  ;Lesevorgang aktivieren
ret

;Division################################################################
Division:
.def Ergebnis = r30
.def Rest = r31	

push r18

; Division r16 : r17	
	ldi r18, 8 ; 8 Bit Division
	clr Rest ; Register für die Zwischenergebnisse / Rest
	clr Ergebnis ; Ergebnis

divloop:
	lsl r16 ; Zwischenergebnis mal 2 nehmen und das
	rol Rest ; nächste Bit des Dividenden anhängen
	lsl Ergebnis ; das Ergebnis auf jeden Fall mal 2 nehmen,das hängt effektiv eine 0 an das Ergebnis an.
	; Sollte das nächste Ergebnis-Bit 1 sein, dann wird diese 0 in Folge durch eine 1 ausgetauscht
	
	cp Rest, r17 ; ist der Divisor größer?
	brlo div_zero ; wenn nein, dann bleibt die 0
	sbr Ergebnis, 1 ; wenn ja, dann jetzt die 0 durch eine 1 austauschen ...
	sub Rest, r17 ; ... und den Divisor abziehen

div_zero: 
	dec r18 ; das Ganze 8 mal wiederholen
	brne divloop; dividiere solange, bis ganze 8 Bit fertig

; in Ergebnis (r30) steht das Ergebnis der Division
; in Rest (r31) steht der bei der Division entstehende Rest

pop r18

ret ; 4 Takte
;########################################################################

StartADConChanel0_8Bit:
	push r16
		ldi r16, 0b00100000
		out ADMUX, r16
	pop r16
	
		sbi ADCSRA, ADSC 	;Starte ADC durch setzen des Bits ADSC	
ABC0:	sbis ADCSRA, ADSC	;Warte bis Messung fertig ist
ret ;dann zurück
rjmp ABC0 ;ansonsten schau nach bis sie fertig is
	
StartADConChanel1_8Bit:
	push r16
		ldi r16, 0b00100001		;Kanal 1, ADLAR = 1 --> 8Bit Ergebnis
		out ADMUX, r16			;Ausgabe
	pop r16
	
			sbi ADCSRA, ADSC 	;Starte ADC durch setzen des Bits ADSC	
ABC1:		sbis ADCSRA, ADSC	;Warte bis Messung fertig ist
ret ;dann zurück
rjmp ABC1 ;ansonsten schau nach bis sie fertig is
	
StartADConChanel2_8Bit:
	push r16
		ldi r16, 0b00100010		;Kanal 2, ADLAR = 1 --> 8Bit Ergebnis
		out ADMUX, r16			;Ausgabe
	pop r16
	
			sbi ADCSRA, ADSC 	;Starte ADC durch setzen des Bits ADSC	
ABC2:	sbis ADCSRA, ADSC	;Warte bis Messung fertig ist
ret ;dann zurück
rjmp ABC2 ;ansonsten schau nach bis sie fertig is