Máscaras e operações de bits em C/C++

Um byte tem oito posições, numeradas de 0 a 7. A posição 0 é o bit menos significativo (à direita); a 7 é o mais significativo (à esquerda).

Uma máscara é um valor inteiro usado para marcar posições de interesse: cada bit em 1 seleciona sua posição correspondente. Por enquanto, apenas leia a máscara: ela não muda nenhuma variável sozinha.

O prefixo 0x informa que o literal está em hexadecimal. O tipo uint8_t armazena os oito bits da máscara.

Compare o padrão de oito bits com seu hexadecimal. Bits em 0 não são selecionados; bits em 1 são selecionados.

Por exemplo, 0x24 corresponde a 0010 0100: seleciona as posições 5 e 2. A máscara é somente um padrão de seleção; as operações que a aplicam serão estudadas depois.

Agora faça as associações.

Complete a declaração com o literal que seleciona simultaneamente as posições 7 e 0 de um byte. Use o prefixo hexadecimal 0x.

Os operadores bit a bit trabalham posição por posição entre dois valores inteiros. Para cada coluna de bits, eles geram outro bit:

• & resulta em 1 somente quando os dois bits são 1.
• | resulta em 1 quando pelo menos um bit é 1.
• ^ resulta em 1 quando os bits são diferentes.

Com a = 0x30 (00110000) e b = 0x0C (00001100), não há nenhuma posição em que ambos tenham 1. Portanto, a & b vale 0x00 — mesmo que a e b sejam valores não nulos.

Uma máscara indica quais posições importam no resultado. Se mascara tem 1 em uma posição:

• valor & mascara mantém o bit de valor naquela posição; onde a máscara tem 0, o resultado fica 0.
• valor | mascara produz 1 naquela posição; onde a máscara tem 0, o resultado acompanha valor.
• valor ^ mascara produz o bit oposto naquela posição; onde a máscara tem 0, o resultado acompanha valor.

Essas expressões produzem valores inteiros. Elas não são, por si só, perguntas verdadeiras ou falsas.

Compare os tipos de resultado destas duas intenções.

Em uma expressão bit a bit, os dois operandos são avaliados para que seus bits possam ser combinados. Já && e || usam curto-circuito:

• Em testeA() && testeB(), se testeA() for falsa, testeB() não é chamada.
• Em testeA() || testeB(), se testeA() for verdadeira, testeB() não é chamada.

Assim, não troque & por && apenas porque ambos lembram AND. Além de retornarem tipos de resultado diferentes, a execução das funções nos operandos pode mudar.

Nas duas primeiras linhas, as duas funções são chamadas. Nas demais, a segunda chamada depende do resultado da primeira.

No Uno R3, uint8_t armazena 8 bits, mas, em uma expressão, ele é promovido a int. Isso ocorre porque o int de 16 bits da placa representa todos os valores de 0 a 255.

Assim, se byteValor contém 0x5A, a expressão ~byteValor complementa os 16 bits do int promovido. Considerando esses 16 bits, o padrão passa de 0x005A para 0xFFA5 — não apenas de 0x5A para 0xA5.

A variável original continua com 0x5A: ~ produz um resultado, mas não altera seu operando.

~ e ! não são duas formas equivalentes de negar um valor.

• ~ complementa cada bit da largura efetiva da expressão e produz um padrão inteiro. Para 0x5A promovido no Uno R3, o padrão resultante é 0xFFA5 em 16 bits.
• ! avalia logicamente o valor: produz false para qualquer valor diferente de zero e true para zero. Portanto, !0x5A é false.

Quando a intenção for trabalhar explicitamente com um padrão sem sinal de 16 bits no Uno R3, use um operando unsigned int, como um literal com sufixo U. O literal 0x005AU é sem sinal; seu complemento tem o padrão 0xFFA5 nessa largura.

O sufixo U torna o literal sem sinal. No Uno R3, unsigned int tem 16 bits.

Se o objetivo é guardar somente o byte invertido, limite primeiro o resultado largo aos oito bits inferiores. Com original = 0x5A, o complemento sem sinal é 0xFFA5; a máscara 0x00FFU produz 0x00A5. Só depois represente esse valor como uint8_t.

A conversão final escolhe a representação de destino. Ela não valida automaticamente a faixa, não reduz a largura da expressão anterior e não substitui uma limitação explícita quando ela faz parte da intenção do código.

