Fundamentos · 13 min de leitura

Sistema de numeração binário: hexadecimal, bits e operações bit a bit no Arduino

Sistema binário, conversões entre hexadecimal e decimal, bits e bytes, 0b e 0x no Arduino, &, |, ^, ~, <<, >> com bitRead, além de exemplos com 74HC595 e registradores.

O sistema de numeração binário usa apenas os algarismos 0 e 1 e é a base de toda a eletrônica digital. Cada pino, cada registrador e cada byte na memória de um Arduino é, na verdade, um número binário formado por chaves ligadas ou desligadas: 1 significa que um pino está em HIGH e 0 significa que está em LOW. Expressões que você encontra no código, como 0b10110101, 0xB5 ou PORTB |= (1 << 5), podem assustar, mas, depois de entender os sistemas binário e hexadecimal, todas se resumem a algumas regras simples.

Neste guia, você vai ver primeiro como converter números decimais, binários e hexadecimais entre si à mão, o que são bits, nibbles e bytes e como os números negativos são armazenados na memória. Depois, vai aprender a escrever números no Arduino com 0b e 0x, ler e alterar um único bit com operações AND, OR, XOR, NOT e deslocamento e usar as funções bitRead, bitWrite e bitSet. Por fim, vai preparar bytes para um display de 7 segmentos e um 74HC595 e escrever diretamente nos registradores do Uno, ESP32 e Pico.

O que é um sistema de numeração? Decimal, binário e hexadecimal

O sistema decimal que usamos no dia a dia tem 10 algarismos, e cada posição vale 10 vezes a anterior: 181 é 1×100 + 8×10 + 1×1. O sistema binário tem apenas dois algarismos, e cada posição vale o dobro da anterior; da direita para a esquerda, os valores posicionais são 1, 2, 4, 8, 16, 32, 64, 128. O sistema hexadecimal (abreviado como hex) tem 16 algarismos: depois de 0–9 vêm A=10, B=11, C=12, D=13, E=14, F=15. O hexadecimal é tão popular na eletrônica porque cada algarismo hexadecimal corresponde exatamente a 4 bits; é a forma mais prática de escrever números binários longos de maneira curta e legível.

DecimalBinárioHexDecimalBinárioHex
000000810008
100011910019
200102101010A
300113111011B
401004121100C
501015131101D
601106141110E
701117151111F

Conversões entre decimal, binário e hexadecimal

Para converter de decimal para binário, divida o número repetidamente por 2 e anote os restos; a leitura dos restos de baixo para cima fornece o número binário. Para 181: 181/2 = 90 com resto 1, 90/2 = 45 com resto 0, 45/2 = 22 com resto 1, 22/2 = 11 com resto 0, 11/2 = 5 com resto 1, 5/2 = 2 com resto 1, 2/2 = 1 com resto 0, 1/2 = 0 com resto 1. Lendo de baixo para cima, você obtém 10110101. Converter de binário para decimal é mais fácil: some os valores posicionais das posições que contêm 1. 10110101 = 128 + 32 + 16 + 4 + 1 = 181.

Valor posicional1286432168421
10110101 (181)10110101
00001100 (12)00001100
11111111 (255)11111111

Para converter de binário para hexadecimal, separe os bits em grupos de quatro começando pela direita e substitua cada grupo pelo algarismo hexadecimal correspondente na tabela: 1011 0101 → B 5 → 0xB5. O inverso é igualmente fácil: 0x3C → 0011 1100. Para converter de hexadecimal para decimal, multiplique cada algarismo por uma potência de 16: 0xB5 = 11×16 + 5 = 181, 0x3FF = 3×256 + 15×16 + 15 = 1023. O último exemplo deve parecer familiar: o limite superior do valor de analogRead de 10 bits do Uno é 1023, que corresponde a dez bits 1. Você encontra a relação entre leituras analógicas e quantidade de bits no artigo sobre ADC.

