Exemplo da criação de um código binário.

O objetivo deste trabalho é construir um sistema que converta um número decimal para um
código binário chamado “código teste”, depois, o resultado será convertido em decimal
observado em um display de sete segmentos. Esse processo será executado através de um
codificador decimal para código teste e, depois o código teste deve ser transformado em
binário, com a utilização de um codificador de condigo teste para binário e finalizando com um
decodificador BCD para display de sete segmentos. Veja no diagrama abaixo.

Codificador DEC – Codificador Decodificador

Display de sete
Teclado COD_teste COD_teste –BCD BCD – display de
segmentos
sete segmentos

Algoritmo para construção do código teste

O código teste é um código é um número construído a partir da transformação de um número

binário em complemento de dois.

O Complemento de 2 (dois) é usado para representar número binários negativos Para isto uma
seqüência de bits que representem convenciona-se que o bit mais a esquerda representa o sinal
do número. Se 0 (zero) corresponde a um número positivo e se 1 (um) corresponde a um
número negativo.

Exemplos: 0110 (bit mais a esquerda é zero. Representa número positivo). 1001 (representa
número negativo).

O complemento de 2 (dois) de um número é encontrado através do seguinte algoritmo

Determina-se primeiro o complemento de 1 (um) do número. Invertendo a seqüência de bits

(todo 1 vira zero, todo zero vira um)

Exemplo : O complemento um de 0011. O resultado é 1100.

Soma-se 1 ao número em complemento de 1 (um). O resultado corresponde ao complemento

de 2 (dois) do número.

Somando 1 a 1100 obtém-se 1101.Portanto , o complemento 2 de 0011 é 1101.

Para converter o binário em código teste, transformamos em complemento de dois.

Dessa forma completamos a tabela com o Código Teste.

Binário Complemento de 1 Complemento de 2

Decimal
D C B A ~D ~C ~B ~A S3 S2 S1 S0
0 0 0 0 0 1 1 1 1 0 0 0 0
1 0 0 0 1 1 1 1 0 1 1 1 1
2 0 0 1 0 1 1 0 1 1 1 1 0
3 0 0 1 1 1 1 0 0 1 1 0 1
4 0 1 0 0 1 0 1 1 1 1 0 0
5 0 1 0 1 1 0 1 0 1 0 1 1
6 0 1 1 0 1 0 0 1 1 0 1 0
7 0 1 1 1 1 0 0 0 1 0 0 1
8 1 0 0 0 0 1 1 1 1 0 0 0
9 1 0 0 1 0 1 1 0 0 1 1 1
10 1 0 1 0 0 1 0 1 0 1 1 0
11 1 0 1 1 0 1 0 0 0 1 0 1
12 1 1 0 0 0 0 1 1 0 1 0 0
13 1 1 0 1 0 0 1 0 0 0 1 1
14 1 1 1 0 0 0 0 1 0 0 1 0
15 1 1 1 1 0 0 0 0 0 0 0 1
Codificador Decimal/ Código Teste

Como codificador, utilizaremos um codificador com dez entradas em forma de tecla e a saída
em Código Teste de quatro bits.

A tabela verdade mostra uma entrada para cada número decimal, em um total de dez
entradas, e saída com quatro bits no código teste.

Entradas Saídas
E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 S3 S2 S1 S0
0 0 0 0 0 0 0 0 0 1 0 0 0 0
0 0 0 0 0 0 0 0 1 0 1 1 1 1
0 0 0 0 0 0 0 1 0 0 1 1 1 0
0 0 0 0 0 0 1 0 0 0 1 1 0 1
0 0 0 0 0 1 0 0 0 0 1 1 0 0
0 0 0 0 1 0 0 0 0 0 1 0 1 1
0 0 0 1 0 0 0 0 0 0 1 0 1 0
0 0 1 0 0 0 0 0 0 0 1 0 0 1
0 1 0 0 0 0 0 0 0 0 1 0 0 0
1 0 0 0 0 0 0 0 0 0 0 1 1 1

