Basi · 12 min di lettura

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.

DecimaleBinarioHexDecimaleBinarioHex
000000810008
100011910019
200102101010A
300113111011B
401004121100C
501015131101D
601106141110E
701117151111F

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.

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

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.

La modalità programmatore della calcolatrice del computer e il Monitor seriale di Arduino sono i modi più rapidi per controllare una conversione. Serial.println(181, BIN) stampa 10110101 e Serial.println(181, HEX) stampa B5. Fare la conversione a mano qualche volta, però, rende molto più facile leggere tabelle di registri e datasheet.

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.

DimensioneTipo ArduinoIntervallo senza segnoIntervallo con segno
8 bit (1 byte)byte, uint8_t / int8_t0–255da -128 a 127
16 bit (2 byte)int sull'Uno, word, uint16_t0–65535da -32768 a 32767
32 bit (4 byte)long, uint32_t; int su ESP32 e Pico0–4.294.967.295da -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.

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}
In C++ uno zero davanti a un numero lo trasforma in un numero ottale: 010 vale otto, non dieci, e 0255 vale 173. Se scrivi 08 o 09 per allineare numeri di pin od orari, il compilatore dà errore; se scrivi 010, fa la cosa sbagliata senza avvisare. Non mettere mai uno zero davanti a un numero decimale.

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):

OperazioneCosa fa?Risultato (binario)HexDecimale
a & bBit che valgono 1 in entrambi100010000x88136
a | bBit che valgono 1 in almeno uno111011100xEE238
a ^ bBit diversi011001100x66102
~a (byte)Tutti i bit invertiti001101010x3553
a << 1 (byte)Una posizione a sinistra, il bit di sinistra si perde100101000x94148
a >> 2Due posizioni a destra, si perdono i due bit di destra001100100x3250

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:

ObiettivoCon la mascheraFunzione ArduinoEsempio (n = 3)
Portare il bit a 1x |= (1 << n);bitSet(x, n);00000000 → 00001000
Portare il bit a 0x &= ~(1 << n);bitClear(x, n);11111111 → 11110111
Invertire il bitx ^= (1 << n);bitWrite(x, n, !bitRead(x, n));00001000 → 00000000
Leggere (testare) il bit(x >> n) & 1bitRead(x, n);00001000 → 1
Scrivere un valore nel bitx = (x & ~(1 << n)) | (v << n);bitWrite(x, n, v);v = 1 → 00001000
Peso del 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}

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.

CifraSegmenti accesiBinario (DP g f e d c b a)Catodo comuneAnodo comune (~)
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

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.

CollegamentoArduino UnoESP32Raspberry Pi Pico
DS (14), dati serialiD11GPIO 23GP19
SH_CP (11), clockD13GPIO 18GP18
ST_CP (12), latchD10GPIO 5GP17
OE (13) / MR (10)GND / 5VGND / 3V3GND / 3V3(OUT)
Q0–Q6 / Q7Segmenti a–g / DP, ognuno con la sua resistenzaUgualeUguale
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}

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 UnoPorta e bitPin UnoPorta e bit
D0–D7PD0–PD7 (PORTD)D8–D13PB0–PB5 (PORTB)
A0–A5PC0–PC5 (PORTC)D13 (LED integrato)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}
Il codice con i registri dipende dalla scheda: una riga con PORTB che funziona sull'Uno comanda altri pin su un Mega, non comanda nulla su ESP32 o Pico e lì non compila nemmeno. Inoltre i bit 0 e 1 di PORTD sono i pin della porta seriale; una riga che scrive tutta la porta in un colpo, come PORTD = 0xFF, può guastare Serial. Cambia con una maschera solo i bit che ti interessano e usa il codice con i registri solo dove la velocità conta davvero.

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.

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}

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.

EspressioneRisultatoSpiegazione
(0xFC << 8) | 0x180xFC18Unisce due byte in un numero a 16 bit
(int16_t)0xFC18-1000Negativo nella lettura con segno perché il bit di sinistra è 1
highByte(1000)0x031000 = 0x03E8; il byte alto
lowByte(1000)0xE8Il byte basso (232)
word(0x03, 0xE8)1000Riunisce i due byte
(stato >> 4) & 0x0FNibble altoEstrae 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).

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)

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

ErroreCosa succede?Forma corretta
if (x & 0x04 == 0)== viene valutato per primo, l'espressione diventa x & 0 ed è sempre falsaif ((x & 0x04) == 0)
Usare 2 ^ 3 come potenza^ è XOR; 2 ^ 3 = 11 << 3 oppure pow(2, 3)
1 << 15 o 1 << 20 sull'UnoL'int a 16 bit trabocca: -32768 o 01UL << 20 (unsigned long)
Pensare che Serial.println(x, BIN) stampi 8 bitGli zeri iniziali non vengono stampati: 12 → 1100Stampa 8 bit in un ciclo con bitRead
Mettere uno 0 davanti a un numero (010)Diventa ottale: 010 = 8Togli gli zeri iniziali dai numeri decimali
Usare il risultato di ~ in un intSi invertono anche i bit superiori: ~0x0F = -16Assegna il risultato a un byte o maschera con & 0xFF
Scrivere && invece di &Si confrontano due condizioni, non i bitUna sola & per i bit, && per le condizioni
Se hai dubbi su un'operazione sui bit, stampa il risultato in tre forme: Serial.println(x), Serial.println(x, BIN) e Serial.println(x, HEX). Vedere lo stesso valore in decimale, binario ed esadecimale mostra subito se la maschera o lo scorrimento hanno toccato i bit che ti aspettavi.

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.

Vedi tutti i progetti
LED in sequenza
AR-5Intermedio

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…

4.6(87)
218
Effetto Supercar con LED
AR-6Intermedio

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.

4.8(107)
214
Visualizzare i numeri da 0 a 9 su display a 7 segmenti
AR-41Intermedio
Premium

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.

4.5(30)
43
Visualizzare i numeri da 0 a 99 su display a 7 segmenti
AR-42Avanzato
Premium

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.

4.5(27)
35
Numeri da 0 a 9999 su display a 7 segmenti a 4 cifre
AR-47Intermedio
Premium

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.

4.4(19)
25
Orologio digitale con display a 7 segmenti a 4 cifre
AR-48Intermedio
Premium

Orologio digitale con display a 7 segmenti a 4 cifre

Un orologio digitale luminoso a quattro cifre, simile a quello del forno in cucina.

4.8(56)
73
Orologio e calendario a matrice di punti (MAX7219, DS1307)
AR-84Intermedio
Premium

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.

5.0(37)
59
Serpente di pixel Matrice 8x8
AR-88Avanzato
Premium

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…

4.7(39)
57