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écimal | Binaire | Hex | Décimal | Binaire | Hex |
|---|---|---|---|---|---|
| 0 | 0000 | 0 | 8 | 1000 | 8 |
| 1 | 0001 | 1 | 9 | 1001 | 9 |
| 2 | 0010 | 2 | 10 | 1010 | A |
| 3 | 0011 | 3 | 11 | 1011 | B |
| 4 | 0100 | 4 | 12 | 1100 | C |
| 5 | 0101 | 5 | 13 | 1101 | D |
| 6 | 0110 | 6 | 14 | 1110 | E |
| 7 | 0111 | 7 | 15 | 1111 | F |
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.
| Poids | 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 |
|---|---|---|---|---|---|---|---|---|
| 10110101 (181) | 1 | 0 | 1 | 1 | 0 | 1 | 0 | 1 |
| 00001100 (12) | 0 | 0 | 0 | 0 | 1 | 1 | 0 | 0 |
| 11111111 (255) | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 |
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.
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.
| Taille | Type Arduino | Plage non signée | Plage signée |
|---|---|---|---|
| 8 bits (1 octet) | byte, uint8_t / int8_t | 0–255 | -128 à 127 |
| 16 bits (2 octets) | int sur l'Uno, word, uint16_t | 0–65535 | -32768 à 32767 |
| 32 bits (4 octets) | long, uint32_t ; int sur ESP32 et Pico | 0–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.
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}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ération | Que fait-elle ? | Résultat (binaire) | Hex | Décimal |
|---|---|---|---|---|
| a & b | Bits à 1 dans les deux | 10001000 | 0x88 | 136 |
| a | b | Bits à 1 dans au moins un | 11101110 | 0xEE | 238 |
| a ^ b | Bits qui diffèrent | 01100110 | 0x66 | 102 |
| ~a (byte) | Tous les bits inversés | 00110101 | 0x35 | 53 |
| a << 1 (byte) | Une position vers la gauche, le bit de gauche est perdu | 10010100 | 0x94 | 148 |
| a >> 2 | Deux positions vers la droite, les deux bits de droite sont perdus | 00110010 | 0x32 | 50 |
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 :
| But | Avec un masque | Fonction Arduino | Exemple (n = 3) |
|---|---|---|---|
| Mettre le bit à 1 | x |= (1 << n); | bitSet(x, n); | 00000000 → 00001000 |
| Mettre le bit à 0 | x &= ~(1 << n); | bitClear(x, n); | 11111111 → 11110111 |
| Inverser le bit | x ^= (1 << n); | bitWrite(x, n, !bitRead(x, n)); | 00001000 → 00000000 |
| Lire (tester) le bit | (x >> n) & 1 | bitRead(x, n); | 00001000 → 1 |
| Écrire une valeur dans le bit | x = (x & ~(1 << n)) | (v << n); | bitWrite(x, n, v); | v = 1 → 00001000 |
| Poids du bit n | 1 << n | bit(n); | bit(3) = 8 |
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.
| Chiffre | Segments allumés | Binaire (DP g f e d c b a) | Cathode commune | Anode commune (~) |
|---|---|---|---|---|
| 0 | a b c d e f | 00111111 | 0x3F | 0xC0 |
| 1 | b c | 00000110 | 0x06 | 0xF9 |
| 2 | a b d e g | 01011011 | 0x5B | 0xA4 |
| 3 | a b c d g | 01001111 | 0x4F | 0xB0 |
| 4 | b c f g | 01100110 | 0x66 | 0x99 |
| 5 | a c d f g | 01101101 | 0x6D | 0x92 |
| 6 | a c d e f g | 01111101 | 0x7D | 0x82 |
| 7 | a b c | 00000111 | 0x07 | 0xF8 |
| 8 | a b c d e f g | 01111111 | 0x7F | 0x80 |
| 9 | a b c d f g | 01101111 | 0x6F | 0x90 |
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.
| Connexion | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| DS (14), données série | D11 | GPIO 23 | GP19 |
| SH_CP (11), horloge | D13 | GPIO 18 | GP18 |
| ST_CP (12), verrou (latch) | D10 | GPIO 5 | GP17 |
| OE (13) / MR (10) | GND / 5V | GND / 3V3 | GND / 3V3(OUT) |
| Q0–Q6 / Q7 | Segments a–g / DP, chacun via une résistance | Identique | Identique |
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 Uno | Port et bit | Broche Uno | Port et bit |
|---|---|---|---|
| D0–D7 | PD0–PD7 (PORTD) | D8–D13 | PB0–PB5 (PORTB) |
| A0–A5 | PC0–PC5 (PORTC) | D13 (LED intégrée) | PB5 |
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}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.
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.
| Expression | Résultat | Explication |
|---|---|---|
| (0xFC << 8) | 0x18 | 0xFC18 | Assemble deux octets en un nombre de 16 bits |
| (int16_t)0xFC18 | -1000 | Négatif en lecture signée car le bit de gauche vaut 1 |
| highByte(1000) | 0x03 | 1000 = 0x03E8 ; l'octet de poids fort |
| lowByte(1000) | 0xE8 | L'octet de poids faible (232) |
| word(0x03, 0xE8) | 1000 | Réunit à nouveau les deux octets |
| (etat >> 4) & 0x0F | Quartet haut | Extrait 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).
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
| Erreur | Que se passe-t-il ? | Forme correcte |
|---|---|---|
| if (x & 0x04 == 0) | == est évalué en premier, l'expression devient x & 0 et est toujours fausse | if ((x & 0x04) == 0) |
| Utiliser 2 ^ 3 comme puissance | ^ est un XOR ; 2 ^ 3 = 1 | 1 << 3 ou pow(2, 3) |
| 1 << 15 ou 1 << 20 sur l'Uno | L'int 16 bits déborde : -32768 ou 0 | 1UL << 20 (unsigned long) |
| Croire que Serial.println(x, BIN) affiche 8 bits | Les zéros de tête ne s'affichent pas : 12 → 1100 | Afficher 8 bits dans une boucle avec bitRead |
| Mettre un 0 devant un nombre (010) | Il devient octal : 010 = 8 | Retirer les zéros de tête des nombres décimaux |
| Utiliser le résultat de ~ dans un int | Les bits supérieurs sont aussi inversés : ~0x0F = -16 | Affecter le résultat à un byte ou masquer avec & 0xFF |
| Écrire && au lieu de & | Deux conditions sont comparées, pas des bits | Un seul & pour les bits, && pour les conditions |
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.
Projets à réaliser après cet article
Voir tous les projets
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…

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

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.

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.

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.

Horloge numérique avec afficheur 7 segments à 4 chiffres
Une horloge numérique lumineuse à quatre chiffres, comme celle du four de la cuisine.

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.

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…
Autres articles
Application BlueGrays
Réalise ce montage pas à pas sur ton téléphone
Schéma, code et liste des composants sur un seul écran. Plus de 500 projets Arduino, ESP32 et Pico à réaliser.
Scanne avec ton téléphone
Pointe l’appareil photo vers le code : la boutique d’applications de ton téléphone s’ouvre.
ou ouvre la boutique

