Bases · 13 min de lecture

Système binaire et hexadécimal : opérations sur les bits Arduino

Système binaire, conversions hexadécimal et décimal, bits et octets, 0b et 0x sur Arduino, &, |, ^, ~, <<, >> avec bitRead, exemples 74HC595 et registres.

Le système binaire n'utilise que les chiffres 0 et 1 et constitue la base de toute l'électronique numérique. Chaque broche, chaque registre et chaque octet de la mémoire d'un Arduino est en réalité un nombre binaire fait d'interrupteurs ouverts ou fermés : 1 signifie qu'une broche est à HIGH, 0 qu'elle est à LOW. Des expressions comme 0b10110101, 0xB5 ou PORTB |= (1 << 5) peuvent impressionner dans le code, mais une fois le binaire et l'hexadécimal compris, elles se ramènent toutes à quelques règles simples.

Dans ce guide, tu verras d'abord comment convertir à la main les nombres décimaux, binaires et hexadécimaux les uns dans les autres, ce que sont le bit, le quartet et l'octet, et comment les nombres négatifs sont stockés en mémoire. Tu apprendras ensuite à écrire des nombres sur Arduino avec 0b et 0x, à lire et modifier un seul bit avec AND, OR, XOR, NOT et les décalages, et à utiliser les fonctions bitRead, bitWrite et bitSet. Enfin, tu prépareras des octets pour un afficheur 7 segments et un 74HC595, et tu écriras directement dans les registres de l'Uno, de l'ESP32 et de la Pico.

Qu'est-ce qu'un système de numération ? Décimal, binaire et hexadécimal

Le système décimal que nous utilisons tous les jours compte 10 chiffres, et chaque position vaut 10 fois la précédente : 181 vaut 1×100 + 8×10 + 1×1. Le système binaire n'a que deux chiffres et chaque position vaut le double de la précédente ; de droite à gauche, les poids sont 1, 2, 4, 8, 16, 32, 64, 128. Le système hexadécimal (hex) compte 16 chiffres : après 0–9 viennent A=10, B=11, C=12, D=13, E=14, F=15. L'hex est très apprécié en électronique parce que chaque chiffre hexadécimal correspond exactement à 4 bits ; c'est la façon la plus pratique d'écrire de longs nombres binaires de manière courte et lisible.

DécimalBinaireHexDécimalBinaireHex
000000810008
100011910019
200102101010A
300113111011B
401004121100C
501015131101D
601106141110E
701117151111F

Conversions entre décimal, binaire et hex

Pour passer du décimal au binaire, divise le nombre par 2 encore et encore en notant les restes ; en lisant les restes de bas en haut, tu obtiens le nombre binaire. Pour 181 : 181/2 = 90 reste 1, 90/2 = 45 reste 0, 45/2 = 22 reste 1, 22/2 = 11 reste 0, 11/2 = 5 reste 1, 5/2 = 2 reste 1, 2/2 = 1 reste 0, 1/2 = 0 reste 1. Lu de bas en haut, cela donne 10110101. Passer du binaire au décimal est plus simple : additionne les poids des positions qui contiennent un 1. 10110101 = 128 + 32 + 16 + 4 + 1 = 181.

Poids1286432168421
10110101 (181)10110101
00001100 (12)00001100
11111111 (255)11111111

Pour passer du binaire à l'hex, découpe les bits en groupes de quatre en partant de la droite et remplace chaque groupe par son chiffre hexadécimal du tableau : 1011 0101 → B 5 → 0xB5. Dans l'autre sens, c'est aussi simple : 0x3C → 0011 1100. Pour passer de l'hex au décimal, multiplie chaque chiffre par une puissance de 16 : 0xB5 = 11×16 + 5 = 181, 0x3FF = 3×256 + 15×16 + 15 = 1023. Le dernier exemple doit te parler : la limite haute de la valeur 10 bits d'analogRead sur l'Uno est 1023, soit dix 1. Tu trouveras le lien entre lecture analogique et nombre de bits dans l'article sur l'ADC.

