Sistema binario ed esadecimale: operazioni sui bit con Arduino
Sistema binario, conversioni esadecimale e decimale, bit e byte, 0b e 0x su Arduino, &, |, ^, ~, <<, >> con bitRead, esempi con 74HC595 e registri.
Il sistema binario usa solo le cifre 0 e 1 ed è la base di tutta l'elettronica digitale. Ogni pin, ogni registro e ogni byte della memoria di un Arduino è in realtà un numero binario fatto di interruttori accesi o spenti: 1 significa che un pin è HIGH, 0 che è LOW. Espressioni che trovi nel codice come 0b10110101, 0xB5 o PORTB |= (1 << 5) possono spaventare, ma una volta capiti binario ed esadecimale si riducono tutte a poche regole semplici.
In questa guida vedrai prima come convertire a mano numeri decimali, binari ed esadecimali tra loro, cosa sono bit, nibble e byte e come vengono memorizzati i numeri negativi. Poi imparerai a scrivere numeri su Arduino con 0b e 0x, a leggere e cambiare un singolo bit con AND, OR, XOR, NOT e scorrimenti, e a usare le funzioni bitRead, bitWrite e bitSet. Infine preparerai byte per un display a 7 segmenti e un 74HC595 e scriverai direttamente nei registri di Uno, ESP32 e Pico.
Che cos'è un sistema di numerazione? Decimale, binario ed esadecimale
Il sistema decimale che usiamo ogni giorno ha 10 cifre e ogni posizione vale 10 volte la precedente: 181 è 1×100 + 8×10 + 1×1. Il sistema binario ha solo due cifre e ogni posizione vale il doppio della precedente; da destra a sinistra i pesi sono 1, 2, 4, 8, 16, 32, 64, 128. Il sistema esadecimale (hex) ha 16 cifre: dopo 0–9 vengono A=10, B=11, C=12, D=13, E=14, F=15. L'hex è così amato in elettronica perché ogni cifra esadecimale corrisponde esattamente a 4 bit; è il modo più pratico per scrivere numeri binari lunghi in forma breve e leggibile.
| Decimale | Binario | Hex | Decimale | Binario | 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 |
Conversioni tra decimale, binario ed esadecimale
Per passare da decimale a binario dividi il numero per 2 più volte e annoti i resti; leggendo i resti dal basso verso l'alto ottieni il numero binario. Per 181: 181/2 = 90 resto 1, 90/2 = 45 resto 0, 45/2 = 22 resto 1, 22/2 = 11 resto 0, 11/2 = 5 resto 1, 5/2 = 2 resto 1, 2/2 = 1 resto 0, 1/2 = 0 resto 1. Letto dal basso verso l'alto diventa 10110101. Passare da binario a decimale è più facile: sommi i pesi delle posizioni che contengono un 1. 10110101 = 128 + 32 + 16 + 4 + 1 = 181.
| Peso | 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 |
Per passare da binario a hex dividi i bit in gruppi di quattro partendo da destra e sostituisci ogni gruppo con la sua cifra esadecimale della tabella: 1011 0101 → B 5 → 0xB5. Al contrario è altrettanto facile: 0x3C → 0011 1100. Per passare da hex a decimale moltiplica ogni cifra per una potenza di 16: 0xB5 = 11×16 + 5 = 181, 0x3FF = 3×256 + 15×16 + 15 = 1023. L'ultimo esempio ti suonerà familiare: il limite superiore del valore a 10 bit di analogRead sull'Uno è 1023, cioè dieci 1. Il legame tra lettura analogica e numero di bit è spiegato nell'articolo sull'ADC.
Bit, nibble, byte e intervalli di valori
Una singola cifra binaria si chiama bit. 4 bit formano un nibble, cioè una cifra esadecimale; 8 bit formano un byte, che si scrive con due cifre hex. Il bit più a destra di un byte è il bit meno significativo (LSB, bit 0), quello più a sinistra il più significativo (MSB, bit 7). I numeri dei bit partono sempre da 0, quindi i bit di un numero a 8 bit sono numerati da 0 a 7. Con n bit si possono scrivere 2ⁿ valori diversi: 8 bit danno 256 valori, 10 bit 1024 e 16 bit 65536.
| Dimensione | Tipo Arduino | Intervallo senza segno | Intervallo con segno |
|---|---|---|---|
| 8 bit (1 byte) | byte, uint8_t / int8_t | 0–255 | da -128 a 127 |
| 16 bit (2 byte) | int sull'Uno, word, uint16_t | 0–65535 | da -32768 a 32767 |
| 32 bit (4 byte) | long, uint32_t; int su ESP32 e Pico | 0–4.294.967.295 | da -2.147.483.648 a 2.147.483.647 |
Numeri negativi: il complemento a due
I microcontrollori memorizzano i numeri negativi in complemento a due: in un numero con segno, se il bit più a sinistra è 1 il numero è negativo. Per ottenere l'opposto di un numero inverti tutti i bit e aggiungi 1. 5 = 00000101; invertito 11111010; aggiungendo 1 si ottiene 11111011 = 0xFB, cioè -5. La stessa sequenza di bit è un numero diverso a seconda di come la leggi: 0xFF vale 255 come byte e -1 come int8_t. Per questo è così importante assegnare al tipo giusto i byte grezzi di un sensore. Quando una variabile supera il suo limite superiore ricomincia da capo: in un byte 255 + 1 = 0, con un int sull'Uno 32767 + 1 = -32768; si chiama overflow (traboccamento).
Scrivere numeri con 0b, 0x e B su Arduino
Nel codice Arduino puoi scrivere lo stesso numero in tre modi senza alcuna differenza per il compilatore: 181 (decimale), 0b10110101 (binario, standard da C++14) e 0xB5 (esadecimale). Arduino riconosce anche la forma B10110101 rimasta dal codice più vecchio, ma sono costanti definite solo per valori a 8 bit e nel codice nuovo è meglio 0b. La scelta dipende dalla leggibilità: il binario è il più chiaro per schemi di LED e impostazioni dei registri, l'hex per indirizzi e codici colore, il decimale per le misure.
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}Operazioni sui bit: &, |, ^, ~, << e >>
Le operazioni sui bit confrontano uno per uno i bit nella stessa posizione di due numeri. AND (&) dà 1 solo se entrambi i bit sono 1; OR (|) dà 1 se almeno uno dei bit è 1; XOR (^) dà 1 se i bit sono diversi; NOT (~) inverte tutti i bit. Lo scorrimento a sinistra (<<) sposta i bit verso sinistra e aggiunge 0 a destra, moltiplicando il numero per 2 a ogni passo; lo scorrimento a destra (>>) li sposta verso destra e divide per 2 a ogni passo. Sono la versione software delle porte logiche; puoi vederne le tabelle di verità nell'articolo porte logiche e nello strumento delle porte logiche. La tabella mostra i risultati per a = 0b11001010 (202) e b = 0b10101100 (172):
| Operazione | Cosa fa? | Risultato (binario) | Hex | Decimale |
|---|---|---|---|---|
| a & b | Bit che valgono 1 in entrambi | 10001000 | 0x88 | 136 |
| a | b | Bit che valgono 1 in almeno uno | 11101110 | 0xEE | 238 |
| a ^ b | Bit diversi | 01100110 | 0x66 | 102 |
| ~a (byte) | Tutti i bit invertiti | 00110101 | 0x35 | 53 |
| a << 1 (byte) | Una posizione a sinistra, il bit di sinistra si perde | 10010100 | 0x94 | 148 |
| a >> 2 | Due posizioni a destra, si perdono i due bit di destra | 00110010 | 0x32 | 50 |
Nota due dettagli della tabella. Se il risultato di a << 1 viene salvato in un byte, il bit di sinistra esce e resta 148; la stessa operazione in un int dà 404, perché in un int c'è spazio per il bit che trabocca. Con ~a succede qualcosa di simile: come byte vale 53, ma calcolato come int vengono invertiti anche i bit superiori e il risultato è -203. Nelle operazioni sui bit devi sempre sapere in quale tipo finisce il risultato. E non confondere & con &&: il primo lavora bit per bit, il secondo verifica se due condizioni sono vere.
Maschere di bit: leggere, impostare e azzerare un singolo bit
Nei progetti reali le operazioni sui bit si usano quasi sempre con una maschera. Una maschera è un numero in cui valgono 1 solo i bit che ti interessano, e di solito si costruisce con (1 << n): (1 << 3) = 0b00001000. Con una maschera si fanno quattro operazioni di base, e Arduino offre una funzione pronta per ciascuna. Il codice seguente tiene lo stato di 8 LED in un solo byte invece che in 8 variabili bool e lo riporta sui LED collegati a D2–D9:
| Obiettivo | Con la maschera | Funzione Arduino | Esempio (n = 3) |
|---|---|---|---|
| Portare il bit a 1 | x |= (1 << n); | bitSet(x, n); | 00000000 → 00001000 |
| Portare il bit a 0 | x &= ~(1 << n); | bitClear(x, n); | 11111111 → 11110111 |
| Invertire il bit | x ^= (1 << n); | bitWrite(x, n, !bitRead(x, n)); | 00001000 → 00000000 |
| Leggere (testare) il bit | (x >> n) & 1 | bitRead(x, n); | 00001000 → 1 |
| Scrivere un valore nel bit | x = (x & ~(1 << n)) | (v << n); | bitWrite(x, n, v); | v = 1 → 00001000 |
| Peso del 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}Preparare i byte per un display a 7 segmenti
Gli otto elementi di un display a 7 segmenti (segmenti a–g e il punto) stanno esattamente in un byte. Se assegni il bit 0 al segmento a, il bit 6 al segmento g e il bit 7 al punto decimale (DP), ogni cifra si esprime con un solo numero. Il 2, per esempio, si disegna con i segmenti a, b, d, e e g: 1 + 2 + 8 + 16 + 64 = 91 = 0x5B. Nei display ad anodo comune un segmento si accende con LOW, quindi inverti la stessa tabella con ~. Per i dettagli del collegamento dei segmenti leggi l'articolo display a 7 segmenti.
| Cifra | Segmenti accesi | Binario (DP g f e d c b a) | Catodo comune | Anodo comune (~) |
|---|---|---|---|---|
| 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 |
Inviare il byte alle uscite con un 74HC595
Lo shift register 74HC595 distribuisce un byte su otto uscite usando solo tre pin, ed è il chip in cui le operazioni sui bit si vedono meglio: ogni bit del byte inviato accende o spegne un'uscita. Con MSBFIRST, shiftOut invia per primo il bit 7, che finisce in Q7, mentre il bit 0 arriva in Q0. Quindi se colleghi Q0 al segmento a, Q6 al g e Q7 al DP, la tabella precedente funziona direttamente. Per tutti i pin del chip e il collegamento in cascata leggi l'articolo shift register 74HC595.
| Collegamento | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| DS (14), dati seriali | D11 | GPIO 23 | GP19 |
| SH_CP (11), clock | D13 | GPIO 18 | GP18 |
| ST_CP (12), latch | D10 | GPIO 5 | GP17 |
| OE (13) / MR (10) | GND / 5V | GND / 3V3 | GND / 3V3(OUT) |
| Q0–Q6 / Q7 | Segmenti a–g / DP, ognuno con la sua resistenza | Uguale | Uguale |
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}Scrivere direttamente nei registri: PORTB e DDRB
Nell'ATmega328P dell'Uno i pin sono raggruppati a 8 a 8 in porte, e ogni porta ha tre registri: DDRx contiene la direzione (1 = uscita), PORTx il livello d'uscita e PINx il livello letto. I pin D8–D13 sono sulla porta B; D13 (il LED integrato) è PB5, cioè il bit 5 di PORTB. pinMode e digitalWrite in realtà cambiano questi bit, ma poiché prima traducono il numero del pin in una porta impiegano qualche microsecondo. Scrivere direttamente nel registro è una sola istruzione macchina che a 16 MHz richiede 2 cicli di clock, circa 125 nanosecondi. Inoltre permette di cambiare più pin della stessa porta esattamente nello stesso istante.
| Pin Uno | Porta e bit | Pin Uno | Porta e bit |
|---|---|---|---|
| D0–D7 | PD0–PD7 (PORTD) | D8–D13 | PB0–PB5 (PORTB) |
| A0–A5 | PC0–PC5 (PORTC) | D13 (LED integrato) | 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}Comandare i pin tramite registri sull'ESP32
Sull'ESP32 i pin sono comandati da registri a 32 bit e, a differenza dell'AVR, esistono registri separati per impostare e azzerare: ogni bit a 1 scritto in GPIO_OUT_W1TS_REG (write 1 to set) porta HIGH il pin corrispondente, ogni bit a 1 scritto in GPIO_OUT_W1TC_REG (write 1 to clear) lo porta LOW, mentre i bit a 0 non toccano nessun pin. Poiché non serve leggere, modificare e riscrivere, è sicuro con gli interrupt e tra i due core. Questi due registri coprono solo i GPIO 0–31; dal 32 in su si usano i registri 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}Unire e separare i dati dei sensori
I sensori I2C e SPI di solito inviano le misure a 16 bit come due byte separati: prima il byte alto (MSB), poi il byte basso (LSB). Per unirli sposti il byte alto di 8 posizioni a sinistra e lo combini in OR con il byte basso: int16_t grezzo = (msb << 8) | lsb;. Se un accelerometro invia 0xFC e 0x18, per esempio, il risultato è 0xFC18; letto come int16_t questo numero vale -1000, perché il bit di sinistra è 1. Nel verso opposto, per inviare un numero o scriverlo in EEPROM ci sono highByte(x) e lowByte(x), e word(alto, basso) per unire due byte. La comunicazione I2C è spiegata in Che cos'è l'I2C?, un sensore che lavora con dati grezzi a due byte nell'articolo MPU6050.
| Espressione | Risultato | Spiegazione |
|---|---|---|
| (0xFC << 8) | 0x18 | 0xFC18 | Unisce due byte in un numero a 16 bit |
| (int16_t)0xFC18 | -1000 | Negativo nella lettura con segno perché il bit di sinistra è 1 |
| highByte(1000) | 0x03 | 1000 = 0x03E8; il byte alto |
| lowByte(1000) | 0xE8 | Il byte basso (232) |
| word(0x03, 0xE8) | 1000 | Riunisce i due byte |
| (stato >> 4) & 0x0F | Nibble alto | Estrae i 4 bit superiori di un byte (es. un campo di registro) |
I bit su Raspberry Pi Pico e in MicroPython
In MicroPython valgono gli stessi operatori e in più ci sono funzioni di conversione pronte: bin(), hex() e int(testo, base). Poiché gli interi di Python crescono senza limiti, se vuoi che i risultati di ~ e << stiano in un byte devi mascherarli con & 0xFF. Anche il chip RP2040 del Pico ha registri separati per impostare, azzerare e invertire (XOR), come l'ESP32, e puoi scriverci direttamente con machine.mem32. Il codice seguente fa lampeggiare il LED integrato del Pico su GP25 con il registro XOR (sul Pico W il LED integrato è collegato al chip Wi-Fi, quindi lì usa un LED esterno).
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)Idee di progetto con le operazioni sui bit
- Contatore binario: realizza un contatore che conta da 0 a 255 su 8 LED e osserva il sistema binario con i tuoi occhi; un pulsante aggiunge uno, l'altro toglie uno.
- Effetto Supercar: fai scorrere un byte con << e >> perché i LED vadano avanti e indietro; il montaggio passo passo è nell'articolo effetto Supercar e LED in sequenza.
- Orologio digitale: mostra l'ora su un display a 7 segmenti a quattro cifre e fai lampeggiare ogni secondo il punto della seconda cifra con la maschera 0x80.
- Icone su matrice LED: disegna ogni riga di una matrice 8×8 come un byte e crea cuori, frecce o lettere con 0b. L'articolo matrice LED MAX7219 usa proprio questo metodo.
- Flag delle impostazioni: tieni impostazioni acceso/spento come suono attivo, schermo luminoso o sveglia impostata nei bit di un solo byte e scrivile in EEPROM in un colpo.
- Scelta dell'indirizzo con DIP switch: leggi un DIP switch a 4 vie per ottenere un indirizzo del dispositivo tra 0 e 15.
Errori comuni e soluzioni
| Errore | Cosa succede? | Forma corretta |
|---|---|---|
| if (x & 0x04 == 0) | == viene valutato per primo, l'espressione diventa x & 0 ed è sempre falsa | if ((x & 0x04) == 0) |
| Usare 2 ^ 3 come potenza | ^ è XOR; 2 ^ 3 = 1 | 1 << 3 oppure pow(2, 3) |
| 1 << 15 o 1 << 20 sull'Uno | L'int a 16 bit trabocca: -32768 o 0 | 1UL << 20 (unsigned long) |
| Pensare che Serial.println(x, BIN) stampi 8 bit | Gli zeri iniziali non vengono stampati: 12 → 1100 | Stampa 8 bit in un ciclo con bitRead |
| Mettere uno 0 davanti a un numero (010) | Diventa ottale: 010 = 8 | Togli gli zeri iniziali dai numeri decimali |
| Usare il risultato di ~ in un int | Si invertono anche i bit superiori: ~0x0F = -16 | Assegna il risultato a un byte o maschera con & 0xFF |
| Scrivere && invece di & | Si confrontano due condizioni, non i bit | Una sola & per i bit, && per le condizioni |
Numeri binari ed esadecimali e operazioni sui bit sembrano astratti all'inizio, ma in elettronica li incontri ogni giorno, dal comandare una fila di LED con un solo byte all'unire i dati dei sensori. Imparati insieme alle basi della programmazione Arduino, rendono il codice più corto e più veloce. Nell'app BlueGrays puoi esplorare contatori a 7 segmenti, un orologio digitale, LED in sequenza, l'effetto Supercar e progetti con matrice LED, con schemi passo passo e codice scritto con queste operazioni sui bit.
Domande frequenti
Che cos'è il sistema binario?
Il sistema binario usa solo le cifre 0 e 1 e ogni posizione vale il doppio della precedente. Da destra a sinistra i pesi sono 1, 2, 4, 8, 16, 32, 64, 128. Poiché nei circuiti digitali 1 rappresenta una tensione alta e 0 una bassa, tutti i computer e i microcontrollori lavorano con questo sistema.
Come si converte un numero decimale in binario?
Dividi il numero per 2 finché non arrivi a 0 e annota il resto a ogni passo; leggendo i resti dal basso verso l'alto ottieni il numero binario. Per 13: 6 resto 1, 3 resto 0, 1 resto 1, 0 resto 1, e il risultato è 1101. Per controllare sommi i pesi degli 1: 8 + 4 + 1 = 13.
Perché si usa il sistema esadecimale?
Ogni cifra esadecimale corrisponde esattamente a 4 bit, quindi è il modo più semplice per scrivere numeri binari lunghi in forma breve e senza errori. Un byte a 8 bit si scrive con due cifre hex, per esempio B5 invece di 10110101. Per questo indirizzi I2C, codici colore, valori dei registri e indirizzi di memoria sono sempre in hex.
Cosa significano 0b e 0x su Arduino?
I numeri che iniziano con 0b vengono letti in binario, quelli con 0x in esadecimale; 0b10110101, 0xB5 e 181 sono lo stesso numero. Quale forma scrivi non importa al compilatore, conta solo per la leggibilità. Arduino accetta anche la forma a 8 bit B10110101 del codice più vecchio.
A cosa servono bitRead e bitWrite?
bitRead(x, n) restituisce il bit numero n di x come 0 o 1; bitWrite(x, n, v) imposta lo stesso bit al valore v. bitSet e bitClear portano un bit direttamente a 1 o a 0. Queste funzioni rendono leggibili maschere e scorrimenti; i numeri dei bit partono da 0.
Cosa fanno gli operatori << e >> su Arduino?
<< sposta i bit a sinistra e moltiplica il numero per 2 a ogni passo; >> li sposta a destra e divide per 2 a ogni passo. 1 << 3 vale 8, ed è così che si costruiscono le maschere che selezionano un singolo bit. Poiché sull'Uno l'int è a 16 bit, per scorrimenti oltre 15 posizioni bisogna scrivere 1UL << n.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
LED in sequenza
Luci che si accendono una dopo l'altra, come se corressero. L'Arduino accende sei LED uno alla volta; ognuno brilla per un istante e si spegne, così la luce percorre la fila dall'inizio alla fine e…

