.include "c:\avrtools\appnotes\2313def.inc"

;Empfänger-Subroutine

.cseg
.org 0
	rjmp reset		;Reset handler
	reti			;External interrupt 0
	reti			;External interrupt 1
	reti			;Counter1 capture event
	rjmp compare		;Counter1 compare match
	rjmp timer1		;Counter1 overflow
	rjmp timer0		;Counter0 overflow
	rjmp serial		;UART RX complete
	reti			;UART Data register empty
	reti			;UART TX complete
	reti			;Analog comparator

.def	temp3		= r1
.def	temp4		= r2
.def	temp5		= r3
.def	kanal_nr	= r4
.def	ser_pointer	= r7
.def	funktion	= r8
.def	time_out	= r9
.def	ist_alt		= r12
.def	error_cnt	= r13
.def	temp		= r16
.def	temp2		= r17
.def	delta		= r17
.def	motor_bits	= r18
.def	counter		= r19
.def	pwm_counter	= r20
.def	ser_counter	= r23
.def	flags		= r25

.equ	f_start		= 0
.equ	f_complete	= 1
.equ	f_error		= 2
.equ	f_update	= 3

;Das Programm wurde ursprünglich für einen AT90S2333 geschrieben
;für 2313 werden folgende Registerdefinitionen benötigt:
.equ UCSRB		= UCR
.equ UCSRA		= USR
.equ OCR1H		= OCR1AH
.equ OCR1L		= OCR1AL
.equ COM11		= COM1A1
.equ COM10		= COM1A0
.equ OCF1		= OCF1A
.equ OCIE1		= OCIE1A

.equ	ser_buffer	= $60			;Empfangspuffer für die seriellen Daten
.equ	data_buffer	= ser_buffer+14		;umgewandelte Daten (manchester dekodiert)
.equ	pwm_buffer	= data_buffer+8		;PWM Werte für die 4 Ausgänge
.equ	analog_buffer	= pwm_buffer+4		;aktuelle Analogwerte (Empfänger)
.equ	pwm_alt_puffer	= analog_buffer+8	;alte PWM-Werte für Servo-Funktion
.equ	adresse		= pwm_alt_puffer+4	;eigene Adresse (Konstante)
.equ	servo_puffer	= adresse+1

.equ 	left		= 0			;Bitdefinitionen
.equ	right		= 1
.equ	stellweg	= 4
.equ	servo		= 5

.equ	quarz		= 3686400		;Für Berechnung der Baudrate
.equ	baud		= 2400
.equ	baud_wert	= (quarz/(16*baud))-1


; Lochrasterplatine mit TLE 4205 + 2313
; Belegung
;
; Motor 1: Richtung = 	PD2, Enable = 	PD4
; Motor 2: 		PD3		PD5
; Motor 3: 		PB4          	PB1
; Motor 4: 		PB5		PB2
; Zur einfachen Anpassung an andere Hardware-Umgebungen
; sind alle Definitionen als Variable ausgeführt.

.equ pwm_m1	= 4
.equ pwm_m2	= 5
.equ pwm_m3	= 1
.equ pwm_m4	= 2

.equ dir_m1	= 2
.equ dir_m2	= 3
.equ dir_m3	= 4
.equ dir_m4	= 5

.equ port_pwm_m1	= PORTD
.equ port_pwm_m2	= PORTD
.equ port_pwm_m3	= PORTB
.equ port_pwm_m4	= PORTB
.equ port_dir_m1	= PORTD
.equ port_dir_m2	= PORTD
.equ port_dir_m3	= PORTB
.equ port_dir_m4	= PORTB


reset:
	ldi temp,RAMEND	
	out SPL,temp
	
	ldi xl,ser_buffer			;den seriellen Puffer löschen
	clr temp
	ldi temp2,$70
