Binär in Hex umwandeln

[Sven (Gast)]

Hallo zusammen,

ich versuche mich gerade daran eine Binärzahl (z.B 0110 0101) in das 
Hex-Format (0x65) zu bringen, um dies dann auf einem LC-Display 
auszugeben.

Das Ganze soll auf einem HC12 passieren.

Ich muss aber zugeben, dass ich bei der Umwandlung noch nicht ganz 
durchsteige.

Grundsätzlich würde ich sagen, dass man die Binär-Zahl in eine 
Dezimalzahl umwandelt und die Dezmalzahl dann in Hex oder gibt es da 
einen direkten Weg.

Auf dem Papier ist das klar, aber irgendwie bekomme ich das nicht in 
einen Code verpackt.

Hat jemand schon mal etwas ähnliches gemacht und kann mir da auf die 
Sprünge helfen?

Vielen Dank

Gruß
Sven

[Peter II (Gast)]

Sven schrieb:
> Grundsätzlich würde ich sagen, dass man die Binär-Zahl in eine
> Dezimalzahl umwandelt und die Dezmalzahl dann in Hex oder gibt es da
> einen direkten Weg.
ja gibt es.

jede "Ziffer" der Hex-Zahl sind 4bits.

0110 0101

0000 ->  0
0001 ->  1
....
0110 ->  6
0101 ->  5
...
1111  -> F

[Willi W. (Gast)]

Sven schrieb:
> Grundsätzlich würde ich sagen, dass man die Binär-Zahl in eine
> Dezimalzahl umwandelt und die Dezmalzahl dann in Hex oder gibt es da
> einen direkten Weg.

Binär nach Hex ist der direkte Weg. Du kannst direkt vier Stellen einer 
Binärzahl zu einer Stelle einer Hexzahl zusammenfassen, da 2^4=16^1 ist. 
Was soll dir der Umweg über das Dezimalsystem bringen?

[Klaus W. (mfgkw)]

Hast du deine Binärzahl
- als String von 0- und 1-Zeichen, oder
- als Variable, die intern halt binär abgelegt ist, oder
- ?

Generell kann man binär nach hex wandeln, indem man je 4 Binärstellen zu 
eine Hex-Stelle zusammenfasst:

binär  -> hex
0000   -> 0
0001   -> 1
0010   -> 2
0011   -> 3
0100   -> 4
0101   -> 5
0110   -> 6
0111   -> 7
1000   -> 8
1001   -> 9
1010   -> A
1011   -> B
1100   -> C
1101   -> D
1110   -> E
1111   -> F

Eine Zwischenrechnung ins Dezimalsystem ist Unsinn und kostet nur 
Aufwand.

Sven schrieb:
> Auf dem Papier ist das klar, ...

Das wäre ja schon mal ein guter Anfang :-)

[Sven (Gast)]

Hallo,

ich habe z.B. folgendes:

unsigned char data1[12];

length= CAN0RXFG[12];              // Read Data Length Register
for (i = 0; i < 8; i++)
{
  if (length & 0x80 >> i)
    data1[i] = '1';
  else
    data1[i] = '0';
}

data1 gebe ich dann auf dem LCD aus. Da steht dann z.B. 00001000.

So, nun würde ich nun gerne haben, dass ich 08 auf dem Display ausgeben 
kann, denn es sollen auch noch die gesendeten Daten ausgegeben werden. 
Damit das aufs Display passt, ist eben Hex besser als binär.

Klaus Wachtler schrieb:
> binär  -> hex
> 0000   -> 0
> 0001   -> 1
> 0010   -> 2
> 0011   -> 3
> 0100   -> 4
> 0101   -> 5
> 0110   -> 6
> 0111   -> 7
> 1000   -> 8
> 1001   -> 9
> 1010   -> A
> 1011   -> B
> 1100   -> C
> 1101   -> D
> 1110   -> E
> 1111   -> F

Das war mir klar, nun nur der Schritt von der Auflistung zum Code. Da 
weiß ich gar nicht, wie ich ansetzen soll.

Grüße Sven

[Guest (Gast)]

Array zyklisch durchlaufen und dann je nach Stelle 1,2,4,8,16,32,64 usw. 
zur Zahl addieren. Diese Dezimalzahl dann mit printf als Hex ausgeben.

[Matthias L. (Gast)]

Zum Nachdenken:

unsigned char data1[12];

value;  // umzuwandelnder Wert

uint8_t hilf;   // Hilfsvariable

hilf = ( value>>4 );
datal[0] = hilf + 0x30;
if ( hilf > 9 ) datal[0] += ( 'A' - '9' - 1 );

hilf = ( value & 15);
datal[1] = hilf + 0x30;
if ( hilf > 9 ) datal[1] += ( 'A' - '9' - 1 );

datal[2] = 0;

[Michel (Gast)]

Guest schrieb:
> Array zyklisch durchlaufen und dann je nach Stelle 1,2,4,8,16,32,64 usw.
> zur Zahl addieren. Diese Dezimalzahl dann mit printf als Hex ausgeben.

Klasse Tip. Es gibt Leute, die brauchen 51 Leuten, um eine Glühbirne zu 
wechseln: Einer hält das Leuchtmittel und 50 drehen das Haus.
Hast du dir mal angesehen, wieviel Code der Compiler dafür 
erzeugt/einbindet?

Wie wäre es mit:

static const uint8 cBin2Hex [16] =
{'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
...
datal[0] = cBin2Hex[value>>4];
datal[1] = cBin2Hex[value & 0x0F];

[Peter R. (pnu)]

Der Grund für die Anwendung der hex-Zahlen ist doch gerade, dass man 
große Binärzahlen in Vierergruppen aufteilt.

Die Angabe <11110101> spricht sich doch wesentlich schwerer als <f5>. 
Auch das Aufschreiben von zwei Ziffern anstatt 8 Ziffern geht schneller.

Die Umwandlung ist doch ganz einfach: Vierergruppen von rechts ausgehend 
nacheinander isolieren (Durch Maske 0f oder f0 und swap-befehl bei 
8-bit-bytes)

und anschließend die vier-bit-Gruppen entsprechend Tabelle umsetzen.

1111101010110011 wird zu : 1111 1010 1011 0011 und dann zu f a b 3

[Klaus W. (mfgkw)]

Michel schrieb:
> ...
> Wie wäre es mit:
>

> static const uint8 cBin2Hex [16] =
> {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
> ...
> datal[0] = cBin2Hex[value>>4];
> datal[1] = cBin2Hex[value & 0x0F];
>

Gute Sache so; nur als Nachtrag: wenn man datal dann als String 
behandeln will, muß man mit datal[2] = '\0';  noch terminieren.

[Michel (Gast)]

Klaus Wachtler schrieb:
> Gute Sache so; nur als Nachtrag: wenn man datal dann als String
> behandeln will, muß man mit datal[2] = '\0';  noch terminieren.

Die Behandlung als String bringt aber erstmal keinen wesentlichen 
Vorteil. Man kann genausogut datal[0] und datal[1] direkt zum LCD 
schicken, was die Stringausgabe letzlich auch macht.