.CSEG
.ORG	0x0000
	reset_00:
	RJMP start
	
.ORG INT0addr			;External Interrupt0
	RETI
	
.ORG INT1addr			;External Interrupt1
	RJMP manchaster_ein_100
	
.ORG ICP1addr			;Input capture interrupt 1
	RETI
	
.ORG OC1Aaddr			;Timer/Counter1 Compare Match A 
	RETI
	
.ORG OVF1addr			;Overflow1 Interrupt 
	RETI
	
.ORG OVF0addr			;Overflow0 Interrupt
	RETI;rjmp zeitgeber_0_up
	
.ORG URXC0addr			;USART0 RX Complete Interrupt
	RJMP ser_empf_interrupt
	
.ORG UDRE0addr			;USART0 Data Register Empty Interrupt
	RETI
	
.ORG UTXC0addr			;USART0 TX Complete Interrupt 
	RETI
	
.ORG ACIaddr			;Analog Comparator Interrupt 
	RETI
	
;.ORG PCINTaddr			;Pin Change Interrupt
	RETI
	
.ORG OC1Baddr			;Timer/Counter1 Compare Match B
	RETI
	
.ORG OC0Aaddr			;Timer/Counter0 Compare Match A   
	RJMP zeitgeber_0_up
	
.ORG OC0Baddr			;Timer/Counter0 Compare Match B 
	RETI
	
.ORG USI_STARTaddr		;USI start interrupt
	RETI
	
.ORG USI_OVFaddr		;USI overflow interrupt
	RETI
	
.ORG ERDYaddr			;EEPROM write complete
	RETI
	
.ORG WDTaddr			;Watchdog Timer Interrupt
	RETI
;------------------------------------------------------------------------------
;
.include "tn2313def.inc"
.include "variablen.asm"
.include "interrupt_vektoren_atmega2313.asm"

.ORG	0x0015
start:
	cli

;-------------------------------------------------------------------
;Ende des Rambereichs laden
	ldi tmp4,(RAMEND)
	ldi xl,96
;Datum für das Auffüllen laden	
	ldi tmp1,0

rambereinigung:
	st x+,tmp1
	cp xl,tmp4
	brne rambereinigung

;Setzen des Stabelzeigers
	out SPL,tmp4
;-------------------------------------------------------------------

;-------------------------------------------------------------------
;Serielle Schnittstelle konfigurieren
	ldi tmp1,0		;Uebertragungsrate einstellen
	out UBRRH,tmp1	;9600 Baud
	ldi tmp1,52
	out UBRRL,tmp1

	ldi tmp1,(0<<UMSEL)|(0<<USBS)|(0<<UPM1)|(0<<UPM0)|(0<<UCSZ2)|(1<<UCSZ1)|(1<<UCSZ0)
	out UCSRC,tmp1
	
	ldi tmp1, (1<<RXCIE)|(0<<TXCIE)|(0<<UDRIE)|(1<<RXEN)|(1<<TXEN)
	out UCSRB,tmp1
;-------------------------------------------------------------------

;-------------------------------------------------------------------
portinit:
;hier werden alle Ports konfiguriert
	ldi tmp1,0b11111111
	out DDRB,tmp1
	ldi tmp1,0b11110111
	out DDRD,tmp1
;hier wird der Pullupwiederstand abgeschaltet
	ldi tmp1,0b00000000
	out portb,tmp1
	ldi tmp1,0b00000000
	out portd,tmp1
;-------------------------------------------------------------------
;-------------------------------------------------------------------
	in tmp1,MCUCR
	sbr tmp1,0b00000100
	out MCUCR,tmp1
	in tmp1,GIMSK
	sbr tmp1,0b10000000
	out GIMSK,tmp1
;-------------------------------------------------------------------
;-------------------------------------------------------------------
; ;Konfiguration Timer 0
; ;;--------------------------------------------
; ;;TCCR0A setzen
; ;;--------------------------------------------
	ldi tmp1,0b00000010
 	out TCCR0A,tmp1           ;Timer 0 im CTC-Modus
; ;;--------------------------------------------
; ;;TCCR0B setzen
; ;;--------------------------------------------
 	ldi tmp1,0b00000001       ;Teiler durch 8
 	out TCCR0B,tmp1
; ;;--------------------------------------------
; ;;Timer 0 Interrupt bei Überlauf setzen
; ;;--------------------------------------------
	ldi tmp1,120
	out ocr0a,tmp1
 	in tmp1,TIMSK
 	sbr tmp1,0b00000001
 	cbr tmp1,0b00000110
 	out TIMSK,tmp1
 	clr tempreg3
 	clr tempreg4
 	clr tempreg5
 	clr tempreg6
