Máscara de bits aplicada à programação

Se você é programador de computadores ou microcontroladores ou mesmo um simpatizante da eletrônica, com certeza já ouviu falar das operações lógicas ou booleanas. Certo?

Bom, neste artigo vou tratar de três operações importantíssimas na programação. São elas a operação E (AND), OU (OR) e OU Exclusivo (XOR).

Veremos como aplicá-las com o intuito de manipular bits específicos de uma variável ou registrador sem afetar os demais bits.

Recordar não faz mal a ninguém, vamos às clássicas tabelas verdades das operações que utilizaremos:

Lógica OU (OR) Lógica E (AND) Lógica OU EXCLUSIVO (XOR)
A B S     A B S     A B S
0 0 0     0 0 0     0 0 0
0 1 1     0 1 0     0 1 1
1 0 1     1 0 0     1 0 1
1 1 1     1 1 1     1 1 0

Considere nas tabelas que A e B são entradas e que S é a saída após aplicada a operação lógica correspondente.

Até aqui, nenhuma novidade, parece o mesmo de sempre.

Mas vamos tirar proveito deste conhecimento para atualizarmos um ou mais bits de uma variável ou registrador, seja com valor 0, 1 ou simplesmente invertendo o estado anterior. Para isso utilizaremos as operações descritas com o cuidado de aplicá-las a uma variável a ser atualizada e a uma segunda variável ou constante criada minuciosamente para produzir o resultado desejado de forma simples e eficaz do ponto de vista computacional.

Essa técnica é chamada de mascaramento ou simplesmente máscara de bits.

Vou separar o estudo em três casos, quando se deseja força um bit para 1, quando se deseja força para 0 e quando e deseja inverter seu estado.


1.      Máscara de OU (OR) – Força um ou mais bits para 1 sem afetar os demais

 

Variável -> 0 0 0 0 0 1 0 1 1 1 1 1 X X X X
Máscara -> 0 0 0 1 1 0 0 0 1 0 0 1 1 1 0 0
Resultado -> 0 0 0 1 1 1 0 1 1 1 1 1 1 1 X X
(a) (b) (c) (d)

Observe que nos exemplos (a), (b) e (c) sempre que existe um bit 1 na máscara o resultado da operação lógica é forçado para 1 e quando a máscara vale 0 o resultado se mantém o mesmo da variável de entrada.

O exemplo (d), representa o caso geral, onde independente da entrada, sempre que aplicada uma máscara de OU (OR) o resultado será 1 nas mesmas posições dos bits 1s da máscara e se manterá inalterado nos demais.

Exemplo de aplicação da máscara de OU (OR) em linguagem C-style:

unsigned char A = 0xF0;        //Em binário 11110000

//Desejo setar o bit 0 (lsb)

A = A | 0x01;            //A = 0xF1 ou 11110001 em binário

//Também pode ser usando a forma compacta (minha preferência)

A |= 0x01;                  //A = 0xF1 ou 11110001 em binário

Perceba que com o uso da máscara de OU (OR) os demais bits se mantiveram inalterados. Isso pode ser facilmente realizado por qualquer processador ou microcontrolador, na maioria das vezes requer apenas um ciclo de máquina (tempo necessário para executar uma instrução em linguagem Assembly).


2.      Máscara de E (AND) – Força um ou mais bits para 0 sem afetar os demais

 

Variável -> 1 1 1 1 1 0 1 0 0 0 0 0 X X X X
Máscara -> 1 1 1 0 0 1 1 1 0 1 1 0 0 0 0 0
Resultado -> 1 1 1 0 0 0 1 0 0 0 0 0 0 0 X X
(a) (b) (c) (d)

Observe que nos exemplos (a), (b) e (c) sempre que existe um bit 0 na máscara o resultado da operação lógica é forçado para 0 e quando a máscara vale 1 o resultado se mantém o mesmo da variável de entrada.

O exemplo (d), representa o caso geral, onde independente da entrada, sempre que aplicada uma máscara de E (AND) o resultado será 0 nas mesmas posições dos bits 0s da máscara e se manterá inalterado nos demais.

