Hex -> Dez Umwandlung 8051

Da fehlt noch die Information über die Programmiersprache...

Tja, wuerde eine erstige Umwandlung von Hex in the Binaere Ganzzahl Sinn 
machen ? Dann koennte man in einem zweiten Schritt diese in eine 
Dezimalzahl wandeln. Nein ?

z.

@Zotti:
Eine Umwandlung von Hex nach Binär? Was soll das denn sein?

@zotti:
Falls Dir das nicht klar ist: Hex ist nur eine andere Darstellung von 
Binär. Da ist nix umzuwandeln.

entschuldigung, es sollte die Programmiersprache Assambler verwendet 
werden, in C wäre mir der Algorithmus klar.

Nun, da 8 Bit zur Darstellung einer 8-stelligen Hex-Zahl nicht 
ausreichen, muss man mehrere Bytes zusammenfassen. In diesem Fall wären 
das 4 Bytes (eine 2-stellige Hex-Zahl repräsentiert ein Byte).
Im Prinzip muss also die Tastatur-Eingabe erst einmal in diese 4 Bytes 
hinein, das sollte noch nicht das Problem sein.
Nun müssen die Rechenoperationen zur Umwandlung in einr Dezimalzahl von 
8 Bit auf 32Bit erweitert werden, hierzu gibt es bei den 
Rechenoperationen das sog. Carry-Bit. Man wird also nicht drumherum 
kommen, einen Algorithmus zu entwerfen, der eine 32Bit-Zahl durch 10 
teilen kann. Wenn man sich mal ganz genau anschaut, wie man eine 
Dezimalzahl von Hand schriftlich dividiert, müsste man drauf kommen...

Aus dem µController Applikations-Kochbuch

@johnny.m
Von Hex nach Binaer keine Umwandlung ? Also Hex ist ein ASCII string und 
Binaer mit 8 Hexstellen ist ein Longword. Da gibt schon was zu tun. 
Nicht allzuviel zwar. Aber man  muss es mal gemacht haben.

Z.

@zotti:
Hex (oder vollständig "Hexadezimal") ist eine andere Darstellung einer 
Binärzahl, bei der immer 4 Bits zu einem Zahlzeichen zusammengefasst 
werden, und nichts anderes! Oben steht eindeutig "Hexadezimalzahl", und 
das hat nichts mit ASCII zu tun, sonst hätte der OP es geschrieben!

Hallo Herr Kahl,

ich habe ein 8051-Programm geschrieben, das eine 32-Bit-Zahl vom 
Binärsystem in eine entsprechende Dezimalzahl umwandelt, die dann auf 
einem LCD-Display (Modul) ausgegeben wird. Das folgende ist das 
Unterprogramm in Assembler (für einen 8051 - Standardcontroller). Es 
läuft sogar auf Mikrocontrollern der Vorläuferfamilie(MCS48), die nur 
addieren können.
Nachteil - es dauert eine Weile.

Funktionsweise: Nachdem die 32-Bit-Zahl (4*8Bit) in ihr Einerkomplement 
umgewandelt wurde(damit mit Addition gearbeitet werden kann), wird 
ermittelt, wie oft eine Milliarde bis zum Überlauf (Carry-Bit) auf diese 
(Binärzahl) aufaddiert werden kann. Das ist dann die Anzahl der 
Milliarden.

Dasselbe anschließend mit Hundertmillionen, Zehnmillionen, 
Millionen...bis zu den Einern. An das Zehnersystem angepasst!

Die Zehner-Ziffern werden ASCII-codiert(odern mit 30h oder 30h addieren) 
und gespeichert. Am Ende ist die 32Bit-Zahl konvertiert in eine 
10-stellige Dezimalzahl.

;30h-33h reserviert fr die 32bit-Variable (umzuwandelnde Binärzahl)
;34h-37h reserviert fr den Zwischenspeicher
;38h-3bh reserviert fr die Summanden - Milliarde ... Eins
;3ch-45h reserviert fr die Dezimalstellen
;alles im Big-Endian-Format(High-Byte zuerst)


_bintodec       mov R3,#3ch         ;Dezimalstellen-Ablage
                mov R0,#33h         ;Einerkomplement bilden
                mov A,@R0
                cpl A
                mov @R0,A
                dec R0
                mov A,@R0
                cpl A
                mov @R0,A
                dec R0
                mov A,@R0
                cpl A
                mov @R0,A
                dec R0
                mov A,@R0
                cpl A
                mov @R0,A
                mov R0,#3bh         ;Milliarde
                mov @R0,#00h
                dec R0
                mov @R0,#0cah
                dec R0
                mov @R0,#9ah
                dec R0
                mov @R0,#3bh
                acall _add32         ;Addition/Anzahl Milliarden 
ermitteln
                mov R0,#3bh         ;Hundert-Millionen
                mov @R0,#00h
                dec R0
                mov @R0,#0e1h
                dec R0
                mov @R0,#0f5h
                dec R0
                mov @R0,#05h
                acall _add32         ;Addition/Anzahl Hundert-Millionen
                mov R0,#3bh         ;Zehn-Millionen
                mov @R0,#80h
                dec R0
                mov @R0,#96h
                dec R0
                mov @R0,#98h
                dec R0
                mov @R0,#00h
                acall _add32         ;Addition/Anzahl Zehn-Millionen
                mov R0,#3bh         ;Millionen
                mov @R0,#40h
                dec R0
                mov @R0,#42h
                dec R0
                mov @R0,#0fh
                dec R0
                mov @R0,#00h
                acall _add32         ;Addition/Anzahl Millionen
                mov R0,#3bh         ;Hundert-Tausend
                mov @R0,#0a0h
                dec R0
                mov @R0,#86h
                dec R0
                mov @R0,#01h
                dec R0
                mov @R0,#00h
                acall _add32         ;Addition/Anzahl Hundert-Tausender
                mov R0,#3bh         ;Zehn-Tausend
                mov @R0,#10h
                dec R0
                mov @R0,#27h
                dec R0
                mov @R0,#00h
                dec R0
                mov @R0,#00h
                acall _add32         ;Addition/Anzahl Zehn-Tausender
                mov R0,#3bh         ;Tausend
                mov @R0,#0e8h
                dec R0
                mov @R0,#03h
                dec R0
                mov @R0,#00h
                dec R0
                mov @R0,#00h
                acall _add32         ;Addition/Anzahl Tausender
                mov R0,#3bh         ;Hundert
                mov @R0,#64h
                dec R0
                mov @R0,#00h
                dec R0
                mov @R0,#00h
                dec R0
                mov @R0,#00h
                acall _add32         ;Addition/Anzahl Hunderter
                mov R0,#3bh         ;Zehn
                mov @R0,#0ah
                dec R0
                mov @R0,#00h
                dec R0
                mov @R0,#00h
                dec R0
                mov @R0,#00h
                acall _add32         ;Addition/Anzahl Zehner
                mov R0,#3bh         ;Einer
                mov @R0,#01h
                dec R0
                mov @R0,#00h
                dec R0
                mov @R0,#00h
                dec R0
                mov @R0,#00h
                acall _add32         ;Addition/Anzahl Einer
                ret
_add32          mov R2,#-1          ;Dezimal-Ziffer
L010            acall _save          ;alten Wert retten
                mov R0,#33h
                mov R1,#3bh
                inc R2
                mov A,@R0
                add A,@R1
                mov @R0,A
                dec R0
                dec R1
                mov A,@R0
                addc A,@R1
                mov @R0,A
                dec R0
                dec R1
                mov A,@R0
                addc A,@R1
                mov @R0,A
                dec R0
                dec R1
                mov A,@R0
                addc A,@R1
                mov @R0,A
                jnc L010
                acall _restore        ;alten Wert restaurieren
                mov A,R3             ;Dezimalstellen-Ablage
                mov R0,A
                mov A,R2             ;Dezimal-Ziffer
                add A,#30h           ;ASCII-formatieren
                mov @R0,A            ;ablegen
                inc R3
                ret
_save           mov R0,#33h
                mov R1,#37h
                mov A,@R0
                mov @R1,A
                dec R0
                dec R1
                mov A,@R0
                mov @R1,A
                dec R0
                dec R1
                mov A,@R0
                mov @R1,A
                dec R0
                dec R1
                mov A,@R0
                mov @R1,A
                ret
_restore        mov R0,#33h
                mov R1,#37h
                mov A,@R1
                mov @R0,A
                dec R0
                dec R1
                mov A,@R1
                mov @R0,A
                dec R0
                dec R1
                mov A,@R1
                mov @R0,A
                dec R0
                dec R1
                mov A,@R1
                mov @R0,A
                ret


Viel Spaß - Thomas Strauß