Reference   Language | Libraries | Comparison | Changes

Bitweises UND (&), Bitweises ODER (|), Bitweises XOR (^)

Bitweises UND (&)

Die bitweisen Befehle verarbeiten Variablen auf der Bit-Ebene. Dadurch lassen sich verschiedenste programmatische Probleme lösen. Die nachfolgenden Ausführungen stammen aus einem hervorragendem Tutorial, welches hier gefunden werden kann.

Beschreibung und Syntax

Unten finden sich Beschreibung und Syntax für alle bitweisen Operatoren. Weitere Details finden sich im angegebenen Tutorial.

Bitweises UND (&)

Das bitweise UND ist ein einfaches & und wird zwischen zwei Integer Variablen eingefügt, um diese zu verknüpfen. Das bitweise UND wirkt sich auf jedes bit der Operanden aus, unabhängig von den anderen Bits nach folgenden Schema: wenn beide Bits 1 sind, dann ist dieses Bit im Ergebnis auch 1, andernfalls ist es 0. Die folgende Darstellung verdeutlicht das:

    0  0  1  1    operand1
    0  1  0  1    operand2
    ----------
    0  0  0  1    (operand1 & operand2) = Ergebnis

In der Arduino IDE ist der Datentyp int 16 bit breit, also werden im folgenden Codeschnipsel 16 einzelne UND Operationen durchgeführt:

    int a =  92;    // binär: 0000000001011100
    int b = 101;    // binär: 0000000001100101
    int c = a & b;  // Ergebnis:    0000000001000100, oder 68 in dezimal.

Jedes der 16 Bits in den Variablen a und b werden mit dem bitweisen UND verarbeitet und alle 16 resultierenden Bits werden in der Variable c gespeichert. Das Ergebnis binär dargestellt ist 01000100, was dem dezimalen Wert 68 entspricht.

Eine der häufigsten Anwendungen des bitweisen UND ist die Auswahl einen bestimmten Bits von einem Integer-Wert, das sogenannte Masking. Ein Beispiel hierzu findet sich weiter unten.

Bitweises ODER (|)

Das bitweise ODER ist das | Symbol und wirkt sich wir das bitweise UND auf jedes Bit eines Integers einzeln aus. Das bitweise ODER gibt eine 1 zurück, wenn mindestens eines oder beide Bits auch 1 sind, andernfalls gibt es 0 zurück. Die folgende Darstellung verdeutlicht das:

    0  0  1  1    operand1
    0  1  0  1    operand2
    ----------
    0  1  1  1    (operand1 | operand2) = Ergebnis

Angewendet auf das vorheriges Beispiel ergibt sich:

    int a =  92;    // binär: 0000000001011100
    int b = 101;    // binär: 0000000001100101
    int c = a | b;  // Ergebnis:    0000000001111101, oder 125 in dezimal.

Beispiel

Eine häufige Anwendung für das bitweise UND und das bitweise ODER ist das sogenannte Lese-Ändere-Schreibe eines Ports. Bei Microcontrollern ist der Port eine 8-bit Nummer, welche eine entsprechende Anzahl Ausgänge darstellt. Wenn man nun einen Wert auf einen Port ausgibt, dann steuert man damit sämtliche Ausgänge auf einmal.

PORTD ist eine eingebaute Konstante, welche die digitalen Ausgänge 0,1,2,3,4,5,6,7 des Arduino-Boards beschreibt. Wenn nun eine 1 an einer bestimmten Bit-Position steht, dann ist dieser Ausgang entsprechend auf HIGH gesetzt. (Die Ausgänge müssen vorgängig als solche definiert werden, dazu wird der Befehl pinMode() verwendet.) Schreibt man also PORTD = B00110001; werden die Ausgänge 2,3,7 auf HIGH gesetzt. Ein Haken an dieser Methode ist, dass möglicherweise auch der Zustand von Ausgang 0 und 1 verändert wurde. Diese werden vom Arduino-Board für die serielle Kommunikation verwendet, welche dadurch gestört werden kann.

Der Algorithmus für diese Progamm lautet:

  • Lade Wert von PORTD und lösche alle Bits der Ausgänge, welche gesteuert werden sollen (durch Verwendung des bitweisen UND).
  • Kombiniere den modifizierten Wert von PORTD mit den neuen Werten der zusteuernden Ausgänge (durch Verwendung des bitweisen ODER).

int i;     // Zählvariable
int j;

void setup(){
DDRD = DDRD | B11111100; // Setze Bits für Ausgang 2 bis 7, lasse 0 und 1 unberührt (xx | 00 == xx)
// Enstspricht pinMode(pin, OUTPUT) für Ausgang 2 bis 7
Serial.begin(9600);
}

void loop(){
for (i=0; i<64; i++){

PORTD = PORTD & B00000011;  // Lösche Bits 2 - 7, lasse 0 und 1 unberührt (xx & 11 == xx)
j = (i << 2);               // Schiebe Variable um zwei Stellen, damit Ausgang 0 and 1 übersprungen werden
PORTD = PORTD | j;          // Kombiniere den Wert des Portes mit den neuen Werten für die LED-Ausgänge
Serial.println(PORTD, BIN); // Ausgabe der Werte, um Masking anzuzeigen
delay(100);
   }
}

Bitweises XOR (^)

Das bitweise EXKLUSIV ODER, auch XOR (ausgesprochen: “eks-or”), ist das ^ Symbol. Der Operator ist ähnlich zum bitweisen ODER, allerdings ist das Ergebnis nur dann 1, wenn nur eines der Bits 1 ist:

    0  0  1  1    operand1
    0  1  0  1    operand2
    ----------
    0  1  1  0    (operand1 ^ operand2) = Ergebnis

Man kann sich das bitweise XOR auch so vorstellen, dass es eine 1 zurückgibt, wenn die Bits einer Stelle in den Operatoren verschieden sind und eine 0 zurückgibt, wenn beide Bits in den Operatoren gleich sind.

Das folgende Codebeispiel verdeutlich das:

    int x = 12;     // binär: 1100
    int y = 10;     // binär: 1010
    int z = x ^ y;  // binär: 0110, oder dezimal 6

Das bitweise XOR wird meist verwendet um bestimmete Bits zu “togglen” (engl. to toggle ["toggl"]: umschalten), also von 0 auf 1 und umgekehrt zu schalten.

Hier ein Beispiel, welches eine LED an Pin 5 blinken lässt:

// Blink_Pin_5
// demo for Exclusive OR
void setup(){
DDRD = DDRD | B00100000; // Pin 5 auf Ausgang 
Serial.begin(9600);
}

void loop(){
PORTD = PORTD ^ B00100000;  // invertiere Bit 5, ohne dabei andere Bits zu invertieren
delay(100);
}

Siehe auch

  • &&(Boolean UND)
  • ||(Boolean ODER)

Reference Home

Corrections, suggestions, and new documentation should be posted to the Forum.

The text of the Arduino reference is licensed under a Creative Commons Attribution-ShareAlike 3.0 License. Code samples in the reference are released into the public domain.

Share