rloop:
	st x+,temp
	dec temp2
	brne rloop

	ldi temp,(1<<RXEN)|(1<<TXEN)|1<<(RXCIE)|(1<<TXCIE)
	out UCSRB,temp

	ldi temp,baud_wert
	out UBRR,temp

	ldi temp,(1<<CS00)			;Timer0 ohne prescaler
	out TCCR0,temp

	ldi temp,(1<<CS10)			;Timer1 ohne prescaler
	out TCCR1B,temp
	
	
				;Timer0 Overflow,Timer1 Overflow, Timer1 Compare match
	ldi temp,(1<<TOIE0)|(1<<TOIE1)
	out TIMSK,temp

	ldi temp,0b11111111			;Ausgänge initialisieren
	out DDRB,temp

	ldi temp,0b11111100
	out DDRD,temp

	clr flags				;Fehler-Register löschen

	clr xh
	clr yh

	ldi xl,pwm_buffer			;alle PWM-Ausgänge mit 0 vordefinieren
	st x+,temp
	st x+,temp
	st x+,temp
	st x+,temp

	ldi temp,$10				;EEPROM-Adresse für Modul-Adresse
	out EEAR,temp
	sbi EECR,EERE				;Read-Strobe an EEPROM senden
	in temp,EEDR				;in temp Adresse laden
	andi temp,$0F				;nur unteres Nibble verwenden
	sts adresse,temp			;im Speicher als Konstante speichern

	sei
;****************
;*Hauptschleife *
;****************

loop:
	sei
	sbrc flags,f_complete			;Receive complete Flag =1?
	rcall main_uebertrage			;wenn eine Übertragung komplett ist, dann berechne die Werte
	sbrc flags,f_update
	rcall main1
	rjmp loop

main_uebertrage:
	rcall uebertrage			;Umrechnung der Manchester-Codierung + der komprimierten Analog-Werte
	cbr flags,(1<<f_complete)		;Übertragung quittieren
	sbrs flags,f_error			;Fehler aufgetaucht?
	rjmp main_uebertrage1			;kein Fehler
	dec error_cnt				;Fehler-Zähler
	brmi main_uebertrage1			;Fehler-Zähler negativ?
	cbr flags,(1<<f_error)			;solange noch nicht das Limit für Fehler erreicht ist, die Motoren weiterlaufen lassen

main_uebertrage1:

	lds temp,adresse			;Die eigene Modul-Adresse lesen
	lds temp2,data_buffer			;Übertragene Modul-Adresse lesen
	andi temp2,$0F				;nur unteres Nibble verwenden
	cp temp,temp2				;Soll-Wert mit Ist-Wert vergleichen	
	breq main_adresse_ok			;wenn gleich, dann Dekodierung fortsetzen
	sbr flags,(1<<f_error)			;Fehler-Bit setzen (Motoren ausschalten)
	ret					;nächste Übertragung abwarten
main_adresse_ok:
	ret

;In dieser Subroutine werden die Motor-Ausgänge berechnet und gesetzt, bei gewählter
;Servo-Funktion die Werte verglichen und die Ausgleichsbewegungen berechnet.
;Diese Subroutine wird Interruptgesteuert ca. 56 /Sekunde ausgeführt.

main1:
	tst time_out
	breq main1a
	dec time_out
	rjmp main1b
main1a:
	sbr flags,(1<<f_error)
