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;




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



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));




Somador6: soma1 port map ( A =>A(5), B=>B(5), Cin=>c4, cout=>c5, Y=>Y(5));


Somador8: soma1 port map ( A =>A(7), B=>B(7), Cin=>c6, cout=>cout,Y=>Y(7));

end Behavioral;

ENTIDADE ARITMETICO

library IEEE;




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);


Sel: in std_logic_vector ( 2 downto 0));

End ARITMETICO;

architecture NICE of ARITMETICO is

component soma8 is


Cin: in std_logic;



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;




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;




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;




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);



end ULA;

architecture unit of ULA is

COMPONENT LOGIC IS




END COMPONENT LOGIC;

COMPONENT ARITMETICO IS


Cin :in std_logic;




END COMPONENT ARITMETICO;

COMPONENT MUX IS



SEL: IN std_logic ;


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;




entity Soma1 is



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;




entity soma8 is


Cin: in std_logic;



end soma8;

architecture Behavioral of soma8 is

component soma1 is



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));







Somador8: soma1 port map ( A =>A(7), B=>B(7), Cin=>c6, cout=>cout,Y=>Y(7));

end Behavioral;

ENTIDADE ARITH_2

library IEEE;




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);



end Arith_2;

architecture alternativa of Arith_2 is

component soma8 is


Cin: in std_logic;



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


A + B WHEN SEL = "100" 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;




entity logic is




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;




entity mux is



SEL: IN std_logic ;


end mux;

architecture solar of mux is

begin

Y <= Y_ARITH WHEN SEL = '0' ELSE

Y_LOGIC;

end SOLAR;

ENTIDADE ULA_2

library IEEE;




entity ULA_2 is


Cin :in std_logic;




end ULA_2;

architecture alternate of ULA_2 is

COMPONENT LOGIC IS




END COMPONENT LOGIC;

COMPONENT ARITH_2 IS


Cin :in std_logic;




END COMPONENT ARITH_2;

COMPONENT MUX IS



SEL: IN std_logic ;


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;

Documents

Unidade Lógica e Aritmética