Unidade Lógica e Aritmética

Prévia do material em texto

Projeto de uma Unidade Lógica e Aritmética 
Giovani Pivato, Valci Costa de Oliveira 
Universidade de Caxias do Sul, CARVI, DPEI – Engenharia Elétrica 
giovanipivato@gmail.com, vcoliveira@rge-rs.com.br 
 
 
Resumo 
 
Implementação de uma Unidade Lógica Aritmética 
usando Linguagem de Hardware VHDL, capaz de 
realizar operações pré-determinadas com operandos 
de 8 bits. 
. 
Palavras-chave: ULA, Unidade Lógica, Unidade 
Aritmética, Unidade Lógica-Aritmética, Mux, 
Multiplexador, Somador Completo, Subtrator. 
 
1. Introdução 
 
Este artigo tem o propósito de expor a 
implementação de uma unidade lógica e aritmética, 
usando-se uma linguagem de hardware (VHDL), 
através de uma ferramenta computacional (ISE versão 
11.1). 
A execução do trabalho teve inicio com o estudo e 
introdução na linguagem VHDL, sua sintaxe, forma de 
estruturação, comandos e suas particularidades por ser 
distinta de uma programação usual, como por exemplo, 
C++. 
Após o estudo da linguagem, verificou-se a forma 
de utilização da ferramenta computacional ISE versão 
11.1, que permite que estruturas escritas na linguagem 
VHDL sejam sintetizadas, simuladas e inseridas em 
FPGA’s. 
Utilizando a linguagem e a ferramenta já citadas, foi 
criada uma entidade que soma 1 bit, após, interligando 
esta entidade que soma 1 bit de forma adequada a 
linguagem, construiu-se uma entidade de soma 8 bit’s. 
Na seqüência, foram criadas uma entidade que 
comporta-se como um MUX, uma entidade que 
comporta-se como uma unidade aritmética, uma 
entidade que comporta-se como uma unidade lógica e 
após uma entidade top, que utiliza e interliga todas as 
outras entidades citadas, de forma orientada a se 
comportar como uma ULA. 
Foi simulado o comportamento da ULA na 
ferramenta de simulação existente no ISE 11.1, 
buscando verificar a assertividade do projeto 
executado. 
Este artigo tem na seqüência uma breve revisão 
teórica, os passos do desenvolvimento, resultados 
obtidos, conclusões e os códigos das entidades e 
simulações implementados em VHDL, constam no 
anexo deste trabalho. 
 
2. Revisão bibliográfica 
 
A linguagem VHDL possibilita descrever em 
software o comportamento, funcionalidade de um 
elemento de hardware ou até de um sistema físico 
inteiro. 
 Uma entidade (entity) é uma abstração que 
descreve um sistema, uma placa, um chip, uma função 
ou, até mesmo, uma porta lógica. Na declaração de 
uma entidade, descreve-se o conjunto de entradas e 
saídas. 
Os ports correspondem a pinos e são tratados como 
objetos de dados. Pode-se atribuir valores ou obtê-los 
de ports. Cada entrada ou saída possui um modo 
(mode) de operação. Os modos possíveis são: In, Out, 
buffer, inout. Respectivamente, permitem entrada de 
dados, saída de dados, saída de dados com 
possibilidade de realimentação e a ultima pode 
substituir qualquer uma das outras. 
A arquitetura de uma entidade pode ser descrita de 
três formas distintas, mas que, em geral, conduzem a 
uma mesma implementação funcional. As descrições 
são: comportamentais, por fluxo de dados ou estrutural. 
As regras básicas para formação de nomes são, o 
primeiro caractere deve ser uma letra, o último não 
pode ser underscore, não são permitidos 2 underscores 
em seqüência e maiúscula / minúscula são equivalentes. 
Os sinais são de vital importância em virtualmente 
todos sistemas eletrônicos, podendo transmitir dados 
internamente ou externamente ao sistema, assumindo 
assim um papel muito importante em VHDL. Os sinais 
externos são apresentados na entity e os sinais internos 
são apresentados na architecture. 
 
3. Desenvolvimento 
 
Para obter uma ULA com as funcionalidades 
demonstradas na tabela 1, foram desenvolvidas seis 
entidades em VHDL e interligadas de forma adequada. 
Na seqüência será abordado o desenvolvimento de 
cada entidade e sua funcionalidade. 
 
 
 
 
Tabela1 
SEL OPERAÇÃO UNIDADE 
0000 Y <= A Aritmética 
0001 Y <= B Aritmética 
0010 Y <= A +1 
COM COUT 
Aritmética 
0011 Y <= B +1 
COM COUT 
Aritmética 
0100 Y <= A + B 
SEM COUT 
Aritmética 
0101 Y <= A + B + CIN 
COM COUT 
Aritmética 
0110 Y <= A - 1 
SEM COUT 
Aritmética 
0111 Y <= B - 1 
SEM COUT 
Aritmética 
1000 Y <= A and B Lógica 
1001 Y <= A or B Lógica 
1010 Y <= not A Lógica 
1011 Y <= not B Lógica 
1100 Y <= A xor B Lógica 
1101 Y <= A nand B Lógica 
1110 Y <= 1, se A=B, 0 
se diferente de B 
Lógica 
1111 Y <= 1 se A>B, 0 
se menor ou 
igual a B 
Lógica 
 
A primeira entidade a ser desenvolvida foi 
denominada soma1, que tem a funcionalidade de um 
somador completo de um bit. A implementação desta 
entidade se deu a partir da tabela verdade de um 
somador completo, demonstrada na tabela2. Desta, 
extraiu-se as equações da saída e do carry-out (cout). 
 
Tabela2 
ENTRADAS SAÍDAS 
A B CIN Y COUT 
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 
 
As equações que descrevem a saída Y e o Cout são: 
 Y <= (A Xor B) Xor Cin; 
Cout <= ((A and B)or (Cin and (A xor B))); 
1ª IMPLEMENTAÇÃO (Entidade ULA) 
 
Através da ferramenta de simulações, foi realizado o 
teste de funcionalidade da entidade soma1. Visto ser 
uma entidade simples, foi testada toda a tabela verdade 
e obteve-se o resultado esperado em todas as 
combinações de entrada. 
A segunda entidade criada denominou-se soma8, 
que tem a funcionalidade de um somador de 8 bit`s. sua 
implementação se deu a partir da associação de oito 
somadores completos de 1 bit (entidade soma1), como 
pode ser observado no código fonte desta entidade 
(anexo), as entradas e saídas desta entidade foram 
declaradas do tipo std_logic_vector para comportar os 
8 bits`s. Os carry-out dos somadores foram ligados 
internamente através de sinais, sendo que o carry-out 
de saída da entidade corresponde ao carry-out final da 
soma de 8 bits. 
A entidade soma8 por ser mais complexa e ter 256 
possibilidades de entradas distintas, assim, foi testada 
por amostragem. Foram inseridos valores de entrada e 
verificadas as saídas para os casos testados. 
Utilizando-se o somador de 8 bit’s para as 
operações que contemplam Carry-out, foi 
implementada a entidade Aritmetico, que tem a função 
de realizar as operações aritméticas da ULA. As 
demais operações, ou seja, aquelas que não 
contemplam operações com Carry-out, foram 
implementadas diretamente, o que é viabilizado pelo 
uso da biblioteca STD_LOGIC_UNSIGNED. 
A saída da entidade é controlada por um 
multiplexador 8:1, que determina o valor a ser escrito 
na saída de acordo com o sinal de seleção que há no 
momento, sendo que as três situações em que se utiliza 
o componente soma8, estão comutadas, ligadas no sinal 
S0. 
Também foram utilizados três multiplexadores 2:1, 
em cada um das entradas do componente soma8 (SA, 
SB, CIN), que tem como objetivo, no caso das entradas 
SA e SB, escrever os valores pré-determinados para A 
e B nos casos em que há somas do tipo A+1 com 
Carry-out. No caso no CIN, o multiplexador tem a 
simples função de habilitar o uso do Carry-in na soma, 
fato que ocorre somente quando o Sinal de Seleção é 
“0101”. 
A quarta entidade criada, denominada logic, visa 
realizar as operações lógicas da ULA demonstrada na 
tabela1. 
 Partindo-se da tabela, foram extraídas as funções 
referentes a cada situação do sinal de seleção, que 
foram implementadas através do uso de um 
multiplexador 8:1. As situações que demandavam, 
além do sinal de seleção, outras condições foram 
implementadas com o uso da cláusula AND, ou seja, 
para que o valor de saída fosse o determinado, as duas 
condições deveriam ser atendidas (sinal de seleção 
determinado + outra condição). 
A quinta entidade denominada MUX, é um 
multiplexador 2:1. Tem a simples funçãode determinar 
o valor que será inscrita na saída Y da ULA de acordo 
com o primeiro bit(MSB) do sinal de seleção. 
Finalmente, a ULA propriamente dita, entidade top, 
é uma associação de todas as entidades descritas 
anteriormente, tem a função de executar as operações 
aritméticas e lógicas e escrever o valor esperado na 
saída, de acordo com a tabela1. 
Foram utilizados dois sinais internos do tipo 
Std_logic_vector de 8 bits, que tem a função de 
transportar o sinala de saída da unidade lógica (SL) e 
da unidade aritmética(SA) até o multiplexador, que 
controla a saída geral da ULA. 
Os testes das entidades Aritmético, Logic, Mux e 
ULA foram executados exatamente como os testes da 
entidade Soma8: fez-se a atribuição dos valores 
aleatórios nas entradas e observou-se se as saídas 
correspondiam as valores esperados. 
 
2ª IMPLEMENTAÇÃO (Entidade ULA_2) 
 
Após a implementação da ULA, conforme descrito 
acima, partiu-se para a implementação de uma solução 
alternativa, tendo como objetivo a busca pela solução 
mais eficiente, ou seja, que execute as mesmas 
operações ocupando menos hardware. 
Construiu-se uma nova entidade Arith_2, operador 
aritmético alternativo para a ULA. Os componentes 
soma1 e soma8 são os mesmos utilizados na entidade 
AriTmetico. 
A saída da entidade Arith_2 é controlada por um 
multiplexador 8:1, que faz a escolha do sinal a ser 
escrito no sinal de saída Y da entidade. Assim como na 
entidade Aritmético, as operações que não utilizam 
Carry-out são executadas diretamente. 
No entanto, as operações que envolvem Carry-out 
foram implementadas com a utilização de 3 somadores 
completos de oito bits, do tipo soma8. Em cada 
situação são escritos valores nas estradas do somador, 
definidos de acordo com a tabela 1. Foram utilizados 3 
sinais do tipo_std_logic_vector de 8 bits, interligados à 
saída de cada um dos somadores. O multiplexador 
controla a saída a ser habilitada. 
Foram utilizados, complementarmente, 2 
multiplexadores, sendo um deles detinado a controlar o 
valor de entrada no Carry-In, e um destinado a 
controlar o valor a ser escrito no Carry-out. 
Para viabilizar a utilização dos Três somadores, 
foram necessários 5 sinais do tipo std_logic_vector de 
8 bits e 4 sinais do tipo std_logic. 
O restante da implementação foi idêntica à primeira 
descrita, sendo que para a composição da solução 
alternativa mudou-se apenas a Unidade Lógica, tendo o 
resto da implementação permanecido inalterado. 
Para a realização dos testes, foi utilizada a mesma 
metodologia descrita na implementação anterior. 
 
4. Resultados obtidos 
 
Os resultados obtidos para os testes de todas as 
entidades indicaram que estas atingiram os objetivos, 
ou seja, realizaram as operações de forma a que o 
resultado obtido nas saídas estivesse de acordo com o 
determinado para a tabela de soluções do problema. 
Com relação à comparação entre as 
implementações, pode-se afirmar que a primeira 
implementação apresentou os resultados mais 
satisfatórios. 
A tabela abaixo apresenta os resultados obtidos: 
Implementação N° de Slices 
utilizados 
N° de Slices 
disponíves 
Utilização 
1ª 
Implementação 
(ULA) 
71 4656 1% 
2° 
Implementação 
(ULA_2) 
77 1920 4% 
A primeira implementação (ULA) utilizou, no total, 
13 sinais internos às entidades: 7 – soma8, 4 – 
aritmético, 2 – ULA. 
A segunda implementação (ULA_2), por sua vez, 
utilizou 18 sinais: 7 – soma8, 9 – Arith_2, 2 – ULA. 
 
5. Conclusões 
 
Após o desenvolvimento das duas soluções e 
simulação das mesmas, como pode ser observado no 
corpo deste trabalho e nos resultados obtidos a 
primeira implementação apresenta vantagens em 
relação à segunda. 
A primeira implementação ocupa uma área de 
hardware significativamente menor do que a segunda. 
Em relação à funcionalidade, as duas 
implementações atendem a tabela verdade proposta 
para esta ULA, logo, ficou evidente a possibilidade de 
várias e diferentes implementações para solução de um 
mesmo problema. 
Das soluções desenvolvidas a escolhida foi a 
primeira implementação, por se mostrar mais eficiente 
na utilização do hardware e por conseqüência, no 
desempenho do circuito implementado. 
Observa-se também, que a utilização de um número 
menor de sinais internos contribuiu para a eficiência da 
primeira implementação, demonstrando que as 
rotinas/estruturas das entidades criadas pelo 
programador têm um papel fundamental não só na 
questão funcionalidade, mas também, na eficiência e 
desempenho que esta implementação terá. 
Durante o desenvolvimento deste projeto foram 
enfrentadas dificuldades, sobretudo, pelo 
desconhecimento das particularidades da linguagem 
VHDL e da utilização da ferramenta ISE 11.1. 
Pelo exposto ao longo deste trabalho e com base 
nos resultados e argumentações já realizadas, entendeu-
se por escolher a primeira implantação da ULA. 
 
 
 
 
 
 
 
Anexo 1 – Códigos fonte das implementações 
 
1ª IMPLEMENTAÇÃO 
 
ENTIDADA SOMA1 
 
library IEEE; 
use IEEE.STD_LOGIC_1164.ALL; 
use IEEE.STD_LOGIC_ARITH.ALL; 
use IEEE.STD_LOGIC_UNSIGNED.ALL; 
entity Soma1 is 
 port( A,B,Cin :in std_logic; 
 Y, Cout: out std_logic); 
end Soma1; 
architecture Behavioral of Soma1 is 
begin 
Y <= (A Xor B) Xor Cin; 
Cout <= ((A and B)or (Cin and (A xor B))); 
end Behavioral; 
 
 
ENTIDADA SOMA8 
 
library IEEE; 
use IEEE.STD_LOGIC_1164.ALL; 
use IEEE.STD_LOGIC_ARITH.ALL; 
use IEEE.STD_LOGIC_UNSIGNED.ALL; 
entity soma8 is 
Port ( A, B: in std_logic_vector ( 7 downto 0); 
Cin: in std_logic; 
Cout: out std_logic; 
Y : out std_logic_vector ( 7 downto 0)); 
end soma8; 
architecture Behavioral of soma8 is 
 component soma1 is 
port( A,B,Cin :in std_logic; 
Y, Cout: out std_logic); 
end component soma1; 
Signal C0, c1, c2, c3, c4,c5, c6: std_logic; 
Begin 
somador1: soma1 port map ( A =>A(0), B=>B(0), Cin=>cin, cout=>c0, Y=>Y(0));
 somador2: soma1 port map ( A =>A(1), B=>B(1), Cin=>c0, cout=>c1, Y=>Y(1)); 
 somador3: soma1 port map ( A =>A(2), B=>B(2), Cin=>c1, cout=>c2, Y=>Y(2)); 
 somador4: soma1 port map ( A =>A(3), B=>B(3), Cin=>c2, cout=>c3, Y=>Y(3)); 
 somador5: soma1 port map ( A =>A(4), B=>B(4), Cin=>c3, cout=>c4, Y=>Y(4)); 
 Somador6: soma1 port map ( A =>A(5), B=>B(5), Cin=>c4, cout=>c5, Y=>Y(5)); 
 Somador7: soma1 port map ( A =>A(6), B=>B(6), Cin=>c5, cout=>c6, Y=>Y(6)); 
 Somador8: soma1 port map ( A =>A(7), B=>B(7), Cin=>c6, cout=>cout,Y=>Y(7)); 
end Behavioral; 
 
 
 
 
ENTIDADE ARITMETICO 
 
 
library IEEE; 
use IEEE.STD_LOGIC_1164.ALL; 
use IEEE.STD_LOGIC_ARITH.ALL; 
use IEEE.STD_LOGIC_UNSIGNED.ALL; 
entity ARITMETICO is 
port( A,B : in std_logic_vector (7 downto 0 ); 
Cin :in std_logic; 
Y: out std_logic_vector ( 7 downto 0); 
Cout: out std_logic; 
Sel: in std_logic_vector ( 2 downto 0)); 
End ARITMETICO; 
architecture NICE of ARITMETICO is 
component soma8 is 
Port ( A, B: in std_logic_vector ( 7 downto 0); 
Cin: in std_logic; 
Cout: out std_logic; 
Y : out std_logic_vector ( 7 downto 0)); 
end COMPONENT soma8; 
SIGNAL S0, SA, SB: std_logic_vector (7 downto 0); 
SIGNAL SIN: std_logic; 
Begin 
Y <= A WHEN SEL = "000" ELSE 
B WHEN SEL = "001" ELSE 
A + B WHEN SEL = "100" ELSE 
A - 1 WHEN SEL = "110" ELSE 
B-1 WHEN SEL = "111" ELSE 
S0; 
 
somador: soma8 port map (A=>SA ,B=> SB, Cin=>Sin, cout=>cout, Y => S0); 
 
SA <= "00000001" WHEN SEL = "011" ELSE 
 A; 
SB <= "00000001" WHEN SEL ="010" ELSE 
 B; 
SIN <= CIN WHEN SEL ="101" ELSE 
 '0'; 
end NICE; 
 
ENTIDADE LOGIC 
 
library IEEE; 
use IEEE.STD_LOGIC_1164.ALL; 
use IEEE.STD_LOGIC_ARITH.ALL; 
use IEEE.STD_LOGIC_UNSIGNED.ALL; 
entity logic is 
 Port (A, B : in std_logic_vector ( 7 downto 0); 
 Sel : in std_logic_vector( 2 downto 0); 
 Y: out std_logic_vector ( 7 downto 0)); 
end logic; 
architecture nova of logic is 
begin 
 
 Y <= A AND B WHEN SEL = "000" ELSE 
 A OR B WHEN SEL = "001" ELSE 
 NOT A WHEN SEL = "010" ELSE 
 NOT B WHEN SEL = "011" ELSE 
 A XOR B WHEN SEL = "100" ELSE 
 A NAND B WHEN SEL = "101" ELSE 
 "00000001" WHEN SEL = "110" AND A = B ELSE 
 "00000000" WHEN SEL = "110" AND A /= B ELSE 
 "00000001" WHEN SEL = "111" AND A > B ELSE 
 "00000000"; 
end nova; 
 
 
ENTIDADE MUX 
 