Uma flag é um bit usado para representar um estado dentro de uma variável comum. Por exemplo, em estado, o bit 2 pode indicar que uma condição está ativa.

Para consultar uma flag, aplique a máscara com & e compare o resultado com zero:

(estado & mascara) != 0

A operação & produz um valor temporário. Ela não grava nada em estado; portanto, uma consulta não altera a variável.

Observe que somente a posição selecionada permanece no resultado temporário.

Use parênteses para tornar a intenção explícita: primeiro isole os bits com &; depois compare o resultado.

Neste exemplo, 0x04 seleciona o bit 2. Como estado vale 0x24, a consulta produz 0x04. Esse resultado não é 1, mas ainda é diferente de zero — logo, a flag está ativa.

Uma condição que consulta o bit 2 sem modificar estado.

Uma máscara também pode selecionar várias posições. Em uma condição como:

(estado & ALERTAS) != 0

a pergunta é: pelo menos um dos bits selecionados está ativo?

Se nenhum estiver ativo, o AND resulta em zero. Se um ou mais estiverem ativos, o resultado é diferente de zero. A variável original permanece igual nos dois casos.

As duas consultas usam a mesma máscara, mas produzem respostas diferentes conforme os bits do valor.

ALERTAS seleciona as posições 3 e 4. O resultado 0x10 confirma que pelo menos uma delas está ativa.

Para ativar posições de uma máscara, use OR (|). Onde a máscara tem 1, o resultado fica em 1; onde ela tem 0, o bit original é preservado.

Exemplo: 0xB2 | 0x0C resulta em 0xBE.

• 0xB2 = 10110010
• 0x0C = 00001100
• 0xBE = 10111110

Só os bits 3 e 2 mudaram. A máscara não determina o valor dos demais bits: eles continuam vindo de flags.

As duas formas abaixo atualizam a própria variável. A forma composta deixa explícita a intenção de modificar flags.

Para limpar posições, aplique AND (&) com a máscara complementada. Os 1 da máscara viram 0, forçando essas posições a zero; as outras posições devem receber 1 para serem preservadas.

No Uno R3, uint8_t é promovido a int em muitas expressões. Portanto, ~mascara não deve ser interpretado automaticamente como “o inverso de apenas oito bits”. Primeiro mantenha o cálculo em uma largura sem sinal e limite-o ao byte antes de converter.

Este padrão torna visíveis a largura intermediária e o limite de 8 bits antes do armazenamento em uint8_t.

Para inverter flags, use XOR (^). Onde a máscara tem 1, o bit troca: 0 vira 1 e 1 vira 0. Onde a máscara tem 0, o bit fica igual.

Assim, flags ^= mascara; é apropriado para alternar estados selecionados. Não é uma operação de consulta: ela modifica flags.

Use um operando sem sinal para deixar explícita a largura em que o deslocamento ocorre. No Uno R3, unsigned int tem 16 bits. Em 1U << posicao, o literal 1U começa com um único bit em 1 e tem tipo unsigned int.

<< move os bits para a esquerda, insere zeros pela direita e descarta o que sair pela extremidade esquerda. Assim, 1U << 5 produz 0x0020. Com um operando sem sinal, >> move os bits para a direita, insere zeros pela esquerda e descarta os bits que saem à direita.

A operação acontece na largura efetiva do operando, não na largura da variável que talvez receba o resultado depois.

A contagem deve ser válida antes do deslocamento: ela não pode ser negativa e deve ser estritamente menor que a largura efetiva do operando.

No Uno R3, para 1U como unsigned int de 16 bits, as contagens de 0 a 15 são válidas para a operação. Logo, 1U << 8 é uma operação válida e produz 0x0100.

Mas uma máscara destinada a uint8_t tem outra regra: só pode selecionar posições de 0 a 7. Portanto, 1U << 8 é válido em 16 bits, porém não cabe em um byte e não representa uma máscara de byte.

Para construir uma máscara de byte a partir de uma posição informada, valide primeiro o objetivo específico: a posição deve estar entre 0 e 7. Só então execute 1U << posicao.

O U em 1U é importante: ele cria o ponto de partida como unsigned int. Se o operando à esquerda fosse um uint8_t, ele poderia ser promovido a int antes do deslocamento no Uno R3. Quando a intenção exigir uma largura sem sinal específica, converta o operando antes de deslocar; converter somente o resultado não muda a operação que já ocorreu.

