Algebra com BITs

0
5226

Olá pessoal!

Nesse novo artigo usaremos matemática com BITS, operadores lógicos e outros conceitos interessantes para manipular números inteiros.


Os números e a matemática dominam nossa vida. Não passamos um dia sem usarmos uma álgebra ou um calculo mesmo que não seja diretamente. O que não nos mostram na escola é que os números podem ter diferentes representações e só nos é apresentada o sistema de base dez ou decimal.

No mundo das maquinas aonde os números são representados em conjuntos de 1 e 0 temos a base dois ou binária que será usada no dia a dia de um programador de sistemas embarcados.Bem como a hexadecimal aonde temos um sistema de base 16 que nos ajudara a representar números binários longos.

Os números no sistema binário serão representados com sequências de 1 e 0 porem como trabalhar esses valores?
Que numero decimal o binário 10010010 representa?

A conversão se dará assim:
casa: 7 6 5 4 3 2 1 0
numero: 1 0 0 1 0 0 1 0
2^Casa:128 64 32 16 8 4 2 1 = 128+16+2=146.

A conversão se trata basicamente de multiplicar o binário da referida casa por uma potencia de 2 elevado a casa do numero. O maior numero decimal a ser representado por um numero de 8Bits seria 255 então podemos usar em um registrador um inteiro de 0 a 255.

Seguindo essa linha de raciocínio qual seria o maior numero representando por um inteiro de 16 bits?


Operadores lógicos

Para quem nunca fez um curso voltado a área de tecnologia fica complicado entender a lógica por trás de varias ferramentas implementadas em compiladores.

Temos basicamente quatro operadores lógicos no C:

OR representado pelo “|”
AND representado pelo “&”
XOR representado pelo “^”
NOT representado pelo “~”

Cada operador possui uma tabela verdade que mostra o seu comportamento:

Bitwise OR (OU)(|):
0 | 0 == 0
0 | 1 == 1
1 | 0 == 1
1 | 1 == 1

Como observamos o comportamento desse operador se trata quando “uma entrada ou outra” estão em 1 a saída será um.

Exemplo usando 8bits: 0b10001000|0b0110001 =?

0b10001000
0b01100001 =0b11101001

A lógica OR servira para certificar que um certo bit em um numero será 1.


Bitwise AND (e)(&):
0 & 0 == 0
0 & 1 == 0
1 & 0 == 0
1 & 1 == 1

Como observamos o comportamento desse operador se trata quando “uma entrada e a outra” estão em 1 a saída será um.

Exemplo usando 8bits: 0b10001001&0b0110001 =?

0b10001001
&
0b01100001 = 0b00000001

A lógica AND servira para verificar qual o estado de um bit em certa casa decimal.
Por exemplo:

Ob11001100 & 0b00001000 == 1
ou
Ob11001100 & 0b00000001 == 0


Bitwise NOT (não)(~):
~ 0 == 1
~ 1 == 0

Como observamos o operador NOT inverte o valor de entrada.

Exemplo usando 8bits: ~0b10001001 == 0b01110110

A logica NOT poderá ser usada para inverter o estado de um numero ou mesmo mudar o comportamento de operadores lógicos anteriores como o OR ou AND.


Bitwise XOR (OU EXCLUSIVA)(^):
0 ^ 0 == 0
0 ^ 1 == 1
1 ^ 0 == 1
1 ^ 1 == 0

Verificamos que a saída do operador será “1” quando as entradas forem diferentes ou exclusivamente um ou outro

Exemplo usando 8bits: 0b10000001^0b00000001 =?

0b10000001
^
0b00000001 = 0b10000000

Pois:
casa 7: 1^0==1
casa 6: 0^0==0
casa 5: 0^0==0
casa 4: 0^0==0
casa 3: 0^0==0
casa 2: 0^0==0
casa 1: 0^0==0
casa 0: 1^0==0

A lógica XOR servira para inverter o estado de um determinado BIT por exemplo.


BIT SHIFT

Podemos alterar a posição de um bit usando os operadores de deslocamento.

>> : para deslocar a direita
<< : para deslocar a esquerda
exemplo:

0b00010000<<3==0b10000000
0b00010000>>7==0b00000001


Mas finalmente amigo para que serve tudo isso.

Irei dar exemplos simples:

Como veremos em um futuro artigo cada pino de GPIO corresponde a um BIT de um endereço de memoria. O PORTD seria o nome do endereço com os 8bits referentes aos 8 pinos do mesmo.

1: Queremos acionar uma luz no pino 4 do PORTD porem não podemos alterar nenhum outro BIT no mesmo PORT pois no pino 3 temos uma sirene e no 2 o controle de uma tranca.Destacando que o primeiro BIT é representado por 0 e o 8º sera o numero 7.

O estado atual do PORTD esta assim: 0b00000100

Como vimos o pino 2 é a tranca e esta acionada não posso em uma operação desativar essa tranca.

Se eu fizer somente isso PORTD=Ob00010000; teremos um erro catastrofico pois iremos limpar o BIT referente a tranca.

Para um correto acionamento usaremos a lógica OR: PORTD=PORTD|0b0001000

Como o estado do PORTD era: 0b00000100

0b00000100
|
0b00010000 == 0b00010100

Sucesso!!! Acionaremos nossa lampada sem desativar nossa tranca

Podemos simplificar a expressão ainda assim: PORTD|=0b0001000 ou ainda usando bit shift com a seguinte expressão PORTD|=(1<<4)

Passado algum tempo queremos que a luz seja desactivada porem como no caso anterior sem mexer nos outros BITS.

Não da para usar a lógica OR pois 1|0 ira retornar “1” não fazendo diferença. Usando uma lógica AND temos o resultado esperado pois 1&0==0 e para manter os outros BITS podemos fazer uma AND com 1 pois 1&1==1 e 0&1==0 então todo BIT que estiver em 1 continuara bem como 0 continuara 0.

0b00010100
&
0b11101111 = 0b00000100

então obtemos a expressão PORTD=PORTD&0b11101111; seguindo a mesma lógica da lógica OR podemos reduzir a expressão PORTD&=&0b11101111;.

Podemos usar o bitshift nesse caso porem com a seguinte lógica:

(1<<4)==0b00010000
~0b00010000==0b11101111

Realizaremos então um deslocamento a esquerda e apos uma inversão resultando na expressão:
PORTD&=~(1<<4);

ótimo agora podemos setar e apagar bits sem alterar outros em um endereço de memoria.

Pessoal por hoje é só.Ate a proxima!

LEAVE A REPLY