Umwandlung der CS_UID zur Ausgabe über UART

#3682547
Lesenswert?

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..

-----------------------------------------------------
1
#include <stdio.h>
2
#include <string.h>
3

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

12
int hex_to_ascii(char c, char d){
13
        int high = hex_to_int(c) * 16;
14
        int low = hex_to_int(d);
15
        return high+low;
16
}
17

18
int main(){
19
        const char* st = "48656C6C6F3B";
20
        int length = strlen(st);
21
        int i;
22
        char buf = 0;
23
        for(i = 0; i < length; i++){
24
                if(i % 2 != 0){
25
                        printf("%c", hex_to_ascii(buf, st[i]));
26
                }else{
27
                        buf = st[i];
28
                }
29
        }
30
}
------------------------------------------------------------------------

und folgendes ist dabei rausgekommen..

------------------------------------------------------------------------
1
#include <stdio.h>
2
#include <string.h>
3

4
#define CS_UID 0x1234567890abcdff
5

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

14
int hex_to_ascii(char c, char d){
15
  int high = hex_to_int(c) * 16;
16
  int low = hex_to_int(d);
17
  return high+low;
18
}
19

20
int main (void){
21

22
const char* st = CS_UID;
23
char csuid_array[8]; //Zum Ausgeben später über UART
24
int length = strlen(st);
25
int j;
26
char buf = 0;
27
  for (j=0; j < length; j++){
28
    if(j % 2 != 0){
29
      csuid_array[j] = hex_to_ascii(buf,st[j]);
30
    }
31
    else{
32
      buf = st[j];
33
    }
34
  }
35
}
-----------------------------------------------------------------------

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!
Gast #3682649
Lesenswert?

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
Gast #3682735
Lesenswert?

Hi,
1
#define CS_UID 0x1234567890abcdff

das ist eine Zahl!
Aber du willst hier eine Zeichenkette auswerten
1
const char* st = CS_UID;
2
int length = strlen(st);

das geht nicht!!!
versuchmal so
1
#define CS_UID "0x1234567890abcdff"
2
const char* st = CS_UID;
3
int length = strlen(st);

das sollte gehen.
#3682830
Lesenswert?

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?
#3682833
Lesenswert?

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
Gast #3682900
Lesenswert?

Mit den Funktionen von oben sollte es so gehen:
1
uint64_t csuid = CS_UID;
2
char csuid_array[8]; //Zum Ausgeben später über UART
3
for (uint8_t i = 0; i < 8; i++)
4
{
5
  csuid_array[7 - i] = hex_to_ascii(csuid & 0xFF);
6
  csuid >>= 8;
7
}
Gast #3682912
Lesenswert?

> 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
#3682918
Lesenswert?

Du warst doch schon dicht dran.

So z.B. könnte das aussehen:
1
#include <stdio.h>
2

3
#define CS_UID 0x1234567890abcdff
4

5
void nibble2hex(unsigned char nibble, char *ret)
6
{
7
    if (nibble < 10)
8
        *ret++ = nibble + '0';
9
    else
10
        *ret++ = nibble - 10 + 'A';
11
    *ret++ = '\0';
12
}
13

14
int cs_uid_out(void)
15
{
16
    int i;
17
    char result[64 / 4 + 1];
18
    char *cp = &result[0];
19
    
20
    for (i = 64 - 4; i >= 0; i -= 4)
21
    {
22
        nibble2hex((CS_UID >> i) & 0xf, cp);
23
        cp++;
24
    }
25
    
26
    wie_auch_immer_ein_string_zum_uart_geschickt_wird(result);
27
}
Gast #3682923
Lesenswert?

Och Leute warum denn so kompliziert?
1
int cs_uid_out(void)
2
{
3
#    int i;
4
#    char result[64 / 4 + 1];
5
#    char *cp = &result[0];
6
#    
7
#    for (i = 64 - 4; i >= 0; i -= 4)
8
#    {
9
#        nibble2hex((CS_UID >> i) & 0xf, cp);
10
#        cp++;
11
#    }
12
#    
13
#    wie_auch_immer_ein_string_zum_uart_geschickt_wird(result);
14
    wie_auch_immer_ein_string_zum_uart_geschickt_wird(#CS_UID);
15
}
Gast #3682929
Lesenswert?

..korrektur, das hätte eigentlich noch nicht losgeschickt werden sollen:
1
#define to_string2(x)   #x
2
#define to_string(x)    to_string2( x )
3

4
int cs_uid_out(void)
5
{
6
   wie_auch_immer_ein_string_zum_uart_geschickt_wird(to_string(CS_UID));
7
}

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

oder

Mit Google-Account einloggen

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren