Umwandlung der CS_UID zur Ausgabe über UART

[Thomas M. (need_help)]

Hallo Leute, ich brauche Hilfe bei der Umwandlung und Ausgabe folgender 
hexadezimaler CS_UID(immer 64bit lang) die so definiert ist:

- #define CS_UID 0x1234567890abcdff

und welche mit folgender Methode an die UART geschrieben wird:

- void appWriteDataToUart(uint8_t* aData, uint8_t aLength);

Ich möchte die CS_UID irgendwie sinnvoll umwandeln, sodass sie über die 
UART ausgegeben werden kann..

Jemand meinte der folgende Code würde mir helfen es in ascii 
umzuwandeln..

-----------------------------------------------------

#include <stdio.h>
#include <string.h>

int hex_to_int(char c){
        int first = c / 16 - 3;
        int second = c % 16;
        int result = first*10 + second;
        if(result > 9) result--;
        return result;
}

int hex_to_ascii(char c, char d){
        int high = hex_to_int(c) * 16;
        int low = hex_to_int(d);
        return high+low;
}

int main(){
        const char* st = "48656C6C6F3B";
        int length = strlen(st);
        int i;
        char buf = 0;
        for(i = 0; i < length; i++){
                if(i % 2 != 0){
                        printf("%c", hex_to_ascii(buf, st[i]));
                }else{
                        buf = st[i];
                }
        }
}

------------------------------------------------------------------------

und folgendes ist dabei rausgekommen..

------------------------------------------------------------------------

#include <stdio.h>
#include <string.h>

#define CS_UID 0x1234567890abcdff

int hex_to_int(char c){
  int first = c / 16 - 3;
  int second = c % 16;
  int result = first*10 + second;
  if(result > 9) result--;
  return result;
}

int hex_to_ascii(char c, char d){
  int high = hex_to_int(c) * 16;
  int low = hex_to_int(d);
  return high+low;
}

int main (void){

const char* st = CS_UID;
char csuid_array[8]; //Zum Ausgeben später über UART
int length = strlen(st);
int j;
char buf = 0;
  for (j=0; j < length; j++){
    if(j % 2 != 0){
      csuid_array[j] = hex_to_ascii(buf,st[j]);
    }
    else{
      buf = st[j];
    }
  }
}

-----------------------------------------------------------------------

aber es funktioniert nicht, ich habe sicherlich einiges falsch gemacht, 
bin da noch nicht so erfahren.. ich wäre dankbar für jegliche Hilfe oder 
andere Lösungen/Lösungsansätze!

[Kaj (Gast)]

Thomas Müller schrieb:
> Ich möchte die CS_UID irgendwie sinnvoll umwandeln, sodass sie über die
> UART ausgegeben werden kann..
Um da was über den UART zu schicken musst du nichts umwandeln.
Aber egal: die Funktion, die du suchst heißt (prinzipiel) itoa (integer 
to ascii)bzw. ultoa (unsigned long to ascii) 
http://www-01.ibm.com/support/knowledgecenter/SSLTBW_1.12.0/com.ibm.zos.r12.bpxbd00/ultoa.htm%23ultoa?lang=en
Da das aber leider nur für Werte bis 32bit gedacht ist hilft dir 
vielleicht die funktion sprintf: 
http://stackoverflow.com/questions/8147175/how-to-convert-long-long-ascii-hex-values-into-a-string

[Stephan (Gast)]

Hi,

#define CS_UID 0x1234567890abcdff

das ist eine Zahl!
Aber du willst hier eine Zeichenkette auswerten

const char* st = CS_UID;
int length = strlen(st);

das geht nicht!!!
versuchmal so

#define CS_UID "0x1234567890abcdff"
const char* st = CS_UID;
int length = strlen(st);

das sollte gehen.

[Thomas M. (need_help)]

Danke Kaj und Danke Stephan. Vielleicht habe ich mich nicht richtig 
ausgedrückt, ich kann/darf an der Deklaration der CS_UID nichts ändern, 
ich muss mit ihr so arbeiten wie sie ist und genau das ist mein Problem, 
wie bekomme ich diese Zahl umgewandelt in Zeichen? Damit dann in einem 
Array  die Zeichenkette "0x1234567890abcdff" drin steht :S?

