UNIVERSIDADE ESTADUAL DE CAMPINAS

FEEC - FACULDADE DE ENGENHARIA E COMPUTAÇÃO

EA773 - LABORATÓRIO DE CIRCUITOS LÓGICOS

RELATÓRIO 3

Nome: João Paulo Pereira de V. Mendes

RA: 237561
Professor: Marco Aurélio Amaral
Turma: U

CAMPINAS
2019
Sumário
1 Objetivos 1

2 Procedimentos e Resultados 1
2.1 Atividade 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
2.1.1 Complementa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
2.1.2 Zera . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.1.3 Soma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.2 Atividade 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.3 Atividade 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.4 Atividade 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.5 Atividade 5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

3 Conclusões 17
3.1 Conceitos Relembrados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
3.2 Noções Adquiridas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

1 Objetivos
O objetivo das atividades feitas são:
1 - Explicar o funcionamento da ULA (Unidade Lógico-Aritmética), hábil em resolver
operações aritméticas básicas com números inteiros em complemento de 2.
2 - Fazer o display da FPGA sinalizar números hexadecimais de 0 até F.

2 Procedimentos e Resultados
Os procedimentos para as atividades consistiram em etapas semelhantes. Em todas,
sem exceção, tivemos de:
1 - Construir a tabela verdade.
2 - Desenhar o mapa de Karnaugh para o obter os circuitos minimizados.
3 - Projetar no Quartus II a expressão calculada.
4 - Testar simulações do tipo .vwf que computam a funcionalidade do circuito.
5 - Testar na placa FPGA Cyclone II o projeto feito

Junto de uma exposição da função de cada bloco construı́do, esses serão os passos que
constarão nos procedimentos das seguintes seções.

2.1 Atividade 1
2.1.1 Complementa
O bloco complementa, basicamente, age transformando as entradas de X ou Y em
complemento de 1, ação esta responsável por negativar o número. Para isso usamos uma
porta XOR que liga as entradas de X ou Y e o complemento (C), que no caso das
atividades posteriores vem do decodificador em forma da booleana ”1”, necessária para
a funcionalidade do bloco. O número binário em complemento de 1 posteriormente, no

1
bloco Soma, soma-se ao binário que não está em complemento e, com a soma do
Carry, obtêm-se como saı́da um número em complemento de 2.

C I3 I2 I1 I0 O3 O2 O1 O0
0 0 0 0 0 0 0 0 0
0 0 0 0 1 0 0 0 1
0 0 0 1 0 0 0 1 0
0 0 0 1 1 0 0 1 1
0 0 1 0 0 0 1 0 0
0 0 1 0 1 0 1 0 1
0 0 1 1 0 0 1 1 0
0 0 1 1 1 0 1 1 1
0 1 0 0 0 1 0 0 0
0 1 0 0 1 1 0 0 1
0 1 0 1 0 1 0 1 0
0 1 0 1 1 1 0 1 1
0 1 1 0 0 1 1 0 0
0 1 1 0 1 1 1 0 1
0 1 1 1 0 1 1 1 0
0 1 1 1 1 1 1 1 1
1 0 0 0 0 1 1 1 1
1 0 0 0 1 1 1 1 0
1 0 0 1 0 1 1 0 1
1 0 0 1 1 1 1 0 0
1 0 1 0 0 1 0 1 1
1 0 1 0 1 1 0 1 0
1 0 1 1 0 1 0 0 1
1 0 1 1 1 1 0 0 0
1 1 0 0 0 0 1 1 1
1 1 0 0 1 0 1 1 0
1 1 0 1 0 0 1 0 1
1 1 0 1 1 0 1 0 0
1 1 1 0 0 0 0 1 1
1 1 1 0 1 0 0 1 0
1 1 1 1 0 0 0 0 1
1 1 1 1 1 0 0 0 0

Tabela 1: Tabela verdade do Complementa

Sendo seu mapa de Karnaugh:

2
Figura 1: Mapa K de O3

Figura 2: Mapa K de O2

Figura 3: Mapa K de O1

3
 Figura 4: Mapa K de O0

Sua função booleana é:

O3 = C ⊕ I3
O2 = C ⊕ I2
O1 = C ⊕ I1
O0 = C ⊕ I0

Figura 5: Circuito no Quartus

Figura 6: Waveform do Complementa

4
 Figura 7: Bloco do Complementa

2.1.2 Zera
O bloco Zera tem a função especı́fica de zerar as entradas, como próprio nome diz.
Para a execução desta tarefa, usamos a porta AND, com uma entrada sendo o Z e a
outra os bits requisitados, que no futuro serão os de Y. Toda vez que Z = 0, temos como
saı́da do bloco a booleana 0.

