UNIVERSIDADE FEDERAL DO AMAZONAS - UFAM

FACULDADE DE TECNOLOGIA - FT
DEPARTAMENTO DE ELETRÔNICA E COMPUTAÇÃO - DTEC

RELATÓRIO DE LABORATÓRIO

Carlos Gabriel
Fábio Arthur Soares
Juliano Salvattore
Nathália Colares

MANAUS
2021
 Carlos Gabriel
Fábio Arthur Soares
Juliano Salvattore
Nathália Colares

RELATÓRIO DE LABORATÓRIO
PROJETO 1: UNIDADE LÓGICA E ARITMÉTICA (ULA)

Relatório apresentado ao curso de graduação em

Engenharia Elétrica da FACULDADE DE
TECNOLOGIA – UNIVERSIDADE FEDERAL DO
AMAZONAS (UFAM) para obtenção de nota parcial da
disciplina de Laboratório de Eletrônica Digital.

Professor: Francisco Januário.

MANAUS
2021
SUMÁRIO
1 Introdução 4

2 Desenvolvimento 5

3 Resultados 10

4 Conclusão 13

Referências Bibliográficas 14

1 Introdução
 A linguagem VHDL, como o próprio nome sugere, é uma linguagem de descrição de
hardware inventada em 1980, que representa: VHSIC Hardware Description Language, ou
Linguagem de Descrição de Hardware, tal linguagem é bastante utilizada para especificação,
simulação, síntese e propriedade intelectual. Os benefícios do VHDL estão, por exemplo: na
possibilidade de uma constante atualização no projeto; verificação do comportamento do
sistema digital através de simulação; descrever o hardware em diversos níveis de abstração.

O programa que iremos utilizar é o Quartus II Lite, que é a IDE mais recomendada
para este tipo de projeto, onde tal programa irá nos permitir criar projetos não só em VHDL,
mas como em Verilog e System Verilog. Além de permitir a sintetização em FPGA’s da
Altera. A unidade lógica e aritmética ou ULA ou em inglês Arithmetic Logic Unit (ALU),
trata-se de um circuito digital onde realiza-se operações lógicas e aritméticas. A ULA é uma
peça primordial da unidade central de processamento, a CPU, e até dos mais simples
microprocessadores. Fazendo uma analogia, podemos dizer que a ULA é como uma grande
calculadora eletrônica, que começou a ser desenvolvida durante a 2ª Guerra Mundial, e onde
essa tecnologia já estava disponível nos primeiros computadores modernos.

Figura 1 - Esquema simplificado de ULA

Fonte: USP (2011)

Como pode-se analisar na imagem acima, a operação que será executada recebe
os dados das entradas A e B e será determinada pelos sinais de controle (S) e o
resultado é obtido na saída (F). A complexidade da ULA será proporcional à
complexidade do sistema em que será utilizada, ou seja, sistemas os quais são simples,
respectivamente permitem o uso de simples ULA’s, bem como sistemas sofisticados
exigem ULA’s mais complexas. Neste projeto, iremos fazer a implementação de uma
ULA de 8 bits, a partir de 8 blocos de ULA’s para 1 bit (Half adder), e para cada
combinação realizada pelo ULA teremos a sua saída definida de forma individual.
2 Desenvolvimento

Agora, iremos demonstrar como realizamos nossa simulação a partir dos trechos do
código em VHDL.

Trecho 1 – Código

library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_unsigned.all;

entity ula8bits is
port ( a,b : in std_logic_vector(7 downto 0);
cin: std_logic;
sel: in std_logic_vector(3 downto 0);
Y: out std_logic_vector(8 downto 0));
end ula8bits;

Nessa parte inicial, declarou-se as bibliotecas que serão utilizadas: padrão (ieee);
std.logic_1164.all; e std_logic_unsigned.all. Feito isso, declaramos a entidade ula8bits que
refere-se à interface de uma porta lógica, na qual possui como entradas a e b que possuem 8
bits cada. O Cin está reservado para ser o carry de entrada, que possui apenas 1 bit. Já a
variável “sel” refere-se a seleção, ou seja, ao teste que está sendo realizado e por isso possui 4
bits. E por fim, declaramos a nossa saída como Y, na qual também possui 8 bits para
representar os respectivos valores da saída.