library IEEE; 
use IEEE.STD_LOGIC_1164.ALL; 
use IEEE.STD_LOGIC_ARITH.ALL; 
use IEEE.STD_LOGIC_UNSIGNED.ALL; 
entity mux is 
 port ( Y_LOGIC: IN std_logic_vector ( 7 downto 0); 
Y_ARITH: IN std_logic_vector ( 7 downto 0); 
 SEL: IN std_logic ; 
 Y: OUT std_logic_vector (7 downto 0)); 
 
end mux; 
architecture solar of mux is 
begin 
 Y <= Y_ARITH WHEN SEL = '0' ELSE 
 Y_LOGIC; 
 
end SOLAR; 
 
ENTIDADE ULA – SOLUÇÃO FINAL 
 
library IEEE; 
use IEEE.STD_LOGIC_1164.ALL; 
use IEEE.STD_LOGIC_ARITH.ALL; 
use IEEE.STD_LOGIC_UNSIGNED.ALL; 
entity ULA is 
port( A,B : in std_logic_vector ( 7 downto 0); 
 Cin :in std_logic; 
 Y: out std_logic_vector (7 downto 0); 
 Cout: out std_logic; 
 Sel: in std_logic_vector ( 3 downto 0)); 
end ULA; 
architecture unit of ULA is 
 COMPONENT LOGIC IS 
 Port (A, B : in std_logic_vector ( 7 downto 0); 
 Sel : in std_logic_vector ( 2 downto 0); 
 Y: out std_logic_vector ( 7 downto 0)); 
 END COMPONENT LOGIC; 
 
 COMPONENT ARITMETICO IS 
 port( A,B : in std_logic_vector ( 7 downto 0); 
 Cin :in std_logic; 
 Y: out std_logic_vector (7 downto 0); 
 Cout: out std_logic; 
 Sel: in std_logic_vector ( 2 downto 0)); 
 END COMPONENT ARITMETICO; 
 
 COMPONENT MUX IS 
 port ( Y_LOGIC: IN std_logic_vector ( 7 downto 0); 
 Y_ARITH: IN std_logic_vector ( 7 downto 0); 
 SEL: IN std_logic ; 
 Y: OUT std_logic_vector (7 downto 0)); 
 END COMPONENT MUX; 
SIGNAL SL, SA : STD_LOGIC_VECTOR (7 DOWNTO 0); 
begin 
 
UNIDADE_LOGICA: LOGIC PORT MAP ( A => A, B => B, SEL => SEL (2 DOWNTO 0) , Y => SL); 
UNIDADE_ARITMETICA: ARITMETICO PORT MAP ( A => A, B=>B, Cin=>cin, COUT=>COUT, Y=> SA, 
sel => sel (2 DOWNTO 0)); 
UNIDADE_MUX: MUX PORT MAP ( Y_LOGIC => SL, Y_ARITH => SA, SEL => SEL(3), Y => Y); 
 
end unit; 
 
 
2ª IMPLEMENTAÇÃO – SOLUÇÃO ALTERNATIVA 
DESCARTADA POR COMPROVADAMENTE SER MENOS EFICIENTE 
 
ENTIDADA SOMA1 
 
library IEEE; 
use IEEE.STD_LOGIC_1164.ALL; 
use IEEE.STD_LOGIC_ARITH.ALL; 
use IEEE.STD_LOGIC_UNSIGNED.ALL; 
entity Soma1 is 
 port( A,B,Cin :in std_logic; 
 Y, Cout: out std_logic); 
end Soma1; 
architecture Behavioral of Soma1 is 
begin 
Y <= (A Xor B) Xor Cin; 
Cout <= ((A and B)or (Cin and (A xor B))); 
end Behavioral; 
 
 
ENTIDADA SOMA8 
 
library IEEE; 
use IEEE.STD_LOGIC_1164.ALL; 
use IEEE.STD_LOGIC_ARITH.ALL; 
use IEEE.STD_LOGIC_UNSIGNED.ALL; 
entity soma8 is 
Port ( A, B: in std_logic_vector ( 7 downto 0); 
Cin: in std_logic; 
Cout: out std_logic; 
Y : out std_logic_vector ( 7 downto 0)); 
end soma8; 
architecture Behavioral of soma8 is 
 component soma1 is 
