; ******************************************************** ; * Routinen zur Zahlumwandlung, Version 0.1 Januar 2002 * ; * (C)2002 by http://www.avr-asm-tutorial.net * ; ******************************************************** ; ; Die folgenden Regeln gelten fuer alle Routinen zur Zahl- ; umwandlung: ; - Fehler waehrend der Umwandlung werden durch ein gesetz- ; tes T-Bit im Status-Register signalisiert. ; - Der Z Zeiger zeigt entweder in das SRAM (Adresse >= ; $0060) oder auf einen Registerbereich (Adressen $0000 ; bis $001D), die Register R0, R16 und R30/31 duerfen ; nicht in dem benutzten Bereich liegen! ; - ASCII- und BCD-kodierte mehrstellige Zahlen sind ab- ; steigend geordnet, d.h. die hoeherwertigen Ziffern ha- ; ben die niedrigerwertigen Adressen. ; - 16-bit-Binaerzahlen sind generell in den Registern ; rBin1H:rBin1L lokalisiert, bei einigen Routinen wird ; zusaetzlich rBin2H:rBin2L verwendet. Diese muessen im ; Hauptprogramm definiert werden. ; - Bei Binaerzahlen ist die Lage im Registerbereich nicht ; massebend, sie koennen auf- oder absteigend geordnet ; sein oder getrennt im Registerraum liegen. Zu vernei- ; den ist eine Zuordnung zu R0, rmp, ZH oder ZL. ; - Register rmp (Bereich: R16..R29) wird innerhalb der ; Rechenroutinen benutzt, sein Inhalt ist nach Rueckkehr ; nicht definiert. ; - Das Registerpaar Z wird innerhalb von Routinen verwen- ; det. Bei der Rueckkehr ist sein Inhalt abhaengig vom ; Fehlerstatus definiert. ; - Einige Routinen verwenden zeitweise Register R0. Sein ; Inhalt wird vor der Rueckkehr wieder hergestellt. ; - Wegen der Verwendung des Z-Registers ist in jedem Fall ; die Headerdatei des Prozessors einzubinden oder ZL ; (R30) und ZH (R31) sind manuell zu definieren. Wird ; die Headerdatei oder die manuelle Definition nicht ; vorgenommen, gibt es beim Assemblieren eine Fehlermel- ; dung oder es geschehen raetselhafte Dinge. ; - Wegen der Verwendung von Unterroutinen muss der Sta- ; pelzeiger (SPH:SPL bzw. SPL bei <256 Byte SRAM) ; initiiert sein. ; ; ************* Ueberblick ueber die Routinen ************** ; Routine Aufruf Bedingungen Rueckkehr, ; Fehler ; -------------------------------------------------------- ; AscToBin2 Z zeigt auf Beendet beim ersten 16-bit-Bin ; erstes Zeichen, das nicht rBin1H:L, ; ASCII- einer Dezimalziffer Ueberlauf- ; Zeichen entspricht, ueber- fehler ; liest Leerzeichen ; und fuehrende Nullen ; Asc5ToBin2 Z zeigt auf Benoetigt exakt 5 16-bit-Bin ; erstes gueltige Ziffern, rBin1H:L, ; ASCII- ueberliest Leerzei- Ueberlauf ; Zeichen chen und Nullen oder unguel- ; tige Ziffern ; Bcd5ToBin2 Z zeigt auf Benoetigt exakt 5 16-bit-Bin ; 5-stellige gueltige Ziffern rBin1H:L ; BCD-Zahl Ueberlauf ; oder unguel- ; tige Ziffern ; Bin2ToBcd5 16-bit-Bin Z zeigt auf erste 5-digit-BCD ; in rBin1H:L BCD-Ziffer (auch ab Z, keine ; nach Rueckkehr) Fehler ; Bin2ToHex4 16-bit-Bin Z zeigt auf erste 4-stellige ; in rBin1H:L Hex-ASCII-Stelle, Hex-Zahl ab ; Ausgabe A...F Z, keine ; Fehler ; Hex4ToBin2 4-digit-Hex Benoetigt exakt vier 16-bit-Bin ; Z zeigt auf Stellen Hex-ASCII, rBin1H:L, ; erste Stelle akzeptiert A...F und ungueltige ; a...f Hex-Ziffer ; ; ******************* Umwandlungscode ******************** ; ; Paket I: Von ASCII bzw. BCD nach Binaer ; ; AscToBin2 ; ========= ; wandelt eine ASCII-kodierte Zahl in eine 2-Byte-/16-Bit- ; Binaerzahl um. ; Aufruf: Z zeigt auf erste Stelle der umzuwandelnden ; Zahl, die Umwandlung wird bei der ersten nicht dezima- ; len Ziffer beendet. ; Stellen: Zulaessig sind alle Zahlen, die innerhalb des ; Wertebereiches von 16 Bit binaer liegen (0..65535). ; Rueckkehr: Gesetztes T-Flag im Statusregister zeigt Feh- ; ler an. ; T=0: Zahl in rBin1H:L ist gueltig, Z zeigt auf erstes ; Zeichen, das keiner Dezimalziffer entsprach ; T=1: Ueberlauffehler (Zahl zu gross), rBin1H:L undefi- ; niert, Z zeigt auf Zeichen, bei dessen Verarbeitung ; der Fehler auftrat. ; Benoetigte Register: rBin1H:L (Ergebnis), rBin2H:L (wieder ; hergestellt), rmp ; Benoetigte Unterroutinen: Bin1Mul10 ; AscToBin2: clr rBin1H ; Ergebnis auf Null setzen clr rBin1L clt ; Fehlerflagge zuruecksetzen AscToBin2a: ld rmp,Z+ ; lese Zeichen cpi rmp,' ' ; ignoriere fuehrende Leerzeichen ... breq AscToBin2a cpi rmp,'0' ; ... und Nullen breq AscToBin2a AscToBin2b: subi rmp,'0' ; Subtrahiere ASCII-Null brcs AscToBin2d ; Ende der Zahl erkannt cpi rmp,10 ; pruefe Ziffer brcc AscToBin2d ; Ende der Umwandlung rcall Bin1Mul10 ; Binaerzahl mit 10 malnehmen brts AscToBin2c ; Ueberlauf, gesetztes T-Flag add rBin1L,rmp ; Addiere Ziffer zur Binaerzahl ld rmp,Z+ ; Lese schon mal naechstes Zeichen brcc AscToBin2b ; Kein Ueberlauf ins MSB inc rBin1H ; Ueberlauf ins naechste Byte brne AscToBin2b ; Kein Ueberlauf ins naechste Byte set ; Setze Ueberlauffehler-Flagge AscToBin2c: sbiw ZL,1 ; Ueberlauf trat bei letztem Zeichen auf AscToBin2d: ret ; fertig, Rueckkehr ; ; Asc5ToBin2 ; ========== ; wandelt eine fuenfstellige ASCII-kodierte Zahl in 2-Byte- ; Binaerzahl um. ; Aufruf: Z zeigt auf erste Stelle der ASCII-kodierten ; Zahl, fuehrende Leerzeichen und Nullen sind erlaubt. ; Stellen: Die Zahl muss exakt 5 gueltige Stellen haben. ; Rueckkehr: T-Flag zeigt Fehlerbedingung an: ; T=0: Binaerzahl in rBin1H:L ist gueltig, Z zeigt auf ; erste Stelle der ASCII-kodierten Zahl. ; T=1: Fehler bei der Umwandlung. Entweder war die Zahl ; zu gross(0..65535, Z zeigt auf die Ziffer, bei der ; der Ueberlauf auftrat) oder sie enthilt ein unguelti- ; ges Zeichen (Z zeigt auf das ungueltige Zeichen). ; Benoetigte Register: rBin1H:L (Ergebnis), R0 (wiederher- ; gestellt), rBin2H:L (wieder hergestellt), rmp ; Aufgerufene Unterroutinen: Bin1Mul10 ; Asc5ToBin2: push R0 ; R0 wird als Zaehler verwendet, retten ldi rmp,6 ; Fuenf Ziffern, einer zu viel mov R0,rmp ; in Zaehlerregister R0 clr rBin1H ; Ergebnis auf Null setzen clr rBin1L clt ; Fehlerflagge T-Bit zuruecksetzen Asc5ToBin2a: dec R0 ; Alle Zeichen leer oder Null? breq Asc5ToBin2d ; Ja, beenden ld rmp,Z+ ; Lese nuechstes Zeichen cpi rmp,' ' ; ueberlese Leerzeichen breq Asc5ToBin2a ; geh zum naechsten Zeichen cpi rmp,'0' ; ueberlese fuehrende Nullen breq Asc5ToBin2a ; geh zum naechsten Zeichen Asc5ToBin2b: subi rmp,'0' ; Behandle Ziffer, ziehe ASCII-0 ab brcs Asc5ToBin2e ; Ziffer ist ungueltig, raus cpi rmp,10 ; Ziffer groesser als neun? brcc Asc5ToBin2e ; Ziffer ist ungueltig, raus rcall Bin1Mul10 ; Multipliziere Binaerzahl mit 10 brts Asc5ToBin2e ; Ueberlauf, raus add rBin1L,rmp ; addiere die Ziffer zur Binaerzahl ld rmp,z+ ; lese schon mal das naechste Zeichen brcc Asc5ToBin2c ; Kein Ueberlauf in das naechste Byte inc rBin1H ; Ueberlauf in das naechste Byte breq Asc5ToBin2e ; Ueberlauf auch ins uebernaechste Byte Asc5ToBin2c: dec R0 ; Verringere Zaehler fuer Anzahl Zeichen brne Asc5ToBin2b ; Wandle weitere Zeichen um Asc5ToBin2d: ; Ende der ASCII-kodierten Zahl erreicht sbiw ZL,5 ; Stelle die Startposition in Z wieder her pop R0 ; Stelle Register R0 wieder her ret ; Kehre zurueck Asc5ToBin2e: ; Letztes Zeichen war ungueltig sbiw ZL,1 ; Zeige mit Z auf ungueltiges Zeichen pop R0 ; Stelle Register R0 wieder her set ; Setze T-Flag fuer Fehler ret ; und kejre zurueck ; ; Bcd5ToBin2 ; ========== ; wandelt eine 5-bit-BCD-Zahl in eine 16-Bit-Binaerzahl um ; Aufruf: Z zeigt auf erste Stelle der BCD-kodierten ; Zahl ; Stellen: Die Zahl muss exakt 5 gueltige Stellen haben. ; Rueckkehr: T-Flag zeigt Fehlerbedingung an: ; T=0: Binaerzahl in rBin1H:L ist gueltig, Z zeigt auf ; erste Stelle der BCD-kodierten Zahl. ; T=1: Fehler bei der Umwandlung. Entweder war die Zahl ; zu gross (0..65535, Z zeigt auf die Ziffer, bei der ; der Ueberlauf auftrat) oder sie enthielt ein unguelti- ; ges Zeichen (Z zeigt auf das ungueltige Zeichen). ; Benoetigte Register: rBin1H:L (Ergebnis), R0 (wiederher- ; gestellt), rBin2H:L (wieder hergestellt), rmp ; Aufgerufene Unterroutinen: Bin1Mul10 ; Bcd5ToBin2: push R0 ; Rette Register R0 clr rBin1H ; Setze Ergebnis Null clr rBin1L ldi rmp,5 ; Setze Zaehler auf 5 Ziffern mov R0,rmp ; R0 ist Zaehler clt ; Setze Fehlerflagge zurueck Bcd5ToBin2a: ld rmp,Z+ ; Lese BCD-Ziffer cpi rmp,10 ; pruefe ob Ziffer korrekt brcc Bcd5ToBin2c ; ungueltige BCD-Ziffer rcall Bin1Mul10 ; Multipliziere Ergebnis mit 10 brts Bcd5ToBin2c ; Ueberlauf aufgetreten add rBin1L,rmp ; Addiere Ziffer brcc Bcd5ToBin2b ; Kein Ueberlauf ins naechste Byte inc rBin1H ; Ueberlauf ins naechste Byte breq Bcd5ToBin2c ; Ueberlauf ins uebernaechste Byte Bcd5ToBin2b: dec R0 ; weitere Ziffer? brne Bcd5ToBin2a ; Ja pop R0 ; Stelle Register wieder her sbiw ZL,5 ; Setze Zeiger auf erste Stelle der BCD-Zahl ret ; Kehre zurueck Bcd5ToBin2c: sbiw ZL,1 ; Eine Ziffer zurueck pop R0 ; Stelle Register wieder her set ; Setze T-flag, Fehler ret ; Kehre zurueck ; ; Bin1Mul10 ; ========= ; Multipliziert die 16-Bit-Binaerzahl mit 10 ; Unterroutine benutzt von AscToBin2, Asc5ToBin2, Bcd5ToBin2 ; Aufruf: 16-Bit-Binaerzahl in rBin1H:L ; Rueckkehr: T-Flag zeigt gueltiges Ergebnis an. ; T=0: rBin1H:L enthaelt gueltiges Ergebnis. ; T=1: ueberlauf bei der Multiplikation, rBin1H:L undefiniert ; Benutzte Register: rBin1H:L (Ergebnis), rBin2H:L (wird wieder ; hergestellt) ; Bin1Mul10: push rBin2H ; Rette die Register rBin2H:L push rBin2L mov rBin2H,rBin1H ; Kopiere die Zahl dort hin mov rBin2L,rBin1L add rBin1L,rBin1L ; Multipliziere Zahl mit 2 adc rBin1H,rBin1H brcs Bin1Mul10b ; Ueberlauf, raus hier! Bin1Mul10a: add rBin1L,rbin1L ; Noch mal mit 2 malnehmen (=4*Zahl) adc rBin1H,rBin1H brcs Bin1Mul10b ; Ueberlauf, raus hier! add rBin1L,rBin2L ; Addiere die Kopie (=5*Zahl) adc rBin1H,rBin2H brcs Bin1Mul10b ;Ueberlauf, raus hier! add rBin1L,rBin1L ; Noch mal mit 2 malnehmen (=10*Zahl) adc rBin1H,rBin1H brcc Bin1Mul10c ; Kein Ueberlauf, ueberspringe Bin1Mul10b: set ; Ueberlauf, setze T-Flag Bin1Mul10c: pop rBin2L ; Stelle die geretteten Register wieder her pop rBin2H ret ; Kehre zurueck ; ; ************************************************ ; ; Paket II: Von Binaer nach ASCII bzw. BCD ; ; Bin2ToAsc5 ; ========== ; wandelt eine 16-Bit-Binaerzahl in eine fuenfstellige ASCII- ; kodierte Dezimalzahl um ; Aufruf: 16-Bit-Binaerzahl in rBin1H:L, Z zeigt auf Anfang ; der Zahl ; Rueckkehr: Z zeigt auf Anfang der Zahl, fuehrende Nullen sind ; mit Leerzeichen ueberschrieben ; Benutzte Register: rBin1H:L (bleibt erhalten), rBin2H:L ; (wird ueberschrieben), rmp ; Aufgerufene Unterroutinen: Bin2ToBcd5 ; Bin2ToAsc5: rcall Bin2ToBcd5 ; wandle Binaerzahl in BCD um ldi rmp,4 ; Zaehler auf 4 mov rBin2L,rmp Bin2ToAsc5a: ld rmp,z ; Lese eine BCD-Ziffer tst rmp ; pruefe ob Null brne Bin2ToAsc5b ; Nein, erste Ziffer <> 0 gefunden ldi rmp,' ' ; mit Leerzeichen ueberschreiben st z+,rmp ; und ablegen dec rBin2L ; Zaehler um eins senken brne Bin2ToAsc5a ; weitere fuehrende Leerzeichen ld rmp,z ; Lese das letzte Zeichen Bin2ToAsc5b: inc rBin2L ; Ein Zeichen mehr Bin2ToAsc5c: subi rmp,-'0' ; Addiere ASCII-0 st z+,rmp ; und speichere ab, erhoehe Zeiger ld rmp,z ; naechstes Zeichen lesen dec rBin2L ; noch Zeichen behandeln? brne Bin2ToAsc5c ; ja, weitermachen sbiw ZL,5 ; Zeiger an Anfang ret ; fertig ; ; Bin2ToAsc ; ========= ; wandelt eine 16-Bit-Binaerzahl in eine fuenfstellige ASCII- ; kodierte Dezimalzahl um, Zeiger zeigt auf die erste signi- ; fikante Ziffer der Zahl, und gibt Anzahl der Ziffern zu- ; rueck ; Aufruf: 16-Bit-Binaerzahl in rBin1H:L, Z zeigt auf Anfang ; der Zahl (5 Stellen erforderlich, auch bei kleineren Zah- ; len!) ; Rueckkehr: Z zeigt auf erste signifikante Ziffer der ASCII- ; kodierten Zahl, rBin2L enthaelt Laenge der Zahl (1..5) ; Benutzte Register: rBin1H:L (bleibt erhalten), rBin2H:L ; (wird ueberschrieben), rmp ; Aufgerufene Unterroutinen: Bin2ToBcd5, Bin2ToAsc5 ; Bin2ToAsc: rcall Bin2ToAsc5 ; Wandle Binaerzahl in ASCII ldi rmp,6 ; Zaehler auf 6 mov rBin2L,rmp Bin2ToAsca: dec rBin2L ; verringere Zaehler ld rmp,z+ ; Lese Zeichen und erhoehe Zeiger cpi rmp,' ' ; war Leerzeichen? breq Bin2ToAsca ; Nein, war nicht sbiw ZL,1 ; ein Zeichen rueckwaerts ret ; fertig ; ; Bin2ToBcd5 ; ========== ; wandelt 16-Bit-Binaerzahl in 5-stellige BCD-Zahl um ; Aufruf: 16-Bit-Binaerzahl in rBin1H:L, Z zeigt auf die ; erste Stelle der BCD-kodierten Resultats ; Stellen: Die BCD-Zahl hat exakt 5 gueltige Stellen. ; Rueckkehr: Z zeigt auf die hoechste BCD-Stelle ; Benoetigte Register: rBin1H:L (wird erhalten), rBin2H:L ; (wird nicht wieder hergestellt), rmp ; Aufgerufene Unterroutinen: Bin2ToDigit ; Bin2ToBcd5: push rBin1H ; Rette Inhalt der Register rBin1H:L push rBin1L ldi rmp,HIGH(10000) ; Lade 10.000 in rBin2H:L mov rBin2H,rmp ldi rmp,LOW(10000) mov rBin2L,rmp rcall Bin2ToDigit ; Ermittle 5.Stelle durch Abziehen ldi rmp,HIGH(1000) ; Lade 1.000 in rBin2H:L mov rBin2H,rmp ldi rmp,LOW(1000) mov rBin2L,rmp rcall Bin2ToDigit ; Ermittle 4.Stelle durch Abziehen ldi rmp,HIGH(100) ; Lade 100 in rBin2H:L mov rBin2H,rmp ldi rmp,LOW(100) mov rBin2L,rmp rcall Bin2ToDigit ; Ermittle 3.Stelle durch Abziehen ldi rmp,HIGH(10) ; Lade 10 in rBin2H:L mov rBin2H,rmp ldi rmp,LOW(10) mov rBin2L,rmp rcall Bin2ToDigit ; Ermittle 2.Stelle durch Abziehen st z,rBin1L ; Rest sind Einer sbiw ZL,4 ; Setze Zeiger Z auf 5.Stelle (erste Ziffer) pop rBin1L ; Stelle den Originalwert wieder her pop rBin1H ret ; und kehre zurueck ; ; Bin2ToDigit ; =========== ; ermittelt eine dezimale Ziffer durch fortgesetztes Abziehen ; einer binaer kodierten Dezimalstelle ; Unterroutine benutzt von: Bin2ToBcd5, Bin2ToAsc5, Bin2ToAsc ; Aufruf: Binaerzahl in rBin1H:L, binaer kodierte Dezimalzahl ; in rBin2H:L, Z zeigt auf bearbeitete BCD-Ziffer ; Rueckkehr: Ergebis in Z (bei Aufruf), Z um eine Stelle er- ; hoeht, keine Fehlerbehandlung ; Benutzte Register: rBin1H:L (enthaelt Rest der Binaerzahl), ; rBin2H (bleibt erhalten), rmp ; Aufgerufene Unterroutinen: - ; Bin2ToDigit: clr rmp ; Zaehler auf Null Bin2ToDigita: cp rBin1H,rBin2H ; Vergleiche MSBs miteinander brcs Bin2ToDigitc ; MSB Binaerzahl kleiner, fertig brne Bin2ToDigitb ; MSB Binaerzahl groesser, subtrahiere cp rBin1L,rBin2L ; MSB gleich, vergleiche LSBs brcs Bin2ToDigitc ; LSB Binaerzahl kleiner, fertig Bin2ToDigitb: sub rBin1L,rBin2L ; Subtrahiere LSB Dezimalzahl sbc rBin1H,rBin2H ; Subtrahiere Carry und MSB inc rmp ; Erhoehe den Zaehler rjmp Bin2ToDigita ; Weiter vergleichen/subtrahieren Bin2ToDigitc: st z+,rmp ; Speichere das Ergebnis und erhoehe Zeiger ret ; zurueck ; ; *********************************************** ; ; Paket III: Von Binaer nach Hex-ASCII ; ; Bin2ToHex4 ; ========== ; wandelt eine 16-Bit-Binaerzahl in Hex-ASCII ; Aufruf: Binaerzahl in rBin1H:L, Z zeigt auf erste Position ; des vierstelligen ASCII-Hex ; Rueckkehr: Z zeigt auf erste Position des vierstelligen ; ASCII-Hex, ASCII-Ziffern A..F in Grossbuchstaben ; Benutzte Register: rBin1H:L (bleibt erhalten), rmp ; Aufgerufene Unterroutinen: Bin1ToHex2, Bin1ToHex1 ; Bin2ToHex4: mov rmp,rBin1H ; MSB in rmp kopieren rcall Bin1ToHex2 ; in Hex-ASCII umwandeln mov rmp,rBin1L ; LSB in rmp kopieren rcall Bin1ToHex2 ; in Hex-ASCII umwandeln sbiw ZL,4 ; Zeiger auf Anfang Hex-ASCII ret ; fertig ; ; Bin1ToHex2 wandelt die 8-Bit-Binaerzahl in rmp in Hex-ASCII ; gehoert zu: Bin2ToHex4 ; Bin1ToHex2: push rmp ; Rette Byte auf dem Stapel swap rmp ; Vertausche die oberen und unteren 4 Bit rcall Bin1ToHex1 ; wandle untere 4 Bits in Hex-ASCII pop rmp ; Stelle das Byte wieder her Bin1ToHex1: andi rmp,$0F ; Maskiere die oberen vier Bits subi rmp,-'0' ; Addiere ASCII-0 cpi rmp,'9'+1 ; Ziffern A..F? brcs Bin1ToHex1a ; Nein subi rmp,-7 ; Addiere 7 fuer A..F Bin1ToHex1a: st z+,rmp ; abspeichern und Zeiger erhoehen ret ; fertig ; ; *********************************************** ; ; Paket IV: Von Hex-ASCII nach Binaer ; ; Hex4ToBin2 ; ========== ; wandelt eine vierstellige Hex-ASCII-Zahl in eine 16-Bit- ; Binaerzahl um ; Aufruf: Z zeigt auf die erste Stelle der Hex-ASCII-Zahl ; Rueckkehr: T-Flag zeigt Fehler an: ; T=0: rBin1H:L enthaelt die 16-Bit-Binaerzahl, Z zeigt ; auf die erste Hex-ASCII-Ziffer wie beim Aufruf ; T=1: ungueltige Hex-ASCII-Ziffer, Z zeigt auf ungueltige ; Ziffer ; Benutzte Register: rBin1H:L (enthaelt Ergebnis), R0 (wie- ; der hergestellt), rmp ; Aufgerufene Unterroutinen: Hex2ToBin1, Hex1ToBin1 ; Hex4ToBin2: clt ; Loesche Fehlerflag rcall Hex2ToBin1 ; Wandle zwei Hex-ASCII-Ziffern brts Hex4ToBin2a ; Fehler, beende hier mov rBin1H,rmp ; kopiere nach MSB Ergebnis rcall Hex2ToBin1 ; Wandle zwei Hex-ASCII-Ziffern brts Hex4ToBin2a ; Fehler, beende hier mov rBin1L,rmp ; kopiere nach LSB Ergebnis sbiw ZL,4 ; Ergebis ok, Zeiger auf Anfang Hex4ToBin2a: ret ; zurueck ; ; Hex2ToBin1 wandelt 2-stellig-Hex-ASCII nach 8-Bit-Binaer ; Hex2ToBin1: push R0 ; Rette Register R0 rcall Hex1ToBin1 ; Wandle naechstes Zeichen in Byte brts Hex2ToBin1a ; Fehler, stop hier swap rmp; untere vier Bits in obere vier Bits mov R0,rmp ; zwischenspeichern rcall Hex1ToBin1 ; Naechstes Zeichen umwandeln brts Hex2ToBin1a ; Fehler, raus hier or rmp,R0 ; untere und obere vier Bits zusammen Hex2ToBin1a: pop R0 ; Stelle R0 wieder her ret ; zurueck ; ; Hex1ToBin1 liest ein Zeichen und wandelt es in Binaer um ; Hex1ToBin1: ld rmp,z+ ; Lese Zeichen subi rmp,'0' ; Ziehe ASCII-0 ab brcs Hex1ToBin1b ; Fehler, kleiner als 0 cpi rmp,10 ; A..F ; Ziffer groesser als 9? brcs Hex1ToBin1c ; nein, fertig cpi rmp,$30 ; Kleinbuchstaben? brcs Hex1ToBin1a ; Nein subi rmp,$20 ; Klein- in Grossbuchstaben Hex1ToBin1a: subi rmp,7 ; Ziehe 7 ab, A..F ergibt $0A..$0F cpi rmp,10 ; Ziffer kleiner $0A? brcs Hex1ToBin1b ; Ja, Fehler cpi rmp,16 ; Ziffer groesser als $0F brcs Hex1ToBin1c ; Nein, Ziffer in Ordnung Hex1ToBin1b: ; Error sbiw ZL,1 ; Ein Zeichen zurueck set ; Setze Fehlerflagge Hex1ToBin1c: ret ; Zurueck