A calculadora do computador no modo programador e o Monitor Serial do Arduino são as maneiras mais rápidas de conferir conversões. Serial.println(181, BIN) imprime 10110101, e Serial.println(181, HEX) imprime B5. Ainda assim, fazer a conversão à mão algumas vezes facilita muito a leitura de tabelas de registradores e datasheets.

Bits, nibbles, bytes e faixas de valores

Um único algarismo binário é chamado de bit. 4 bits formam um nibble, que corresponde a um algarismo hexadecimal; 8 bits formam um byte, escrito com dois algarismos hexadecimais. O bit mais à direita de um byte é o bit menos significativo (LSB, bit 0), e o mais à esquerda é o bit mais significativo (MSB, bit 7). A numeração dos bits sempre começa em 0, portanto os bits de um número de 8 bits são numerados de 0–7. Com n bits, você pode escrever 2ⁿ valores diferentes: 8 bits permitem 256, 10 bits permitem 1.024 e 16 bits permitem 65.536 valores diferentes.

TamanhoTipo no ArduinoFaixa sem sinalFaixa com sinal
8 bits (1 byte)byte, uint8_t / int8_t0–255-128 a 127
16 bits (2 bytes)int no Uno, word, uint16_t0–65535-32.768 a 32.767
32 bits (4 bytes)long, uint32_t; int no ESP32 e no Pico0–4.294.967.295-2.147.483.648 a 2.147.483.647

Números negativos: complemento de dois

Os microcontroladores armazenam números negativos usando complemento de dois: em um número com sinal, se o bit mais à esquerda for 1, o número é negativo. Para obter o negativo de um número, você inverte todos os bits e soma 1. 5 = 00000101; invertido, 11111010; somando 1, você obtém 11111011 = 0xFB, que é -5. O mesmo padrão de bits representa um número diferente dependendo de como você o lê: 0xFF é 255 como byte e -1 como int8_t. Por isso, atribuir os bytes brutos de um sensor ao tipo correto é tão importante. Quando uma variável ultrapassa seu limite superior, ela também volta ao início da faixa: em um byte, 255 + 1 = 0, e com int no Uno, 32767 + 1 = -32768; isso se chama estouro.

Escrevendo números com 0b, 0x e B no Arduino

No código Arduino, você pode escrever o mesmo número de três maneiras, sem nenhuma diferença para o compilador: 181 (decimal), 0b10110101 (binário, padrão desde C++14) e 0xB5 (hexadecimal). O Arduino também reconhece a forma B10110101, herdada de códigos antigos, mas essas são constantes definidas apenas para valores de 8 bits, e 0b é melhor em códigos novos. A escolha da forma depende da legibilidade: o binário é mais claro para padrões de LEDs e configurações de registradores, o hexadecimal para endereços e códigos de cores e o decimal para medições.

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}
Em C++, colocar um zero na frente de um número o transforma em um número octal: 010 é oito, não dez, e 0255 é 173. Se você escrever 08 ou 09 para alinhar números de pinos ou tempos, o compilador informa um erro; se escrever 010, ele faz a coisa errada sem avisar. Nunca coloque um zero à esquerda em números decimais.

Operações bit a bit: &, |, ^, ~, << e >>

As operações bit a bit comparam, um a um, os bits na mesma posição de dois números. AND (&) resulta em 1 somente se ambos os bits forem 1; OR (|) resulta em 1 se pelo menos um bit for 1; XOR (^) resulta em 1 se os bits forem diferentes; NOT (~) inverte todos os bits. O deslocamento à esquerda (<<) move os bits para a esquerda e acrescenta bits 0 à direita, multiplicando o número por 2 a cada passo; o deslocamento à direita (>>) move os bits para a direita, dividindo por 2 a cada passo. Essas são as versões em software das portas lógicas; você pode ver suas tabelas-verdade no artigo sobre portas lógicas e na ferramenta Portas lógicas. A tabela abaixo mostra os resultados para a = 0b11001010 (202) e b = 0b10101100 (172):