port( A,B,Cin :in std_logic; 
Y, Cout: out std_logic); 
end component soma1; 
Signal C0, c1, c2, c3, c4,c5, c6: std_logic; 
Begin 
somador1: soma1 port map ( A =>A(0), B=>B(0), Cin=>cin, cout=>c0, Y=>Y(0));
 somador2: soma1 port map ( A =>A(1), B=>B(1), Cin=>c0, cout=>c1, Y=>Y(1)); 
 somador3: soma1 port map ( A =>A(2), B=>B(2), Cin=>c1, cout=>c2, Y=>Y(2)); 
 somador4: soma1 port map ( A =>A(3), B=>B(3), Cin=>c2, cout=>c3, Y=>Y(3)); 
 somador5: soma1 port map ( A =>A(4), B=>B(4), Cin=>c3, cout=>c4, Y=>Y(4)); 
 Somador6: soma1 port map ( A =>A(5), B=>B(5), Cin=>c4, cout=>c5, Y=>Y(5)); 
 Somador7: soma1 port map ( A =>A(6), B=>B(6), Cin=>c5, cout=>c6, Y=>Y(6)); 
 Somador8: soma1 port map ( A =>A(7), B=>B(7), Cin=>c6, cout=>cout,Y=>Y(7)); 
end Behavioral; 
 
 
 
 
ENTIDADE ARITH_2 
 
 
library IEEE; 
use IEEE.STD_LOGIC_1164.ALL; 
use IEEE.STD_LOGIC_ARITH.ALL; 
use IEEE.STD_LOGIC_UNSIGNED.ALL; 
entity Arith_2 is 
 port( A,B : in std_logic_vector (7 downto 0 ); 
 Cin :in std_logic; 
 Y: out std_logic_vector ( 7 downto 0); 
 Cout: out std_logic; 
 Sel: in std_logic_vector ( 2 downto 0)); 
 
end Arith_2; 
architecture alternativa of Arith_2 is 
 component soma8 is 
 Port ( A, B: in std_logic_vector ( 7 downto 0); 
 Cin: in std_logic; 
 Cout: out std_logic; 
 Y : out std_logic_vector ( 7 downto 0)); 
 
end COMPONENT soma8; 
 
SIGNAL S1, S2, S3, SA1, SB1: std_logic_vector (7 downto 0); 
SIGNAL SIN, SOUT1, SOUT2, SOUT3: std_logic; 
begin 
 Y <= A WHEN SEL = "000" ELSE 
 B WHEN SEL = "001" ELSE 
 S1 WHEN SEL = "010" ELSE 
 S2 WHEN SEL = "011" ELSE 
 A + B WHEN SEL = "100" ELSE 
 S3 WHEN SEL = "101" ELSE 
 A - 1 WHEN SEL = "110" ELSE 
 B - 1; 
 
 SA1 <= "00000001"; 
 SB1 <= "00000001"; 
 
 SIN <= CIN WHEN SEL = "101" ELSE 
 '0'; 
 
 COUT <= SOUT1 WHEN SEL = "010" ELSE 
 SOUT2 WHEN SEL = "011" ELSE 
 SOUT3; 
 
 somador1: soma8 port map (A=> A ,B=> SB1, Cin=> Sin, cout=> SOUT1, Y => S1); 
 somador2: soma8 port map (A=> SA1 ,B=> B, Cin=> Sin, cout=> SOUT2, Y => S2); 
 somador3: soma8 port map (A=> A ,B=> B, Cin=> Sin, cout=> SOUT3, Y => S3); 
 
 
end alternativa; 
ENTIDADE LOGIC 
 