Le mode programmeur de la calculatrice de ton ordinateur et le moniteur série d'Arduino sont les moyens les plus rapides de vérifier une conversion. Serial.println(181, BIN) affiche 10110101 et Serial.println(181, HEX) affiche B5. Faire la conversion à la main quelques fois rend pourtant la lecture des tableaux de registres et des fiches techniques bien plus facile.

Bit, quartet, octet et plages de valeurs

Un seul chiffre binaire s'appelle un bit. 4 bits forment un quartet (nibble), c'est-à-dire un chiffre hexadécimal ; 8 bits forment un octet (byte), écrit avec deux chiffres hex. Le bit le plus à droite d'un octet est le bit de poids faible (LSB, bit 0), le plus à gauche le bit de poids fort (MSB, bit 7). Les numéros de bit commencent toujours à 0, donc les bits d'un nombre de 8 bits sont numérotés de 0 à 7. Avec n bits, on peut écrire 2ⁿ valeurs différentes : 8 bits donnent 256 valeurs, 10 bits 1024 et 16 bits 65536.

TailleType ArduinoPlage non signéePlage signée
8 bits (1 octet)byte, uint8_t / int8_t0–255-128 à 127
16 bits (2 octets)int sur l'Uno, word, uint16_t0–65535-32768 à 32767
32 bits (4 octets)long, uint32_t ; int sur ESP32 et Pico0–4 294 967 295-2 147 483 648 à 2 147 483 647

Nombres négatifs : le complément à deux

Les microcontrôleurs stockent les nombres négatifs en complément à deux : dans un nombre signé, si le bit le plus à gauche vaut 1, le nombre est négatif. Pour obtenir l'opposé d'un nombre, on inverse tous ses bits et on ajoute 1. 5 = 00000101 ; inversé 11111010 ; plus 1 donne 11111011 = 0xFB, soit -5. La même suite de bits représente un nombre différent selon la façon de la lire : 0xFF vaut 255 en byte et -1 en int8_t. C'est pourquoi il est si important d'affecter les octets bruts d'un capteur au bon type. Quand une variable dépasse sa limite haute, elle repart du début : en byte, 255 + 1 = 0, et avec un int sur l'Uno, 32767 + 1 = -32768 ; c'est un dépassement (overflow).

Écrire des nombres avec 0b, 0x et B sur Arduino

Dans le code Arduino, tu peux écrire le même nombre de trois façons sans que cela change quoi que ce soit pour le compilateur : 181 (décimal), 0b10110101 (binaire, standard depuis C++14) et 0xB5 (hexadécimal). Arduino reconnaît aussi la forme B10110101 héritée d'anciens codes, mais il s'agit de constantes définies uniquement pour des valeurs 8 bits, et 0b est préférable dans un nouveau code. Le choix dépend de la lisibilité : le binaire est le plus clair pour des motifs de LED et des réglages de registres, l'hex pour des adresses et des codes couleur, le décimal pour des mesures.

C++ (Arduino IDE)
1// Aynı sayının üç yazımı ve Seri Monitör'de gösterimi
2// Three ways to write the same number and print it
3void binaryYaz(byte deger) {               // baştaki sıfırlarla 8 bit yaz / print 8 bits with leading zeros
4  for (int i = 7; i >= 0; i--) {
5    Serial.print(bitRead(deger, i));
6  }
7  Serial.println();
8}
9
10void setup() {
11  Serial.begin(9600);
12  byte a = 0b10110101;                       // ikilik / binary
13  byte b = 0xB5;                             // onaltılık / hex
14  byte c = 181;                              // onluk / decimal
15  Serial.println(a == b && b == c ? "Ucu de ayni / All equal" : "Farkli / Different");
16  Serial.println(c, BIN);                    // 10110101
17  Serial.println(c, HEX);                    // B5
18  Serial.println(c, DEC);                    // 181
19  Serial.println(12, BIN);                   // 1100 (baştaki sıfırlar yok / no leading zeros)
20  binaryYaz(12);                             // 00001100
21  Serial.println(010);                       // 8: baştaki 0 sekizlik demek / leading 0 means octal
22}
23
24void loop() {
25}
En C++, un zéro devant un nombre en fait un nombre octal : 010 vaut huit et non dix, et 0255 vaut 173. Si tu écris 08 ou 09 pour aligner des numéros de broche ou des heures, le compilateur signale une erreur ; si tu écris 010, il fait la mauvaise chose sans prévenir. Ne mets jamais de zéro devant un nombre décimal.

