Hilfe bei Zuweisung von u32Bit Wert an u8Bit Wert

[Sebastian Sobierajski (Gast)]

Hallo,

ich hab hier ein Problem bei der Typumwandlung.
Es geht um folgendes.

Ich hab ein Wert der in einer Variablen des Typs UINT32 (unsigned long
32 bit)abgespeichert ist.
Diesen muss ich über Ethernet verschicken.
Der Ethernetpuffer ist aber vom Typ UINT8 (unsigned 8-bit).
Jetzt wollte ich den 32Bit Wert casten um diesen so an ein UINT8 Buffer
zu übergeben.
Hat einer eine Idee wie man diesen Wert in diesen Puffer schreiben
kann.

Beispiel Werte für 32Bit Wert : 4600
Ich kann aber nur im unsigned char (allso UINT8) Wert max. 255
eingeben.
Das ich die 4600 aufteilen muss ist mir klar. aber WIE ???

Danke für jede Art von Hilfe

[Bri (Gast)]

UINT8 puffer[4];
UIINT32 wert;

puffer[0] = (UINT8)(wert >> 24);
puffer[1] = (UINT8)(wert >> 16);
puffer[2] = (UINT8)(wert >> 8);
puffer[3] = (UINT8)wert;

[Matthias (Gast)]

Hi

es gibt dafür zig Varianten. Hier mal ein paar

1.
net_buf[i++] = *(((UINT8 *)(&longvar))+0);
net_buf[i++] = *(((UINT8 *)(&longvar))+1);
net_buf[i++] = *(((UINT8 *)(&longvar))+2);
net_buf[i++] = *(((UINT8 *)(&longvar))+3);

2.
net_buf[i++] = ((UINT8 *)(&longvar))[0];
net_buf[i++] = ((UINT8 *)(&longvar))[1];
net_buf[i++] = ((UINT8 *)(&longvar))[2];
net_buf[i++] = ((UINT8 *)(&longvar))[3];

3.
net_buf[i++] = (longvar>>0)  & 0xFF;
net_buf[i++] = (longvar>>8)  & 0xFF;
net_buf[i++] = (longvar>>16) & 0xFF;
net_buf[i++] = (longvar>>24) & 0xFF;

4.
net_buf[i++] = (longvar)  & 0xFF;
net_buf[i++] = (longvar/256)  & 0xFF;
net_buf[i++] = (longvar/(256*256)) & 0xFF;
net_buf[i++] = (longvar/(256*256*256)) & 0xFF;

5.
memcpy(net_buf,&longvar,4);

Es gibt da noch diverse Möglichkeiten (z.B. unter zuhilfenahme von
union's) aber das sollte fürs erste reichen.

Matthias

[Bri (Gast)]

es gänge aber auch so:

UINT8 puffer[4];
UINT32 wert, *p = (UINT32 *)puffer;

*p = wert;

Die Bytereihenfolge hängt dann aber vom Prozessor und/oder Compiler ab!
Deshalb solltest du besser die erste Variante nehmen.

[Sebastian Sobierajski (Gast)]

Als erstes Danke für die schnelle Hilfe.
Dieses Forum ist echt spitze :-)

Ich hab das Problem so gelöst hab mir etwas von meine IP Stack
abgeschaut
Ich schifte die Bits :-)
Das klappt auch wunderbar.

Aber  jetzt hab ich das Problem den empfangenen Buffer auf der PC Seite
wieder umzuwandeln....
Big Endian (Motorola) versus Little Endian (Intel)....

Bei Motorolla werden die Daten fogendermassen dargestellt:
0xA1B2C3D4 = Motorolla Darstellung der Daten
auf dem Intel bzw. bei mir AMD soll es so aussehen
0xD4C3B2A1...

Ich verzweifle beim Port der ist Dezimal 5000 das entspricht 0x1388
Diese 0x1388 teile ich in den unsigned Buffer auf also einmal 13 und
88
Auf der PC Seite will ich diese jetzt wieder zum INT zusammen
packen...
Aber es kommt nur Mist raus.

Hat einer Ahnung was ich falsch machen

Danke für jede Art von Hilfe...
Sibi

[A.K. (Gast)]

Such mal in der Socket-Doku nach den Funktionen htonl/ntohl.

[Bri (Gast)]

Also erstmal solltest du probieren, ob eine von den beiden Varianten
beim zusammenbauen geht:

UINT32 w;
UINT8 puffer[4];

w = (puffer[0] << 24) | (puffer[1] << 16) | (puffer[2] << 8) |
(puffer[3])

oder

w = (puffer[3] << 24) | (puffer[2] << 16) | (puffer[1] << 8) |
(puffer[0])

Wenn w nur den Wert des letzten Wertes aus dem Puffer hat (also
puffer[3] oder puffer[0]) dann bedeutet das, das der Compiler beim
shiften UINT8 verwendet und die bits sozusagen "rausrutschen". Du
musst dann die Werte im Puffer erst in UINT32 wandeln:

w = ((UINT32)(puffer[0]) << 24) | ((UINT32)(puffer[1]) << 16) |
((UINT32)(puffer[2]) << 8) | (puffer[3])

oder

w = ((UINT32)(puffer[3]) << 24) | ((UINT32)(puffer[2]) << 16) |
((UINT32)(puffer[1]) << 8) | (puffer[0])