Exemplo de aplicação da máscara de E (AND) em linguagem C-style:

unsigned char A = 0x0F;                //Em binário 00001111

//Desejo resetar o bit 0 (lsb)

A = A & 0xFE;               //A = 0x0E ou 00001110 em binário

//Também pode ser usando a forma compacta

A &= 0xFE;                    //A = 0x0E ou 00001110 em binário

Outra forma de se aplicar esta máscara, que acho mais elegante do ponto de vista de estilo de programação, é tentar manter a ênfase aos bits que serão resetados (zerados) pela máscara. Isso quer dizer, montar a expressão de forma que fique claro quais bits serão mantidos e quais serão forçados para zero. Veja a expressão reescrita.

A = A & ~0x01;

//ou (minha preferência)

A &= ~0x01;

O operador ~ realiza o complemento do valor da máscara antes de realizar a operação lógica E, mantendo dessa forma o valor original. Essa forma de representar deixa evidente que o bit a ser forçado para 0 é o bit 0.


3.      Máscara de OU Exclusivo (XOR) – Força um ou mais bits a inverter seu estado sem afetar os demais

 

Variável -> 0 0 0 0 1 0 1 0 1 1 1 0 X X X X
Máscara -> 0 0 0 1 1 0 0 0 1 0 0 1 1 1 0 0
Resultado -> 0 0 0 1 0 0 1 0 0 1 1 1 /X /X X X
(a) (b) (c) (d)

Observe que nos exemplos (a), (b) e (c) sempre que existe um bit 1 na máscara o resultado da operação lógica é forçado para o inverso do estado inicial e quando a máscara vale 0 o resultado se mantém o mesmo da variável de entrada.

O exemplo (d), representa o caso geral, onde independente da entrada, sempre que aplicada uma máscara de OU Exclusivo (XOR) o resultado será o inverso (complemento) nas mesmas posições dos bits 1s da máscara e se manterá inalterado nos demais.

Exemplo de aplicação da máscara de OU Exclusivo (XOR) em linguagem C-style:

unsigned char A = 0x0F;                //Em binário 00001111

//Desejo inverter o bit 0 (lsb)

A = A ^ 0x01;                 //A = 0x0E ou 00001110 em binário

//Se aplicar novamente usando a forma compacta (minha preferência)

A ^= 0x01;                      //A = 0x0F ou 00001111 em binário

//Se aplicar mais uma vez

A ^= 0x01;                      //A = 0x0E ou 00001110 em binário

Perceba que com o uso da máscara de OU Exclusivo (XOR) os demais bits se mantiveram inalterados. Se você é da “eletrônica” e faz seus projetos com microcontrolador, com certeza já precisou fazer um LED piscar. Esta é uma forma bastante simples de fazer isso!

As técnicas apresentadas foram exemplificadas com apenas um bit sendo alterado, mas com demonstrado nos exemplos com expressões lógicas, você pode alterar quantos bits quiser.


Resumão

Máscara de OU (OR) – Força um ou mais bits para 1

A = A | máscara;               //Onde tem 1 vai para 1

A |= máscara;

Máscara de E (AND) – Força um ou mais bits para 0

A = A & máscara;             //Onde tem 0 vai para 1

A |= máscara;

Máscara de OU Exclusivo (XOR) – Inverte um ou mais bits

A = A ^ máscara;              //Onde tem 1 é invertido

A ^= máscara;


 

Vídeo com essas explicações no YouTube:

 

 

Uma resposta para Máscara de bits aplicada à programação

  1. Renato Machado disse:

    Muito bom prof. Leandro!

Deixe uma resposta

Preencha os seus dados abaixo ou clique em um ícone para log in:

Logotipo do WordPress.com

Você está comentando utilizando sua conta WordPress.com. Sair / Alterar )

Imagem do Twitter

Você está comentando utilizando sua conta Twitter. Sair / Alterar )

Foto do Facebook

Você está comentando utilizando sua conta Facebook. Sair / Alterar )

Foto do Google+

Você está comentando utilizando sua conta Google+. Sair / Alterar )

Conectando a %s

%d blogueiros gostam disto: