Operadores bit a bit do Arduino e bitRead, em um dígito de sete segmentos
Iniciante
- 526componentes na bancada
- 46placas rodando agora
- 1.00xtempo real, em todas as placas
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.
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.
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.
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.
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 circuitoPerguntas
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.
Continuar
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.