4 uint8_t in uint32_t konvertieren

[daniel (Gast)]

Hi,

ich möchte gerne 4 uint8_t Variablen in eine uint32_t Variable 
konvertieren, folgenden Testcode habe ich geschrieben:

#include <avr/io.h>
#include <stdint.h>

int main() {
  uint8_t b1, b2, b3, b4;
  uint32_t w;
  
  b1 = 0xBC;
  b2 = 0x11;
  b3 = 0x33;
  b4 = 0x44;

  w = b1 & 0xFF;
  w |= b2 << 8;
  w |= (uint32_t)b3 << 16;
  w |= (uint32_t)b4 << 24;
}

Funktioniert eigentlich auch, aber wenn ich b2 auf z.B. A9 abändere, 
dann sind die höheren 16 Bit in w immer FFFF. Wieso?

Gruss Daniel

[Micha 3.0 (Gast)]

Hier:

  w = b1 & 0xFF;

koppierst Du doch nur 0xFF in die Varialble.

Bsp:
Denn 10100110 & 11111111 ergibt 11111111

[Alf (Gast)]

Micha 3.0 schrieb:
> w = b1 & 0xFF;
>
> koppierst Du doch nur 0xFF in die Varialble.

Das wäre bei | so!

[Karl H. (kbuchegg)]

Weil du hier ein Zwischenergebnis hast

w |= b2 << 8;


Die Reihenfolge der Ereignisse ist:

b2 auf int (16-Bit signed) aufblasen. Dies deshalb, weil ein 16 Bit 
signed int alle Werte eines uint8_t aufnehmen kann

Damit hast du einen int mit dem Wert 0x00A9

Dieser int wird nun um 8 Stellen nach links verschoben und wird somit zu

0xA900

Aber Achtung: Es ist immer noch ein 16 BIt Wert mit Vorzeichen. Und als 
solcher ist er im 2-er Komplement negativ.

Jetzt wird dieser int dem w 'zugewiesen'.
Du w ein uint32_t ist, wird zunächste der 16 Bit int auf 32 Bit 
aufgeblasen. Und jetzt passierts. Da 0xA900 einen negativen 2-er 
Komplement-Wert darstellt, lautet der entsprechende 32-Bit signed Wert 
dazu 0xFFFFA900

Und so kommen deine 0xFFFF in die höherwertigen 16 BIt.

Caste b2 zuerst auf einen 16 Bit unsigned

w |= (uint16_t)b2 << 8;

Ich denke, das sollte dem Spuk Einhalt gebieten.

[daniel (Gast)]

Sicher?

Ich dachte immer:
10100110 & 11111111 = 10100110

[PittyJ (Gast)]

Denn 10100110 & 11111111 ergibt 11111111

Hm, sowie ich die Und-Verknüpfung kenne, ist diese Aussage falsch.


für Daniel:

mach auch den Cast für b2, also

 w |= ((uint32_t)b2) << 8;

[Karl H. (kbuchegg)]

Micha 3.0 schrieb:
> Hier:
>
>   w = b1 & 0xFF;
>
> koppierst Du doch nur 0xFF in die Varialble.
>
> Bsp:
> Denn 10100110 & 11111111 ergibt 11111111

Falsch.
Ausserdem ist das nicht die Quelle seines Problems.

[daniel (Gast)]

@Karl-Heinz:

BOMBE ! Vielen Dank für die super Erklärung ! Nun funktioniert es !

Gruss Daniel

[Matthias N. (nippey)]

Ich mache sowas gerne mit unions, finde ich schön übersichtlich:

union bitMix { 
  // 4 x 8bit 
  struct achtBit_t { 
    uint8_t a, b, c, d;
  } achtBit;
 
  // 1 x 32bit 
  uint32_t abcd; 
};

int main(void) { 
  bitMix mix1;
  mix1.achtBit.a = 0xDE;
  mix1.achtBit.b = 0xAD;
  mix1.achtBit.c = 0xBE;
  mix1.achtBit.d = 0xEF;

  mix1.abcd = 0xDEADBEEF;
}

[Zwie B. (zwieblum)]

uint8_t b[4]={1,2,3,4};
uint32_t *abc=(uint32_t*)b;

[DirkB (Gast)]

@Matthias N. und @Zwie Blum

Und wie haltet ihr dass mit der Endianess?

[Zwie B. (zwieblum)]

Würd' mal vorschlagen, das sollte man beim Befüllen des Arrays klären.

[olf79 (Gast)]

warum nicht einfach so:

union _u8_u32 {uint8_t b[4];  uint32_t dw; } val;

val.b[0] = 0xBC;
val.b[1] = 0x11;
val.b[2] = 0x33;
val.b[3] = 0x44;

und man hat in val.dw den u32-Wert stehen.

Die Endianess muss man natürlich in der Befüll-Reihenfolge 
berücksichtigen..

[Simon K. (simon)]

Das Endian Problem hat man auch mit der Union.