Unidade Lógica e Aritmética
Click here to load reader
-
Upload
pablo-carvalho -
Category
Documents
-
view
47 -
download
1
Transcript of Unidade Lógica e Aritmética
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
[email protected], [email protected]
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ção de 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;