; 	ret
;---------------------------------------------

	sei

hpt_prg:
	rcall manchester_send_pre_interrupt
	rcall daten_in_ser_empf_einschreiben
	rcall manchaster_ein_ausgabe
      rjmp hpt_prg
;---------------------------------------------
;---------------------------------------------
.dseg
	manchester_send_zaehler:
		.byte 1
	manchester_empf_zaehler:
		.byte 1
;---------------------------------------------
.cseg
;---------------------------------------------
;Einsprungprozedur
;Retten der tmporaeren Register tmp1
;und SREG
zeitgeber_0_up:
	push tmp1
	in tmp1,SREG
	push tmp1
;---------------------------------------------
;ca. 3000 mal in der Sekunde 
;---------------------------------------------
	lds tmp1,manchester_empf_zaehler
	inc tmp1
	sts manchester_empf_zaehler,tmp1

	lds tmp1,manchester_send_zaehler
	inc tmp1
	sts manchester_send_zaehler,tmp1
	cpi tmp1,25
	brlo zeitgeber_0_ueberlauf_ende
	clr tmp1
	sts manchester_send_zaehler,tmp1
;---------------------------------------------
;Hier die Anwendungen
    lds tmp1,manchaster_aus_status
	sbrs tmp1,1
	rjmp manchaster_send_interrupt_1100
	sbrc tmp1,6
	rjmp manchaster_send_interrupt_1000
   	sbic portd,4						;Springe wenn Bit geloescht
	rjmp manchester_send_interrupt_510
	sbi portd,4
	rjmp manchaster_send_interrupt_1000

manchester_send_interrupt_510:
	cbi portd,4

manchaster_send_interrupt_1000:
	cbr tmp1,0b00000010
	rjmp manchaster_send_interrupt_1200

manchaster_send_interrupt_1100:
	sbr tmp1,0b00000001

manchaster_send_interrupt_1200:
	sts manchaster_aus_status,tmp1
;---------------------------------------------
	rcall ser_send
;---------------------------------------------
;Zurueckspeichern der tmporaeren Register SREG und tmp1
zeitgeber_0_ueberlauf_ende:
	pop tmp1
	out SREG,tmp1
	pop tmp1
	reti
;---------------------------------------------
;---------------------------------------------
.DSEG
	ser_send_ein:	;Zeiger der für das einschreiben der ausgangs
		.byte 1
	ser_send_aus:
		.byte 1
	ser_send_ws:
		.byte 20

.CSEG
;-------------------------------------------------------------------------------------
;-------------------------------------------------------------------------------------
in_ser_send_ws:
;!!Nicht in einer Interruptroutine anwenden!!
;In tmp4 steht das Datum, das Uebertragen werden soll
;Das Programm wird so lange nicht verlassen, bis der Wert geschrieben wurde
	lds xl,ser_send_ein
	inc xl
	cpi xl,20			;Max. Eintraege in die SchreibWS
	brlo in_ser_send_ws_fuellen_10
	clr xl 

in_ser_send_ws_fuellen_10:
	lds xh,ser_send_aus
	cp xl,xh			;Wenn Eingangs- und Ausgangszeiger gleich kein Platz mehr
	breq in_ser_send_ws_fuellen_10
	sts ser_send_ein,xl
	ldi xh,low(ser_send_ws)		;Lade Grundadresse des Ringspeicher
	add xl,xh
	clr xh
	st x,tmp4
	ret
;-------------------------------------------------------------------------------------
;-------------------------------------------------------------------------------------
ser_send:
	sbis UCSRA,UDRE			;Wenn Hardware frei für Byte zur seriellen Uebertragung
	ret					;Wird das nächste Datenbyte aus dem Ringspeicher geladen
	push tmp4
	in tmp4,sreg
	push tmp4
	push xl				;und in das Senderegister geschrieben
;--------------------------------------------
ser_send10:	
	lds tmp4,ser_send_aus
	lds xl,ser_send_ein
	cp tmp4,xl				;Wenn Eingangs- und Ausgangszeiger gleich keine neue Daten
	breq ser_send_100
	inc tmp4
	cpi tmp4,20			;Max. Eintraege in die SchreibWS
	brlo ser_send_20
	clr tmp4 

