BYTE Alogrithmus



  • Martin Richter schrieb:

    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 😮



  • Ich probiere es mal aus.

    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...



  • simcon schrieb:

    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.



  • OK.
    Danke an alle......
    Ich probiere mal alles aus......



  • 😕 Das versteh ich nicht 😞
    folgendes Bsp.:

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



  • Nein, das bedeutet, daß das 4. Bit gesetzt ist ("wert & 2i" sagt dir, ob das (i+1)te Bit in wert gesetzt ist, dabei kann i von 0 bis 8*sizeof(wert)-1 laufen - das höchste Bit in einem BYTE fragst du mit "wert&128" ab)



  • 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.



  • Das Beispiel von estartu funktioniert, weil sie die Werte korrekt potenziert hat (w&1 -> Ausgang 1, w&2 -> Ausgang 2, w&4 -> Ausgang 3) - daß die Bitmaske und die Bitnummer übereinstimmen, gilt allerdings nur für die Ausgänge 1 und 2. Schau dir mal Martins Schleife an, so funktioniert es korrekt.



  • connan schrieb:

    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). ⚠



  • 💡 Alles klar! Da hab ich wohl mal wieder was übersehen 🙄



  • CStoll schrieb:

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

    Welche denn genau?



  • 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 🙂



  • connan schrieb:

    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)



  • 😃



  • CStoll schrieb:

    (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[...]



  • Und wie funzt es mit << bzw >>, ich kriege es immer noch nicht hin



  • connan schrieb:

    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.



  • Also,
    Wenn ich als Wert 0x1000 (int 😎 habe, dann ruft er mir die TuWas funktion bei
    folgenden Werten für i auf:
    7
    6
    5
    3

    Rein theoretisch müsste er mir doch nur einmal in diese Funktion kommen, nämlich bei Bit 4 (8), oder?????? 😕 😕 😕



  • Ich glaub, ich hab es....

    DezZahl = einzulesende Dezimalzahl
    i = Schleifenzaehler

    for ( i = 7 ; i >= 0 ; i--)
    {
    /*

    ist der Bitwert an der Stelle i eine 1,
    so wird 1 ausgeben, ansonsten eine 0

    */
    if ( DezZahl&(1<<i))
    printf ("1");
    else
    printf ("0");
    }


Anmelden zum Antworten