Operadores de bits

Os operadores de bits realizam cálculos ao nível de bits das variáveis. Eles ajudama resolver uma grande quantidade de problemas de programação. Muito do material abaixo é de um excelente tutorial sobre este tema que pode ser encontrado aqui.

Operador de bits AND (&)

O operador de bits AND (e) em C++ é um simples & usado entre duas outras expressões inteiras. Ele realiza uma operação entre cada bit de cada uma destas expresões de acordo com a seguinte regra: se os dois bits de entrada forem 1 o resultado da operação também é 1, caso contrário é 0. Outro modo de expressar esta regra é:

    0  0  1  1    operando1
0 1 0 1 operando2
----------
0 0 0 1 (operando1 & operando2) - resultado de retorno

Em Arduino o tipo int (inteiro) é um valor de 16 bits, portanto usando & entre duas expressões int faz com que ocorram 16 operações AND simultâneas. Em um fragmento de código:

    int a =  92;    // em binario: 0000000001011100
int b = 101; // em binario: 0000000001100101
int c = a & b; // resultado: 0000000001000100, ou 68 em decimal.

Cada um dos 16 bits em a AND b são processados usando este operador, e todos os 16 bits resultantes são armazenados em c resultado o valor 0000000001000100, que é 68 na notação decimal.

Um dos usos mais comuns do operador de bits AND é selecionar alguns bits de um valor inteiro, freqüentemente chamado de máscara. Veja o exemplo abaixo para um exemplo.

Operador de bits OR (|)

O operador de bits OR (ou) em C++ é o símbolo de barra vertical, |. Como o operador & ele realiza cálculos com cada bit de duas expressões seguindo a seguinte regra: o resultado da opração é 1 se um dos bits de entrada for 1, caso contrário é 0. Em outras palavras:

    0  0  1  1    operando1
0 1 0 1 operando2
----------
0 1 1 1 (operando1 | operando2) - resultado de retorno

Em um fragmento de código:

    int a =  92;    // in binario: 0000000001011100
int b = 101; // in binario: 0000000001100101
int c = a | b; // resultado: 0000000001111101, ou 125 em decimal.

Programa de Exemplo

Um uso comum para os operadores de bits AND e OR é o que os programadores chamam Ler-Modificar-Escrever em uma porta. Em microcontroladores uma porta é um número de 8 bits que representa algo sobre a condição dos pinos. Escrevendo em um controle de porta todos os pinos de uma vez.

PORTD é uma constante pré-construída que se refere aos estados de saída dos pinos digitais 0,1,2,3,4,5,6,7. Se há um 1 em algum dos bits, então este pino está em HIGH. (os pinos ainda precisam ser defindos como pinos de saída pelo comando pinMode()). Deste modo se escrevemos PORTD = B00110001; o que fazemos é colocar os pinos 2,3 e 7 em HIGH. Um efeito colateral é que mudamos o estado dos pinos 0 e 1 que são usados pelo Arduino na comunicação serial, ou seja, interferimos nesta comunicação.

 

Nosso algoritmo para este programa deve:

  • Ler o PORTD e limpar somente os bits que queremos controlar (com o operador AND).
  • Combinar o valor modificado de PORTD com o novo valor dos pinos que queremos controlar (com o operador OR).
int i;     // variável do contador
int j;

void setup(){
DDRD = DDRD | B11111100; // marca a direcao dos bits para os pinos 2 a 7 deixando o 0 e o 1 intocados (xx | 00 == xx)
// o mesmo que pinMode(pin, OUTPUT) para os pinos 2 a 7
Serial.begin(9600);
}

void loop(){
for (i=0; i<64; i++){

PORTD = PORTD & B00000011; // limpa os bits de 2 - 7, deixa os pinos 0 e 1 intocados (xx & 11 == xx)
j = (i << 2); // desvia os bits da variavel 2 bits para a esquerda para evitar os pino 0 e 1
PORTD = PORTD | j; // combina a informação da porta com a nova informação para os pinos dos LEDs
Serial.println(PORTD, BIN); // debug para verificar a máscara
delay(100);
}
}

Operador de bits XOR (^)

Há um operador um pouco raro em C++ chamado EXCLUSIVE OR (ou exclusivo) também conhecido por XOR (em inglês se pronuncia "equis-or"). Este operador é escrito com o símbolo do acento circunflexo ^. O resultado desta operação é 1 se os dois bits de entrada forem diferentes, caso contrário retorna 0:

    0  0  1  1    operando1
0 1 0 1 operando2
----------
0 1 1 0 (operando1 ^ operando2) - resultado de retorno

Um simpples código de exemplo:

    int x = 12;     // binario: 1100
int y = 10; // binario: 1010
int z = x ^ y; // binario: 0110, or decimal 6

O operador XOR é freqüentemente utilizado para inverter alguns dos bits de uma expressão inteira. Na máscara deste operador se há um 1 o bit correspondente é invertido, se há um zero o bit é mantido como está. Abaixo há um programa para piscar o pino digital 5.

// Piscar_Pino_5
// demonstração para o Exclusive OR
void setup(){
DDRD = DDRD | B00100000; // marca o pino digital 5 como saida.
Serial.begin(9600);
}

void loop(){
PORTD = PORTD ^ B00100000; // inverte o bit 5 (digital pino 5), mantem os demais intocados.
delay(100);
}

Veja também:

  • &&(Boolean AND)
  • ||(Boolean OR)

 

Página de início da referência

Correções, sugestões, e nova documentação devem ser enviadas ao Forum.

O texto de referência do Arduino está baixo uma Licença Creative Commons Attribution-ShareAlike 3.0. Amostras de código utilizadas na referência foram deixados  ao domínio público.

 

O conteúdo desta página é uma tradução para o português a partir do site original do Arduino.

Esta obra está sob uma Licença Creative Commons.

Creative Commons License