Opérations sur les bits : &, |, ^, ~, << et >>

Les opérations sur les bits comparent un à un les bits de même position de deux nombres. AND (&) donne 1 seulement si les deux bits valent 1 ; OR (|) donne 1 si l'un des bits vaut 1 ; XOR (^) donne 1 si les bits diffèrent ; NOT (~) inverse tous les bits. Le décalage à gauche (<<) pousse les bits vers la gauche et ajoute des 0 à droite, ce qui multiplie le nombre par 2 à chaque pas ; le décalage à droite (>>) les pousse vers la droite et divise par 2 à chaque pas. Ce sont les équivalents logiciels des portes logiques ; tu verras leurs tables de vérité dans l'article portes logiques et dans l'outil portes logiques. Le tableau donne les résultats pour a = 0b11001010 (202) et b = 0b10101100 (172) :

OpérationQue fait-elle ?Résultat (binaire)HexDécimal
a & bBits à 1 dans les deux100010000x88136
a | bBits à 1 dans au moins un111011100xEE238
a ^ bBits qui diffèrent011001100x66102
~a (byte)Tous les bits inversés001101010x3553
a << 1 (byte)Une position vers la gauche, le bit de gauche est perdu100101000x94148
a >> 2Deux positions vers la droite, les deux bits de droite sont perdus001100100x3250

Remarque deux détails du tableau. Si le résultat de a << 1 est stocké dans un byte, le bit de gauche sort et il reste 148 ; la même opération dans un int donne 404, car un int a de la place pour le bit qui déborde. ~a est semblable : 53 en byte, mais calculé en int, les bits supérieurs sont aussi inversés et le résultat vaut -203. Avec les opérations sur les bits, tu dois toujours savoir dans quel type tu ranges le résultat. Et ne confonds pas & et && : le premier travaille bit par bit, le second vérifie si deux conditions sont vraies.

Masques de bits : lire, mettre à 1 et effacer un seul bit

Dans les vrais projets, les opérations sur les bits s'utilisent presque toujours avec un masque. Un masque est un nombre dont seuls les bits qui t'intéressent valent 1 ; on le construit généralement avec (1 << n) : (1 << 3) = 0b00001000. Un masque permet quatre opérations de base, et Arduino propose une fonction toute prête pour chacune. Le code suivant garde l'état de 8 LED dans un seul octet plutôt que dans 8 variables bool et le reporte sur les LED de D2 à D9 :

ButAvec un masqueFonction ArduinoExemple (n = 3)
Mettre le bit à 1x |= (1 << n);bitSet(x, n);00000000 → 00001000
Mettre le bit à 0x &= ~(1 << n);bitClear(x, n);11111111 → 11110111
Inverser le bitx ^= (1 << n);bitWrite(x, n, !bitRead(x, n));00001000 → 00000000
Lire (tester) le bit(x >> n) & 1bitRead(x, n);00001000 → 1
Écrire une valeur dans le bitx = (x & ~(1 << n)) | (v << n);bitWrite(x, n, v);v = 1 → 00001000
Poids du bit n1 << nbit(n);bit(3) = 8
C++ (Arduino IDE)
1// 8 LED'in durumu tek bir baytta / the state of 8 LEDs in one byte
2const byte LED_PINLERI[8] = {2, 3, 4, 5, 6, 7, 8, 9};   // bit 0 -> D2 ... bit 7 -> D9
3byte durum = 0b00000000;
4
5void goster() {                                // baytı LED'lere yansıt / mirror the byte to the LEDs
6  for (byte i = 0; i < 8; i++) {
7    digitalWrite(LED_PINLERI[i], bitRead(durum, i));
8  }
9}
10
11void setup() {
12  Serial.begin(9600);
13  for (byte i = 0; i < 8; i++) pinMode(LED_PINLERI[i], OUTPUT);
14}
15
16void loop() {
17  durum |= (1 << 3);                           // bit 3'ü aç (D5) / set bit 3 (D5)
18  durum ^= 0b10000001;                         // bit 0 ve 7'yi tersle / toggle bits 0 and 7
19  goster();
20  Serial.println(durum, BIN);
21  delay(500);
22
23  durum &= ~(1 << 3);                          // bit 3'ü kapat / clear bit 3
24  bitWrite(durum, 5, !bitRead(durum, 5));      // bit 5'i tersle / toggle bit 5
25  goster();
26  if (durum & (1 << 5)) {                      // bit 5 açık mı? / is bit 5 set?
27    Serial.println(F("Bit 5 acik / Bit 5 is on"));
28  }
29  delay(500);
30}