Effetto Supercar con LED
La classica luce che va e viene: un punto luminoso scorre da un capo all'altro di sei LED e poi torna indietro.

Visualizzare i numeri da 0 a 9 su display a 7 segmenti
Scrivi tu stesso quei numeri familiari degli ascensori e degli orologi digitali. Su un display fatto di sette piccole barre luminose, l'Arduino mostra una cifra da 0 a 9 ogni secondo e poi ricomincia.

Visualizzare i numeri da 0 a 99 su display a 7 segmenti
Un display a due cifre fatto di piccoli segmenti, come quello di una calcolatrice, conta da 0 a 99.

Numeri da 0 a 9999 su display a 7 segmenti a 4 cifre
Su un display a quattro cifre i numeri corrono da 0 a 9999 e poi ripartono da zero.

Orologio digitale con display a 7 segmenti a 4 cifre
Un orologio digitale luminoso a quattro cifre, simile a quello del forno in cucina.

Orologio e calendario a matrice di punti (MAX7219, DS1307)
Un pannello luminoso per la scrivania o la parete che mostra ora e data con scritte scorrevoli.

Serpente di pixel Matrice 8x8
Costruisci con le tue mani il classico gioco del serpente e giocaci. Su una matrice di luci colorate 8x8 guidi un serpente verde con un joystick e mangi mele rosse; a ogni mela il serpente si…
Altri articoli
App BlueGrays
Costruisci questo circuito passo passo sul telefono
Schema, codice ed elenco componenti in un’unica schermata. Oltre 500 progetti Arduino, ESP32 e Pico da realizzare.
Inquadra con il telefono
Punta la fotocamera sul codice: si apre lo store del tuo telefono.
oppure apri lo store

