Hex in String umwandeln

[Sebastian (Gast)]

Hallo zusammen,

ich habe folgendes Problem und stehe im Moment ein wenig auf der 
Leitung...

Ich habe 8 Byte Daten. In Hex würden die nur mal als Beispiel wie folgt 
aussehen.

88 77 66 55 44 33 22 11

Nun wollte ich diese Daten so vom µC per RS232 an den PC senden und in 
einem Terminal Programm ausgeben, so wie es oben steht. Wenn ich die 
Daten einfach so sende, wird nur Mist angezeigt, klar, weil die Werte 
falsch interpretiert werden, bzw nicht so, wie ich das möchte. Ich 
müsste die Daten ja in einen String umwandeln, um es dann zu senden. Das 
ganze müsste dann in Hex doch so aussehen 38 38 für angezeigte 88 im 
Terminalprogramm. Richtig?

Allerdings komm ich nicht drauf, wie ich das ganze entsprechend 
umwandle. Wäre klasse, wenn mir da jemand auf die Sprünge helfen könnte.

Vielen Dank.

Grüße
Sebastian

[Justus S. (jussa)]

in C:
char s[17];
zahl = 0x88 77 66 55 44 33 22 11;
uart_puts(utoa(zahl,s,16));

[Sebastian (Gast)]

Hallo,

vielen Dank erst einmal, aber irgendwie gibt mein Kompiler keine 
Funktion utoa oder ähnliches her, nur in umgekehrter Richtung. Ich 
verwende einen Kompiler von Cosmic für einen HC12 von Freescale.

Hat jemand vielleicht eine andere Lösung oder schon einmal eine eigene 
Funktion geschrieben oder so?

Vielen Dank!

Grüße
Sebastian

[Peter D. (pdiener)]

Einige Varianten von printf können das auch.

unsigned char a=0x20, b=0x25, c=0x31;

printf("Hier kommen die Zahlen: %x %x %x", a, b, c);

Grüße,

Peter

[Eddy C. (chrisi)]

Ich schätze, utoa reicht eh nicht, weil

a) Kleinbuchstaben gewandelt werden (mag akzeptabel sein)
b) Vornullen unterdrückt werden

Leider werden solche Details aus dem Beispiel nicht deutlich.

Mache folgendes:

Schreib eine Routine, die einen Nibble (=ein Hex-Zeichen) sendet:

void SendNibble(unsigned char Nibble)
{
   // Preserve range
   Nibble &= 0x0F;
   uart_putchar(Nibble <= 9 ? '0'+Nibble : 'A'+Nibble-10);
}

Und eine Routine zum Byte senden:

void SendByte(unsigned char Byte)
{
   // Send upper nibble
   SendNibble(Byte >> 4);
   // Send lower nibble
   SendNibble(Byte);
}

Feddisch. Da mögen jetzt noch Compilerfehler drin sein ;-)

[STK500-Besitzer (Gast)]

Kann man itoa nicht auch mit Basis 16 betreiben?

[!nullchecker (Gast)]

printf ist wohl die einfachste Lösung...

Dein Problem ist wohl schon in den 70'igern gelöst worden und in der 
ANSI C-Library berücksichtig worden.


http://www.cplusplus.com/reference/clibrary/cstdio/printf.html

[Sebastian (Gast)]

Hallo,

ich habe das genze nun mit printf gelöst. Allerdings habe ich noch ein 
Problem dabei. Ich habe z.B. die Hex-Werte 11 22 33 44 55 66 77 88, 
geseichert in

CAN0TXFG[4]....CAN0TXFG[11]

for(ii = 0; ii < 8; ii++)
    {    
        zahl = CAN0TXFG[ii+4];
        Send(printf("%x", CAN0TXFG[ii+4]));
    }

Allerdings stimmt die Ausgabe dabei nicht. Es kommt raus:
0  22 33 44 55 66 77 88

Egal was ich mache und ausgeben lasse, der erste Wert ist immer die 
0...sollte in diesem Fall eigentlich eine 11 sein. Egal was ich mache, 
es wird als erstes immer eine 0 ausgegeben beim ersten 
Schleifendurchlauf. Hat jemand eine Idee, woran das liegen könnte oder 
was ich falsch mache?

Vielen Dank!

Grüße
Sebastian

[Ak T. (aktronik)]

@Sebastian

für Strings:

char cHexValue = 0xf3;
CString s;