OperaçãoO que faz?Resultado (binário)HexDecimal
a & bBits que são 1 em ambos100010000x88136
a | bBits que são 1 em pelo menos um111011100xEE238
a ^ bBits que são diferentes011001100x66102
~a (byte)Todos os bits invertidos001101010x3553
a << 1 (byte)Uma posição à esquerda, o bit mais à esquerda é descartado100101000x94148
a >> 2Duas posições à direita, os dois bits mais à direita são descartados001100100x3250

Observe dois detalhes na tabela. Quando o resultado de a << 1 é armazenado em um byte, o bit mais à esquerda é descartado e resta 148; feita em um int, a mesma operação resulta em 404, pois um int tem espaço para o bit excedente. Com ~a acontece algo parecido: como byte, o resultado é 53, mas, calculado como int, os bits superiores também são invertidos e o resultado é -203. Nas operações bit a bit, você precisa sempre saber qual tipo armazena o resultado. E não confunda & com &&: o primeiro atua sobre bits individuais, e o segundo verifica se duas condições são verdadeiras.

Máscaras de bits: ler, definir e zerar um único bit

Em projetos reais, as operações bit a bit quase sempre são usadas com uma máscara. Uma máscara é um número em que apenas os bits de interesse são 1, geralmente criado com (1 << n): (1 << 3) = 0b00001000. Você faz quatro operações básicas com uma máscara, e o Arduino oferece uma função pronta para cada uma delas. O código abaixo armazena o estado de 8 LEDs em um único byte, em vez de 8 variáveis bool separadas, e reproduz esse estado nos LEDs em D2–D9:

ObjetivoCom uma máscaraFunção do ArduinoExemplo (n = 3)
Definir o bit como 1x |= (1 << n);bitSet(x, n);00000000 → 00001000
Zerar o bit para 0x &= ~(1 << n);bitClear(x, n);11111111 → 11110111
Inverter o bitx ^= (1 << n);bitWrite(x, n, !bitRead(x, n));00001000 → 00000000
Ler (testar) o bit(x >> n) & 1bitRead(x, n);00001000 → 1
Escrever um valor específico no bitx = (x & ~(1 << n)) | (v << n);bitWrite(x, n, v);v = 1 → 00001000
Valor do 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}

Preparando bytes para um display de 7 segmentos

As oito partes de um display de 7 segmentos (segmentos a–g e o ponto decimal) cabem exatamente em um byte. Se você atribuir o bit 0 ao segmento a, o bit 6 ao segmento g e o bit 7 ao ponto decimal (DP), cada algarismo poderá ser expresso como um único número. O algarismo 2, por exemplo, é formado pelos segmentos a, b, d, e e g: 1 + 2 + 8 + 16 + 64 = 91 = 0x5B. Nos displays de ânodo comum, um segmento acende em LOW, então você inverte a mesma tabela com ~. Para detalhes das conexões dos segmentos, veja o artigo sobre display de 7 segmentos.

AlgarismoSegmentos acesosBinário (DP g f e d c b a)Cátodo comumÂnodo comum (~)
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

Enviando o byte às saídas com um 74HC595

O registrador de deslocamento 74HC595 distribui um byte por oito saídas usando apenas três pinos, e é o chip em que você vê as operações bit a bit com mais clareza: cada bit do byte enviado liga ou desliga uma saída. Quando shiftOut é usado com MSBFIRST, o bit 7 é enviado primeiro e termina em Q7, enquanto o bit 0 termina em Q0. Assim, se você conectar Q0 ao segmento a, Q6 ao g e Q7 ao DP, a tabela acima funciona diretamente. Para conhecer todos os pinos do chip e a ligação em cascata, veja o artigo sobre o registrador de deslocamento 74HC595.

ConexãoArduino UnoESP32Raspberry Pi Pico
DS (14), dados seriaisD11GPIO 23GP19
SH_CP (11), clockD13GPIO 18GP18
ST_CP (12), latchD10GPIO 5GP17
OE (13) / MR (10)GND / 5VGND / 3V3GND / 3V3(OUT)
Q0–Q6 / Q7Segmentos a–g / DP, cada um por meio de um resistorIgualIgual
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}

Escrevendo diretamente nos registradores: PORTB e DDRB

