Relatório Calculadora (VHDL)

Prévia do material em texto

UNIVERSIDADE FEDERAL DO ACRE 
CENTRO DE CIÊNCIAS EXATAS E TECNOLÓGICAS 
CURSO DE BACHARELADO EM ENGENHARIA ELÉTRICA 
 
 
 
 
 
Sander Bryan Felicio da Cruz Brito 
 
 
 
 
 
 
 
RELATÓRIO DO PROJETO EM VHDL DA CALCULADORA 
 
 
 
 
 
 
 
 
 
 
 
 
Rio Branco 
2015 
Sander Bryan Felicio da Cruz Brito 
 
 
 
 
 
 
 
 
 
 
 
 
 
RELATÓRIO DO PROJETO EM VHDL DA CALCULADORA 
 
 
Relatório de Projeto apresentado à disciplina de 
Circuitos Digitais II, do Curso de Bacharelado em 
Engenharia Elétrica, do Centro de Ciências Exatas e 
Tecnológicas, da Universidade Federal do Acre, 
como requisito parcial para obtenção da N2. 
 
 
Prof. Dr. Roger Fredy Larico Chávez 
 
 
 
 
Rio Branco 
2015 
SUMÁRIO 
 
 
 
 
1. OBJETIVO ......................................................................................................................................4 
2. INTRODUÇÃO ...............................................................................................................................5 
3. PROJETO EM VHDL DA CALCULADORA .............................................................................7 
3.1. Descrição ...............................................................................................................................7 
3.2. Esquemático .........................................................................................................................8 
3.3. Limitações .............................................................................................................................9 
3.4. Simulações ......................................................................................................................... 10 
4. CONCLUSÃO ............................................................................................................................. 14 
5. REFERÊNCIA BIBLIOGRÁFICA ............................................................................................ 16 
6. ANEXO ......................................................................................................................................... 17 
6.1. Código Documentado ..................................................................................................... 17 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1. OBJETIVO 
 
 
 
 
Este relatório tem por finalidade apresentar o processo e o resultado do 
desenvolvimento em linguagem VHDL de uma calculadora simples. Esta, por sua vez, 
apresenta as funções de soma e multiplicação para duas entradas de valores decimais 
na faixa de 0 a 15. Serão apresentadas as diversas características do código (a ser 
descrito no processo), bem como sua relação com os aspectos funcionais do elemento 
processado (no caso, a calculadora). Além disso, hão de ser discutidas as limitações 
do projeto, bem como as formas sugeridas de uso. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2. INTRODUÇÃO 
 
 
 
 
O estado atual de desenvolvimento tecnológico nos apresenta uma gama de 
variedades de produtos capazes de realizar as mais diversas funções que podemos 
imaginar. Dentre esses aparelhos que nos rodeiam, para o fim deste trabalho, chamo 
a atenção para os instrumentos de contagem e processamento de operações 
aritméticas. 
Apesar de ser a matemática temida pela grande parte dos leigos, todos acabam 
se valendo dela pelos meios fáceis que nos foram ofertados pelo avanço tecnológico. 
Contar e calcular é uma necessidade humana, fruto da maneira social de como nos 
organizamos. 
A contagem passou por estágios primitivos, juntando pedras e ossos e dando 
a estas quantidades um significado. Depois veio o advento de aparelhos mais 
sofisticados, como o ábaco. Mais avanço, sobretudo com John Napier (1550 – 1617), 
com seu dispositivo de calcular logaritmos, e Blaise Pascal (1623 – 1662), com a sua 
pioneira Pascaline, vieram produtos com novas configurações, até que o advento das 
ideias precursoras da Máquina Analítica de Charles Babbage (1791 – 1871), tornasse 
possível a expansão das máquinas hoje conhecidas como computadores. 
De modo geral, o processo de cálculo gira em torno de ferramentas conhecidas 
como “calculadoras”, que tem a função de realizar operações aritméticas de acordo 
com comandos do usuário, e assim, facilitando muito os processos antigamente 
manuais. 
No entanto, como é bem conhecido, ao operar com máquinas (sobretudo 
circuitos e computadores), estamos operando com sistemas e determinados níveis de 
tensão. E operando especificamente em Circuitos Digitais, definimos as operações 
simplesmente pelo fato de, em determinada trilha, ter ou não certo nível de tensão. E 
assim aplica-se adequadamente a Álgebra Booleana com seus valores binários. 
As operações aritméticas em binário seguem o mesmo padrão de operação 
habitual utilizado com os decimais, com a restrição de só utilizar dois dígitos (1 e 0), 
para dois níveis lógicos de tensão (ALTO ou BAIXO). 
Esse fato carrega o problema de ser necessário mais signos (bits, as unidades 
binárias) para representar os mesmos valores decimais. Com isso vem anexa uma 
preocupação constante com a capacidade de operação dos sistemas, e a verificação 
da quantidade de informação relacionada – bem como a possibilidade de alguns 
processos gerarem informação além da capacidade de armazenamento, o que é 
denominado overflow. 
Outra questão é a necessidade de representação de valores com sinal, que foi 
solucionada com o método do complemento a dois. Este, por sua vez trata-se da 
negação do valores lógicos do número binário original (ou seja, inversão de valores), 
e adiciona-se uma unidade binária. O retorno ao valor original se dá pelo mesmo 
processo. Assim, não só a representação, como também a operação de valores desta 
natureza torna-se muito mais simples. Por exemplo, uma subtração poderia ser 
encarada com uma adição. 
Com o passar do tempo e o desenvolvimento dos sistemas, surgiu uma 
ferramenta para facilitar a criação, descrição, síntese e universalização dos circuitos 
digitais. Trata-se da linguagem de descrição de hardware. 
A partir daqui vai surgir a iminente necessidade de utilizar as funções das 
bibliotecas – ou, para situações mais específicas, como foi o caso, a criação dos 
próprios pacotes. Para isso, a descrição deve seguir um padrão de abstração para 
facilitar ocasionais mudanças próprias do usuário. 
Nesse ponto teremos funções aritméticas correlacionadas numa descrição 
comportamental ou em fluxo de dados. E isto requer uma compreensão adequada de 
como os dados se comportam. Primeiro porque queremos que os dados de entrada 
sejam carregados corretamente, e que uma operação ocorra de cada vez. Segundo, 
porque operamos com vetores de bits – o que exige descrições apropriadas, a fim de 
facilitar as operações. 
Assim, ilustraremos a aplicação destas ferramentas num simples projeto, 
descrito e explanado nas seguintes, que pode ser base de grandes ideias. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3. PROJETO EM VHDL DA CALCULADORA 
 
 
 
 
3.1. Descrição 
 