library IEEE; 
use IEEE.STD_LOGIC_1164.ALL; 
use IEEE.STD_LOGIC_ARITH.ALL; 
use IEEE.STD_LOGIC_UNSIGNED.ALL; 
entity logic is 
 Port (A, B : in std_logic_vector ( 7 downto 0); 
 Sel : in std_logic_vector ( 2 downto 0); 
 Y: out std_logic_vector ( 7 downto 0)); 
end logic; 
architecture nova of logic is 
begin 
 
 Y <= A AND B WHEN SEL = "000" ELSE 
 A OR B WHEN SEL = "001" ELSE 
 NOT A WHEN SEL = "010" ELSE 
 NOT B WHEN SEL = "011" ELSE 
 A XOR B WHEN SEL = "100" ELSE 
 A NAND B WHEN SEL = "101" ELSE 
 "00000001" WHEN SEL = "110" AND A = B ELSE 
 "00000000" WHEN SEL = "110" AND A /= B ELSE 
 "00000001" WHEN SEL = "111" AND A > B ELSE 
 "00000000"; 
end nova; 
 
 
ENTIDADE MUX 
 
library IEEE; 
use IEEE.STD_LOGIC_1164.ALL; 
use IEEE.STD_LOGIC_ARITH.ALL; 
use IEEE.STD_LOGIC_UNSIGNED.ALL; 
entity mux is 
 port ( Y_LOGIC: IN std_logic_vector ( 7 downto 0); 
Y_ARITH: IN std_logic_vector ( 7 downto 0); 
 SEL: IN std_logic ; 
 Y: OUT std_logic_vector (7 downto 0)); 
 
end mux; 
architecture solar of mux is 
begin 
 Y <= Y_ARITH WHEN SEL = '0' ELSE 
 Y_LOGIC; 
 
end SOLAR; 
 
ENTIDADE ULA_2 
 
 
library IEEE; 
use IEEE.STD_LOGIC_1164.ALL; 
use IEEE.STD_LOGIC_ARITH.ALL; 
use IEEE.STD_LOGIC_UNSIGNED.ALL; 
entity ULA_2 is 
 port( A,B : in std_logic_vector ( 7 downto 0); 
 Cin :in std_logic; 
 Y: out std_logic_vector (7 downto 0); 
 Cout: out std_logic; 
 Sel: in std_logic_vector ( 3 downto 0)); 
end ULA_2; 
architecture alternate of ULA_2 is 
 
 COMPONENT LOGIC IS 
 Port (A, B : in std_logic_vector ( 7 downto 0); 
 Sel : in std_logic_vector ( 2 downto 0); 
 Y: out std_logic_vector ( 7 downto 0)); 
 END COMPONENT LOGIC; 
 
 COMPONENT ARITH_2 IS 
 port( A,B : in std_logic_vector ( 7 downto 0); 
 Cin :in std_logic; 
 Y: out std_logic_vector (7 downto 0); 
 Cout: out std_logic; 
 Sel: in std_logic_vector ( 2 downto 0)); 
 END COMPONENT ARITH_2; 
 
 COMPONENT MUX IS 
 port ( Y_LOGIC: IN std_logic_vector ( 7 downto 0); 
 Y_ARITH: IN std_logic_vector ( 7 downto 0); 
 SEL: IN std_logic ; 
 Y: OUT std_logic_vector (7 downto 0)); 
 END COMPONENT MUX; 
 
SIGNAL SL, SA : STD_LOGIC_VECTOR (7 DOWNTO 0); 
begin 
 
UNIDADE_LOGICA: LOGIC PORT MAP ( A => A, B => B, SEL => SEL (2 DOWNTO 0) , Y => SL); 
UNIDADE_ARITMETICA: ARITH_2 PORT MAP ( A => A, B=>B, Cin=>cin, COUT=>COUT, Y=>SA, sel => 
sel (2 DOWNTO 0)); 
UNIDADE_MUX: MUX PORT MAP ( Y_LOGIC => SL, Y_ARITH => SA, SEL => SEL(3), Y => Y); 
 
end alternate;