Préparer des octets pour un afficheur 7 segments

Les huit éléments d'un afficheur 7 segments (segments a–g et le point) tiennent exactement dans un octet. Si tu attribues le bit 0 au segment a, le bit 6 au segment g et le bit 7 au point décimal (DP), chaque chiffre s'exprime par un seul nombre. Le 2, par exemple, se dessine avec les segments a, b, d, e et g : 1 + 2 + 8 + 16 + 64 = 91 = 0x5B. Sur les afficheurs à anode commune, un segment s'allume à LOW ; tu inverses donc le même tableau avec ~. Pour le câblage des segments, vois l'article afficheur 7 segments.

ChiffreSegments allumésBinaire (DP g f e d c b a)Cathode communeAnode commune (~)
0a b c d e f001111110x3F0xC0
1b c000001100x060xF9
2a b d e g010110110x5B0xA4
3a b c d g010011110x4F0xB0
4b c f g011001100x660x99
5a c d f g011011010x6D0x92
6a c d e f g011111010x7D0x82
7a b c000001110x070xF8
8a b c d e f g011111110x7F0x80
9a b c d f g011011110x6F0x90

Envoyer l'octet vers les sorties avec un 74HC595

Le registre à décalage 74HC595 répartit un octet sur huit sorties avec seulement trois broches, et c'est la puce où l'on voit le plus clairement les opérations sur les bits : chaque bit de l'octet envoyé allume ou éteint une sortie. Avec MSBFIRST, shiftOut envoie d'abord le bit 7, qui finit dans Q7, tandis que le bit 0 arrive dans Q0. Si tu relies Q0 au segment a, Q6 au g et Q7 au DP, le tableau ci-dessus fonctionne donc directement. Pour toutes les broches de la puce et le chaînage, vois l'article registre à décalage 74HC595.

ConnexionArduino UnoESP32Raspberry Pi Pico
DS (14), données sérieD11GPIO 23GP19
SH_CP (11), horlogeD13GPIO 18GP18
ST_CP (12), verrou (latch)D10GPIO 5GP17
OE (13) / MR (10)GND / 5VGND / 3V3GND / 3V3(OUT)
Q0–Q6 / Q7Segments a–g / DP, chacun via une résistanceIdentiqueIdentique
C++ (Arduino IDE)
1// 74HC595 + ortak katotlu 7 segment: 0-9 sayacı / 0-9 counter
2const byte DATA_PIN = 11;    // DS (14)
3const byte CLOCK_PIN = 13;   // SH_CP (11)
4const byte LATCH_PIN = 10;   // ST_CP (12)
5const bool ORTAK_ANOT = false;   // ortak anotsa true / true for common anode
6
7// bit 0 = a ... bit 6 = g, bit 7 = DP
8const byte RAKAMLAR[10] = {0x3F, 0x06, 0x5B, 0x4F, 0x66, 0x6D, 0x7D, 0x07, 0x7F, 0x6F};
9
10void yaz595(byte desen) {
11  if (ORTAK_ANOT) desen = ~desen;                    // segmentler LOW ile yanar / segments light on LOW
12  digitalWrite(LATCH_PIN, LOW);
13  shiftOut(DATA_PIN, CLOCK_PIN, MSBFIRST, desen);    // bit 7 önce -> Q7 / bit 7 first -> Q7
14  digitalWrite(LATCH_PIN, HIGH);                     // çıkışlara aktar / copy to the outputs
15}
16
17void setup() {
18  pinMode(DATA_PIN, OUTPUT);
19  pinMode(CLOCK_PIN, OUTPUT);
20  pinMode(LATCH_PIN, OUTPUT);
21}
22
23void loop() {
24  for (byte i = 0; i < 10; i++) {
25    byte desen = RAKAMLAR[i];
26    if (i % 2 == 1) desen |= 0x80;                   // tek sayılarda noktayı yak / DP on odd digits
27    yaz595(desen);
28    delay(700);
29  }
30}