Este projeto refere-se a uma calculadora simples, capaz de realizar operações 
de soma e multiplicação. Ela realiza operações sobre vetores de bits de entrada “in_a” 
e “in_b”, cujo tamanho está definido por uma constante declarada num pacote 
denominado “calc” anexo à descrição. Para este caso, que desejávamos um ranking 
de 0 a 15 (valores decimais), utilizamos apenas 4 bits.A fim de definir qual a operação que se deseja realizar com os vetores da 
entrada, existe uma entrada de controle denominada “add_mult”. Estando em nível 
baixo, a calculadora somará os vetores de entrada. Estando em alto, será realizada a 
operação de multiplicação. 
No entanto, nestas restritas circunstâncias, a calculadora sempre estaria 
realizando uma operação, com os dados da entrada – o que poderia gerar dados 
ambíguos, caso as entradas não fossem carregadas da maneira correta. Assim, foi 
inserida uma entrada “enable”, que tem por função simplesmente permitir que a 
operação programada pela entrada de controle seja efetuada sobre as entradas. 
Podemos comparar seu uso ao da tecla “igual” (=) nas calculadoras convencionais. 
Por fim, temos a única saída, denominada “result”, cujo número de bits também 
foi pré-determinado no pacote. A fim de evitar overflow das operações aritméticas, 
tratamos de ter cuidado com essa determinação prévia. Estando fixado o número de 
bits das entradas, bastava verificar o valor máximo possível resultante nas operações. 
Este seria justamente o produto entre os dois maiores valores possíveis de entrada. 
Essa quantidade de saída seria, então, a referência máxima. 
Em nosso caso, com 4 bits de entrada, temos valores decimais de 0 a 15. 
Portanto, o produto máximo é 15*15, que tem com resultado 225. Nosso novo ranking 
é de 0 a 225 (ou seja, oito bits). 
Vale destacar que descrevemos as operações no pacote. Então, definido o 
número de bits n na entrada, automaticamente será definido o ranking de contagem 
dos dados que podem ser operados (de 0 até 2 elevado a n). Assim, estará definido o 
ranking de saída (de 0 até m*m, onde m é justamente o valor máximo decimal definido 
pela operação anterior). 
Podemos sintetizar a descrição na seguinte tabela: 
 
Nome da Porta Característica Descrição 
in_a Entrada (vetor) Primeira parcela 
in_b Entrada (vetor) Segunda parcela 
add_mult Entrada (bit) Controle de operação 
enable Entrada (bit) Habilita operação 
result Saída (vetor) Resultado da operação 
 
 
3.2. Esquemático 
 
