Ausgabe als hex-Wert

[Jens (Gast)]

Hi,

ich möchte eine Integer Variable als 4 stelligen Hex-Wert über die UART 
ausgeben. Wie programmiere ich das am Besten in c?

[Klaus W. (mfgkw)]

    char puffer[5];
    snprintf( puffer, 4, "%04X", meinWert );
    // dann puffer ausgeben...

oder itoa() bzw. utoa() verwenden, und die Stellenanzahl von Hand 
hinbiegen.

[Klaus W. (mfgkw)]

Zumindest ist das der übliche Weg.

Man könnte auch die UART zur Standardausgabe machen, dann kann man ohne 
Umweg über einen Puffer direkt z.B. mit printf() schreiben.

[Jens (Gast)]

Danke!
Wie könnte ich es mit itoa() machen? Wäre das schneller, oder besser?

[Klaus W. (mfgkw)]

Die printf-Funktionen brauchen viel Code und sind relativ langsam.

Jens schrieb:
> Wie könnte ich es mit itoa() machen? Wäre das schneller, oder besser?

Doku lesen: http://www.nongnu.org/avr-libc/user-manual/index.html

itoa() liefert soviele Stellen, wie nötig.
Ggf. musst du halt auf deine 4 Stellen auffüllen.

Dafür ist itoa() sehr sparsam im Vergleich zu snprintf().
Wenn du in deinem Programm aber eh die printf-Dinger brauchst, kannst du 
sie hier auch gleich verwenden. Von der zweiten Verwendung an blähen sie 
das Programm ja nicht mehr weiter auf

[Klaus W. (mfgkw)]

Wahrscheinlich brauchst du aber eher utoa(), weil ich bei "hex" erstmal 
von unsigned ausgehe. itoa() ist für signed.

[Rufus Τ. F. (rufus)]

Klaus Wachtler schrieb:
> itoa() liefert soviele Stellen, wie nötig.

Andersrum formuliert: Keine führenden Nullen.

[Jens (Gast)]

Hallo,
könnte wer von euch mal drüberschauen, ob der Code so in Ordnung ist?
DANKE!

Gegeben Integervariable value;

unsigned int valueL, valueH;
unsigned char nibble1;
unsigned char nibble2;
unsigned char nibble3;
unsigned char nibble4;
unsigned char hextable[] = { '0','1','2'.
                             '3','4','5'.
                             '6','7','8',
                             '9','A','B',
                             'D'.'E','F', };

valueL = value;
valueH = value >> 8;


nibble1 = hextable[ ( valueH & 0xF0 ) >> 4) ];
nibble2 = hextable[ ( valueH & 0x0F) ];
nibble3 = hextable[ ( valueL & 0xF0 ) >> 4) ];
nibble4 = hextable[ ( valueL & 0x0F) ];

putchar(nibble1); putchar(nibble2);putchar(nibble3); putchar(nibble4);

[DirkB (Gast)]

Da nibbleX und hextable[] Zeichen enthalten, sollten sie vom Typ char 
(nur char, kein signed/unsigned) sein.
Und es ist besser erst zu verschieben und dann zu maskieren.

[Klaus W. (mfgkw)]

Wenn man um 4 nach rechts schiebt, braucht man vorher nicht zu 
maskieren.

Kompilierbar ist es eh nicht, alleine wegen der Punkte in der Tabelle.

[Holger W. (holgerw)]

irgendwo hatte ich sowas gefunden:

unsigned char nibble;
unsigned char hex0,hex1;
  
    nibble = (data & 0xf0) >> 4;
    hex0 = (nibble < 10) ? ('0' + nibble) : ('a' + nibble - 10);
 
    nibble = (data & 0x0f);
    hex1 = (nibble < 10) ? ('0' + nibble) : ('a' + nibble - 10);

Holger

edit: auch hier könnte das erste maskieren entfallen

[Stefan (Gast)]

Jens schrieb:
> unsigned char hextable[] = { '0','1','2'.
>                              '3','4','5'.
>                              '6','7','8',
>                              '9','A','B',
>                              'D'.'E','F', };

Wo ist 'C' ???

Gruss Stefan

[DirkB (Gast)]

Das ist alles C.

Wenn es vom C-Compiler ohne Fehler übersetzt wird, ist es C. :-)