Bit Position für Array verwenden

[Simon (Gast)]

Kann man diesen code nicht irgendwie schöner zusammen fassen?

changed beinhaltet einzelne bits und ich frage quasi ab an welcher 
Position
diese sich befinden.

0b00000001 = 0x01 = Bit 0 ist gesetzt = val_digital[0]
0b00000010 = 0x02 = Bit 1 ist gesetzt = val_digital[1]
...

Gibt es hier eine elegantere Lösung als das einzelnd aufzählen zu 
müssen?

   if (changed & 0x01) digital[0].value += 1;
   if (changed & 0x02) digital[1].value += 1;
   if (changed & 0x04) digital[2].value += 1;
   if (changed & 0x08) digital[3].value += 1;
   if (changed & 0x10) digital[4].value += 1;
   if (changed & 0x20) digital[5].value += 1;
   if (changed & 0x40) digital[6].value += 1;
   if (changed & 0x80) digital[7].value += 1;

[Yalu X. (yalu) (Moderator)]

Du kannst das Ganze in eine Schleife packen. Dadurch wird es im 
Quellcode schöner aber evtl. auch etwas langsamer.

[Simon (Gast)]

genau das mit der Schleife habe ich vor, nur das setzt irgendwie voraus 
das
ich x in

digital[x].value += 1;

errechnen kann und zwar anhand des bits in changed.

bzw eigentlich andersrum.

for (x=0; x<8; x++) {
 if (changed & 0x20) digital[x].value += 1;
}

Nur hier hab ich ebend genau das problem dies Bit zu erechnen

[Karl H. (kbuchegg)]

Simon schrieb:

> errechnen kann und zwar anhand des bits in changed.

Na ja.
Das ist ja nicht weiter schwer.
Die Verundung mit einem Maskenwert bleibt weiterhin.
Einziger UNterschied.
Bisher waren deine Maskenwerte 0x01, 0x02, 0x04, 0x08, ....
WEnn man sich die aber mal auf Bitebene ansieht, dann sieht man, dass 
das im Grunde ja immer nur ein einzige 1 Bit ist, welches in jeder 
weiteren Maskenstufe um 1 Position nach links rutscht.

Bei x gleich 0     0x01       00000001
Bei x gleich 1     0x02       00000010
Bei x gleich 2     0x04       00000100
Bei x gleich 3     0x08       00001000
...

Diese 'weiterrutschen' kann man natürlich auch programmierern.

  uint8_t mask = 0x01;

  for (x=0; x<8; x++) {
    if (changed & mask)
      digital[x].value += 1;
    mask = mask << 1;
  }

PS: Bitte vergiss mein voriges Posting wieder - ich habs bereits 
gelöscht. Das war Blödsinn und ist so in deinem konkreten Fall nicht 
anwendbar.

[Simon (Gast)]

Vielen Dank für deine Antwort.

ok... das wird funktionieren,
aber habe ich damit wirklich irgendwas gewonnen?

Ich meine der code ist nicht einfacher geworden und vermutlich auch 
nicht
schneller. Fazit.. ich lasse es wie es ist?

[Karl H. (kbuchegg)]

Simon schrieb:
> Vielen Dank für deine Antwort.
>
> ok... das wird funktionieren,
> aber habe ich damit wirklich irgendwas gewonnen?
>
> Ich meine der code ist nicht einfacher geworden und vermutlich auch
> nicht
> schneller.

Das ist schwer zu sagen.
Im Zweifelsfall musst du es kompilieren und dir das Ergebnis auf 
Assembler-Ebene ansehen.
Kürzer ist er auf Assembler-ebene schon - würde ich mal sagen.
Obs auch schneller ist, ist eine andere Frage.

[Axel Z. (axel_z)]

Noch sparender geht es wohl so:

digital[0].value += changed & 1; changed>>=1;
digital[1].value += changed & 1; changed>>=1;
digital[2].value += changed & 1; changed>>=1;
digital[3].value += changed & 1; changed>>=1;
digital[4].value += changed & 1; changed>>=1;
digital[5].value += changed & 1; changed>>=1;
digital[6].value += changed & 1; changed>>=1;
digital[7].value += changed & 1;

oder als schleife

uint8_t i;
for (i=0; i<8; ++i){
  digital[i].value += changed & 1;
  changed>>=1;
}

Gruß

[Simon (Gast)]

Vielen Dank für beide Beispiele!

Man merkt aber auch schon das es dann immer
schwerer wird den code zu lesen und zu verstehen :-)

[Johann L. (gjlayde)]

Simon schrieb:
> Gibt es hier eine elegantere Lösung als das einzelnd aufzählen zu
> müssen?

Mit GCC:

digital[0].value += __builtin_popcount (changed);

http://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html

Je nach Target ist das in Assembler imlementiert, z.B. für die aktuellen 
Versionen von avr-gcc (ab 4.7).