Aprender

Operadores bit a bit do Arduino e bitRead, em um dígito de sete segmentos

Iniciante

Ou veja todas as aulas.

  • 526componentes na bancada
  • 46placas rodando agora
  • 1.00xtempo real, em todas as placas
Arduino Uno: um dígito de sete segmentos aceso pelos bits de um byteao vivo0.000 s 0.00x
Clique para abrir no editor
Cada dígito é um byte; bitRead() escolhe o bit de cada segmento.

Os operadores bit a bit trabalham nos bits individuais de um número. & (e) mantém os bits definidos nos dois números, | (ou) os bits definidos em qualquer um, ^ (ou exclusivo) os bits definidos em um mas não nos dois, ~ (não) inverte todos os bits, e << e >> deslizam os bits para a esquerda ou para a direita. O Arduino adiciona bitRead(), bitWrite(), bitSet() e bitClear() para trabalhar um bit de cada vez.

O circuito acima é um dígito de sete segmentos ligado direto a um Uno, contando de 0 a 9 uma vez por segundo. Cada dígito é um byte com o segmento a no bit 0, e bitRead(DIGITS[n], s) decide se o segmento s acende. Aperte Rodar e veja a contagem; o monitor serial imprime cada número conforme ele aparece.

Abaixo está como esse byte funciona, os seis operadores com o que cada um imprimiu, definir e testar um bit, os deslocamentos que passam do limite, & contra &&, e juntar dois bytes em um número.

Um byte por dígito

Aqui estão a tabela e a função do sketch acima. 0x06 é 0b00000110 em binário: os bits 1 e 2 estão definidos, que são os segmentos b e c, os dois da direita, e isso é um 1. 0x3F define os seis bits de a a f, tudo menos a barra do meio, que é um 0. show() percorre os sete bits e escreve cada um no pino do seu segmento.

Dez bytes guardam os dez dígitos. Dez arrays de sete HIGHs e LOWs guardariam a mesma coisa ocupando catorze vezes mais espaço.

firmware/uno/examples/sfseg (o dígito rodando acima)
const byte DIGITS[10] = {0x3F, 0x06, 0x5B, 0x4F, 0x66, 0x6D, 0x7D, 0x07, 0x7F, 0x6F};
const int SEGMENT_PINS[7] = {7, 6, 5, 11, 10, 8, 9};  // a to g
const int DOT_PIN = 4;

void show(int n) {
  for (int s = 0; s < 7; s++) digitalWrite(SEGMENT_PINS[s], bitRead(DIGITS[n], s));
}

Os seis operadores

Com a valendo 1100 e b valendo 1010 em binário, o sketch abaixo imprimiu 1000 para a & b, 1110 para a | b, 110 para a ^ b, 11000 para a << 1 e 11 para a >> 2. Deslocar para a esquerda por um dobra um número e deslocar para a direita por um divide por dois, descartando o resto.

Os números podem ser escritos de três jeitos. 0b1100 é binário, 0x0C é hexadecimal e 12 é decimal, e os três são o mesmo número para o compilador. Binário é o mais fácil de ler quando cada bit significa uma coisa, como um segmento ou um interruptor, e hexadecimal é mais curto para bytes inteiros: cada dígito hex é exatamente quatro bits.

~a imprimiu -13, e não 11110011. O ~ agiu sobre um int, porque o C++ transforma um byte em int antes de fazer aritmética com ele, então os dezesseis bits foram invertidos e o primeiro tornou o número negativo. Convertendo a resposta de volta, (byte)~a, imprimiu 11110011.

Cada operador sobre dois bytes
void setup() {
  Serial.begin(9600);
  byte a = 0b1100;
  byte b = 0b1010;
  Serial.println(a & b, BIN);
  Serial.println(a | b, BIN);
  Serial.println(a ^ b, BIN);
  Serial.println(a << 1, BIN);
  Serial.println(a >> 2, BIN);
  Serial.println(~a);
  Serial.println((byte)~a, BIN);
}

void loop() {
}

Abrir este sketch no editorSó o código: o editor posiciona a placa e os componentes que ele consegue ler do sketch.

Definir, limpar, inverter e testar um bit

1 << n é um número com apenas o bit n definido, chamado de máscara. flags |= (1 << 3) define o bit 3 e deixa o resto como está, flags &= ~(1 << 3) limpa, flags ^= (1 << 0) inverte o bit 0, e if (flags & (1 << 0)) testa. O sketch abaixo imprimiu 1000, 1001 e 1, e depois "bit 0 está definido".