Zy I3 I2 I1 I0 O3 O2 O1 O0
0 0 0 0 0 0 0 0 0
0 0 0 0 1 0 0 0 0
0 0 0 1 0 0 0 0 0
0 0 0 1 1 0 0 0 0
0 0 1 0 0 0 0 0 0
0 0 1 0 1 0 0 0 0
0 0 1 1 0 0 0 0 0
0 0 1 1 1 0 0 0 0
0 1 0 0 0 0 0 0 0
0 1 0 0 1 0 0 0 0
0 1 0 1 0 0 0 0 0
0 1 0 1 1 0 0 0 0
0 1 1 0 0 0 0 0 0
0 1 1 0 1 0 0 0 0
0 1 1 1 0 0 0 0 0
0 1 1 1 1 0 0 0 0
1 0 0 0 0 0 0 0 0
1 0 0 0 1 0 0 0 1
1 0 0 1 0 0 0 1 0
1 0 0 1 1 0 0 1 1
1 0 1 0 0 0 1 0 0
1 0 1 0 1 0 1 0 1
1 0 1 1 0 0 1 1 0
1 0 1 1 1 0 1 1 1
1 1 0 0 0 1 0 0 0
1 1 0 0 1 1 0 0 1
1 1 0 1 0 1 0 1 0
1 1 0 1 1 1 0 1 1
1 1 1 0 0 1 1 0 0
1 1 1 0 1 1 1 0 1
1 1 1 1 0 1 1 1 0
1 1 1 1 1 1 1 1 1

Tabela 2: Tabela verdade do Zera

5
 Pela explicação dada acima, torna-se trivial que as expressões booleanas sejam:
O3 = Zy.I3
O2 = Zy.I2
O1 = Zy.I1
O0 = Zy.I0

Figura 8: Circuito no Quartus

Figura 9: Waveform do Zera

Figura 10: Bloco do Zera

2.1.3 Soma
O bloco Soma age somando as 8 entradas e trazendo a tona 8 saı́das, os quais S[3..0]
representam os bits da soma e Z, N, V, C são indicações (flags) de quando a soma
equivale a zero (Z), a soma dá um número negativo (N), quando há overflow (V) e, por
último, quando a soma produz um carry-out (C).

Para isso usamos 4 Full-Adder, são eles os responsáveis por somar os 2 ”nibbles”.

Já os Flags têm a função de sinalizar quando alguma das situações supracitadas
ocorrem.

6
 Figura 11: Full-Adder acoplado (Ai = Xi e Bi = Yi)

Xi Yi Cin S C
0 0 0 0 0
0 0 1 1 0
0 1 0 1 0
0 1 1 0 1
1 0 0 1 0
1 0 1 0 1
1 1 0 0 1
1 1 1 1 1

Tabela 3: Tabela verdade de um Full-Adder

Figura 12: Mapa K de S

Figura 13: Mapa K de Cout

As expressões booleanas achadas foram:

S = (Xi ⊕ Yi) ⊕ Cin
C = (Xi.Yi) + ((Xi ⊕ Yi).Cin )

7
 S[3] S[2] S[1] S[0] Z
0 0 0 0 1
0 0 0 1 0
0 0 1 0 0
0 0 1 1 0
0 1 0 0 0
0 1 0 1 0
0 1 1 0 0
0 1 1 1 0
1 0 0 0 0
1 0 0 1 0
1 0 1 0 0
1 0 1 1 0
1 1 0 0 0
1 1 0 1 0
1 1 1 0 0
1 1 1 1 0

Tabela 4: Tabela verdade da flag Z

Pela falta de necessidade de um mapa K e pela auto evidência, temos que a função
booleana é igual a:
Z = (S[3] + S[2] + S[1] + S[0])’

Para a saı́da N utiliza-se o bit mais significativo que indica o sinal do número que está
representado na saı́da. No caso ele é dado por S[3], portanto ligamos ele diretamente a
saı́da N:
N = S[3]

S[3] X[3] Y[3] V

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

Tabela 5: Tabela verdade da flag V

A flag V tem função de detectar quando a soma de dois números positivos resultam em
um número negativo ou quando a soma de dois números negativos resultam em um
número positivo. Isso se tornou possı́vel em nosso circuito através desta expressão
booleana:

8
 Figura 14: Mapa K de V

V = S[3].X[3]’.Y[3]’ + S[3]’.X[3].Y[3]

Figura 15: Circuito completo no Quartus

Figura 16: Waveform comprovando funcionalidade das flags

Figura 17: Bloco da Soma

9
2.2 Atividade 2
A Atividade 2 nos introduziu o módulo Decodifica, que possui 3 entradas que juntas
formam o Código de Operação, que selecionará a operação que deverá ser executada
pela ULA. Seguindo as instruções da tabela abaixo, escolhemos um RA da dupla, sendo
o RA escolhido o meu, cujo número é 237561 e fizemos os cálculos.