ser_send_20:
	sts ser_send_aus,tmp4
	push xh
	ldi xl,low(ser_send_ws)	;Lade Grundadresse des Ringspeicher 
	clr xh
	add xl,tmp4
	ld tmp4,x				;Datum aus Warteschlange lesen
	out UDR,tmp4			;Datum in Ausgabebyte schreiben
	pop xh

ser_send_100:
	pop xl
	pop tmp4
	out sreg,tmp4
	pop tmp4
	ret
;-------------------------------------------------------------------------------------
;-------------------------------------------------------------------------------------
.DSEG
ser_ein_int_stat:
	.byte 1
datum_ser_eing:
	.byte 1

.CSEG
ser_empf_interrupt:
  push tmp4
  in tmp4,sreg
  push tmp4
;----------------------------------------------
  in tmp4,UDR				;Lade Uebertragenes Byte
  sts datum_ser_eing,tmp4		;Speichere Datum ab
  lds tmp4,ser_ein_int_stat	
  sbr tmp4,0b00001000
  sts ser_ein_int_stat,tmp4
;----------------------------------------------
  pop tmp4
  out sreg,tmp4
  pop tmp4
  reti
;------------------------------------------------------------------------------	
;------------------------------------------------------------------------------	
daten_in_ser_empf_einschreiben:
	lds tmp9,ser_ein_int_stat	;Ueberpruefen ob neue Daten zu Senden bereit stehen
	sbrs tmp9,3
	ret
	cbr tmp9,0b00001000
	sts ser_ein_int_stat,tmp9
	lds tmp9,manchester_send_ein
	inc tmp9
	cpi tmp9,20
	brlo daten_in_ser_empf_einschreiben_130
 	clr tmp9

daten_in_ser_empf_einschreiben_130:
	lds xl,manchester_send_aus
	cp tmp9,xl
	breq daten_in_ser_empf_einschreiben_150
	ldi xl,low(manchester_send_ws)		;Laden Grundadresse des Ringspeicher in das X-Register
	add xl,tmp9
	lds tmp4,datum_ser_eing
	st x,tmp4
	sts manchester_send_ein,tmp9

daten_in_ser_empf_einschreiben_150:
	ret
;---------------------------------------
manchaster_ein_ausgabe:
	lds tmp3,manchaster_ein_status
	sbrs tmp3,1
	ret
	cbr tmp3,0b00000010
	sts manchaster_ein_status,tmp3
	lds tmp4,manchaster_ein_fertig
	rcall in_ser_send_ws
	ret
.dseg
    manchester_send_ein:
        .byte 1
    manchester_send_ws:
        .byte 20
    manchaster_aus_status:
        .byte 1
    manchester_send_aktuell:
        .byte 1
    manchester_send_vorrat:
        .byte 1
	manchester_send_kontroll_vorrat:
		.byte 1
    manchester_send_bit_zaehler:
        .byte 1
	manchester_send_aus:
		.byte 1
	manchester_send_fehler_zaehler:
        .byte 1
.cseg
;------------------------------------------------------------------------
; Es werden am Anfang 13 Bits übertragen. Die ersten drei Bits sind die Anfangsbedingung,
; 010. Danach folgen 8 Datenbits und zwei Statusbits. Das erste Statusbit ist ein
; Priority-Bit, das zweite Statusbit ist das Ergebnis des gesendeten Byte, das mit dem
; empfangenen Byte verglichen wird, (0 = OK, 1 = KO). Nach den ersten 13 Bit werden,
;solange der Sendevorgang dauert, 10 Bits übertragen
manchester_send_pre_interrupt:			;Einzelne Stati der Übertrgung unterschieden
    lds tmp1,manchaster_aus_status
	sbrc tmp1,1
	rjmp manchester_send_interrupt_ende	;Hardware noch nicht bereit
	sbrc tmp1,3
    rjmp manchester_send_interrupt_41		;Der zweite Pegel wird immer gewechselt
	sbrc tmp1,4
    rjmp manchester_send_interrupt_100  	;Wenn ein Byte bereits gesendet wird dann springe
	sbrc tmp1,2
	rjmp manchester_send_interrupt_10	;Wenn Übertragung wiederholt werden muß
	sbrc tmp1,5
	rjmp manchester_send_interrupt_5	;Wenn neues Datum vorhanden ist
	rcall manchester_aus_ws_in_vorrat
	rjmp manchester_send_interrupt_520	;Springe wenn kein Datum vorhanden--