Depois de validar 0 a 7, o resultado de 1U << posicao está entre 0x0001 e 0x0080, portanto cabe em uint8_t.

Bloco direto para criar uma máscara de byte. A variável começa com zero caso a posição seja recusada.

Um campo de bits é um grupo de posições contíguas que guarda um pequeno valor dentro de uma variável. Para lê-lo, use duas etapas sem alterar o byte original:

1. Aplique uma máscara para manter somente o campo.
2. Desloque o resultado à direita até o bit menos significativo.

Considere status = 0xB4, ou 10110100 em oito bits. Vamos interpretar as posições 5, 4 e 3 como um campo de três bits. A máscara 0x38U seleciona exatamente essas posições.

Depois de isolar o campo, seu padrão ainda está nas posições 5 a 3. O deslocamento de três posições o alinha à posição 0, permitindo lê-lo como um número de 0 a 7.

No Uno R3, um uint8_t pode ser promovido para int em uma expressão. Para deixar explícito que o isolamento e o deslocamento devem usar um tipo sem sinal, converta o valor para uint16_t antes dessas operações.

A máscara produz 0x30: os bits externos ao campo se tornam zero. Em seguida, 0x30 >> 3 resulta em 0x06, isto é, o valor decimal 6.

O campo tem apenas três bits, portanto seu resultado está entre 0 e 7. Só então é seguro representá-lo em uint8_t. Note que status não recebe nenhuma atribuição: ele continua sendo 0xB4.

Exemplo de extração das posições 5, 4 e 3 de um byte.

O diagrama mostra um campo nas posições 5, 4 e 3 do byte 0xB4. Complete o código para isolá-lo, alinhá-lo ao bit 0 e registrar o valor previsto. Não há atribuição a status, portanto o byte de origem deve permanecer preservado.

Uma palavra uint16_t tem 16 bits. Para reunir dois uint8_t, trate um como byte mais significativo (alto) e o outro como byte menos significativo (baixo):

• alto ocupará as posições 15 a 8.
• baixo ocupará as posições 7 a 0.

Exemplo: alto = 0xA5 e baixo = 0x3C formam a palavra 0xA53C.

Isso descreve o valor da variável. Não informa nem depende de como bytes podem estar dispostos na memória física.

No Uno R3, converta alto para uint16_t antes de deslocá-lo oito posições. Assim, o deslocamento atua sobre um operando sem sinal de 16 bits, em vez de depender da promoção de uint8_t para int.

Depois, use OR para unir as regiões que não se sobrepõem. Também convertemos baixo para uint16_t, deixando os dois operandos do OR na mesma largura explícita.

Para recuperar os valores, mantenha somente os oito bits inferiores ou desloque os oito superiores para a direita. A máscara 0x00FFU confirma que o resultado está entre 0x00 e 0xFF; só então ele é convertido para uint8_t. Nenhuma dessas operações altera palavra.

Composição e recuperação de dois bytes

Nesta aplicação final, você vai prever e conferir uma sequência completa usando apenas variáveis comuns.

Antes de aceitar um resultado, percorra esta lista:

1. A posição destinada a uma máscara de byte está entre 0 e 7?
2. O operando à esquerda do deslocamento tem o tipo pretendido, como 1U?
3. A contagem é menor que a largura efetiva desse operando?
4. O resultado foi limitado à faixa do destino antes da conversão para uint8_t, quando necessário?
5. Os bits fora da máscara permaneceram iguais?

Uma conversão posterior não torna válido um deslocamento que já era inválido.

Copie este sketch para a IDE Arduino apenas se quiser fazer a conferência local. Ele usa somente o LED integrado: após a gravação, o LED fica aceso quando todas as comparações são verdadeiras.

No Uno R3, o byte alto é convertido para uint16_t antes de << 8. Portanto, o deslocamento ocorre sobre um operando sem sinal de 16 bits, e deslocar oito posições é válido.

O sketch também não constrói máscara para posicaoInvalida = 8: ele apenas confirma que esse valor deve ser rejeitado para a finalidade de um byte. Se você executar a prática, LED aceso confirma as comparações programadas; LED apagado indica que alguma expectativa não foi satisfeita.