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.
| Decimal | Binário | Hex | Decimal | Binário | 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 |
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 posicional | 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 |
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.
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.
| Tamanho | Tipo no Arduino | Faixa sem sinal | Faixa com sinal |
|---|---|---|---|
| 8 bits (1 byte) | byte, uint8_t / int8_t | 0–255 | -128 a 127 |
| 16 bits (2 bytes) | int no Uno, word, uint16_t | 0–65535 | -32.768 a 32.767 |
| 32 bits (4 bytes) | long, uint32_t; int no ESP32 e no Pico | 0–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.
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}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ção | O que faz? | Resultado (binário) | Hex | Decimal |
|---|---|---|---|---|
| a & b | Bits que são 1 em ambos | 10001000 | 0x88 | 136 |
| a | b | Bits que são 1 em pelo menos um | 11101110 | 0xEE | 238 |
| a ^ b | Bits que são diferentes | 01100110 | 0x66 | 102 |
| ~a (byte) | Todos os bits invertidos | 00110101 | 0x35 | 53 |
| a << 1 (byte) | Uma posição à esquerda, o bit mais à esquerda é descartado | 10010100 | 0x94 | 148 |
| a >> 2 | Duas posições à direita, os dois bits mais à direita são descartados | 00110010 | 0x32 | 50 |
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:
| Objetivo | Com uma máscara | Função do Arduino | Exemplo (n = 3) |
|---|---|---|---|
| Definir o bit como 1 | x |= (1 << n); | bitSet(x, n); | 00000000 → 00001000 |
| Zerar o bit para 0 | x &= ~(1 << n); | bitClear(x, n); | 11111111 → 11110111 |
| Inverter o bit | x ^= (1 << n); | bitWrite(x, n, !bitRead(x, n)); | 00001000 → 00000000 |
| Ler (testar) o bit | (x >> n) & 1 | bitRead(x, n); | 00001000 → 1 |
| Escrever um valor específico no bit | x = (x & ~(1 << n)) | (v << n); | bitWrite(x, n, v); | v = 1 → 00001000 |
| Valor do 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}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.
| Algarismo | Segmentos acesos | Binário (DP g f e d c b a) | Cátodo comum | Ânodo comum (~) |
|---|---|---|---|---|
| 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 |
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ão | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| DS (14), dados seriais | 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 | Segmentos a–g / DP, cada um por meio de um resistor | Igual | Igual |
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 Uno | Porta e bit | Pino do Uno | Porta e bit |
|---|---|---|---|
| D0–D7 | PD0–PD7 (PORTD) | D8–D13 | PB0–PB5 (PORTB) |
| A0–A5 | PC0–PC5 (PORTC) | D13 (LED integrado) | 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}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.
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ão | Resultado | Explicação |
|---|---|---|
| (0xFC << 8) | 0x18 | 0xFC18 | Combina dois bytes em um único número de 16 bits |
| (int16_t)0xFC18 | -1000 | Negativo na leitura com sinal porque o bit mais à esquerda é 1 |
| highByte(1000) | 0x03 | 1000 = 0x03E8; o byte mais significativo |
| lowByte(1000) | 0xE8 | O byte menos significativo (232) |
| word(0x03, 0xE8) | 1000 | Une os dois bytes novamente |
| (state >> 4) & 0x0F | Nibble superior | Extrai 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).
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
| Erro | O que acontece? | Forma correta |
|---|---|---|
| if (x & 0x04 == 0) | == é avaliado primeiro, a expressão se torna x & 0 e é sempre falsa | if ((x & 0x04) == 0) |
| Usar 2 ^ 3 para uma potência | ^ é XOR; 2 ^ 3 = 1 | 1 << 3 ou pow(2, 3) |
| 1 << 15 ou 1 << 20 no Uno | O int de 16 bits sofre estouro: -32768 ou 0 | 1UL << 20 (unsigned long) |
| Supor que Serial.println(x, BIN) imprime 8 bits | Os zeros à esquerda não são impressos: 12 → 1100 | Imprima 8 bits em um laço com bitRead |
| Colocar um 0 na frente de um número (010) | Ele se torna octal: 010 = 8 | Remova os zeros à esquerda dos números decimais |
| Usar o resultado de ~ em um int | Os bits superiores também são invertidos: ~0x0F = -16 | Atribua 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 bits | Um único & para bits, && para condições |
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.
Projetos para montar depois desta leitura
Ver todos os projetos
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…

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.

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…

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.

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.

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.

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.

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…
Mais artigos
- Tutorial do 74HC595 com Arduino: registrador de deslocamento para 8+ LEDs com 3 pinos
- Como usar um display de 7 segmentos: mostrando números com Arduino, ânodo comum vs cátodo comum
- Portas lógicas explicadas: tabelas-verdade de AND, OR, NOT e XOR e Arduino
- Fundamentos da programação Arduino: variáveis, laços e funções
App BlueGrays
Monte este circuito passo a passo pelo celular
Esquema do circuito, código e lista de componentes em uma só tela. Mais de 500 projetos com Arduino, ESP32 e Pico prontos para montar.
Escaneie com seu celular
Aponte a câmera para o código para abrir a loja de aplicativos do seu celular.
ou abrir a loja