No ATmega328P do Uno, os pinos são agrupados em portas de 8 pinos, e cada porta tem três registradores: DDRx armazena a direção do pino (1 = saída), PORTx o nível de saída e PINx o nível lido. Os pinos D8–D13 estão na porta B; D13 (o LED integrado) é PB5, o bit 5 de PORTB. pinMode e digitalWrite, na verdade, alteram esses bits, mas, como primeiro convertem o número do pino em uma porta, levam alguns microssegundos. Escrever diretamente no registrador é uma única instrução de máquina e termina em 2 ciclos de clock a 16 MHz, cerca de 125 nanossegundos. Isso também permite alterar vários pinos da mesma porta exatamente no mesmo instante.

Pino do UnoPorta e bitPino do UnoPorta e bit
D0–D7PD0–PD7 (PORTD)D8–D13PB0–PB5 (PORTB)
A0–A5PC0–PC5 (PORTC)D13 (LED integrado)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}
O código de registradores é específico de cada placa: uma linha com PORTB que funciona no Uno controla outros pinos no Mega, não controla nada no ESP32 ou no Pico e nem sequer compila nessas placas. Além disso, os bits 0 e 1 de PORTD são os pinos da porta serial; uma linha que escreve em toda a porta de uma vez, como PORTD = 0xFF, pode prejudicar o funcionamento de Serial. Altere apenas os bits de interesse com uma máscara e use código de registradores somente onde a velocidade realmente importa.

Acionando pinos por registradores no ESP32

No ESP32, os pinos são controlados por registradores de 32 bits e, diferentemente do AVR, existem registradores separados de set e clear: cada bit 1 que você escreve em GPIO_OUT_W1TS_REG (escrever 1 para definir) coloca o pino correspondente em HIGH; cada bit 1 que escreve em GPIO_OUT_W1TC_REG (escrever 1 para zerar) o coloca em LOW; e os bits 0 não alteram nenhum pino. Como isso não exige leitura-modificação-escrita, é seguro com interrupções e entre os dois núcleos. Esses dois registradores abrangem apenas GPIO 0–31; para 32 e acima, são usados os registradores 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}

Combinando e separando dados de sensores

Sensores I2C e SPI geralmente enviam leituras de 16 bits como dois bytes separados: primeiro o byte mais significativo (MSB), depois o byte menos significativo (LSB). Para combiná-los, você desloca o byte mais significativo 8 posições para a esquerda e faz uma operação OR com o byte menos significativo: int16_t raw = (msb << 8) | lsb;. Se um acelerômetro enviar 0xFC e 0x18, por exemplo, o resultado será 0xFC18; lido como int16_t, esse número é -1000, pois o bit mais à esquerda é 1. No sentido inverso, para enviar um número ou gravá-lo na EEPROM, existem highByte(x) e lowByte(x), além de word(high, low) para unir dois bytes. Você encontra a comunicação I2C em si em O que é I2C?, e um sensor que trabalha com dados brutos de dois bytes no artigo sobre o MPU6050.

ExpressãoResultadoExplicação
(0xFC << 8) | 0x180xFC18Combina dois bytes em um único número de 16 bits
(int16_t)0xFC18-1000Negativo na leitura com sinal porque o bit mais à esquerda é 1
highByte(1000)0x031000 = 0x03E8; o byte mais significativo
lowByte(1000)0xE8O byte menos significativo (232)
word(0x03, 0xE8)1000Une os dois bytes novamente
(state >> 4) & 0x0FNibble superiorExtrai os 4 bits superiores de um byte (por exemplo, um campo de registrador)

Bits no Raspberry Pi Pico e no MicroPython

Os mesmos operadores se aplicam no MicroPython, que também oferece funções prontas de conversão: bin(), hex() e int(text, base). Como os números inteiros do Python crescem sem limite, você precisa mascarar os resultados de ~ e << com & 0xFF se quiser que caibam em um byte. O chip RP2040 do Pico também tem registradores separados de set, clear e XOR, como o ESP32, e você pode escrever diretamente neles com machine.mem32. O código abaixo pisca o LED integrado do Pico em GP25 usando o registrador XOR (no Pico W, o LED integrado está conectado ao chip Wi-Fi, então use um LED externo nesse caso).

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)

