vier 8bit Variablen in eine 32bit Variable

test schrieb:

> msg_in_32 = msg.data[7];
> msg_in_32 = 8<<msg_in_32;
> msg_in_32 = msg.data[6];

Nope.
Hier überschreibst du dir ja msg_in_32 komplett!

Das ist nicht das was du willst. Denn selbst, wenn die vorhergehenden 
Operationen korrekt gewesen wären, wäre damit der 'Beitrag' von 
msg.data[7] komplett 'aus dem Rennen' genommen worden. Zuweisung ist 
Zuweisung. Und dabei wird der linke Teil von der Zuweisung unter 
Beachtung seines Datentyps komplett beschrieben.

Ausserdem stimmt die Angabe beim Verschieben nicht

    a << b

bedeutet: verschiebe den Inhalt von a um b Bits nach links.
Genauso wie

    a >> b

bedeutet: verschiebe den Inhalt von a um b Bits nach rechts.

Links von der Operation, egal ob << oder >>, steht das "womit". Und 
rechts von der Operation steht um "wieviele" Bits.
Liest du denn kein C Buch, ehe du mit programmieren anfängst? Da wirst 
du noch ein paar mal schön auf die Schnauze fallen.

Hallo,

ich denke*, Du suchst etwas wie das Folgende, wobei msg_in_32 den 
übertragenen Wert enthält, der in die 4 Array-Werte msg.data[x] 
"aufgesplittet" wird.

1

msg.data[4] = (msg_in_32 & 0x000F);

2

msg.data[5] = (msg_in_32 & 0x00F0) >> 8;

3

msg.data[6] = (msg_in_32 & 0x0F00) >> 16;

4

msg.data[7] = (msg_in_32 & 0xF000) >> 24;

*Oder habe ich mal wieder einen kapitalen Denkfehler gemacht? ;-)

Tobias S. schrieb:
> Hallo,
>
> ich denke*, Du suchst etwas wie das Folgende, wobei msg_in_32 den
> übertragenen Wert enthält, der in die 4 Array-Werte msg.data[x]
> "aufgesplittet" wird.
>
>

1

msg.data[4] = (msg_in_32 & 0x000F);

2

> msg.data[5] = (msg_in_32 & 0x00F0) >> 8;

3

> msg.data[6] = (msg_in_32 & 0x0F00) >> 16;

4

> msg.data[7] = (msg_in_32 & 0xF000) >> 24;

>
> *Oder habe ich mal wieder einen kapitalen Denkfehler gemacht? ;-)

Falsche Datenflussrichtung.
Er hat die 4 Einzelwerte und will sie zusammensetzen.

test schrieb:
> Wie kann ich dann das Problem lösen?

Na, ja.
Die 4 Bytes eben geeignet verschoben wieder zusammensetzen.

1

msg_in_32  = ( (uint32_t)msg.data[7] << 24 )   |

2

             ( (uint32_t)msg_data[6] << 16 )   |

3

             ( (uint32_t)msg_data[5] <<  8 )   |

4

             ( (uint32_t)msg_data[4]       );

ein bischen optimieren könnte man das noch bezüglich der Casts.

Hallo Karl Heinz, ich zitiere mal von oben:

1

unsigned int _4567;

2

3

[...]

4

sende ueber can 

5

[...]

6

uint32_t msg_in_32 = 0;

7

msg_in_32 = msg.data[7];

8

[...]

für mich sah das so aus, dass er schon über CAN gesendet hat und den 
32bitter wieder auseinanderpfriemeln will, daher auch der Name 
msg_*in*_32.

Wie gesagt, wäre aber nicht das erste Mal, dass ich mich irre ;-)

packed union, um sicherzugehen :-)

Karl Heinz schrieb:
>>

1

msg.data[4] = (msg_in_32 & 0x000F);

2

>> msg.data[5] = (msg_in_32 & 0x00F0) >> 8;

3

>> msg.data[6] = (msg_in_32 & 0x0F00) >> 16;

4

>> msg.data[7] = (msg_in_32 & 0xF000) >> 24;

>>
>> *Oder habe ich mal wieder einen kapitalen Denkfehler gemacht? ;-)
>
> Falsche Datenflussrichtung.

Nicht nur das. Maskieren von Nibbles statt Bytes ist hier wenig 
zielführend. ;-)

Wenn msg.data[] vom typ unsigned char ist, kann man sich das maskieren 
mit 0xff sparen, weil nicht mehr Bits reinpassen.