Figura 18: Cálculos feitos com o RA

1 - Adição: Soma os números de entrada X e Y na entrada do somador final não

acionando nenhum outro bloco.
2 - Subtração: É necessário fazer o complemento de 2 na entrada Y, por isso Cy e o
carry são ativados.
3 - Complemento: Complementa o número de X. Para isso aciona-se Cx e Zy , que está
em lógica negativa.
4 - Oposto de X: É necessário transformar o número em um complemento de 2,
acionando assim Cx , Zy e o carry.

Função f2 f1 f0
ADD 0 0 1
SUB 0 1 0
CMX 0 1 1
CSX 1 0 0

Tabela 6: Código de operação baseado nas contas feitas com o RA

Podemos, assim, fazer a tabela verdade, os mapas e, por fim, o circuito que deu
origem ao bloco Decodifica.

f2 f1 f0 Cx Cy Zy Carry
0 0 0 x x x x
0 0 1 0 0 1 0
0 1 0 0 1 1 1
0 1 1 1 0 0 0
1 0 0 1 0 0 1
1 0 1 x x x x
1 1 0 x x x x
1 1 1 x x x x

Tabela 7: Tabela verdade do decodificador

10
 Figura 19: Mapa K de Cx

Figura 20: Mapa K de Cy

Figura 21: Mapa K de Zy

Figura 22: Mapa K do Carry

11
As funções booleanas são:
Cx = f2 + f1 .f0
Cy = f2 ’.f0 ’
Zy = f2 ’.(f1 ’ + f0 ’)
Carry = f0 ’

Figura 23: Circuito no Quartus

Figura 24: Waveform do Decodificador

Figura 25: Bloco Decodifica

2.3 Atividade 3
A atividade 3 foi a atividade responsável por aglutinar os blocos antes compostos em
uma unidade lógico-aritmética. Seguem as imagens e testes da ULA no software
Quartus:

12
 Figura 26: Testes requeridos no moodle

Figura 27: Simulações que executamos

Figura 28: Waveform da ULA

Figura 29: Circuito da ULA

2.4 Atividade 4
A quarta tarefa propunha criarmos um decodificador que alimentasse o display da
FPGA afim de reproduzir os números binários setados em números hexadecimais de 0 a
F considerando no projeto a atividade dos leds em BAIXO. Fizemos as seguintes tabelas
baseando-se na imagem:

13
Figura 30: Display Hexadecimal

Figura 31: Tabela verdade

Figura 32: Mapa K de 0

Figura 33: Mapa K de 1

Figura 34: Mapa K de 2

14
 Figura 35: Mapa K de 3

Figura 36: Mapa K de 4

Figura 37: Mapa K de 5

Figura 38: Mapa K de 6

As funções booleanas encontradas foram:

S[0] = D’.B’.(C ⊕ A) + D.A.(C ⊕ B)
S[1] = C.B.A’ + D.B.A + D.C.A’ + D’.C.B’.A
S[2] = D.C.A’ + D.C.B + D’.C’.B.A’ S[3] = C’.B’.A + C.B.A + D’.C.B’.A’ + D.C’.B.A’
S[4] = D’.A + C’.B’.A + D’.C.B’
S[5] = D’.C’.A + D’.C’.B + D’.B.A + D.C.B’.A
S[6] = D’.C’.B’ + D’.C.B.A + D.C.B’.A’

15
 Figura 39: Circuito do decodificador Hexadecimal

Figura 40: Waveform do Circuito

2.5 Atividade 5
Implementamos, conforme pedido, um circuito para a entrada de dados na ULA e a
visualização das operações nos displays de 7 segmentos (números) e leds (bits de
condição). Com os displays HEX3, HEX2, HEX1 e HEX0 mostramos os valores de X, Y
e resultado, respectivamente. Os bits de condição Z, N, V, C foram mostrados,
respectivamente, nos leds LEDG[3], LEDG[2], LEDG[1] e LEDG[0]. Para o código da
operação usamos SW[2] a SW[0], para X, as chaves SW[6] a SW[3] e KEY[3] a KEY[0]
para Y. Após isso realizamos novamente os testes e seguem os resultados:

16
 Figura 41: Circuito

Figura 42: Waveform do Circuito

3 Conclusões
3.1 Conceitos Relembrados
Lembramos, a partir da atividade a parte referente aos somadores e decodificadores.
Inovamos bastante ao uni-los em um só circuito.

3.2 Noções Adquiridas

A noção substancial adquirida na atividade foi de como funciona e também como
fazemos uma ULA.

17