s.Format("%02X, cHexValue);

für Arrays:

char cArray[128];
char cHex[8];

sprintf(cArray, "%02X %02X %02X %02X %02X %02X %02X %02X",
  cHex[0],cHex[1],cHex[2],cHex[3],cHex[4],cHex[5],cHex[6],cHex[7]);

MfG
Ak Tronik

[Sebastian (Gast)]

Hallo,

ja, das habe ich soweit, ich habe nur das Problem, dass wenn ich nun 
mein Array wie oben angegeben in einer Schleife ausgebe, ist der erste 
Wert immer 00 egal ob da 0x11, 0x22, 0x99 drin steht. Beim ersten 
Schleifendurchlauf wird immer 00 ausgegeben. Ich habe nun einmal die 
Schleife durch 8 Zeilen  der Art PutStSCI0(printf("%02X", CAN0TXFG[4])); 
ersetzt  CAN0TXFG[4]...CAN0TXFG[11]. der erste Wert ist immer 00. Wenn 
ich dann die Reihenfolge der Ausgabe ändere, ist immer der erste Wert 
der ausgegeben wird 00.
CAN0TXFG[4]...CAN0TXFG[11] -> 0x11 0x22 0x33 0x44 0x55 0x66 0x77 0x88
Ausgabe 00 22 33 44 55 66 77 88

CAN0TXFG[5]...CAN0TXFG[11]CAN0TXFG[4]
0x22 0x33 0x44 0x55 0x66 0x77 0x88 0x11

Ausgabe 00 33 44 55 66 77 88 11

Jemand eine Idee, was das sein könnte?

Vielen Dank!
Grüße
Sebastian

[Ak T. (aktronik)]

@Sebastian

und wenn Du sprintf oder CString verwendest.

Oder poste mal den kompletten Codeschnippsel.

MfG
Ak Tronik

[Uwe B. (boerge)]

Wie wäre es hiermit, ohne printf etc. und für ein Byte:

uint8_t n2hex(uint8_t val)
{
  if (val > 9){
    return val + 'A' - 10;
  }
  else{
  return val + '0';
  }
}

void byte2hex(uint8_t val,char *str)
{
  *str++ = n2hex(val >> 4);
  *str = n2hex(val & 0x0f);
}

...

byte2hex(byte_wert, s);

[Sebastian (Gast)]

Hallo,

mit sprintf erhalte ich gar keine Ausgabe.

Hier mal der Codeschnipsel...

    PutStSCI0(printf("%02X", CAN0TXFG[5]));  // 0x22
    PutStSCI0(printf("%02X", CAN0TXFG[6]));  // 0x33
    PutStSCI0(printf("%02X", CAN0TXFG[7]));  // 0x44
    PutStSCI0(printf("%02X", CAN0TXFG[4]));  // 0x11
    PutStSCI0(printf("%02X", CAN0TXFG[8]));  // 0x55
    PutStSCI0(printf("%02X", CAN0TXFG[9]));  // 0x66
    PutStSCI0(printf("%02X", CAN0TXFG[10])); // 0x77
    PutStSCI0(printf("%02X", CAN0TXFG[11])); // 0x88
    /*for(ii = 0; ii < NumBytes; ii++)
    {    
        zahl = CAN0TXFG[ii+4];
        PutStSCI0(printf("%02X", CAN0TXFG[ii+4]));
    }*/

Die Ausgabe ist aber: 00 33 44 11 55 66 77 88 Egal in welcher 
Reihenfolge das ganze ausgegeben wird, die erste Ausgabe ist immer 00!!!

>Wie wäre es hiermit, ohne printf etc. und für ein Byte:
>
>uint8_t n2hex(uint8_t val)
>{
>  if (val > 9){
>    return val + 'A' - 10;
>  }
>  else{
>  return val + '0';
>  }
>}
>
>void byte2hex(uint8_t val,char *str)
>{
>  *str++ = n2hex(val >> 4);
>  *str = n2hex(val & 0x0f);
>}
>
>...
>
>byte2hex(byte_wert, s);

..-> noch nicht getestet...

Vielen Dank!

Grüße
Sebastian

[Tommy (Gast)]

Hallo Sebastian,

Könnte es sein, dass Du nach dem Einschalten der
Betriebsspannung gleich anfängst über RS232 zu
senden? Denk dran, dass der MAY232 eine Zeit braucht,
bis die Ladungspumpen die Spannungen aufgebaut haben.
Mach doch mal einen richtig langen delay bevor Du
anfängst zu senden. Ruhig 1,2,3... Sekunden.

[Tommy (Gast)]

Uups, das sollte natürlich MAX232 heissen...

[Sebastian (Gast)]

Hallo,

> Könnte es sein, dass Du nach dem Einschalten der
> Betriebsspannung gleich anfängst über RS232 zu
> senden?

Ich sende schon voher Text. Der wird einwandfrei übertragen.

Ich habe mal folgendes probiert:

    zahl= 170;   // 0xAA
    PutStSCI0(printf("%02X", zahl));
    PutStSCI0(printf("%02X", CAN0TXFG[4]));  // 0x11
    PutStSCI0(printf("%02X", CAN0TXFG[5]));  // 0x22
    PutStSCI0(printf("%02X", CAN0TXFG[6]));  // 0x33
    PutStSCI0(printf("%02X", CAN0TXFG[7]));  // 0x44
    PutStSCI0(printf("%02X", CAN0TXFG[8]));  // 0x55
    PutStSCI0(printf("%02X", CAN0TXFG[9]));  // 0x66
    PutStSCI0(printf("%02X", CAN0TXFG[10])); // 0x77
    PutStSCI0(printf("%02X", CAN0TXFG[11])); // 0x88

Dabei sieht die Ausganbe dann wie folgt aus:
AA 11 22 33 44 55 66 77 88, also so, wie es sein soll. Nehme ich 
PutStSCI0(printf("%02X", zahl)); wieder raus gehts wieder so los 00 22 
33 44....

Grüße
Sebastian

[Sebastian (Gast)]

Hallo,

mit

zahl= 170;
PutStSCI0(printf("%02X", zahl));
for(ii = 0; ii < NumBytes; ii++)
    {    
        PutStSCI0(printf("%02X", CAN0TXFG[ii+4]));
    }

geht es auch. Lässt man PutStSCI0(printf("%02X", zahl)); weg, fängt auch 
hier das ganze wieder mit 00 22 33 44...... an

Grüße
Sebastian

[Karl H. (kbuchegg)]

Sebastian wrote:

> Dabei sieht die Ausganbe dann wie folgt aus:
> AA 11 22 33 44 55 66 77 88, also so, wie es sein soll. Nehme ich
> PutStSCI0(printf("%02X", zahl)); wieder raus gehts wieder so los 00 22
> 33 44....

Zeig mal mehr Code (am besten ein vollständiges kleines(!) Programm, 
welches den Fehler zeigt). Aus dem Snippet kann man nicht wirklich was 
entnehmen.

[Sebastian (Gast)]

Hallo,

das Programm ist zu umfangreich, um es hier alles anzugeben. Die 
Funktion, in der das ganze ablaufen soll, ist folgende:

void SendCANMessage(unsigned char NumBytes, unsigned char *TXBuf)
{
    unsigned char NACAN, ii;
    unsigned char data[9];
    unsigned int zahl;
    PutStSCI0("Nachricht senden (hex): ");
    while(!CAN0TFLG);                   // Wait for available buffer
    NACAN = CAN0TFLG;                   // Get the next aveilable CAN buffer
    CAN0TBSEL = NACAN;

    CAN0TXFG[0] = 0x00;                 // Set the Transmit ID
    CAN0TXFG[1]=  0x00;       // ... Identifier: 00, höchste Priorität
    if(NumBytes > 8)
        NumBytes = 8;
    for(ii = 0; ii < NumBytes; ii++)
        CAN0TXFG[ii+4] = *TXBuf++;            // Store the data
                                              // Data Segment Registers (DSR0-7); site 42
    CAN0TXFG[12] = NumBytes;                  // Set Number of Bytes to send
                                              // Data Lenght Register (DLR); Site 42
    NACAN = CAN0TBSEL;
    CAN0TFLG = NACAN;                         // Start transmission
    zahl= 170;
    PutStSCI0(printf("%02X", zahl));
    /*PutStSCI0(printf("%02X", CAN0TXFG[4]));
    PutStSCI0(printf("%02X", CAN0TXFG[5]));
    PutStSCI0(printf("%02X", CAN0TXFG[6]));
    PutStSCI0(printf("%02X", CAN0TXFG[7]));
    PutStSCI0(printf("%02X", CAN0TXFG[8]));
    PutStSCI0(printf("%02X", CAN0TXFG[9]));
    PutStSCI0(printf("%02X", CAN0TXFG[10]));
    PutStSCI0(printf("%02X", CAN0TXFG[11]));*/
    for(ii = 0; ii < NumBytes; ii++)
    {    
        zahl = CAN0TXFG[ii+4];
        PutStSCI0(printf("%02X", zahl));
    }
    PutStSCI0(" OK\n");
}

Das ganze gehört zu einem Projekt in dem es unter anderem um CAN geht. 
Mit der obigen Funktion werden eben CAN-Botschafen gesendet. Das 
funktioniert auch prima. Weiter sollen halt bestimmte Daten über RS232 
an den PC gesendet werden, in diesem Fall eben die per CAN gesendeten 
Daten.

So wie es oben steht funktioniert das ganze. die ausgabe sieht dann wie 
folgt aus:
AA 11 22 33 44 55 66 77 88 (die AA kommen aus der zahl= 170; der Rest 
ist eben in CAN0TXFG[4]...CAN0TXFG[11] gespeichert.
Wenn ich nun die Zeile "PutStSCI0(printf("%02X", zahl));" 
auskommentiere, sieht die Ausgabe wie folgt aus: 00 22 33 44 55 66 77 
88.

Alle anderen Textausgaben usw. funktionieren einwandfrei. Werte im Array 
habe ich mehrfach überprüft. Die stimmen, also sind z.B. 11 auch wenn 
die 00 ausgegeben wird. Das ganze stimmt nur, wenn vor der eigentlichen 
Ausgabe schon was mit PutStSCI0(printf("%02X", zahl)); ausgegeben wird.

Grüße
Sebastian

[Karl H. (kbuchegg)]

OK.

Ich kann aus dem Codeschnipsel immer noch nicht erkennen, ob CAN0TXCFG 
korrekte Werte enthält oder nicht, ob du das Array überläufst oder 
nicht, etc.

Aber seis drum.

WO hast du eigentlich diesen Schwachsinn her
    PutStSCI0(printf("%02X", zahl));

printf dazu einzusetzen, einen temporären String aufzubauen, der von 
printf verwaltet wird, ist ja wohl mehr als gefährlich. Ausserdem stimmt 
der Return Wert von printf nicht. Alles in allem, sollte man dir dafür 
alleine schon einen nassen Fetzen um den Kopf schlagen :-)

Eine Stringausgabe kann man sich zb so vorbereiten

     char Buffer[20];

     sprintf( Buffer, "%02X", zahl );

jetzt hast du in Buffer einen String, den du mit der Stringausgabe 
ausgeben kannst:

     PutStSCI0( Buffer );

[Sebastian (Gast)]

Hallo,

ich habe das ganze mal wie folgt geändert:

    zahl= 170;
    sprintf(Buffer, "%02X", zahl) 
    PutStSCI0(Buffer);
    for(ii = 0; ii < NumBytes; ii++)
    {    
         zahl = CAN0TXFG[ii+4];
         sprintf( Buffer, "%02X", zahl );
         PutStSCI0(Buffer);
    }

Die Ausgabe hierbei ist AA1122334455667788.

Lässt man hier die Zeilen vor der Schleife weg, ergibt sich die folgende 
Ausgabe: 001122334455667788.

Dies sind die Daten, die gesendet werden sollen, diese werden ja an die 
obige Funktion übergeben:

   TXBuf[0]= 0x11;
   TXBuf[1]= 0x22;
   TXBuf[2]= 0x33;
   TXBuf[3]= 0x44;
   TXBuf[4]= 0x55;
   TXBuf[5]= 0x66;
   TXBuf[6]= 0x77; 
   TXBuf[7]= 0x88;

Grüße
Sebastian

[Karl H. (kbuchegg)]

Sebastian wrote:

> Lässt man hier die Zeilen vor der Schleife weg, ergibt sich die folgende
> Ausgabe: 001122334455667788.

mysteriös. (und ich mein das wirklich nicht ironisch)


Bei solch mysteriösen Dingen ist es oft so, dass der eigentliche Fehler 
ganz woanders steckt und du nur die Auswirkungen siehst. Wird dir wohl 
nichts anderes übrig bleiben, als abspecken, abspecken, abspecken, bis 
der Fehler verschwindet. Die Wahrscheinlichkeit ist hoch, dass der 
eigentliche Fehler im zuletzt abgespeckten Bereich war. Fehler 
korrigieren und das abgespeckte (=auskommentierte) wieder stückchenweise 
freigeben und Ausschau nach sonstigen ungewöhnlichen Effekten halten.

[P. S. (Gast)]

Sebastian wrote:

> das Programm ist zu umfangreich, um es hier alles anzugeben. Die
> Funktion, in der das ganze ablaufen soll, ist folgende:

Dann reduziere es. So geht das nunmal beim Debugging.

[Oha (Gast)]

>Einige Varianten von printf können das auch.

Das printf monster ist nicht totzukriegen. Wenn man das in ein 
embedded projekt hinzulinkt kann man gleich den Strick bestellen...

[Sebastian (Gast)]

Hallo,

> Das printf monster ist nicht totzukriegen. Wenn man das in ein
> embedded projekt hinzulinkt kann man gleich den Strick bestellen...


Andere Vorschläge?

Ich glaube, ich habe den Fehler gefunden. Es liegt anscheinend daran, 
dass ich die Daten vorher schon einmal verarbeite/verwende. Ich verwende 
nun nicht die Register CAN0TXFG[ii+4] usw. sondern direkt *TXBuf++. 
Damit funktioniert es nun.

Vielen Dank!

Grüße
Sebastian

[Markus S. (bastetfur)]

Hmm...
Hier mein, eben aus der Hand geschüttelter, Vorschlag:

unsigned char hex2chrtab[] = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
char Hex2String(unsigned char i, char *out)
{
  out[1] = hex2chrtab[i & 15];
  out[0] = hex2chrtab[((i & 240)>>4)];
  out[2] = '\0';
  return i;
}

Ungetestet, sollte aber so tun.
Am besten vorher mit einem normalem C Programm testen.
Vorteil meiner Lösung: Keine externe Lib. ;)