;------------------------------------------------------------------------------------------
manchester_send_interrupt_5:
	lds tmp2,manchester_send_vorrat		;neues Datum wird übertragen
	cbr tmp1,0b00100000				;neues Datum aus Zwischenspeicher laden
	rjmp manchester_send_interrupt_20			;
													
manchester_send_interrupt_10:					;
	lds tmp2,manchester_send_kontroll_vorrat	;Datum wird nocheinal gesendet
	cbr tmp1,0b00000100		
								
manchester_send_interrupt_20:
	sts manchester_send_aktuell,tmp2	;Datum in Verabeitungsspeicher
	sts manchester_send_kontroll_vorrat,tmp2	;Datum in Speicher für event. Wiederholung
	clr tmp2
	sts manchester_send_bit_zaehler,tmp2
	cbr tmp1,0b10001000				;Parity-Bit auf 0, Neues Daum vorh auf 0
	sbr tmp1,0b00010000				;Übertragung läuft
;-------------------------------------------------------------------------------------------
manchester_send_interrupt_100:
	lds tmp2,manchester_send_bit_zaehler		;Zähler für die Anzahl der gesendeten Bits
    inc tmp2
	sts manchester_send_bit_zaehler,tmp2
	cpi tmp2,9							;Was passiert
	breq manchester_send_interrupt_30		;bei Bit 9
	brlo manchester_send_interrupt_40		;bei Bit 1 - 8
;-------------------------------------------	;bei Bit 10
	lds tmp3,manchester_send_kontroll_vorrat
	lds tmp2,manchaster_ein_fertig 			;manchaster_ein_datum
	cp tmp3,tmp2
	brne Uebertragungskontrolle_10
	clr tmp3							;Bit 10 = 0 == Uetragung OK
	sts manchester_send_fehler_zaehler,tmp3
	cbr tmp1,0b00010100
	rjmp Uebertragungskontrolle_25

Uebertragungskontrolle_10:						
	lds tmp3,manchester_send_fehler_zaehler	;Die Übertragung wird max. dreimal wiederholt
	inc tmp3
	sts manchester_send_fehler_zaehler,tmp3
	cpi tmp3,2
	brsh Uebertragungskontrolle_15
	sbr tmp1,0b00000100					;Setzte Bit Übertragung wiederholen
	cbr tmp1,0b00010000
	rjmp Uebertragungskontrolle_20

Uebertragungskontrolle_15:
	clr tmp3
	sts manchester_send_fehler_zaehler,tmp3
	cbr tmp1,0b00010100

Uebertragungskontrolle_20:
	ldi tmp3,0b10000000					;Bit 10 = 1 == Fehler in Ueertragung

Uebertragungskontrolle_25:
	sts manchester_send_aktuell,tmp3
	rjmp manchester_send_interrupt_40a
;--------------------------------------------------------------------------------------------
manchester_send_interrupt_30:
	sts manchester_send_aktuell,tmp1		;Parity-Bit in Sendespeicher
	cbr tmp1,0b00100000
	rjmp manchester_send_interrupt_40a
;--------------------------------------------------------------------------------------------
manchester_send_interrupt_40:
	sbrs tmp1,0						;Soll zuerst die Anfangsbedingung übertragen werden?
	rjmp manchester_send_interrupt_40a
	cpi tmp2,1
	breq Uebertragungskontrolle_28
	cpi tmp2,3
	brne manchester_send_interrupt_40a
	cbr tmp1,0b00010001					;Loesche Anfangsbedingung übertragen, Byte wird übertragen
	sbr tmp1,0b00000100					;Setzte gespeichertes Byte muß übertragen werden
	rjmp manchester_send_interrupt_40a	

Uebertragungskontrolle_28:
	ldi tmp2,0b01000000
	sts manchester_send_aktuell,tmp2

manchester_send_interrupt_40a:
	sbr tmp1,0b00001000					;Setzte Bit, erster Teil des Bits übertragen
    lds tmp2,manchester_send_aktuell			;
    rol tmp2
    sts manchester_send_aktuell,tmp2
    brcc manchester_send_interrupt_42			;Springe zu Pegelwechsel wenn Low-Bit uebertragen werden
	ldi tmp2,0b10000000					;soll. Bei Highbits wird im zweiten Abschnitt kein Pegel
	eor tmp1,tmp2  						;wechsel vorgenommen, aber das Kontrollbit bei einem
	sbr tmp1,0b01000000
	rjmp manchester_send_interrupt_43		;gewechselt
;------------------------------------------------  
manchester_send_interrupt_41:
	cbr tmp1,0b00001000