Ideias de projetos com operações bit a bit

  • Contador binário: Monte um contador que conte de 0 a 255 em 8 LEDs e veja o sistema binário com seus próprios olhos; um botão soma um, o outro subtrai um.
  • Efeito Super Máquina: Desloque um byte com << e >> para acender os LEDs em um movimento de ida e volta; a montagem passo a passo está no artigo efeito Super Máquina e LED sequencial.
  • Relógio digital: Mostre a hora em um display de 7 segmentos com quatro dígitos e faça o ponto decimal do segundo dígito piscar a cada segundo com a máscara 0x80.
  • Ícones em matriz de LEDs: Desenhe cada linha de uma matriz 8×8 como um byte; crie corações, setas ou letras com 0b. O artigo sobre a matriz de LEDs MAX7219 usa esse método.
  • Flags de configurações: Armazene configurações de ligado/desligado, como som ativado, tela brilhante e alarme definido, nos bits de um único byte e grave-as na EEPROM de uma só vez.
  • Seleção de endereço com chave DIP: Leia uma chave DIP de 4 posições para obter um endereço de dispositivo entre 0 e 15.

Erros comuns e como corrigi-los

ErroO que acontece?Forma correta
if (x & 0x04 == 0)== é avaliado primeiro, a expressão se torna x & 0 e é sempre falsaif ((x & 0x04) == 0)
Usar 2 ^ 3 para uma potência^ é XOR; 2 ^ 3 = 11 << 3 ou pow(2, 3)
1 << 15 ou 1 << 20 no UnoO int de 16 bits sofre estouro: -32768 ou 01UL << 20 (unsigned long)
Supor que Serial.println(x, BIN) imprime 8 bitsOs zeros à esquerda não são impressos: 12 → 1100Imprima 8 bits em um laço com bitRead
Colocar um 0 na frente de um número (010)Ele se torna octal: 010 = 8Remova os zeros à esquerda dos números decimais
Usar o resultado de ~ em um intOs bits superiores também são invertidos: ~0x0F = -16Atribua o resultado a um byte ou aplique uma máscara com & 0xFF
Escrever && em vez de &Duas condições são comparadas, não os bitsUm único & para bits, && para condições
Se você tiver dúvidas sobre uma operação bit a bit, imprima o resultado de três formas: Serial.println(x), Serial.println(x, BIN) e Serial.println(x, HEX). Ver o mesmo valor em decimal, binário e hexadecimal mostra imediatamente se a máscara ou o deslocamento alterou os bits esperados.

Números binários e hexadecimais e operações bit a bit parecem abstratos no início, mas você os encontra todos os dias na eletrônica, desde acionar uma fileira de LEDs com um único byte até combinar dados de sensores. Quando aprendidos junto com os fundamentos da programação Arduino, eles deixam seu código mais curto e mais rápido. No app BlueGrays, você pode explorar projetos de contadores de 7 segmentos, relógio digital, LEDs sequenciais, efeito Super Máquina e matriz de LEDs com esquemas do circuito passo a passo e código escrito com essas operações bit a bit.

Perguntas frequentes

O que é o sistema de numeração binário?

O sistema de numeração binário usa apenas os algarismos 0 e 1, e cada posição vale o dobro da anterior. Da direita para a esquerda, os valores posicionais são 1, 2, 4, 8, 16, 32, 64, 128. Como 1 representa uma tensão alta e 0 uma tensão baixa nos circuitos digitais, todos os computadores e microcontroladores trabalham com esse sistema.

Como converter um número decimal para binário?

Divida o número repetidamente por 2 até chegar a 0 e anote o resto em cada passo; lendo os restos de baixo para cima, você obtém o número binário. Para 13: 6 com resto 1, 3 com resto 0, 1 com resto 1, 0 com resto 1, portanto o resultado é 1101. Para conferir, some os valores posicionais dos bits 1: 8 + 4 + 1 = 13.

