8 Bit Umwandeln in Hexzahlen und ausgeben

[Stef (Gast)]

Hallo,
ich versuche im Moment, 8 Bit, die ich erhalte, mithilfe von 
Bitmanipulation und einer If-Schleife in lesbar Hexzahlen umzuwandeln.

             temp_bwf = bwf; /* bwf sind die Daten, die ich erhalte */
             temp_bwf &= 0xF0; /* glaube nicht, dass das stímmt */
             TXBUF0 = temp_bwf; ???

             temp_bwf = bwf; /* hier arbeite ich mit den letzten Nippel 
*/
             temp_bwf = temp_bwf >>4;
             temp_bwf &= 0x0F;
             TXBUF0 = temp_bwf;


Mit den Bitmanipulationen kenne ich mich nicht so aus.
Und das schlimmste ist, ích muss diesen Wirrwarr an Bits noch in 1-9 und 
A-F für Hex umwandlen.
Mein größtes Problem jedoch ist der Nippelwirrwarr, ich habe dort keinen 
richtigen Durchblick.

Nja, mal sehen, ob wer mir weiterhelfen kann.

Danke

[Läubi .. (laeubi)]

Stef wrote:
> Mein größtes Problem jedoch ist der Nippelwirrwarr, ich habe dort keinen
> richtigen Durchblick.
>
Ja das kann bei der Arbeit Mörderisch sein! o.O
ein halbes byte heißt Nibble!

Ich (vermute) das du eine Zahl in (lesbares) ASCII HEX umwandeln willst.
Dein vorgehen ist da schon richtig, nur das du noch einen Offset 
draufaddieren mußt damits auch eine Buchstabe wird (schau dir mal die 
ASCII Tabelle an) Ansosnten bietet C auch funktionen wie sprintf die dir 
das abnehmen...

[F. K. (freddy436)]

in zwei Nibbles zerlegen, dann sollte sowas gehen:

if(nibble < 10)
 hex_char = 0x30 + nibble // 0x30 = ASCII 0
else
 hex_char = 0x41 - 10 + nibble // 0x41 = ASCII A

[Stef (Gast)]

Das mit dem draufaddieren ist mir klar, denn sonst bekomme ich nur 
Smilys oder komische Zeichen, aber es funktioniert trotzdem noch nicht.

Kann jemand vielleicht ein konkretes Beispiel bringen, wie es richtig 
aussehen müsste???

Danke

[Stef (Gast)]

Achso, dank, war ich wieder einmal zu langsam


Wie komme ich aber an das höhrere Paar Nippel dran??
Da habe ich noch keine konkrete Idee.
Bis jetzt

temp_bwf = bwf;
             temp_bwf = temp_bwf >>4;
             temp_bwf &= 0x0F;

habe ich hier doch bloß das niedere Paar bearbeitet, oder nicht??

[F. K. (freddy436)]

hier mal ein sehr einfaches beispiel:

#include <iostream.h>

int main()
{
    unsigned char nibble, byte, hex_char;
    byte = 0x3A;
    
    // high nibble
    nibble = (byte >> 4); // shift
    nibble &= 0x0F; // mask
    if(nibble < 10)
    {
        hex_char = 0x30 + nibble;
    }
    else
    {
        hex_char = 0x41 - 10 + nibble;
    }
    cout << hex_char;
    
    // low nibble  
    nibble = (byte >> 0); // no shift 
    nibble &= 0x0F; // mask
    if(nibble < 10)
    {
        hex_char = 0x30 + nibble;
    }
    else
    {
        hex_char = 0x41 - 10 + nibble;
    }
    cout << hex_char;
}

Das ganze solltest du so aber nicht verwenden, besser in eine Schleife 
umbauen. Es ändert sich ja nur die die shift Zahl.

[Stef (Gast)]

Danke, jetzt ist es auch gut zu verstehen.
Super, nochmals danke.
Nur eine Frage: was macht bei dir
[c] cout << hex_char; [c/]

Was ist bei dir cout und was machst du zum Schluß der Funktion?

[F. K. (freddy436)]

cout ist ne alte standard Ausgabe Funktion (console).

Beim µC Quellcode die zwei Zeilen durch entsprechende Ausgabe Funktionen 
(uart, lcd, etc.) oder was auch immer ersetzen.
#include <iostream.h> brauchst du auch nicht beim µC

[Jörg X. (Gast)]

btw.: "cout", "<<" oder ">>" mit was anderem als ints ist C++, kein C ;)

hth. Jörg

[Christian (Gast)]

Hallo Stef,


ähm, was willst du genau ?

nZahl = 10;

sprintf(szBuff, "0x%X\0", nZahl);

szBuff = 0xA



Im Beispiel oben hast du das höherwertige nible bearbeitet...

11111111 & 0xF0 = 11110000
11111111 & 0x0F = 00001111
10000000 >> 4   = 00010000
00010000 << 4   = 10000000

Hoffe das hilft ...

[Jörg X. (Gast)]

> 10000000 >> 4   = 00010000
> 00010000 << 4   = 10000000
eher:
0b10000000 >> 4 = 0b00001000
0b00001000 << 4 = 0b10000000

;) Jörg

[Uhu U. (uhu)]

Es ist natürlich gut, wenn man solche Wandlungen mal selbst gemacht hat 
- dann weiß man, wies geht.

Wenn man es gelernt hat, kann man auch die Standard-Funktion itoa dafür 
verwenden...

[F. K. (freddy436)]

Uhu Uhuhu wrote:
> Wenn man es gelernt hat, kann man auch die Standard-Funktion itoa dafür
> verwenden...

Gerade bei µCs machen eigene Lösungen meistens mehr Sinn. Die machen 
dann nur das was man auch genau braucht dabei sind sie meistens 
kleiner/schneller als Standardfunktionen.