main1b:

	cbr flags,(1<<f_update)			;Update erledigt

	clr kanal_nr				;R4 ist Zähler für Kanal-Nummer

	;Ausgang 1
	
	rcall calc_one				;Berechnungen durchführen
						;in R18 Bit 0 und 1 ist die Richtung (links/rechts)
	sts pwm_buffer,temp2			;berechneten PWM-Wert in Speicher schreiben
						;Übertrage die berechneten Bits von (motorbits)
						;auf die Portbits.
	sbrs motor_bits,0			;Die Laufrichtung des Motors festlegen
	cbi port_dir_m1,dir_m1
	sbrc motor_bits,0
	sbi port_dir_m1,dir_m1

	inc kanal_nr				;nächste Kanal-Nummer auswählen

	rcall calc_one				;Berechnung für den aktuellen Kanal durchführen
	sts pwm_buffer+1,temp2			;berechneten Wert in den Speicher schreiben

	sbrs motor_bits,0
	cbi port_dir_m2,dir_m2
	sbrc motor_bits,0
	sbi port_dir_m2,dir_m2

	inc kanal_nr				;nächste Kanal-Nummer auswählen

	rcall calc_one 				;Berechnung für den aktuellen Kanal ausführen

	sts pwm_buffer+2,temp2			;berechneten Wert in den Speicher schreiben

	sbrs motor_bits,0
	cbi port_dir_m3,dir_m3
	sbrc motor_bits,0
	sbi port_dir_m3,dir_m3

	inc kanal_nr				;nächste Kanal-Nummer auswählen
	rcall calc_one				;Berechnung für den aktuellen Kanal ausführen

	sts pwm_buffer+3,temp2			;berechneten Wert in den Speicher schreiben

	sbrs motor_bits,0
	cbi port_dir_m4,dir_m4
	sbrc motor_bits,0
	sbi port_dir_m4,dir_m4

	inc kanal_nr
	rcall calc_pwm_servo			;den PWM-Servo-Ausgang berechnen

	ret					;zurück zur Hauptschleife


calc_pwm_servo:
	
	mov temp,kanal_nr
	rcall read_eeprom
	mov funktion,temp
	rcall get_analog			;Analog-Kanal Nr(temp) lesen (temp 0..3)
	sbrs funktion,stellweg			;Den Stellweg umsetzen (90 oder 270°)
	rcall umrechnung
	sbrc funktion,stellweg
	rcall umrechnung2
	push temp				;in temp befindet sich momentan die Kanal-Nr, diese sichern
	ldi temp,$22				;temp mit Adresse $22 laden = Multiplikationsfaktor
	rcall read_eeprom			;Inhalt der Adresse $22 lesen -> temp
	mov temp2,temp
	pop temp
	rcall mul14				;den 8-Bit Wert mit dem Faktor aus dem EEPROM multiplizieren
	push temp
	ldi temp,$21				;Offset kommt aus dem eeprom ($20=High,$21=Low)
	rcall read_eeprom
	mov temp3,temp
	ldi temp,$20
	rcall read_eeprom
	mov temp4,temp
	pop temp
	
	add temp,temp3				;Offset hinzuaddieren
	adc temp2,temp4		

	sts servo_puffer,temp2			;Zuerst High-Byte
	sts servo_puffer+1,temp			;

	ret

;Dieses Unterprogramm berechnet die Motorrichtung und Geschwindigkeit (PWM-Wert)
;Parameter: 
;R4 = Nummer des Kanals (0..3)
;

calc_one:	
	mov temp,kanal_nr
	rcall read_eeprom	
	andi temp,$0F				;nur die unteren 4 Bit verwenden
	cpi temp,$04				;Analog oder Digital-Kanal?
	brcc calc_digital			;Kanal-Nummer > 4 ist Digital-Kanal	

calc_analog:
	in funktion,EEDR			;nochmals die Kanal-Nummer lesen
	rcall get_analog			;den entsprechenden Analog-Wert lesen

	sbrs funktion,stellweg			;Bit 4 = 90° oder 270°
	rcall umrechnung			;90° Stellwegumrechnung auf jeden Fall (zum Testen)
						;Ergebnis ist in temp
	sbrc funktion,stellweg
	rcall umrechnung2			;Umwandlung des 10-Bit in einen 8-Bit-Wert
	
	rcall calculate				;PWM-Wert berechnen, Ergebnis in temp2, in motor_bits ist Maske

	ret

calc_digital:
	subi temp,$04				;Nummer bereinigen
	rcall get_digital			;Kanal-Nummer laden, Ergebnis in motor_bits
	ldi temp2,$FF				;Kanal auf Dauerbetrieb schalten
	ret	