Através da tabela construímos uma expressão booleana para cada saída.

Com a expressão construímos o circuito.

Codificador Código Teste/ Binário.

Para converter o código teste em binário, transformamos em complemento de dois.

A tabela verdade mostra

Cod_Test Complemento de 1 Complemento de 2

S3 S2 S1 S0 ~D ~C ~B ~A D C B A
0 0 0 0 1 1 1 1 0 0 0 0
0 0 0 1 1 1 1 0 1 1 1 1
0 0 1 0 1 1 0 1 1 1 1 0
0 0 1 1 1 1 0 0 1 1 0 1
0 1 0 0 1 0 1 1 1 1 0 0
0 1 0 1 1 0 1 0 1 0 1 1
0 1 1 0 1 0 0 1 1 0 1 0
0 1 1 1 1 0 0 0 1 0 0 1
1 0 0 0 0 1 1 1 1 0 0 0
1 0 0 1 0 1 1 0 0 1 1 1
1 0 1 0 0 1 0 1 0 1 1 0
1 0 1 1 0 1 0 0 0 1 0 1
1 1 0 0 0 0 1 1 0 1 0 0
1 1 0 1 0 0 1 0 0 0 1 1
1 1 1 0 0 0 0 1 0 0 1 0
1 1 1 1 0 0 0 0 0 0 0 1

A tabela verdade em uma ordem de acordo com o Cod_Test mostra

Entrada Cod_test Saída binário

Decimal
S3 S2 S1 S0 D C B A
0 0 0 0 0 0 0 0 0
15 0 0 0 1 1 1 1 1
14 0 0 1 0 1 1 1 0
13 0 0 1 1 1 1 0 1
12 0 1 0 0 1 1 0 0
11 0 1 0 1 1 0 1 1
10 0 1 1 0 1 0 1 0
9 0 1 1 1 1 0 0 1
8 1 0 0 0 1 0 0 0
7 1 0 0 1 0 1 1 1
6 1 0 1 0 0 1 1 0
5 1 0 1 1 0 1 0 1
4 1 1 0 0 0 1 0 0
3 1 1 0 1 0 0 1 1
2 1 1 1 0 0 0 1 0
1 1 1 1 1 0 0 0 1
Através do mapa de karnaugh. Temos.

Saída A

0 1 1 0
0 1 1 0
0 1 1 0
0 1 1 0

Saída B.

0 1 0 1
0 1 0 1
0 1 0 1
0 1 0 1

Saída C.

0 1 1 1
1 0 0 0
1 0 0 0
0 1 1 1
Saída D.

0 1 1 1
1 1 1 1
0 0 0 0
1 0 0 0

Com as expressões montamos o circuito.

Para construir o circuito para converter de binário para decimal para o uso de display
(BCD8421). Temos.

Decimal S3 S2 S1 S0 a b c d e f g
0 0 0 0 0 1 1 1 1 1 1 0
1 1 1 1 1 0 1 1 0 0 0 0
2 1 1 1 0 1 1 0 1 1 0 1
3 1 1 0 1 1 1 1 1 0 0 1
4 1 1 0 0 0 1 1 0 1 1 0
5 1 0 1 1 1 0 1 1 0 1 1
6 1 0 1 0 1 0 1 1 1 1 1
7 1 0 0 1 1 1 1 0 0 0 0
8 1 0 0 0 1 1 1 1 1 1 1
9 0 1 1 1 1 1 1 1 0 1 1
10 0 1 1 0 X X X X X X X
11 0 1 0 1 X X X X X X X
12 0 1 0 0 X X X X X X X
13 0 0 1 1 X X X X X X X
14 0 0 1 0 X X X X X X X
15 0 0 0 1 X X X X X X X

Circuito Decodificador BCD – display de sete segmentos.

Circuito completo com portas básicas.

Circuito completo encapsulado.