Os nomes do próprio Arduino dizem as mesmas coisas em palavras. bitSet(flags, 3), bitClear(flags, 0), bitWrite(flags, 7, 1) e bitRead(flags, 3) trabalham em um bit, e bit(5) é 32, o valor do bit 5 sozinho. Use o que ler melhor; compilam para o mesmo código.

Máscaras
void setup() {
  Serial.begin(9600);
  byte flags = 0b00000000;
  flags |= (1 << 3);
  Serial.println(flags, BIN);
  flags ^= (1 << 0);
  Serial.println(flags, BIN);
  flags &= ~(1 << 3);
  Serial.println(flags, BIN);
  if (flags & (1 << 0)) {
    Serial.println("bit 0 is set");
  }
}

void loop() {
}

Abrir este sketch no editorSó o código: o editor posiciona a placa e os componentes que ele consegue ler do sketch.

Deslocamentos que passam do limite

Um número simples como 1 é um int, e um int no Uno tem 16 bits. 1 << 15 imprimiu -32768, porque o bit 15 é o bit de sinal. 1 << 16 e long big = 1 << 20 deslocam além do fim: o clang avisou shift count >= width of type, e imprimiram 256 e 16777221, nenhum deles correto. Guardar a resposta em um long não ajuda, porque o deslocamento já deu errado.

Faça o 1 virar unsigned long primeiro: 1UL << 16 imprimiu 65536. Faça o mesmo sempre que um deslocamento puder passar do bit 14, para um registrador de 32 bits ou uma máscara para um display de 24 pinos.

& não é &&, e os parênteses que importam

&& pergunta se os dois lados são verdadeiros; & compara bits. Com x valendo 4, if (x & 2) foi falso, porque 100 e 010 não têm nenhum bit em comum, e if (x && 2) foi verdadeiro, porque nenhum é zero. O Clang avisou no segundo: use of logical '&&' with constant operand. O mesmo vale para | e ||.

== é avaliado antes de &, então if (flags & 0b1000 == 0b1000) testa flags & 1. Com flags valendo 1000 imprimiu "not set". O Clang avisou & has lower precedence than ==; == will be evaluated first. Coloque parênteses em volta da máscara: if ((flags & 0b1000) == 0b1000).

Dois bytes em um número, e de volta

Sensores em I2C e SPI costumam enviar uma leitura como um byte alto e um byte baixo. (high << 8) | low junta os dois de novo: 0x03 e 0xE8 formaram 1000. value >> 8 tira o byte alto de novo e value & 0xFF o baixo, que imprimiram 3 e 232.

Juntar e separar
void setup() {
  Serial.begin(9600);
  byte high = 0x03;
  byte low = 0xE8;
  int value = (high << 8) | low;
  Serial.println(value);
  Serial.println(value >> 8);
  Serial.println(value & 0xFF);
}

void loop() {
}

Abrir este sketch no editorSó o código: o editor posiciona a placa e os componentes que ele consegue ler do sketch.

Abra este circuito no editor. Arduino Uno: um dígito de sete segmentos aceso pelos bits de um byte, ligado como roda no topo desta página. Mude um componente ou um valor e rode de novo.

Abrir o circuito

Perguntas

O que o & faz no Arduino?

Entre dois números é o e bit a bit: cada bit da resposta é 1 apenas onde os dois números têm 1. Antes de uma variável significa "o endereço de", que é outra coisa.

Qual a diferença entre & e && no Arduino?

&& é o e lógico, verdadeiro quando os dois lados são diferentes de zero. & compara os números bit a bit. 4 & 2 é 0, que é falso; 4 && 2 é verdadeiro.

Como leio um bit de um byte no Arduino?

bitRead(value, n) dá 0 ou 1 para o bit n, contando a partir do 0 na direita. (value >> n) & 1 é a mesma coisa escrita com operadores.

O que significa 1 << n?

Um número com apenas o bit n definido: 1 << 3 é 8. É a máscara para definir, limpar ou testar o bit n. Escreva 1UL << n quando n puder ser 15 ou mais.

Fontes

De onde vêm as informações desta página

Monte isto de verdade

Abra o editor, mude um valor e veja o número mudar junto. Nada para instalar, e não precisa de conta.