[Sebastian (Gast)]

Hallo,

vielen Dank!

> unsigned char hex2chrtab[] =
> {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
> char Hex2String(unsigned char i, char *out)
>
>   out[1] = hex2chrtab[i & 15];
>   out[0] = hex2chrtab[((i & 240)>>4)];
>   out[2] = '\0';
>   return i;
> }

Das funktioniert auch!!

Grüße
Sebastian

[Markus S. (bastetfur)]

Freut mich, kann ich also doch programmieren. :D

Kann das einer der C Cracks noch kleiner/schneller machen?

[Peter (Gast)]

>Kann das einer der C Cracks noch kleiner/schneller machen?
out[1] = (i & 15)<10?(i & 15) + '0':(i & 15) + 'A'
out[0] = (i & 240)>>4)?(i & 240)>>4) + '0':(i & 240)>>4) + 'A'
out[2] = '\0';

Bei schneller bin ich mir nicht sicher, kommt auf den optimieren an, 
eventuell mit hilfsvariable machen.

[Niffko _. (niffko)]

Peter (Gast) schrieb:
> out[1] = (i & 15)<10?(i & 15) + '0':(i & 15) + 'A'
> out[0] = (i & 240)>>4)?(i & 240)>>4) + '0':(i & 240)>>4) + 'A'
> out[2] = '\0';

Ja, der Fred ist schon etwas älter ... aber da mir dieser Codeschnipsel 
hier am meisten weiter geholfen hat - obwohl er so nicht funktioniert -, 
nachfolgend nochmal die leicht bearbeitete Version für's Protokoll.

out[1] = (i & 15)<10 ? (i & 15)+'0' : (i & 15)+'7';
out[0] = ((i & 240)>>4)<10 ? ((i & 240)>>4)+'0' : ((i & 240)>>4)+'7';
out[2] = '\0';

//Niffko

[Erich (Gast)]

Zum Ursprungsproblem:
>Nun wollte ich diese Daten so vom µC per RS232 an den PC senden
>und in einem Terminal Programm ausgeben, (...)

Dann solltest du ganz einfach ein Terminalprogramm nehmen, welches 
konfiguriert werden kann, alle ankommenden Bytes (0x00 ... 0xFF)
als jeweils 2 Asciizeichen + nachfolgendes Leerzeichen darzustellen.

Lies mal hier weiter
Beitrag "Neues Terminal-Programm für Windows"
bzw.
http://www.der-hammer.info/terminal/index.htm