[Florian K. (florian_k89)]

Hi,

um ein bischen zu tricksen.
mach aus der 64bit Zahl zwei 32Bit Zahlen.
Wandle die beiden Zahlen mit itoa() in die jeweilige Zeichenkette.
Klebe die beiden zeichenketten mit strcat() zu einer Zechenkette 
zusammen.
Und sende die geklebte Zeichenkette anschliessend über die Uart.
ist nicht schön aber ...

gruss
Florian

[Hans (Gast)]

Mit den Funktionen von oben sollte es so gehen:

uint64_t csuid = CS_UID;
char csuid_array[8]; //Zum Ausgeben später über UART
for (uint8_t i = 0; i < 8; i++)
{
  csuid_array[7 - i] = hex_to_ascii(csuid & 0xFF);
  csuid >>= 8;
}

[g457 (Gast)]

> Vielleicht habe ich mich nicht richtig ausgedrückt, ich kann/darf an der
> Deklaration der CS_UID nichts ändern [..] wie bekomme ich diese Zahl
> umgewandelt in Zeichen?

Du brauchst an CS_UID nichts zu ändern, Stringizer ('#') regelt das für 
Dich zur Compilezeit. Kostet Speicherplatz für den String, spart dafür 
Laufzeit und Kompexität.

HTH

[Markus F. (mfro)]

Du warst doch schon dicht dran.

So z.B. könnte das aussehen:

#include <stdio.h>

#define CS_UID 0x1234567890abcdff

void nibble2hex(unsigned char nibble, char *ret)
{
    if (nibble < 10)
        *ret++ = nibble + '0';
    else
        *ret++ = nibble - 10 + 'A';
    *ret++ = '\0';
}

int cs_uid_out(void)
{
    int i;
    char result[64 / 4 + 1];
    char *cp = &result[0];
    
    for (i = 64 - 4; i >= 0; i -= 4)
    {
        nibble2hex((CS_UID >> i) & 0xf, cp);
        cp++;
    }
    
    wie_auch_immer_ein_string_zum_uart_geschickt_wird(result);
}

[g457 (Gast)]

Och Leute warum denn so kompliziert?

int cs_uid_out(void)
{
#    int i;
#    char result[64 / 4 + 1];
#    char *cp = &result[0];
#    
#    for (i = 64 - 4; i >= 0; i -= 4)
#    {
#        nibble2hex((CS_UID >> i) & 0xf, cp);
#        cp++;
#    }
#    
#    wie_auch_immer_ein_string_zum_uart_geschickt_wird(result);
    wie_auch_immer_ein_string_zum_uart_geschickt_wird(#CS_UID);
}

[g457 (Gast)]

..korrektur, das hätte eigentlich noch nicht losgeschickt werden sollen:

#define to_string2(x)   #x
#define to_string(x)    to_string2( x )

int cs_uid_out(void)
{
   wie_auch_immer_ein_string_zum_uart_geschickt_wird(to_string(CS_UID));
}

[Markus F. (mfro)]

g457 schrieb:
> #define to_string2(x)   #x
> #define to_string(x)    to_string2( x )

Ein fieser Trick ;)

Wenn man den Speicher hat, funzt das auch, ja.

[Thomas M. (need_help)]

Hans schrieb:
> Mit den Funktionen von oben sollte es so gehen:
>
>

uint64_t csuid = CS_UID;
> char csuid_array[8]; //Zum Ausgeben später über UART
> for (uint8_t i = 0; i < 8; i++)
> {
>   csuid_array[7 - i] = hex_to_ascii(csuid & 0xFF);
>   csuid >>= 8;
> }

hex_to_ascii(csuid & 0xFF); erwartet aber 2 parameter :S..

[Thomas M. (need_help)]

omfg... DANKE LEUTE!!! Es hat geklappt! :D:D:D Danke auch an g457 du 
bist ein programmier-gott ^^