Main

Référence : Langage Arduino : [ Mini | Standard | Etendue | Maxi ] Librairies : [ Vue d'ensemble | Synthèse ] Infos : [ Comparaison | Changements ]

Opérateurs "bit à bit" ET (&), OU (|), OU EXCLUSIF (^)


Les opérateurs "bit à bit" réalisent leurs opérations au niveau des bits unitaires des variables. Ils aident à résoudre toute une série de problèmes courants de programmation. Beaucoup d'éléments de ce qui suit est issu d'un excellent tutoriel sur les opérations "bit à bit".

Ci-dessous, la description et la syntaxe pour chacun des opérateurs. Davantage de détails peuvent être retrouvés dans ce tutoriel signalé ci-dessus.

Opérateur "bit à bit" ET (&)

Description

L'opérateur "bit à bit" ET en langage C++ est le symbole & utilisé entre deux expressions entières. L'opérateur "bit à bit" AND opère indépendemment et successivement sur chaque bit unitaire des deux expressions entières présentes de part et d'autre de l'opérateur, selon la règle suivante : si les 2 bits d'entrée sont à 1, le résultat de sortie est 1, sinon le résultat de sortie est 0. Une autre façon d'exprimer ceci :

0 0 1 1 opérande 1 (1ère valeur entière)
0 1 0 1 opérande 2 (2ème valeur entière)
________
0 0 0 1 (opérande1 & opérande2) - résultat renvoyé

Syntaxe

Dans le langage Arduino, le type de donnée int est une valeur entière 16 bits, et donc utiliser & entre deux expressions entières int entraîne 16 opérations ET simultanées. Voici un extrait de code réalisant ceci :

    int a =  92;    // en binaire :  0000000001011100
    int b = 101;    // en binaire :  0000000001100101
    int c = a & b;  // résultat :    0000000001000100, ou 68 en décimal.

Chacun des 16 bits des valeurs entières a et b ont été pris en compte par l'instruction ET bit à bit, et les 16 bits résultants ont été stockés dans la variable entière c, donnant le résultat 01000100 en binaire, soit 68 en décimal.

Utilisation

Une des utilisations les plus communes de l'opérateur ET bit à bit est de sélectionner un bit (ou des bits) particulier(s) d'une valeur entière, souvent appelée masque. Voir ci-dessous pour un exemple.

Opérateur bit à bit OU (|)

Description

L'opérateur OU en langage C++ est la barre verticale | . De la même façon que l'opérateur &, l'opérateur | agit indépendemment sur chaque bit unitaire des deux expressions entières de part et d'autre de l'opérateur, mais il agit d'une façon différente évidemment. L'opérateur "bit à bit" OU de 2 bits donne 1 si l'un des deux ou les deux bits d'entrée est 1, sinon il renvoie 0. En d'autres termes :

0 0 1 1 opérande1
0 1 0 1 opérande2
________
0 1 1 1 (opérande1 | opérande2) - résultat renvoyé

Syntaxe

Voici un exemple d'opération OU bit à bit utilisé dans un bout de code C++ :

    int a =  92;    // in binary: 0000000001011100
    int b = 101;    // in binary: 0000000001100101
    int c = a | b;  // result:    0000000001111101, or 125 in decimal.

Programme d'exemple

Une utilisation courante des opérateurs bit à bit ET et OU est ce que les programmeurs appellent "Lire-Modifier-Ecrire" sur un port. Sur les microcontrôleurs (et donc sur une carte Arduino), un port est un nombre de 8 bits qui représente l'état des broches. Ecrire sur un port contrôle toutes les broches d'un coup.

Le PORTD est une constante prédéfinie du langage Arduino qui se réfère à l'état des broches du port D, les broches 0 à 7 d'une carte Arduino. Pour chaque bit qui est à 1, la broche est au niveau HAUT. (Les broches doivent biensûr être configurées en sortie à l'aide de l'instruction pinMode.) Donc, si nous écrivons PORTD=B10001010, nous mettons les broches 1, 3 et 7 au niveau HAUT (le bit de poids faible correspond à la broche 0).

Un problème que nous allons rencontrer ici est que nous allons du coup changer l'état des broches 0 et 1 qui sont utilisées par la carte Arduino pour les communications série, et donc nous allons interférer avec les communications séries.

Notre algorithme pour notre programme sera :

  • Initialiser le port D et mettre à 0 seulement les bits correspondants aux broches que nous voulons contrôler (avec l'opérateur bit à bit ET).
  • Combiner la valeur du port D modifié avec la nouvelle valeur pour les broches sous contrôle (avec l'opérateur bit à bit OU).

int i;     // variable de comptage
int j;

void setup(){
DDRD = DDRD | B11111100; // initialise la direction des bits 2 à 7, laissant 0 et 1 inchangés (xx | 00 == xx)
// identique à pinMode(pin, OUTPUT) pour les broches 2 à 7
Serial.begin(9600); // initialise connexion série
}

void loop(){

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

PORTD = PORTD & B00000011;  // met à 0 les broches 2 à 7, laissant les broches 0 et 1 inchangées (xx & 11 == xx)
j = (i << 2);               // décale la variable des broches  2 - 7 - pour avoir les broches  0 et 1
PORTD = PORTD | j;          // combine la nouvelle information avec celle des broches de LED
Serial.println(PORTD, BIN); // envoi série pour montrer le masquage
delay(100);
   }
}
 

Opérateur "bit à bit" OU EXCLUSIF (^)

Description

Il existe un opérateur inhabituel en langage C++ appelé opérateur bit à bit OU EXCLUSIF, également connu sous le nom d'opérateur "bit à bit" XOR. (En anglais, cela se prononce "eks-or"). L'opérateur "bit à bit" OU EXCLUSIF est écrit en utilisant le symbole ^. Cet opérateur est très semblable à l'opérateur |, à la différence qu'il renvoie la valeur 0 sir les deux bits d'entrée sont à 1 :

0 0 1 1 opérande1
0 1 0 1 opérande2
________
0 1 1 0 (opérande1 ^ opérande2) - résultat renvoyé

Une autre façon de voir l'opérateur OU EXCLUSIF est que le bit de résultat vaut 1 si (et seulement si) les entrées sont différentes, ou 0 si elles sont identiques.

Syntaxe

Voici un code d'exemple simple :

    int x = 12;     // binaire: 1100
    int y = 10;     // binaire: 1010
    int z = x ^ y;  // binaire: 0110, ou 6 en décimal

Exemple

L'opérateur ^ est souvent utilisé pour inversé (càd changer les 0 en 1 et les 1 en 0) de quelques bits d'une expression entière. Dans une opération bit à bit OU EXCLUSIF, si il y a un 1 dans le bit de masque, ce bit sera inversé; si il y a un 0, le bit n'est pas inversé et reste le même. Voici un programme qui fait clignoter la broche numérique 5 :


// fait clignoter la broche 5
// demo du OU EXCLUSIF

void setup(){
DDRD = DDRD | B00100000; // met la broche 5 en sortie
Serial.begin(9600); // initialise la connexion série
}

void loop(){
PORTD = PORTD ^ B00100000;  // inverse le bit 5 (broche numérique 5), laisse les autres inchangées
delay(100);
}
 

Voir également

Commentaires utilisateurs

Aucun commentaire


Page d'accueil de la référence Arduino en français

Corrections, suggestions et nouvelle documentation peuvent être postées sur le Forum Arduino ou à l'adresse suivante : support_at_mon-club-elec_point_fr

Le texte original de la référence Arduino est sous licence Creative Commons Attribution-ShareAlike 3.0 . Les exemples de code dans la référence sont dans le domaine public.

La présente traduction française commentée a été réalisée par Xavier HINAULT (2010-2012) (www.mon-club-elec.fr) et est sous licence Creative Commons Attribution-ShareAlike 3.0.