Écrire directement dans les registres : PORTB et DDRB

Sur l'ATmega328P de l'Uno, les broches sont regroupées par 8 en ports, et chaque port possède trois registres : DDRx contient la direction (1 = sortie), PORTx le niveau de sortie et PINx le niveau lu. Les broches D8–D13 sont sur le port B ; D13 (la LED intégrée) correspond à PB5, le bit 5 de PORTB. pinMode et digitalWrite modifient en fait ces bits, mais comme ils traduisent d'abord le numéro de broche en port, ils prennent quelques microsecondes. Écrire directement dans le registre est une seule instruction machine qui s'exécute en 2 cycles d'horloge à 16 MHz, soit environ 125 nanosecondes. Cela permet aussi de modifier plusieurs broches d'un même port exactement au même instant.

Broche UnoPort et bitBroche UnoPort et bit
D0–D7PD0–PD7 (PORTD)D8–D13PB0–PB5 (PORTB)
A0–A5PC0–PC5 (PORTC)D13 (LED intégrée)PB5
C++ (Arduino IDE)
1// Uno: D13'ü register ile yönet / drive D13 through registers (ATmega328P)
2void setup() {
3  Serial.begin(9600);
4  DDRB |= (1 << DDB5);                // D13 çıkış (pinMode) / D13 as output
5  DDRD &= ~(1 << DDD2);               // D2 giriş / D2 as input
6  PORTD |= (1 << PORTD2);             // D2 dahili pull-up / internal pull-up on D2
7}
8
9void loop() {
10  PORTB |= (1 << PORTB5);             // D13 HIGH
11  delay(200);
12  PORTB &= ~(1 << PORTB5);            // D13 LOW
13  delay(200);
14  PINB = (1 << PINB5);                // PINx'e 1 yazmak pini tersler / writing 1 to PINx toggles
15  delay(200);
16  PINB = (1 << PINB5);
17  bool buton = !(PIND & (1 << PIND2));   // D2 GND'ye çekilince true / true when D2 is pulled to GND
18  Serial.println(buton ? "Basili / Pressed" : "Serbest / Released");
19}
Le code de registres est propre à chaque carte : une ligne PORTB qui fonctionne sur l'Uno pilote d'autres broches sur un Mega, ne pilote rien sur un ESP32 ou une Pico et n'y compile même pas. De plus, les bits 0 et 1 de PORTD sont les broches du port série ; une ligne qui écrit tout le port d'un coup, comme PORTD = 0xFF, peut perturber Serial. Ne modifie que les bits qui t'intéressent avec un masque, et réserve le code de registres aux endroits où la vitesse compte vraiment.

Piloter des broches par registre sur l'ESP32

Sur l'ESP32, les broches sont pilotées par des registres de 32 bits et, contrairement à l'AVR, il existe des registres séparés de mise à 1 et de mise à 0 : chaque bit à 1 écrit dans GPIO_OUT_W1TS_REG (write 1 to set) met la broche correspondante à HIGH, chaque bit à 1 écrit dans GPIO_OUT_W1TC_REG (write 1 to clear) la met à LOW, et les bits à 0 ne touchent aucune broche. Comme il n'y a pas de lecture-modification-écriture, c'est sûr avec les interruptions et entre les deux cœurs. Ces deux registres ne couvrent que les GPIO 0–31 ; à partir de 32, on utilise les registres GPIO_OUT1.

