Wie kann ich 4 Byte Werte in eine int32 Variable speichern?

[M. G. (ixil96)]

Hallo,

ich habe folgendes Problem:

Aus einem Byte Array lese ich 4 Bytes aus (beginnend mit MSB) und möchte 
die Werte in eine uint32 Variable wie folgt speichern:

  baselineNewHighByte  = ( (baseline[0]<<8) + (baseline[1]) );
  baselineNewLowByte  = ( (baseline[3]<<8) + (baseline[4]) );
  baselineNew      = ( (baselineNewHighByte<<8) + (baselineNewLowByte) );

baseline[0] = 0x8f
baseline[1] = 0x40
baseline[3] = 0x8f
baseline[4] = 0x16

Für baselineNew erhalte ich aber 0x0000cf16
baselineNewHighByte und baselineNewLowByte sind uint16 Variablen. Die 
hier gespeicherten Werte mit 0x8f40 und 0x8f16 stimmen.

Muss ich für uint32 Variablen eine andere Vorgehensweise wählen?

[pegel (Gast)]

Versuch mal "oder" statt "plus".

[Pink S. (pinkshell)]

In der 3. Zeile muss es 16 statt 8 heißen. Und dann sollte type casting 
von 16 auf 32 bit stattfinden.

[Der Andere (Gast)]

Wenn man 16 Bit Variablen schon im Namen als "byte" bezeichnet

M. G. schrieb:
> baselineNewHighByte

muss man sich nicht wundern wenn man sie nur 8 bit statt 16 schiebt:

M. G. schrieb:
> (baselineNewHighByte<<8

Leute denkt doch mal für 2 Sekunden nach wie man seine variablen 
sinnvoll benamsd.

[Thomas M. (langhaarrocker)]

Habs nicht weiter im Detail nachvollzogen, nachdem sich mir die Frage 
stellte: Wo schreibst Du baseline[2] (Index zwei) in baselineNewLowByte? 
Und gehört baseline[4] (Index vier) wirklich noch zu Deinem int32?

[Der Andere (Gast)]

Pink S. schrieb:
> Und dann sollte type casting

Stimmt natürlich VORHER auf einen ausreichend großen Datentyp casten.

[Hmmm (Gast)]

Du musst das High Word (das Du Byte nennst) 16 statt 8 Bits shiften.

Oder gleich alles zusammen:

baselineNew = (baseline[0]<<24)
              | (baseline[1]<<16)
              | (baseline[2]<<8)
              | baseline[3];

[Joachim B. (jar)]

Der Andere schrieb:
> Wenn man 16 Bit Variablen schon im Namen als "byte" bezeichnet

würde auch word (besser uword) bevorzugen

[Curby23523 N. (Gast)]

Sowas..?

union{
  uint8_t auc[4];
  uint32_t ul;
} unVariable;

uint8_t aucAnderevariable[4] = {0x12, 0x34, 0x56, 0x78};

unVariable.auc[0] = aucAnderevariable[0];
unVariable.auc[1] = aucAnderevariable[1];
unVariable.auc[2] = aucAnderevariable[2];
unVariable.auc[3] = aucAnderevariable[3];

if(unVariable.ul == 0x12345678){
  //HOORAY!
}

[Falk B. (falk)]

@M. G. (ixil96)

>Aus einem Byte Array lese ich 4 Bytes aus (beginnend mit MSB) und möchte
>die Werte in eine uint32 Variable wie folgt speichern:
>  baselineNewHighByte  = ( (baseline[0]<<8) + (baseline[1]) );
>  baselineNewLowByte  = ( (baseline[3]<<8) + (baseline[4]) );
>  baselineNew      = ( (baselineNewHighByte<<8) + (baselineNewLowByte) );

Da fehlt ein Cast. Eher so.

  baselineNew      = (long)baseline[0] << 0 |
                     (long)baseline[1] << 8 |
                     (long)baseline[2] << 16 |
                     (long)baseline[3] << 24;

>baselineNewHighByte und baselineNewLowByte sind uint16 Variablen.

Das ist das Problem. Der Compiler rechnet bei diesen Schiebeoperationen 
nur mit 16 Bit, wodurch man niemals Daten in höhere Bits schieben kann. 
Mit dem Cast rechnet er mit 32 Bit.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

M. G. schrieb:
> Muss ich für uint32 Variablen eine andere Vorgehensweise wählen?
Nicht bei einem PC, denn dort ist der Integer 32 Bit breit.

Wenn du bei deinem unbekannten Compiler aber einen 16 Bit Integer hast, 
dann musst du ihm bei Rechenoperationen (auch und besonders mit 
Konstanten) mitteilen, dass er sie doch in 32 Bit Breite ausführen 
solle...

[M. G. (ixil96)]

Habs jetzt mit dem Typecast versucht

baselineNew = ( (long)(baseline[0]<<24) | (long)(baseline[1]<<16) | (long)(baseline[3]<<8) | (long)(baseline[4]) );

aber die obersten zwei bytes sind 0xffff

[Einer K. (Gast)]

Weiterhin:
Du solltest lernen, wie man bis 4 zählt.
Im Moment klemmt es ab 1 noch etwas....

Und wie dein Cast wirkt, solltest du noch mal im Handbuch nachlesen.
Denn so wird das nichts.

[Falk B. (falk)]

@M. G. (ixil96)

>Habs jetzt mit dem Typecast versucht
>baselineNew = ( (long)(baseline[0]<<24) | (long)(baseline[1]<<16) | 
(long)>(baseline[3]<<8) | (long)(baseline[4]) );

>aber die obersten zwei bytes sind 0xffff

Was wohl daran liegt, daß long vorzeichenbehaftet ist. Und wenn der 
Compiler eine 16 Bit Zahl auf 32 Bit vorzeichenrichtig erweitert, 
kopiert er Bit 15 in alle Bits 16-31.

[Adam P. (adamap)]

M. G. schrieb:
> Habs jetzt mit dem Typecast versucht
> baselineNew = ( (long)(baseline[0]<<24) | (long)(baseline[1]<<16) |
> (long)(baseline[3]<<8) | (long)(baseline[4]) );
>
> aber die obersten zwei bytes sind 0xffff

Du muss bei Index 0 beginnen:

/* Generiert aus vier Byte Werten ein uint32_t */
static inline uint32_t u8u32(uint8_t *src)
{
   return ((src[3] << 24) | (src[2] << 16) | (src[1] << 8) | (src[0]));
}

Hier meine Lösung die ich verwende.

edit:

Über den Namen der Fkt. kann man sich streiten...
Kannst es dann so verwenden:

uint8_t buf[4];
uint32_t value;

// buf mit Werten befüllen

value = u8u32(&buf[0]);

[R. M. (rmax)]

M. G. schrieb:
> Habs jetzt mit dem Typecast versucht

Leider an der falschen Stelle, Du mußt erst casten und dann schieben, 
nicht umgekehrt:

 (((uint32_t) baseline[0]) << 24)

[Codix (Gast)]

Du solltest auch den Endian Deines Prozessors kennen.
Bitte dieses einmal lesen: 
https://de.wikipedia.org/wiki/Byte-Reihenfolge#Beispiel:_Speicherung_einer_32_Bit-Ganzzahl_in_4_Bytes

[Der Andere (Gast)]

Falk B. schrieb:
> baselineNew      = (long)baseline[0] << 0 |
>                      (long)baseline[1] << 8 |
>                      (long)baseline[2] << 16 |
>                      (long)baseline[3] << 24;

Umgekehrte Reihenfolge.
Das MSByte steht wohl in baseline[0].
Siehe:

M. G. schrieb:
> Aus einem Byte Array lese ich 4 Bytes aus (beginnend mit MSB) und möchte
> die Werte in eine uint32 Variable wie folgt speichern:
>   baselineNewHighByte  = ( (baseline[0]<<8) + (baseline[1]) );

[M. G. (ixil96)]

R. M. schrieb:
> M. G. schrieb:
>> Habs jetzt mit dem Typecast versucht
>
> Leider an der falschen Stelle, Du mußt erst casten und dann schieben,
> nicht umgekehrt:
>
>  (((uint32_t) baseline[0]) << 24)

Jetzt funzt es!

Danke!