Operações com Bits

Programa¸cão de sistemas embarcados: Opera¸cões com
bits
Prof.MSc.Rodrigo Maximiano Antunes de Almeida
Universidade Federal de Itajubá
rodrigomax@unifei.edu.br
ELT024 Programa¸cão de sistemas embarcados: Opera¸cões com bitsrodrigomax@unifei.edu.br 1 / 38

Linguagem C
Tipos de dados em C
Tipos de dados em C

Linguagem C
Tipos de dados em C
Tipo Bits Bytes Faixa de valores
char 8 1 -128 à 127
int 16 2 -32.768 à 32.767
float 32 4 3,4 x 10-38 à 3,4 x 1038
double 64 8 3,4 x 10-308 à 3,4 x 10308

Linguagem C
Conversão Binário, Decimal, Hexadecimal
Conversão Binário-decimal
Dividir o número por 2
Anotar o valor do resto (0 ou 1)
Se o valor é maior que 0 voltar ao número 1
Escrever os valores obtidos através do passo 2 de trás para frente.
Apresentar o resultado

Linguagem C
Bit número 7 6 5 4 3 2 1 0
Potência de 2 27
26
25
24
23
22
21
20
Valor em decimal 128 64 32 16 8 4 2 1

Linguagem C
Base Hexadecimal
Possui 16 ”unidades”diferentes.
10 algarismos mais 6 letras
Facilita escrita de valores binários
Fácil conversão bin-hex

Linguagem C
Dec Bin Hex Dec Bin Hex
0 0000 0 8 1000 8
1 0001 1 9 1001 9
2 0010 2 10 1010 A
3 0011 3 11 1011 B
4 0100 4 12 1100 C
5 0101 5 13 1101 D
6 0110 6 14 1110 E
7 0111 7 15 1111 F

Linguagem C
Opera¸c˜oes com bits

Linguagem C
Opera¸c˜ao l´ogica NOT
A !A
0 1
1 0

Linguagem C
Declara¸cão Lógico Bitwise
1 char A = 12;
2 // A = 0b00001100
1 result = ! A ;
2 // r e s u l t = 0
1 result = Ã ;
2 // r e s u l t = 243
3 // A = 0b00001100
4 // r = 0b11110011

Linguagem C
Opera¸c˜ao l´ogica AND
A B A&&B
0 0 0
0 1 0
1 0 0
1 1 1

Linguagem C
1 char A = 8;
2 // A = 0b00001000
3 char B = 5;
4 // B = 0b00000101
1 result = A && B ;
2 // r e s u l t = 1
1 result = A & B ;
2 // r e s u l t = 0
3 // A = 0b00001000
4 // B = 0b00000101
5 // r = 0b00000000

Linguagem C
Opera¸c˜ao l´ogica OR
A B A||B
0 0 0
0 1 1
1 0 1
1 1 1

Linguagem C
1 char A = 8;
2 // A = 0b00001000
3 char B = 5;
4 // B = 0b00000101
1 result = A | | B ;
2 // r e s u l t = 1
1 result = A | B ;
2 // r e s u l t = 13
3 // A = 0b00001000
4 // B = 0b00000101
5 // r = 0b00001101

Linguagem C
Opera¸c˜ao l´ogica XOR
A B A xor B
0 0 0
0 1 1
1 0 1
1 1 0

Linguagem C
1 char A = 8;
2 // A = 0b00001000
3 char B = 5;
4 // B = 0b00000101
1 // n˜ao e x i s t e ←
em C
1 result = A ˆ B ;
2 // r e s u l t = 13
3 // A = 0b00001000
4 // B = 0b00000101
5 // r = 0b00001101

Linguagem C
A opera¸cão shift desloca os bits
Para a esquerda operador <<
Para direita operador >>
É necessário indicar quantas casas serão deslocadas

Linguagem C
Declara¸c˜ao Shift Esquerda Shift Direita
1 char A = 8;
2 // A = 0b00001000
1 result = A << 2;
2 // r e s u l t = 32
3 // A = 0b00001000
4 // r = 0b00100000
1 result = A >> 2;
2 // r e s u l t = 2
3 // A = 0b00001000
4 // r = 0b00000010

Linguagem C
Ligar um bit
Criar uma ”máscara”cheia de 0 (zeros) e com 1 (um) apenas na
posi¸cão desejada
Fazer uma opera¸cão OR entre a variável e a máscara
Posi¸cão N . . . X+1 X X-1 . . . 0
Valor 0 . . . 0 1 0 . . . 0