Definidas as entradas e a única saída, podemos muito bem representar a 
entidade num esquema, conforme a Figura 1. Vale bem notar a diferença entra as 
setas. As que se dirigem para o bloco são justamente as entradas, e a que sai dele é 
a saída. A opção pela espessura indica o fato de Porta (entrada ou saída) ser um 
único bit, ou um vetor deles. 
 
 
 in_a 
 in_b 
 CALCULADORA result 
 add_mult 
 enable 
 
Figura 1 
 
 
Descrevendo apropriadamente as funções desejadas na linguagem de 
descrição de hardware, e realizando uma análise e síntese pelo software Quartus, 
obtemos o modelo interno pelo Visualizador RTL, conforme a Figura 2. 
O sintetizador optou pelo uso de oito latches e oito multiplexadores, bem como 
um circuito somador e outro multiplicador. 
 
Figura 2 
 
3.3. Limitações 
 
A proposta deste projeto teve um caráter simples, sem muita complexidade de 
operações. Portanto, é importante reconhecer as limitações que o circuito descrito irá 
apresentar, a fim de que não se crie expectativas fantasiosas de funcionamento 
inexistente. 
Primeiro, temos uma clara limitação de entradas. Só podemos carregar valores 
binários com até 4 bits. Estes mesmos dados não estão sendo registrados em outra 
variável – quando carregados, são diretamente direcionados para os CI’s de 
operação. 
Não temos problemas com dataflow, dado que as entradas estão limitadas, e a 
saída tem tamanho suficiente para comportar a possibilidade de máximo resultado de 
operação. 
Por outro lado, nestes termos, não podemos carregar dados já operados na 
saída para serem operados com novas entradas – visto que não registramos a saída 
para que seja operada novamente, e estamos com isso evitando problemas com 
overflow. 
A estrutura não possui clock, sendo, portanto, assíncrona. Cabe, portanto, ao 
usuário utilizar apropriadamente os comandos e verificar os carregamentos. Para tal 
fim tem a ferramenta do enable. Estando desativado, nenhum dado é operado, e a 
saída mantém o último valor. Deste modo, o usuário poderá carregar os dados que 
deseja, e selecionar a operação apropriada. Estando todos os dados em consistência, 
ele ativa a entrada de controle, e o result assume um novo valor. 
É sugerido, no entanto, certo cuidado com a entrada enable. Se esta for 
mantida em alto o tempo inteiro, corre-se o risco que era desejado evitar com sua 
inserção (de carregar os dados apropriadamente antes de realizar a operação, visto 
que enquanto estiver em alta, alguma operação estará sendo realizada). Portanto, é 
recomendado que seja mantida em baixa. Apenas um pulso alto suficiente para 
realizar a operação relativa aos dados carregados. 
A situação é análoga à tecla igual (=) na calculadora. Os valores a ser operados 
são “carregados” pressionando as teclas, e a função da operação desejada é 
selecionada em outra teca de controle. E estando carregados, a tecla igual é 
pressionada (como o enable) e a operação ocorre, apresentando o resultado. Vale, 
porém, destacar que a sequência de eventos (o ato de pressionar as teclas, ou seja, 
carregar os dados) faz diferença na calculadora convencional (justo por ter mais 
funções), enquanto neste projeto isso não faz diferença. 
 
3.4. Simulações 
 
Pelo software ModelSim pudemos simular o funcionamento da calculadora 
projetada. Sendo muitos os estados de operações possíveis, selecionamos alguns 
casos decisivos e críticos de análise, para apresentar sua simulação. Seguem os 
casos e os devidos comentários. 
As Figuras 3 e 4 mostram que mesmo tendo carregado os dados de entrada, e 
não importando a função selecionada para operação (multiplicação ou adição), a 
mesma não se realiza se a entrada de habilitação (enable) não estiver em nível alto. 
 
 
 
Figura 3 
 
Figura 4 
 
 Já as Figuras 5 e 6 mostram a ocorrência de uma soma, estando as entradas 
carregadas (com valor 5 cada uma), a porta add_mult em baixo. A saída de valor 10 
aparece no instante do pulso da entrada de habilitação. 
 
 
Figura 5 
 
Figura 6 
 
As Figuras 7 e 8 apresentam uma operação de multiplicação, estando as entradas 
carregadas (com valor 5 cada uma), a porta add_mult em nível alto. A saída de valor 
25 aparece no instante do pulso da entrada de habilitação. Note que por ser 
assíncrono, é “tudo imediato”. 
 
 
Figura 7 
 
Figura 8 
 
A Figura 9 prova a eficácia da operação de soma dos maiores valores possíveis 
da entrada. O resultado 30 (para a soma de 15 + 15) surge no pulso de habilitação. 
 
 
Figura 9 
 