C++ (Arduino IDE)
1// ESP32: GPIO 2'yi W1TS / W1TC register'larıyla yak-söndür
2// ESP32: blink GPIO 2 with the W1TS / W1TC registers
3#include "soc/gpio_reg.h"
4
5const int LED_PIN = 2;                         // birçok kartta dahili LED / onboard LED on many boards
6
7void setup() {
8  pinMode(LED_PIN, OUTPUT);                    // yön ve pin işlevi / direction and pin function
9}
10
11void loop() {
12  REG_WRITE(GPIO_OUT_W1TS_REG, 1UL << LED_PIN);   // HIGH (yalnız bu bit) / HIGH (only this bit)
13  delay(300);
14  REG_WRITE(GPIO_OUT_W1TC_REG, 1UL << LED_PIN);   // LOW
15  delay(300);
16}

Assembler et séparer les données d'un capteur

Les capteurs I2C et SPI envoient généralement leurs mesures 16 bits sous forme de deux octets séparés : d'abord l'octet de poids fort (MSB), puis l'octet de poids faible (LSB). Pour les assembler, décale l'octet fort de 8 positions vers la gauche et combine-le avec l'octet faible par un OR : int16_t brut = (msb << 8) | lsb;. Si un accéléromètre envoie 0xFC et 0x18, par exemple, le résultat vaut 0xFC18 ; lu en int16_t, ce nombre vaut -1000 car le bit de gauche vaut 1. Dans l'autre sens, pour envoyer un nombre ou l'écrire en EEPROM, il existe highByte(x) et lowByte(x), et word(fort, faible) pour réunir deux octets. La communication I2C elle-même est expliquée dans Qu'est-ce que l'I2C ?, et un capteur qui travaille avec des données brutes sur deux octets dans l'article MPU6050.

ExpressionRésultatExplication
(0xFC << 8) | 0x180xFC18Assemble deux octets en un nombre de 16 bits
(int16_t)0xFC18-1000Négatif en lecture signée car le bit de gauche vaut 1
highByte(1000)0x031000 = 0x03E8 ; l'octet de poids fort
lowByte(1000)0xE8L'octet de poids faible (232)
word(0x03, 0xE8)1000Réunit à nouveau les deux octets
(etat >> 4) & 0x0FQuartet hautExtrait les 4 bits supérieurs d'un octet (par ex. un champ de registre)

Les bits sur la Raspberry Pi Pico et en MicroPython

Les mêmes opérateurs s'appliquent en MicroPython, avec en plus des fonctions de conversion prêtes à l'emploi : bin(), hex() et int(texte, base). Comme les entiers Python grandissent sans limite, il faut masquer les résultats de ~ et << avec & 0xFF si tu veux qu'ils tiennent dans un octet. La puce RP2040 de la Pico possède elle aussi des registres séparés de mise à 1, de mise à 0 et de XOR, comme l'ESP32, et tu peux y écrire directement avec machine.mem32. Le code ci-dessous fait clignoter la LED intégrée de la Pico sur GP25 avec le registre XOR (sur la Pico W, la LED intégrée est reliée à la puce Wi-Fi ; utilise alors une LED externe).

MicroPython
1from machine import Pin, mem32
2import time
3
4x = 181
5print(bin(x), hex(x))                          # 0b10110101 0xb5
6print("{:08b}".format(12))                     # 00001100 (baştaki sıfırlarla / with leading zeros)
7print(int("10110101", 2), int("B5", 16))       # 181 181
8
9a, b = 0b11001010, 0b10101100
10print(a & b, a | b, a ^ b)                     # 136 238 102
11print(~a & 0xFF, (a << 1) & 0xFF, a >> 2)      # 53 148 50 (bayta sığdırılmış / masked to a byte)
12
13led = Pin(25, Pin.OUT)                         # pin işlevini ve yönü ayarla / set function and direction
14SIO_GPIO_OUT_XOR = 0xD000001C                  # RP2040 SIO: çıkışı tersle / toggle outputs
15for _ in range(6):
16    mem32[SIO_GPIO_OUT_XOR] = 1 << 25          # yalnız GP25'i tersle / toggle only GP25
17    time.sleep_ms(250)

