Schonmal danke für Antworten

a[j][26] = (a[j][26]&0xfff)<<4;
a[j][26] = (a[j][26] | ((b[j][i]&0x1)<<1));

> ist die binäre schieben nach rechts

1. Zeile:
Zuerst wird a mit 0xfff verundet. D.h nur die untersten 12 Bit bleiben so wie sie sind, der Rest wird zu 0.
Dann wird der Wert um 4 Bit nach links geschoben. D.h. Bit 12 wird zu Bit 16, ...., Bit 0 wird zu Bit 4, die unteren 4 Bits werden mit 0 aufgefüllt.

2. Zeile:
Von b wird nur das unterste Bit genommen und um eine Stelle nach links geschoben.
Das Ganze wird dann mit a verodert.

In diesem Fall wird also das Bit 0 von b zu Bit 1 von a.

Zeile 2 habe ich (das verordern) leider noch nicht verstanden ...

Wenn in b[j][i] Bit 0 gesetzt ist, wird in a[j][26] Bit 1 gesetzt.

( a[j][26] >> & 0x000000ff)
Bedeutet dies, das 8 Nullen von links angeschoben werden?
Sprich ich hätte in a stehen
11100111010000011 dann würde dies zu
0000000011100111010000011 werden, was für die Zahl nicht von Bedeutung währe, aber vll. für meine I2C übermittlung.
dieses würde dann mit 0x000000ff verglichen werden. Macht es da einen unterschied ob es 0xff oder 0x000000ff ist?

Weiterhin habe ich später im Code ein j>>2 stehen.
j ist eine Laufvariable, was macht das für einen Sinn?

Vielen Dank schonmal für Antworten

Nun eine weitere Frage zu diesem Thema.
Nun habe ich im Folgenden

( a[j][26] >> & 0x000000ff)
Bedeutet dies, das 8 Nullen von links angeschoben werden?

Nicht ganz. Es bedeutet, dass 8 Bits rechts rausgeschoben werden. Von links wird dann mit Nullen aufgefüllt.

Aus 11100111010000011 wird 00000000111001110. Dann wird noch alles bis auf die letzten 8 Bit ausmaskiert, damit erhältst du 00000000011001110.

Bahaoth schrieb:

Macht es da einen unterschied ob es 0xff oder 0x000000ff ist?

Nein.

Bahaoth schrieb:

Weiterhin habe ich später im Code ein j>>2 stehen.
j ist eine Laufvariable, was macht das für einen Sinn?

Das kann man an diesem winzigen Fragment allein nicht erkennen. Aber j>>2 ist dasselbe wie j/4.

( a[j][26] >> & 0x000000ff)
Bedeutet dies, das 8 Nullen von links angeschoben werden?

Das kann man so genau nicht sagen.
Wenn a ein unsifgned Type ist, werden 0 eingeschoben.
Wenn a ein signed Typ ist, hängt es vom Compiler ab ob er eine 0 oder eine Kopie des Vorzeichenbits einschiebt.
Das gilt für das rechts schieben.

Beim links schieben wird eine 0 eingeschoben.

Bei deinem Beispiel ist da aber egal, da danach ja eh nur die untersten 8 Bit betrachtet werden.

a[j][i]= 3700

a[j][i] = (a[j][i]&0xfff)<<4;
a[j][i] = (a[j][i] | ((b[j][i]&0x1)<<1)); // b enthällt immer True oder Flase
a[j][i] = (a[j][i] | (c[j][i]&0x1)); // c enthält immer True oder False

//111001110100 & 0xfff = 111001110100
// <<4 = 1110011101000000
// ((b[j][i]&0x1)<<1)) = | (1 & 1)<<1 = 10
// |10 = 1110011101000010
// (c[j][i]&0x1)) = (1 & 1) = 1
// | 1 = 1110011101000011

Out.I2C.CO[j][cha_efm] = (unsigned char) (a[j][i] & 0x000000ff);
cha_efm++;
Out.I2C.CO[j][cha_efm] = (unsigned char) ( (a[j][i] >> & 0x000000ff);
cha_efm++;

pEfm01->WriteBlock( ((j>>2)(sizeof(uI2COut)/4)) ,(unsigned char)&Out.Lng[j>>2],(sizeof(uI2COut)/4) ,true);

das mit den vordersten 8 löschen wäre absolut bescheuert, da die in dem Programm welches ich habe gerade erst hinein geschrieben wurden....

Die unteren 8 Bits werden zwei Zeilen vorher verarbeitet.