calculate:
	ldi temp2,$80				;Bei Fahrtregler-Funktion den Mittelpunkt festlegen
	sub temp2,temp				;Ist - Soll
	brcc positiv				;positiv oder negativ?
	neg temp2				;wenn negativ, dann Zahl positiv machen
	ldi motor_bits,(1<<left)		;Maske für Linkslauf
	rjmp calc_1
positiv:
	ldi motor_bits,(1<<right)		;Maske für Rechtslauf
calc_1:
	cpi temp2,$10				;Totpunkt (+/- 16, --> 32 Werte)
	brcs calc_2				;damit man den 0-Punkt besser findet
	ret
calc_2:
	clr temp2				;solange der Totpunkt nicht überschritten ist, auf 0 setzen
	ret

;Diese Routine rechnet den 10-Bit Sollwert so um, daß schlußendlich ein
;8-Bit Wert herauskommt. Nebenbei wird eine Reduzierung des Stellwegs
;auf 90° berechnet, wobei durch die 10Bit die Genauigkeit erhalten bleibt.
;in temp2:temp ist der umzurechnende Wert (temp2=High)

umrechnung:
	cpi temp2,$02				;Wert mit $02AA vergleichen
	breq um_1a
	brcc um_1				;Wert ist auf jeden Fall größer
	brne um_2				;Wert ist kleiner
um_1a:
	cpi temp,$AA				;Low-Byte vergleichen
	brcc um_1				;auch Low-Wert ist größer
	
um_2:
	cpi temp2,$01
	brcs um_3				;Wert ist auf jeden Fall kleiner
	brne um_4				;Wert liegt im richtigen Bereich
	cpi temp,$56				;Low-Byte vergleichen
	brcs um_3				;auch Low-Wert ist kleiner

um_4:
	subi temp,$56				;den Wert $0156 =342 abziehen, somit wird der
	sbci temp2,$01				;Wertebereich von 0-1023 auf 0-340 verringert
	rjmp um_5
um_1:	ldi temp,$FF				;Wert war zu groß, also auf Max. setzen
	clr temp2
	ret
um_3:	clr temp				;Wert war zu klein, also auf Min. setzen
	clr temp2
	ret
um_5:
	mov temp3,temp				;den Wert mit 3 multiplizieren
	mov temp4,temp2
	lsl temp				;Zuerst *2
	rol temp2
	add temp,temp3				;nochmal addieren =*3
	adc temp2,temp4

	lsr temp2				;zum Schluß durch 4 dividieren
	ror temp				;340*3/4 = 255
	lsr temp2
	ror temp
	ret					;Fertig, das Ergebnis ist in temp

;Diese Routine rechnet den 10-Bit-Analogwert in temp/temp2 (temp2=high) in einen
;8-Bit Wert in temp um (Division durch 4)

umrechnung2:

	lsr temp2
	ror temp
	lsr temp2
	ror temp
	
	ret

;Adresse in temp, Ergebnis in temp zurück

read_eeprom:
	cli
	out EEAR,temp				;Adresse in Adressregister laden
	sbi EECR,EERE				;EEprom lesen
	in temp,EEDR				;Kanal-Nummer laden
	sei
	ret

;********************
;* In der Routine "Get_analog" wird aus dem Empfangspuffer der Analogwert mit
;* der Nummer (temp) extrahiert. temp kann Werte von 0..3 annehmen.
;* Das Ergebnis ist in temp2:temp (temp2 = High)
;*
;********************

get_analog:
	andi temp,$03				;Sicherheitshalber den Parameter begrenzen
	ldi xl,data_buffer+2			;Basisadresse für die Low-Bytes
	add xl,temp				;Zugriffsnummer des Wertes als Offset verwenden
	lds temp2,data_buffer+1
get_analog1:
	tst temp
	breq get_analog2
	lsr temp2
	lsr temp2
	dec temp
	rjmp get_analog1
get_analog2:
	andi temp2,$03				;das High-Byte korrigieren
	ld temp,x				;das Low-Byte lesen
	ret

