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

Recommended

Recommended

More Related Content

Similar to Operações com Bits

Similar to Operações com Bits (20)

More from Rodrigo Almeida

More from Rodrigo Almeida (20)

Operações com Bits