manchester_send_interrupt_42:
	cbr tmp1,0b01000000					;Datum fuer Hardwareschicht steht bereit

manchester_send_interrupt_43:
	sbr tmp1,0b00000010
	
manchester_send_interrupt_520:
    sts manchaster_aus_status,tmp1

manchester_send_interrupt_ende:
    ret
;------------------------------------------------------------------------
manchester_aus_ws_in_vorrat:		;Ist das aktuelle Datum gesendet, wird
	lds tmp2,manchester_send_aus	;Lade Zeiger auslesen aus Ringspeicher 
	lds xl,manchester_send_ein		;Lade Zeiger einschreiben in Ringspei
	cp tmp2,xl		               	;Zeiger gleich, keine neuen Daten
	brne daten_aus_manchester_aus_ws_in_vorrat_5
	sbr tmp1,0b00000001				;Wenn keine neue Daten, muß Anfangs-
	rjmp daten_aus_manchester_aus_ws_in_vorrat_ende	;bed gesendet werden

daten_aus_manchester_aus_ws_in_vorrat_5:
	inc tmp2						;Inkrementiere Auszeiger
	cpi tmp2,20		              	;Max. Eintraege in die SchreibWS
	brlo daten_aus_manchester_aus_ws_in_vorrat_10
	clr tmp2 						;Wenn Max erreicht fange von Null an

daten_aus_manchester_aus_ws_in_vorrat_10:
	sts manchester_send_aus,tmp2	;Speichere akt. Stand des Auszeiger
	ldi xl,low(manchester_send_ws)	;Lade Grundadresse des Ringspeicher 
	clr xh
	add xl,tmp2
	ld tmp2,x			            ;Datum aus Warteschlange lesen
	sts manchester_send_vorrat,tmp2	;Datum in Ausgabebyte schreiben
    sbr tmp1,0b00100000            ;Bit gueltiger Wert in Datum setzen

daten_aus_manchester_aus_ws_in_vorrat_ende:
	ret
;------------------------------------------------------------------------
;------------------------------------------------------------------------
.dseg
	manchaster_ein_status:
		.byte 1
	manchaster_empf_zeit_basis_high:
		.byte 1
	manchaster_ein_bit_zaehler:
		.byte 1
	manchaster_ein_datum:
		.byte 1
	manchaster_ein_fertig:
		.byte 1
	manchester_empf_1:
		.byte 1
	manchester_empf_2:
		.byte 1
;-----------------------------------------------------------------
.cseg							;------------------------------
manchaster_ein_100:				;	manchester_empf_1
	push tmp3					;------------------------------
	in tmp3,sreg				;   manchester_empf_2
	push tmp3	;Zählerstand	;------------------------------
	push tmp4	;Status			;		tmp3
	push tmp5					;------------------------------
	lds tmp3,manchester_empf_zaehler
	clr tmp5
	sts manchester_empf_zaehler,tmp5	;Lösche Inetrruptzähler
	lds tmp4,manchaster_ein_status
	sbrc tmp4,3					;Wenn Empfangsbedingung noch nicht erkannt
	rjmp manchaster_ein_200

;----------------- Anfangsbedingung erkennen ----------------------
;Die Anfangsbedingnung ist ein High gefolgt von einem Lowbyte.
; Es darf der Inhalt von tmp3 und ..._empf_2 max so gross wie ..._empf_1 sein.
	lds tmp4,manchester_empf_2	;Lade die voletzte Messung
	add tmp4,tmp3				;addiere diese zur letzten Messung
	lds tmp5,manchester_empf_1	;Lade die vor-vorletzte Messung
	sub tmp5,tmp4				;subtrahiere die beiden Werte
	brlo manchaster_ein_510 ;manchaster_ein_9900	;Wenn tmp 4 größer als tmp3 dann Ende
; tmp3 und ..empf_2 sind kleiner-gleich als ..empf_1 und muessen
; aber mindestens 75% von ..empf_1 groß sein.
	lds tmp4,manchester_empf_1
	lsr tmp4
	lsr tmp4
	cp tmp4,tmp5
	lds tmp4,manchaster_ein_status
	brlo manchaster_ein_510 ;manchaster_ein_9900  	;Wenn tmp4 zu klein, dann Ende
;------ Anfangsbedingung erkannt, abspeichern der Zeit -----------
	lds tmp5,manchester_empf_1
	sts manchaster_empf_zeit_basis_high,tmp5
	sbr tmp4,0b00001000
	rjmp manchaster_ein_2010
;------- Ab hier Verarbeitung der Bits --------------------------------
manchaster_ein_200:
	lds tmp5,manchaster_empf_zeit_basis_high	;Lade Zeitbasisvergleich
	inc tmp5
	sub tmp5,tmp3				;Subtrahiere Empfanhswert von Basis
	brlo manchaster_ein_2000 	;Springe wenn Eingang groesser als gespeichert
	cpi tmp5,3					;Wenn die Toleranz bei der Subtraktion kleiner
	brlo manchaster_ein_500		;Drei, dann ein High-Byte
	lds tmp5,manchaster_empf_zeit_basis_high
	lsr tmp5					;Teile Basis durch 2, eine Hälfte von Low
	inc tmp5
	sub tmp5,tmp3
	cpi tmp5,3					;Wenn die Toleranz bei der Subtraktion kleiner
	brlo manchaster_ein_600		;Drei, dann ein Low-Byte
	rjmp manchaster_ein_2000 		;Sonst Fehler in der Übertragung
;-----------------------------------------------------------------
manchaster_ein_500:
;Ein High-Bit in das Datenbyte
	sbrc tmp4,0

manchaster_ein_510:
	rjmp manchaster_ein_2000	;Wenn nur eine Hälft des Null-Bytes übertragen wird, dann Fehler
	set						;Setzte T für High
	rjmp manchaster_ein_650

manchaster_ein_600:
;Ein Low-Bit in das Datenbyte
	sbrs tmp4,0
	rjmp manchaster_ein_610
	cbr tmp4,0b00000001
	clt						;Loesch T fuer Low, nachdem die zweite Low-Haelfte gesendet wurde
	rjmp manchaster_ein_650

manchaster_ein_610:
	sbr tmp4,0b00000001
	rjmp manchaster_ein_2030
;------- Ab hier ist der Empfang abgeschlossen, in T steht das empfangene Bit --------
manchaster_ein_650:
	lds tmp5,manchaster_ein_bit_zaehler
	inc tmp5
	cpi tmp5,9
	breq manchaster_ein_700
	brsh manchaster_ein_800
;-------- Ab hier werden die Bits 1 - 8 verarbeitet ----------------------------------
	lds tmp3,manchaster_ein_datum
	lsl tmp3
	bld tmp3,0					;Übertrage Bit T an Stelle 0 des Ergebnis
	sts manchaster_ein_datum,tmp3
	brtc manchaster_ein_2020
	ldi tmp3,0b10000000
	eor tmp4,tmp3				;Parity-Bit bearbeiten
	rjmp manchaster_ein_2020
;-------- Hier wird das BIt 9 bearbeitet ---------------------------------------------
manchaster_ein_700:
	lds tmp3,manchaster_ein_datum	;Speicher das empfangene Byte in
	sts manchaster_ein_fertig,tmp3	;Ausgangsvariable
	brtc manchaster_ein_710
	sbrs tmp4,7						;T-Bit und Pary = 1
	rjmp manchaster_ein_720		;T-Bit und Pary unglei
	rjmp manchaster_ein_730

manchaster_ein_710:
	sbrc tmp4,7						;T-Bit und Pary unglei
	rjmp manchaster_ein_720		;T-Bit und PAry = 0

manchaster_ein_730:
	sbr tmp4,0b00000100
	rjmp manchaster_ein_2020

manchaster_ein_720:
	cbr tmp4,0b00000100	
;-------- Hier wird das Bit 10 Bearbeitet --------------------------------------------
manchaster_ein_800:
	sbrs tmp4,2				;1 = Parity-Bit OK
	rjmp manchaster_ein_810
	brts manchaster_ein_810		;1 = Datenübertragung KO
	sbr tmp4,0b00000010
	cbr tmp4,0b10000101
	rjmp manchaster_ein_2010

manchaster_ein_810:
	cbr tmp4,0b10000111
	rjmp manchaster_ein_2010

;-----------------------------------------------------------------
manchaster_ein_2000:
	lds tmp4,manchaster_ein_status
	cbr tmp4,0b11101001

manchaster_ein_2010:
	clr tmp5

manchaster_ein_2020:
	sts manchaster_ein_bit_zaehler,tmp5

manchaster_ein_2030:
	sts manchaster_ein_status,tmp4
	lds tmp4,manchester_empf_2
	sts manchester_empf_1,tmp4
	sts manchester_empf_2,tmp3

	pop tmp5
	pop tmp4
	pop tmp3
	out sreg,tmp3
	pop tmp3
	reti