Trecho 2 – Código

architecture arc_Ula8 of ula8bits is

signal logic: std_logic_vector(7 downto 0);
signal arith: std_logic_vector(7 downto 0);
begin
---------- Parte aritmetica ------
 with sel select
arith <= ('0' & a) when "0000", ('0' & a) + 1 when "0001", ('0'
& a) - 1 when "0010", ('0' & b) when "0011",('0' & b) + 1 when "0100", ('0'
& b) - 1 when "0101", ('0' & a) + ('0' & b) when "0110", ('0' & a) + ('0' &
b) + cin when others;

Agora, para descrever a arquitetura da nossa ula, que aqui foi definida como arc_ula8,
onde temos std_logic_vector com 8 bits tanto para a parte lógica, quanto para a parte
aritmética do nosso código, e com a função begin é que nós iremos realmente iniciar a parte
de combinações da nossa ula, como por exemplo: quando o teste 0011 for selecionado, ou
seja, o teste 3, a saída Y retornará a entrada de B. De acordo com a combinação da entrada da
seleção (sel) , que é o nosso teste, será definido individualmente um valor para a saída Y.

Trecho 3 – Código

---------- Parte logica -----------

with sel select
logic <= not(a) when "1000", not (b) when "1001", a and b when
"1010", a or b when "1011",a nand b when "1100", a nor b when "1101", a xor
b when "1110", a xnor b when others;
process (sel)
begin
if sel(3) = '0' then
Y <= arith;
else
Y <= ('0' & logic);
end if;
end process;
end arc_Ula8;
Analogicamente como foi realizado no trecho 2 do código,aqui, na parte lógica
estamos definindo a saída Y de acordo com o valor da entrada Sel. Por exemplo, nesta parte
do código, define-se que quando tivermos na seleção o valor 1100, ou seja, o teste 12, a saída
Y será a combinação das entradas A.B porém barrada.

Tabela 1 – Funções da ULA

 O código abrange basicamente a montagem de uma ULA de 8 bits, inicialmente o
código consiste em importar as bibliotecas necessárias para a montagem. Após isso são
definidos as entradas e saídas do circuito, nele são definidos todas as entradas “a” e “b” e a
entrada “Carry in”, então, é definido a função “sel” que será utilizada para definir se o circuito
irá trabalhar em parte aritmética ou lógica, e por fim a saída do circuito é definida como “Y”.
Com isso é definido as funções que a ULA vai exercer, então, foi desenvolvido o código para
que o programa exerça as funções definidas na tabela 01 e por fim é lido o valor em “sel”
através da função process, onde caso o mesmo seja 0 a saída "Y” se dará por processo
aritmético caso contrário será por lógico, assim terminando o código da ULA.
 Figura 1 – Entradas A e B

Esta primeira figura do circuito consiste na representação da arquitetura das funções

lógicas e aritméticas descrita nos trechos 2 e 3 do código, onde as entradas “a” e “b” com seus
respectivos “Add” são ligados a uma combinação de sequências lógicas e sequências
aritméticas para que sejam feitas as funções da tabela 1.

Figura 2 – “Sel” e “Carry in”

 Na segunda figura, temos a continuação dos trechos 2 e 3 do código, onde o “sel” que
está ligado a um decoder irá ligar os fios que levam para as sequências aritméticas e lógicas,
definindo assim, o que irá acontecer com as entradas. Além disso, ligando as sequências
aritméticas também possui o 'carry in' que tem função de auxiliar nos processos aritméticos.

Figura 3 – Saída Y
 Por fim na figura 3, temos a saída “y” que está ligada a todas as combinações de
mux,onde Y tem seu valor dado por "begin" que irá ler o valor de "sel" para definir a função
para obter o saída "Y" dos valores iniciais "a" e "b".

3 Resultados

Realizadas todas as etapas descritas para o desenvolvimento da nossa ULA, agora

iremos analisar e discutir os resultados obtidos durante a simulação da mesma, através do
Quartus no campo “Simulation Waveform”, onde foram feitas combinações aleatórias dsa
entradas A e B, pelo próprio programa, e onde selecionamos a entrada desejada da entrada de
seleção (Sel) para analisar-se a saída (Y). Segue abaixo as combinações:

Tabela 2 – Combinações de 0 a 4
Teste Sel. A B Y Operação

0 0000 10000111 11100000 010000111 Y=A

1 0001 00000100 11001101 000000101 Y=A+1

2 0010 11011001 11110010 011011000 Y =A-1

3 0011 01010011 10010000 010010000 Y=B

4 0100 01011000 00101010 000101011 Y=B+1

 5 0101 00101000 00011101 00011100 Y= B-1

6 0110 00011101 11000111 11100100 Y=A+B

7 0111 01001110 01111101 11001100 Y=A+B+Cin

8 1000 01110100 10101000 10001011 Y=A’

9 1001 00010110 01011110 10100001 Y=B’

10 1010 11100101 01000000 01000000 Y = A.B

11 1011 01001011 10011001 11011011 Y=A+B

12 1100 10011000 11110000 01101111 Y= (A.B)’

13 1101 01110010 11000001 00001100 Y =(A+B)’

14 1110 10001101 00101001 10100100 Y= A XOR B

15 1111 11010001 00000001 00101111 Y= A XNOR B

Considerando os testes realizados na tabela 2, pode-se observar os formatos de ondas

gerados pelo programa para cada combinação que foi realizada, tanto das entradas (A; B;Cin e
Sel) , quanto da forma de ondas da saída Y. Como podemos ver nos testes realizados abaixo:

Figura 4 – Forma de onda do teste 4

 Aqui para o teste 4 – Sel igual a 0100 – , na entrada A recebeu randomicamente a
combinação 01011000, enquanto que a entrada B, também randomicamente, recebeu a
combinação 00101010. Pelo teste 4, a saída Y será a entrada B + 1, ou seja, 00101010 + 1,
que equivale a 000101011.

Figura 5 – Forma de onda do teste 7

Já neste caso, para o teste 7 – Sel igual a 0111 – temos na entrada A uma combinação
de 01001110, e temos na entrada B, recebeu a combinação 01111101. De acordo com a seleção
para o teste 7, a saída Y deve ser a entrada A+B + Cin, ou seja, 01001110 + 01111101 + 1, que
retorna 11001100 para a saída Y.

Figura 6 – Forma de onda do teste 13

 Para o teste 13 – Sel sendo igual a 1101 – a entrada A recebeu uma combinação de
01110010, e temos na entrada B, recebeu a combinação 11000001. De acordo com a seleção
para o teste 13, a saída Y deve ser a função NOR das entradas A e B, ou seja, ( 01110010 +
11000001)’, que retorna respectivamente a combinação 00001100 para a saída Y .

4 Conclusão

Através da experiência realizada em um programa de dispositivo lógico programável

(Quartus II), obtivemos maior conhecimento sobre a Unidade Lógica e Aritmética (ULA) e a
linguagem de programação VHDL. Em resumo, os resultados que obtivemos no experimento
foram satisfatórios, pois os testes realizados nas tabelas e gráficos de simulação
corresponderam dentro dos resultados esperados de cada uma das funções. Ao fim deste
projeto, ficou nítido o quão importante e imprescindível é o conhecimento sobre o
funcionamento de uma ULA, pois agrega uma indispensável informação sobre o
funcionamento dos sistemas computacionais em seu papel mais essencial: calcular respostas e
resultados a partir de valores de entrada.

Referências Bibliográficas
¹ MARCON, César; MORENO, Edson. Introdução à Linguagem VHDL. USP, São Paulo.
Disponível em: https://edisciplinas.usp.br/pluginfile.php/3020729/mod_resource/content/0/
Aula%20VHDL%20Alternativa.pdf. Acesso em: 31 de Outubro de 2021.

² PRADO, André. VHDL Básico: Parte 1 – Entidade. Outubro, 2013. Disponível em:
https://www.embarcados.com.br/vhdl-basico-parte-1-entidade/. Acesso em: 31 de Outubro de
2021.

³ LIMA, Thiago. Tutorial de Verilog – O primeiro Projeto com Quartus. Disponível em:
https://www.embarcados.com.br/tutorial-de-verilog-projeto-com-quartus/#:~:text=O
%20Quartus%20é%20uma%20IDE,de%20utilizar%20e%20bem%20conhecida. Acesso em:
31 de Outubro de 2021.