;*********************
;* In der Routine "get_digital" wird aus dem Empfangspuffer der Digitalwert
;* mit der Nummer (Temp) gelesen. Temp = 0..3
;* Ergebnis in Bit 0+1 von motor_bits
;*********************

get_digital:
	andi temp,$03				;den Parameter sicherheitshalber begrenzen
	lds temp2,data_buffer+6			;die Digitalkanäle aus dem Speicher lesen
get_digital_loop:
	tst temp
	breq get_digital_1
	lsr temp2
	lsr temp2
	dec temp
	rjmp get_digital_loop
get_digital_1:
	andi temp2,$03
	mov motor_bits,temp2
	ret


;********************
;*Dekodierung des Manchester-Codes 
;*Quelle: ser_buffer
;*Ziel  : data_buffer
;********************

uebertrage:
	cli
	push xl
	push yl

	;zunächst die Manchester-Codierung Dekodieren 
	ldi xl,ser_buffer			;Adresse für Quell-Puffer 
	ldi yl,data_buffer			;Adresse für Ziel-Puffer
	ldi temp2,$07				;Anzahl der umzuwandelnden Bytes

	cbr flags,(1<<f_error)	;Fehler-Bit löschen

manchester_loop:
	ld temp,x+
	rcall dekode				;1 Byte dekodieren, ergibt 1 Nibble
	sbrc flags,f_error			;Fehler-Bit gesetzt?
	rjmp uebertrage_end
	mov temp4,temp3				;das dekodierte Nibble in R1 speichern
	swap temp4				;und als höherwertiges Nibble verwenden
	ld temp,x+				;ein weiteres Byte aus dem Puffer lesen
	rcall dekode				;dekodieren
	sbrc flags,f_error
	rjmp uebertrage_end
	or temp4,temp3				;das Nibble in R1 hineinodern (niederwertiges Nibble)
	st y+,temp4				;schreiben

	dec temp2
	brne manchester_loop
	ldi temp,$03				;Routine ohne Fehler beendet
	mov error_cnt,temp			;Fehler-Zähler zurücksetzen
uebertrage_end:
	ldi xl,$10
	mov time_out,xl
	pop yl
	pop xl
	sei
	ret

;Dekodiert 1 Byte Manchester zu 1 Nibble Daten
;in temp ist das Manchester-kodierte Byte
;in temp3 wird das dekodierte Nibble zurückgegeben


dekode:	
	ldi zh,$04				;Anzahl der zu dekodierenden Bits
	clr temp3				;Ergebnis auf 0 setzen
	mov temp5,temp				;Das zu dekodierende Byte in R2 kopieren
dekode_loop:
	andi temp,$C0				;die obersten beiden Bits isolieren
	cpi temp,$80
	breq dekode_1
	cpi temp,$40
	breq dekode_2
	sbr flags,(1<<f_error)			;Fehler-Bit setzen
dekode_1:					;Code "10" gefunden	
	sec					;Carry auf "1" setzen
	rol temp3				;und in R0 hineinshiften
	rjmp dekode_3				;weiter
dekode_2:					;Code "01" gefunden
	clc					;Carry auf "0" setzen
	rol temp3				;und in R0 hineinshiften
dekode_3:
	rol temp5				;die nächste Bit-Kombination anwählen
	rol temp5				;(2 Bits weiter shiften)
	mov temp,temp5				;geshiftetes Byte nach r16 kopieren
	dec zh
	brne dekode_loop

	ret

;**********************
serial:	
	push temp				;Statusregister und 
	in temp,SREG				;benutzte Register auf Stack speichern
	push temp
	push temp2
	push xl

	mov xl,ser_pointer			;X mit dem Pointer (Puffer für seriellen Empfang) laden
	in temp,UDR
	sbrs flags,f_start			;Flag gesetzt? (ist Startbyte bereits erkannt worden?)
	rjmp serial_0				;Falls noch kein Startbyte erkannt wurde, springen