Por sua vez, a Figura 10 apresenta a validade da operação máxima de 
multiplicação (entre 15 e 15, com resultado 225, o maior possível). Temos, nesse caso 
o controlador add_mult em nível alto. De igual modo só se efetua a operação quando 
o enable estiver em alto. 
 
 
Figura 10 
 
 
 
Por fim, verificamos que não admite-se possibilidade de overflow. Ao tentar 
forçar a entrada in_a para carregar o valor 16, o sistema não reconhece, caracterizado 
pela notação “?(16)”. A simulação, então trava, mesmo ativando o enable ou tentando 
forçar as entradas para outro valor. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4. CONCLUSÃO 
 
 
 
 
Uma grande problemática da resolução de problemas, digamos físicos, através 
de máquinas é o distanciamento entre a soluçãoideal e a solução encontrada. 
Dependendo do fim desejado, pode-se aceitar soluções mais simples, mesmo que 
fosse possível elaborar projetos mais complexos. 
Ao referir-se especificamente a este projeto, descrito ao longo das páginas 
anteriores, tive o intuito de seguir as especificações básicas requeridas – uma 
calculadora que realize soma e multiplicação de valores com 4 bits. E que realizasse 
essas mínimas funções de modo eficaz – incluindo controladores de função e 
habilitador de operação. 
No entanto, não tive a preocupação de realizar incrementos adicionais que 
fugissem da especificação mínima – e, assim, tornassem o projeto mais completo, e, 
por conseguinte, mais complexo. Mas vale a pena destacar algumas possibilidades 
de “upgrade” para a nossa calculadora (que podem servir de guia para algum projeto 
futuro). 
Primeiro, poderíamos adicionar sinais internos que registrassem os dados 
carregados na entrada, e que fossem mantidos independente das mesmas entradas. 
Isso garantiria segurança de operação correta de dados. 
Segundo, poderíamos adicionar mais funções de operação aritmética, como a 
divisão e a subtração (completando as quatro operações básicas). Para cada uma 
seria interessante um controlador próprio, que, quando as entradas estivessem 
carregadas, ao emitir um pulso do correspondente controlador, a operação desejada 
fosse operada (com a observação de se evitar emitir pulsos simultâneos de 
controlador, para evitar ambiguidades). 
Terceiro, inclusas mais funções, precisaríamos nos preocupar com as novas 
representações de valores, sobretudo com os números negativos, o que exigiria um 
aparato de conversão para complemento a 2, e, também, um bit exclusivo para sinal. 
Além disso, por causa da divisão surge a preocupação da representação de valores 
não inteiros, com a presença da vulgar “vígula” que separa parte inteira de fracionária. 
Em quarto lugar, vem a possibilidade de realizar as operações com o dado de 
saída recém operado. Ou seja, tratar a saída inclusive como uma potencial entrada. 
Isso requereria a inclusão de um outro registrador: além do que mantém o sinal de 
saída, teríamos outro que registrasse esse sinal como possível valor a ser carregado 
nas entradas para ser operado de novo. 
Por fim, a consideração clássica: aumentar a capacidade de representação, 
expandindo o número de bits não só nas entradas mas sobretudo nas saídas – sempre 
com o cuidado de evitar o overflow aritmético – ou ao menos indicar a sua ocorrência 
no caso se entrar neste estado. 
Portanto, a realização de um projeto deve envolver uma série de passos (que 
serviram neste caso e servirão para as futuras circunstâncias). A princípio, o projeto 
deve preocupar-se em operar de acordo com as requisições básicas (verificando 
todos os possíveis erros). 
Tratando isto, podemos otimizar o simples processo inserindo variáveis que 
possam facilitar as operações mínimas (com o cuidado de torna-lo mais simples, e 
não mais complexo). 
Assim, estando o projeto operando conforme o desejado e de modo 
compreensível e sintetizado, o projetista pode pensar em ampliar suas funções – sem 
jamais fugir do propósito original. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
5. REFERÊNCIA BIBLIOGRÁFICA 
 
 
 
 
ROONEY, Anne. A História da Matemática – Desde a criação das pirâmides até a 
exploração do infinito. São Paulo: Makron Books, 2012. 
TOCCI, Ronald J.; WIDMER, Neal S. SISTEMAS DIGITAIS – Princípios e 
Aplicações. Tradução de José F. M. do Amaral e Jorge L. M. do Amaral. 7. ed. Rio 
de Janeiro: LTC, 2000. 
TOCCI, Ronald J.; WIDMER, Neal S.; MOSS, Gregory L. Digital Systems – 
Principles and Applications. 10. ed. New Jersey: Prentice Hall, 2007. Digital 
electronics –Textbooks. IBSN 0-13-172579-3. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
6. ANEXO 
 
 
 
 
6.1. Código Documentado 
 
Eis o print do código VHDL documentado.