Por que se usa o sistema hexadecimal (hex)?

Cada algarismo hexadecimal corresponde exatamente a 4 bits, por isso é a maneira mais fácil de escrever números binários longos de forma curta e sem erros. Um byte de 8 bits é escrito com dois algarismos hexadecimais, por exemplo B5 em vez de 10110101. Por isso, endereços I2C, códigos de cores, valores de registradores e endereços de memória são sempre dados em hexadecimal.

O que significam 0b e 0x no Arduino?

Números que começam com 0b são interpretados como binários e os que começam com 0x como hexadecimais; 0b10110101, 0xB5 e 181 são o mesmo número. A forma que você escreve não faz diferença para o compilador, apenas para a legibilidade. O Arduino também aceita a forma de 8 bits B10110101 de códigos antigos.

Para que servem bitRead e bitWrite?

bitRead(x, n) retorna o bit de número n de x como 0 ou 1; bitWrite(x, n, v) define o mesmo bit com o valor v. bitSet e bitClear definem um bit diretamente como 1 ou 0. Essas funções tornam as operações de máscara e deslocamento legíveis; a numeração dos bits começa em 0.

O que fazem os operadores << e >> no Arduino?

<< desloca os bits para a esquerda e multiplica o número por 2 a cada passo; >> desloca para a direita e divide por 2 a cada passo. 1 << 3 resulta em 8, e as máscaras que selecionam um único bit são criadas assim. Como int tem 16 bits no Uno, você precisa escrever 1UL << n para deslocamentos maiores que 15.

Ver todos os projetos
Sequencial de LEDs
AR-5Intermediário

Sequencial de LEDs

Luzes que acendem uma após a outra, como se estivessem correndo. O Arduino acende seis LEDs, um de cada vez; cada um brilha por um instante e apaga, fazendo a luz percorrer a sequência do início ao…

4.6(87)
218
Efeito Knight Rider com LEDs
AR-6Intermediário

Efeito Knight Rider com LEDs

O clássico efeito Knight Rider: um ponto de luz percorre seis LEDs de uma ponta à outra e depois volta.

4.8(107)
214
Exibição de números de 0 a 9 em display de 7 segmentos
AR-41Intermediário
Premium

Exibição de números de 0 a 9 em display de 7 segmentos

Exiba você mesmo aqueles números conhecidos dos elevadores e relógios digitais. Em um display formado por sete pequenas barras luminosas, o Arduino mostra um dígito de 0 a 9 por segundo e depois…

4.5(30)
43
Exibição de números de 0 a 99 em um display de 7 segmentos
AR-42Avançado
Premium

Exibição de números de 0 a 99 em um display de 7 segmentos

Um display de dois dígitos formado por pequenas barras, como os de calculadoras, conta de 0 a 99.

4.5(27)
35
Exibição de 0 a 9.999 em display de 7 segmentos de 4 dígitos
AR-47Intermediário
Premium

Exibição de 0 a 9.999 em display de 7 segmentos de 4 dígitos

Em um display de quatro dígitos, os números passam rapidamente de 0 a 9.999 e depois recomeçam do zero.

4.4(19)
25
Relógio digital com display de 7 segmentos de 4 dígitos
AR-48Intermediário
Premium

Relógio digital com display de 7 segmentos de 4 dígitos

Um relógio digital luminoso de quatro dígitos, parecido com o de um forno de cozinha.

4.8(56)
73
Relógio e calendário de matriz de LEDs (MAX7219, DS1307)
AR-84Intermediário
Premium

Relógio e calendário de matriz de LEDs (MAX7219, DS1307)

Um painel luminoso para a mesa ou a parede que mostra a hora e a data em texto deslizante.

5.0(37)
59
Cobrinha em pixels: matriz 8x8
AR-88Avançado
Premium

Cobrinha em pixels: matriz 8x8

Monte o clássico jogo da cobrinha com as próprias mãos e jogue. Em uma matriz de luzes coloridas 8x8, você guia uma cobra verde com um joystick e come maçãs vermelhas; a cada maçã, a cobra cresce…

4.7(39)
57