serial_0b:
	st x+,temp				;aktuelles Byte in den Puffer schreiben (ser_buffer)
	dec ser_counter
	brne serial_end				;sind alle Bytes übertragen worden?
	cbr flags,(1<<f_start)			;Flag löschen (Startbyte neu erkennen)
	sbr r25,(1<<f_complete)			;Flag für Receive complete (Nachricht an Hauptprogramm)
	ldi temp,$50
	mov time_out,temp
	rjmp serial_end
serial_0:
	cpi temp,$F0				;auf Startbyte checken
	brne serial_end				;kein Startbyte, dann Ende

	sbr flags,(1<<f_start)			;Flag =1   -Startbyte empfangen, also alle 
	ldi ser_counter,$0D			;Counter   -Parameter initialiseren (13 weitere Bytes)
	ldi xl,ser_buffer			;Pointer   -Startadresse für Seriellen Empfangspuffer
	ldi temp,$55				;=0-Nibble
	st x+,temp				;Startbyte "0" in Puffer schreiben
serial_end:
	mov ser_pointer,xl			;Register X in r7 speichern
	pop xl
	pop temp2				;Register wiederherstellen
	pop temp
	out SREG,temp
	pop temp
	reti

;* Dies ist die wichtigste Routine:
;* Hier wird die eigentliche PWM generiert

timer0:
	push temp				;benutzte Register sichern
	in temp,SREG
	push temp
	push temp2
	push zl

	sbrs flags,f_error			;Wenn Error-Flag gesetzt (Fehlübertragung)
	rjmp timer0_x				;dann nicht springen
						;alle Motoren abschalten
	cbi port_pwm_m1,pwm_m1			;Enable Motor1
	cbi port_pwm_m2,pwm_m2			;Enable Motor2
	cbi port_pwm_m3,pwm_m3			;Enable Motor3
	cbi port_pwm_m4,pwm_m4			;Enable Motor4

	rjmp timer0_end

timer0_x:
	ldi zl,pwm_buffer			;Z-Register initialisieren (PWM-Werte)
	inc pwm_counter				;Zähler für PWM
	cpi pwm_counter,$70			;r20=$70 ist der maximalwert
	breq timer0_reset			;wenn dieser Wert erreicht wurde, dann neuen Zyklus beginnen

	ld temp,z+				;den aktuellen Wert aus dem RAM lesen
	cp r16,pwm_counter			;Soll mit Ist vergleichen
	brcc timer0_a
	cbi port_pwm_m1,pwm_m1			;PWM ausschalten (Motor1)
timer0_a:
	ld temp,z+				;nächsten Wert aus RAM laden
	cp temp,pwm_counter			;Vergleich
	brcc timer0_b
	cbi port_pwm_m2,pwm_m2			;Motor 2 abschalten, wenn Wert erreicht
timer0_b:
	ld temp,z+				;und das Ganze nochmal für den 3. Motor
	cp temp,pwm_counter
	brcc timer0_c
	cbi port_pwm_m3,pwm_m3			;Motor 3
timer0_c:
	ld temp,z+
	cp temp,pwm_counter
	brcc timer0_end
	cbi port_pwm_m4,pwm_m4			;Motor 4

	rjmp timer0_end				;Ende des Interrupts anspringen

timer0_reset:
	ldi zl,pwm_buffer			;Basisadresse der PWM-Werte
	ld temp,z+				;lesen
	tst temp				;auf 0 prüfen (damit der Motor bei "0" nicht 
	breq timer0_res_1			;eingeschaltet wird)
	sbi port_pwm_m1,pwm_m1			;PWM einschalten (Wert ist ungleich "0")
timer0_res_1:
	ld temp,z+				;das Ganze nochmal für Motor 2 und 3
	tst temp
	breq timer0_res_2
	sbi port_pwm_m2,pwm_m2
timer0_res_2:
	ld temp,z+
	tst temp
	breq timer0_res_3
	sbi port_pwm_m3,pwm_m3