Linguagem C
Desligar um bit
Criar uma ”máscara”cheia de 1 (uns) e com 0 (zero) apenas na
Fazer uma opera¸cão AND entre a variável e a máscara
Posi¸cão N . . . X+1 X X-1 . . . 0
Valor 1 . . . 1 0 1 . . . 1

Linguagem C
Trocar o valor de um bit
Fazer uma opera¸cão XOR entre a variável e a máscara
Posi¸cão N . . . X+1 X X-1 . . . 0
Valor 0 . . . 0 1 0 . . . 0

Linguagem C
Verificar o estado de um bit
Fazer uma opera¸cão AND entre a variável e a máscara
Não atribuir o resultado à variável
Posi¸cão N . . . X+1 X X-1 . . . 0
Valor 0 . . . 0 1 0 . . . 0

Linguagem C
Opera¸c˜oes com deﬁnes

Linguagem C
Opera¸c˜ao Bit set
Passo a Passo
1 char bit = 2;
2 char mascara ;
3 mascara = 1 << bit ;
4 arg = arg | mascara ;
Uma linha 1 arg |= (1<<bit )
Com deﬁne 1 #define BitSet ( arg , bit ) (( arg ) |= (1<<bit ) )

Linguagem C
Opera¸c˜ao Bit clear
Passo a Passo
1 char bit = 2;
2 char mascara ;
4 arg = arg & ˜mascara ;
Uma linha 1 arg &= ˜(1<<bit )
Com deﬁne 1 #define BitClr ( arg , bit ) (( arg ) &= ˜(1<<bit ) )

Linguagem C
Opera¸cão Bit flip
Passo a Passo
1 char bit = 2;
2 char mascara ;
4 arg = arg ˆ mascara ;
Uma linha 1 arg ˆ= (1<<bit )
Com define 1 #define BitFlp ( arg , bit ) (( arg ) ˆ= (1<<bit ) )

Linguagem C
Opera¸c˜ao Bit test
Passo a Passo
1 char bit = 2;
2 char mascara ;
4 i f ( arg & mascara ) { }
Uma linha 1 i f ( arg & (1<<bit ) ) { }
Com deﬁne 1 #define BitTst ( arg , bit ) (( arg ) & (1<<bit ) )

Linguagem C
Debug de sistemas embarcados

Linguagem C

Linguagem C
Tipos de bugs:
Bohrbug
Mandelbug
Heisenbug
Schroedinbug

Linguagem C
Bohrbug
Bug ”bem comportado”
É poss´ıvel repetir o bug
Não se altera com observa¸cão
Niels H. D. Bohr

Linguagem C
Mandelbug
Oposto do Bohrbug
Tem causas extremamente
complicadas
Parece ter comportamento
ca´otico e indeterminado
Benoˆıt B. Mandelbrot

Linguagem C
Heisenbug
A utiliza¸cão de ferramentas de
debug fazem o bug
desaparecer
Pode estar ligado a opera¸cões
temporais, paralelismo de
fun¸cões
Intertravamento e obten¸cão
de recursos
Werner K. Heisenberg

Linguagem C
Schroedinbug
Um programa está
funcionando
Ao olhar o código descobre-se
que ele não devia funcionar
A partir deste momento o
programa para de funcionar
Erwin R. J. A.
Schrödinger

Linguagem C
Como debugar sistemas embarcados?
Externalizar as informa¸cões
Programa¸cão incremental
Checar poss´ıveis pontos de memory-leak
Existe possibilidade de fragmenta¸cão da memória?
Otimiza¸cão de código
Reproduzir e isolar o erro

Linguagem C
Externalizar as informa¸cões
Cuidado com overhead
Separar alguns leds apenas para debug
Enviar sinais via serial apenas se necessário
Usar um emulador para obter informa¸cões

Linguagem C
Programa¸cão incremental
Apenas inserir mais fun¸cões depois de ter uma primeira versão funcional
Testar após cada altera¸cão do código
Checar poss´ıveis pontos de memory-leak
Verificar se cada malloc() possui seu free()
Existe possibilidade de fragmenta¸cão da memória?
Repensar rotinas que utilizam malloc() e free() demasiadamente

Linguagem C
Otimiza¸cão de código
Nunca otimizar se não for necessário
Se achar que é necessário utilizar um profiler antes
Verificar as otimiza¸cões já realizadas em busca de overflows, typecasts
inadequados, segmentation faults, etc.
Reproduzir e isolar o erro
Abusar do step-by-step de debug
Testar repetibilidade do erro
Isolar as fun¸cões problemáticas

Operações com Bits

Mais conteúdo relacionado

Semelhante a Operações com Bits (20)

Mais de Rodrigo Almeida (20)

Último (19)

Operações com Bits