Idées de projets avec les opérations sur les bits

  • Compteur binaire : réalise un compteur qui compte de 0 à 255 sur 8 LED et vois le système binaire de tes propres yeux ; un bouton ajoute un, l'autre retire un.
  • Effet K2000 : décale un octet avec << et >> pour faire aller et venir les LED ; montage pas à pas dans l'article effet K2000 et chenillard.
  • Horloge numérique : affiche l'heure sur un afficheur 7 segments à quatre chiffres et fais clignoter chaque seconde le point du deuxième chiffre avec le masque 0x80.
  • Icônes sur matrice LED : dessine chaque ligne d'une matrice 8×8 comme un octet et crée cœurs, flèches ou lettres avec 0b. L'article matrice LED MAX7219 utilise cette méthode.
  • Drapeaux de réglages : garde des réglages marche/arrêt comme son activé, écran lumineux ou alarme réglée dans les bits d'un seul octet et écris-les en EEPROM en une fois.
  • Choix d'adresse par DIP switch : lis un DIP switch à 4 interrupteurs pour obtenir une adresse d'appareil entre 0 et 15.

Erreurs fréquentes et solutions

ErreurQue se passe-t-il ?Forme correcte
if (x & 0x04 == 0)== est évalué en premier, l'expression devient x & 0 et est toujours fausseif ((x & 0x04) == 0)
Utiliser 2 ^ 3 comme puissance^ est un XOR ; 2 ^ 3 = 11 << 3 ou pow(2, 3)
1 << 15 ou 1 << 20 sur l'UnoL'int 16 bits déborde : -32768 ou 01UL << 20 (unsigned long)
Croire que Serial.println(x, BIN) affiche 8 bitsLes zéros de tête ne s'affichent pas : 12 → 1100Afficher 8 bits dans une boucle avec bitRead
Mettre un 0 devant un nombre (010)Il devient octal : 010 = 8Retirer les zéros de tête des nombres décimaux
Utiliser le résultat de ~ dans un intLes bits supérieurs sont aussi inversés : ~0x0F = -16Affecter le résultat à un byte ou masquer avec & 0xFF
Écrire && au lieu de &Deux conditions sont comparées, pas des bitsUn seul & pour les bits, && pour les conditions
Si tu as un doute sur une opération de bits, affiche le résultat sous trois formes : Serial.println(x), Serial.println(x, BIN) et Serial.println(x, HEX). Voir la même valeur en décimal, en binaire et en hexadécimal montre tout de suite si le masque ou le décalage a touché les bits attendus.

Les nombres binaires et hexadécimaux et les opérations sur les bits paraissent abstraits au début, mais on les rencontre chaque jour en électronique, du pilotage d'une rangée de LED avec un seul octet à l'assemblage de données de capteurs. Appris avec les bases de la programmation Arduino, ils rendent ton code plus court et plus rapide. Dans l'application BlueGrays, tu peux explorer des compteurs 7 segments, une horloge numérique, des chenillards, l'effet K2000 et des projets de matrice LED, avec des schémas pas à pas et un code écrit avec ces opérations sur les bits.

Questions fréquentes

Qu'est-ce que le système binaire ?

Le système binaire n'utilise que les chiffres 0 et 1, et chaque position vaut le double de la précédente. De droite à gauche, les poids sont 1, 2, 4, 8, 16, 32, 64, 128. Comme dans les circuits numériques 1 représente une tension haute et 0 une tension basse, tous les ordinateurs et microcontrôleurs fonctionnent avec ce système.

Comment convertir un nombre décimal en binaire ?

Divise le nombre par 2 jusqu'à obtenir 0 en notant le reste à chaque étape ; en lisant les restes de bas en haut, tu obtiens le nombre binaire. Pour 13 : 6 reste 1, 3 reste 0, 1 reste 1, 0 reste 1, et le résultat est 1101. Pour vérifier, additionne les poids des 1 : 8 + 4 + 1 = 13.

Pourquoi utilise-t-on l'hexadécimal ?

Chaque chiffre hexadécimal correspond exactement à 4 bits, c'est donc la façon la plus simple d'écrire de longs nombres binaires de manière courte et sans erreur. Un octet de 8 bits s'écrit avec deux chiffres hex, par exemple B5 au lieu de 10110101. C'est pourquoi les adresses I2C, les codes couleur, les valeurs de registres et les adresses mémoire sont toujours donnés en hex.

Que signifient 0b et 0x sur Arduino ?

Les nombres qui commencent par 0b sont lus en binaire et ceux qui commencent par 0x en hexadécimal ; 0b10110101, 0xB5 et 181 sont le même nombre. La forme choisie est indifférente pour le compilateur, elle ne joue que sur la lisibilité. Arduino accepte aussi la forme 8 bits B10110101 des anciens codes.

À quoi servent bitRead et bitWrite ?

bitRead(x, n) renvoie le bit numéro n de x sous forme de 0 ou de 1 ; bitWrite(x, n, v) met ce même bit à la valeur v. bitSet et bitClear mettent directement un bit à 1 ou à 0. Ces fonctions rendent les masques et les décalages lisibles ; les numéros de bit commencent à 0.

Que font les opérateurs << et >> sur Arduino ?

<< décale les bits vers la gauche et multiplie le nombre par 2 à chaque pas ; >> les décale vers la droite et divise par 2 à chaque pas. 1 << 3 vaut 8, et c'est ainsi qu'on construit les masques qui sélectionnent un seul bit. Comme l'int fait 16 bits sur l'Uno, il faut écrire 1UL << n pour les décalages supérieurs à 15.

Voir tous les projets
Chenillard à LED
AR-5Intermédiaire

Chenillard à LED

Des lumières qui s'allument l'une après l'autre, comme si elles couraient. L'Arduino allume six LED une par une ; chacune brille un court instant puis s'éteint, et la lumière parcourt la rangée du…

4.6(87)
218
Chenillard K2000 à LED
AR-6Intermédiaire

Chenillard K2000 à LED

Le fameux balayage lumineux : un point de lumière glisse d'un bout à l'autre de six LED, puis revient.

4.8(107)
214
Afficher les chiffres de 0 à 9 sur un afficheur 7 segments
AR-41Intermédiaire
Premium

Afficher les chiffres de 0 à 9 sur un afficheur 7 segments

Affiche toi-même ces chiffres familiers des ascenseurs et des réveils numériques.

4.5(30)
43
Afficher les nombres de 0 à 99 sur un afficheur 7 segments
AR-42Avancé
Premium

Afficher les nombres de 0 à 99 sur un afficheur 7 segments

Un afficheur à deux chiffres fait de petits segments, comme sur une calculatrice, compte de 0 à 99.

4.5(27)
35
Afficher 0-9999 sur un afficheur 7 segments à 4 chiffres
AR-47Intermédiaire
Premium

Afficher 0-9999 sur un afficheur 7 segments à 4 chiffres

Sur un afficheur à quatre chiffres, les nombres défilent à toute vitesse de 0 à 9999, puis repartent de zéro.

4.4(19)
25
Horloge numérique avec afficheur 7 segments à 4 chiffres
AR-48Intermédiaire
Premium

Horloge numérique avec afficheur 7 segments à 4 chiffres

Une horloge numérique lumineuse à quatre chiffres, comme celle du four de la cuisine.

4.8(56)
73
Horloge et calendrier matriciel (MAX7219, DS1307)
AR-84Intermédiaire
Premium

Horloge et calendrier matriciel (MAX7219, DS1307)

Un panneau lumineux pour ton bureau ou ton mur, qui affiche l'heure et la date en texte défilant.

5.0(37)
59
Serpent à pixels Matrice 8x8
AR-88Avancé
Premium

Serpent à pixels Matrice 8x8

Construis de tes mains le jeu classique du serpent et joue. Sur une matrice lumineuse colorée de 8x8, tu guides un serpent vert avec un joystick et tu manges des pommes rouges ; à chaque pomme, le…

4.7(39)
57