timer0_res_3:
	ld temp,z+
	tst temp
	breq timer0_res_4
	sbi port_pwm_m4,pwm_m4

timer0_res_4:
	ldi pwm_counter,$FF			;Zähler initialisieren
						;$FF deshalb, weil beim ersten Aufruf der Routine
						;zuerst inkrementiert und dann verglichen wird. Trotz
						;Abfrage auf "0" gab es unregelmäßigkeiten.(???)
timer0_end:	
	pop zl
	pop temp2
	pop temp
	out SREG,temp
	pop temp
	reti

;Multiplikation mit temp2
;Quelle: temp. Ziel: temp2:temp (temp2 = high)
;temp2:temp 
;temp4:temp3

mul14:
	ldi counter,$08				;der Multiplikator hat 8 Bits
	clr temp5				;high-Byte des Multiplikanten löschen
	clr temp3				;low (Ergebnis)
	clr temp4				;Das Ergebnis löschen
mul_loop:
	lsr temp2				;das unterste Bit des multiplikators ins carry schieben
	brcc mul_1
	add temp3,temp
	adc temp4,temp5
mul_1:
	lsl temp
	rol temp5
	dec counter
	brne mul_loop
	mov temp,temp3
	mov temp2,temp4
	ret

;Timer1 Overflow (ca. 56* pro Sekunde bei einem 3,6864 MHz-Quarz

timer1:
	push temp
	in temp,SREG
	push temp

	sbr flags,(1<<f_update)			;Im Hauptprogramm die Motorwerte neu berechnen

	lds temp,servo_puffer	
	out OCR1H,temp
	lds temp,servo_puffer+1
	out OCR1L,temp

	ldi temp,(1<<COM11)			;beim Compare match OC1 auf low setzen
	out TCCR1A,temp

	ldi temp,(1<<OCF1)			;das Compare match Interrupt flag löschen
	out TIFR,temp

	in temp,TIMSK				;Compare-match Interrupt freigeben
	sbr temp,(1<<OCIE1)
	out TIMSK,temp

	pop temp
	out SREG,temp
	pop temp
	reti

;Timer1 Compare match Interrupt, wird für die Servo-Ansteuerung genutzt. 
;das OCR-Register wird im Timer1 Overflow-Interrupt berechnet und gesetzt.
;Der Ausgang OC1 wird auf Low gesetzt.

compare:
	push temp
	in temp,SREG
	push temp
	
	ser temp				;temp =$FF
	out OCR1H,temp
	ldi temp,$E0
	out OCR1L,temp				;setze das Compare-Register auf $FFE0

	ldi temp,(1<<COM11)|(1<<COM10)		;beim nächsten Compare Match OC1 auf high setzen
	out TCCR1A,temp

	in temp,TIMSK
	cbr temp,(1<<OCIE1)			;den Compare Match Interrupt abschalten
	out TIMSK,temp
	
	pop temp
	out SREG,temp
	pop temp	
	reti

; Im EEPROM sind die Daten für die Kanäle abgespeichert.
; Format:
; Bit 0..3 = Nummer des übertragenen Kanals (0...3 = Analog-Kanäle, 4...7 = Digital-Kanäle)
; Bit 4  1= Umrechnung auf 90°, 0 = 270° Stellweg (Senderseitig)
; Bit 5  1= Servo-Funktion, 0 = Fahrtregler-Funktion
; bei den digitalen Kanälen werden Bit 4 und 5 nicht genutzt

;!! Laut Atmel kann es vorkommen, daß Byte 0 des internen EEPROMs beim Einschalten verändert wird.
;!! Später noch ändern !!

.eseg						;EEPROM-Segment
.org $00					;Adresse 0..4 = Kanalinformationen

.db $00,$01,$03,$32,$03

.org $10					;Adresse $10 = Emfänger-Nummer
.db $0D
.org $20					;Adresse $20 = Parameter für Servo-Ansteuerung
.db $0A,$A0,$19					;$0AA0 = Offset, $19 = Multiplikationsfaktor