Ich habe ein kleines Problem.
Ich habe ein BYTE, in dem jedes Bit einem Ausgang entspricht.
(Bit 1 -> Ausgang 1 usw).
Dieses BYTE wird in ein Integer Wert dargestellt.

Mein Problem nun ist folgendes.
Es gibt ja ziemlich viele Abfragen, um die Bits abzufragen.
Integer Wert:
1 -> Ausgang 1
3 -> Ausgang 1 + Ausgang 2
5 -> Ausgang 3 + Ausgang 1
usw.
Das ganze geht ja bis 255.

Hat dazu vielleicht jemand eine Idee, wie man es besser machen kann, als die vielen IF's oder switch's ?????

Außerdem... viele ifs? Also mir fallen spontan 8 ein:

if (Wert & 1)
{ // Ausgang 1
}
if (Wert & 2)
{ // Ausgang 2
}
if (Wert & 4)
{ // Ausgang 3
}

Und so weiter...

Man könnte mit << noch eine Schleife draus machen, aber das krieg ich ausm Stehgreif grade nicht hin und finde es auch nicht wesentlich einfacher.

EDIT: FALSCH! s.u.

int i = 8;
while(i--)
{
    if(Wert & i)
    {   //Ausgang i
        break;  
    }
}

Nein! Genau das geht nicht. Das würde erst bit 3 prüfen, dann bit2+1+0...

int i = 8;
while(i--)
{
    if(Wert & (1<<i))
    {   
        TuWas(i);
        break;  
    }
}

Wenn es nur 8 IF's wären......
Es kann auch Ausgang 1 und Ausgang 2 sein , oder Ausgang 3 und Ausgang 8 usw.
Also mit 8 IF's kommt man nicht weit....

Na und?
Wenn es Ausgang 1 und 2 sind, geht er erst in die erste if, dann in die zweite. Wo ist das Problem?
Solange du uns so im Dunkeln lässt, was genau passieren soll, kann man dir da auch nicht wirklich konkreter helfen.

Lass uns mal kurz annehmen, es gibt nur die 2 Ausgänge.
Und es gibt 3 Funktionen:

void Ausgang1An();
void Ausgang2An();
void Ausgang1und2An()
{
    Ausgang1An();
    Ausgang2An();
}

So war meine Vermutung bisher. Und das würde mit den 8 ifs funktionieren.

Wie soll es denn nun sein?

BYTE byShift = 0x01;
for(int i=0; i<8; i++)
{
    if(Wert & (byShift << i))
    {  //Kanal i gesetzt
    }
}

connan schrieb:

int i = 8;
while(i--)
{
    if(Wert & i)
    {   //Ausgang i
        break;  
    }
}

Nein! Genau das geht nicht. Das würde erst bit 3 prüfen, dann bit2+1+0...

Sorry, hatte nur estartus Vorschlag in eine Schleife gepackt

Also nochmal eine kurze Erklärung.
Ich habe 8 Ausgänge.

BYTE INT
-------------------------------------------------
0000 0000 -> 0 -> kein Ausgang schalten z.B.
0000 0001 -> 1 -> Ausgang 1 schalten...
0000 0010 -> 2 -> Ausgang 2 schalten...
0000 0011 -> 3 -> Ausgang 1 und Ausgang 2 schalten...
1111 1111 -> 255 -> alle Ausgänge schalten...

BYTE INT
-------------------------------------------------
0000 0000 -> 0 -> kein Ausgang schalten z.B.
0000 0001 -> 1 -> Ausgang 1 schalten...
0000 0010 -> 2 -> Ausgang 2 schalten...
0000 0011 -> 3 -> Ausgang 1 und Ausgang 2 schalten...
1111 1111 -> 255 -> alle Ausgänge schalten...

Ja, genau so hatte ich das vermutet.
Das geht mit den ifs.

Die machen ja folgendes:

if (Wert & 1) // Steht ganz hinten eine 1?
{ // Ausgang 1
}
if (Wert & 2) // Steht am zweiten von hinten eine 1?
{ // Ausgang 2
}

Bei 0000 0000 hast du Nein, Nein.
Bei 0000 0001 hast du Ja, Nein.
Bei 0000 0010 hast du Nein, Ja.
Bei 0000 0011 hast du Ja, Ja.

(Wert & Wenn das wahr ist heist das doch noch lange nicht, dass das höchstwertige bit gesetzt ist, oder seh ich irgendwas noch nicht?

Ja klar, ich will halt nur verstehen warum oder ob estartus Bsp. funktioniert.
Edit: So wie ich das sehe funktioniert das mehr oder weniger zufällig für die Kanäle 1 und 2.

Deswegen hatte ich das in meinem ganz ersten Beispiel ja auch für 1 (0001), 2 (0010) und 4 (0100) gezeigt.
Für das höchstwertigste Bit musst du also 1000 0000 abfragen und nicht 0000 1000 (8).

Schau dir mal Martins Schleife an, so funktioniert es korrekt.

Welche denn genau?

Diese hier
Edit: Der Unterschied zu estartus Bsp. liegt nur in der if-bedingung. Sie hätte dort (Wert & 2^i) stehen. Was aber das selbe ergibt

Edit: Der Unterschied zu estartus Bsp. liegt nur in der if-bedingung. Sie hätte dort (Wert & 2^i) stehen. Was aber das selbe ergibt

Abgesehen davon, daß ^ nicht potenziert, stimmt das (und wie ich estartu einschätze, hätte sie wohl auch mit shift-Operatoren gearbeitet)

(und wie ich estartu einschätze, hätte sie wohl auch mit shift-Operatoren gearbeitet)

Danke. Das wollte ich ja auch.

estartu schrieb:

Man könnte mit << noch eine Schleife draus machen[...]

int i = 8;
while(i--)
{
    if(Wert & (1<<i))
    {  
        TuWas(i);
        break;  
    }
}

Diese hier
Edit: Der Unterschied zu estartus Bsp. liegt nur in der if-bedingung. Sie hätte dort (Wert & 2^i) stehen. Was aber das selbe ergibt

So wie's hier schon dargestellt ist. Was funktioniert denn nicht?

Edit: Das break musst du wahrscheinlich noch rausmachen, es sei denn es kann immer nur ein bit aktiv sein.