EA773 C – Laboratório de

Circuitos Lógicos
Projeto Final
Luis Filipe Garcia Barbosa RA:221079
Projeto Final
• O objetivo Principal do projeto, seria desenvolver a arquitetura de um
microprocessador de 5 bits, com instruções de 8 bits, utilizando 21
funções diferentes que seriam possíveis de ser realizadas. Utilizamos
uma RAM como memória de trabalho, e deveriam ser desenvolvidos
programas para testar todas as funções implementadas,
assemelhando – se a um real microprocessador.
Projeto Final - ROM
• Como primeiro passo, implementamos uma memória ROM de 32
posições, com 8 bits cada. Esse módulo, seria o responsável por
armazenar as instruções necessárias para realização de cada
programa, e funcionaria como base para que os mesmos
funcionassem corretamente, repassando as informações necessárias.
• Para implementação deste módulo, foi necessário que
construíssemos:
1. Decodificador de linha 5 – 25
• Assim, como no projeto 5, implementamos a ROM, utilizando Tri –
states, fazendo com que estes selecionassem as instruções que iriam
ser repassadas pelo módulo, sequencialmente, devido ao
decodificador de linha.
Projeto Final
• Para construção do módulo Decodificador 5 – 25, primeiramente
utilizamos a tabela de representação binária de 5 bits, que para as 3
entradas, in[2..0] por exemplo, selecionariam as 32 saídas
sequencialmente, ativando cada instrução fornecida pelo Tri – states
de maneira ordenada, sendo Out 0, Out 1, ..., até Out 31.
Projeto Final
• A tabela de representação binária em 5 bits:
Projeto Final
• A partir disso construímos o módulo decodificador de linha de 5 bits,
chamado de demux 32. O circuito pode ser encontrado em Projeto
final/ROM. Além disso, uma entrada Enable foi adicionada ao
módulo, fazendo com que estivesse habilitado somente quando
Enable = 1.
• Agora, foi implementado o circuito de Tri – States, com 8 bits de
instrução, onde a entrada que habilita de cada um, era determinada
pelo decodificador de linha, que os ativaria sequencialmente, de
acordo com cada programa.
Projeto Final
• Assim, para realizar uma simulação, programamos as ROM’s da
seguinte maneira:
Projeto Final
• Assim, com o módulo ROM32 pronto, obtivemos a simulação para a
memória ROM:
Projeto Final
• A partir do mesmo raciocínio para construção da Memória ROM, foi
construído um banco de memórias ROM, Utilizando um decodificador
de linha 23, que podiam ser inseridas 8 ROM’s devidamente
programadas, para seleção.
• Foram adicionadas uma entrada seletora de 3 bits, que poderiam ser
controladas pelo usuário, além de entrada de endereços da ROM, que
eram controladas sequencialmente pelo Contador de programa.
Projeto Final
• O circuito pode ser visualizado em Projeto Final\Circuito Final\
Banco_rom.
Projeto Final - RAM
• Em nosso microprocessador, utilizamos uma Memória RAM de 32
posições de 5 bits como memória de trabalho.
• Nesse caso, nossa memória deveria possibilitar a leitura do que
estaria registrado nela em certo momento, e também dependendo
das funções, deveria possibilitar que escrevêssemos determinadas
informações em seu conteúdo.
• Para construí – lá, utilizamos tanto de módulos de registradores de 5
bits, e também módulos Tri – State de 5 bits, para as funções de
escritura e leitura, respectivamente.
Projeto Final - RAM
• Primeiro, reaproveitamos o módulo registrador, construído no
experimento 4, utilizando Flip – Flops D, para que registrassem tudo
aquilo que fosse inserido naquele momento em sua entrada D, à cada
pulso de clock.
• Seguindo a tabela:
Projeto Final - RAM
• Porém, foi criada uma entrada enable, que habilitaria o
funcionamento do registrador. Nos momentos que a entrada
estivesse desativada, o registrador permaneceria como no estado
anterior:
Projeto Final - RAM
• Com ajuda de um software que realizou as simplificações de
karnaugh, obtemos a expressão lógica:
Q’ = E.D + E’.Q
• E o circuito montado :
Projeto Final - RAM
• A forma de onda para o Reg 5 bits:
Projeto Final - RAM
• Agora construímos o módulo Tri – State de 5 bits, para permitir a
leitura do conteúdo armazenado em cada posição da memória, assim
a tabela que demonstra o funcionamento:

• O circuito pode ser encontrado em Projeto Final/RAM/TRI5

Projeto Final – RAM
• A forma de onda para o tri – state:
Projeto final - RAM
• Assim utilizamos dois decodificadores de linha, construídos no passo
anterior, para funcionarem como “Enable”, uma para os registradores,
para quando quiséssemos escrever na memória, e outro para ler os
conteúdos da RAM, onde a posição escolhida seria determinada pela
entrada adicionada de 5 bits: Posição[4..0], que entraria nos
decodificadores de linha.
• Foram adicionadas uma saída para Cada registrador da RAM, além de
uma saída DATA[4..0], responsável pela saídas dos Tri – States.
• O módulo pode ser encontrado em Projeto Final\RAM\RAM32.
Projeto Final - RAM
• A forma de onda para memória RAM:
Projeto Final - Displays
• Neste passo era Necessário construir um circuito de alimentação dos
Displays hexadecimais contidos na placa FPGA, foi necessário
complementar os decodificador de display do experimento 3, permitindo a
visualização de todos os números em 5 bits. Para valores acima de 15,
foram criadas visualizações, e um dos números deveria apagar
completamente o display.
• Para isso construímos tabelas – verdade, considerando o display aceso em
nível baixo.
• Seguimos a configuração:
Projeto Final
• As representações de 0 a F foram as mesmas, e as criadas para os
demais números foram:
Projeto Final
• Com isso, obtivemos
a tabela verdade:
Projeto Final
• Com a ajuda do software 32x8, realizamos as simplificações de
karnaugh e para cada led obtivemos a respectiva função.
• Para a:

• O circuito pode ser encontrado em Projeto Final\Display\hex_a

Projeto Final
• Para b:

• O circuito pode ser encontrado em Projeto Final\Display\hex_b

Projeto Final
• Para c:

• O circuito pode ser encontrado em Projeto Final\Display\hex_c

Projeto Final
• Para d:

• O circuito pode ser encontrado em Projeto Final\Display\hex_d

Projeto Final
• Para e:

• O circuito pode ser encontrado em Projeto Final\Display\hex_e

Projeto Final
• Para f:

• O circuito pode ser encontrado em Projeto Final\Display\hex_f

Projeto Final
• Para g:

• O circuito pode ser encontrado em Projeto Final\Display\hex_g

Projeto Final
• Com isso foram criados módulos para cada led do display, para serem
todos unidos em um único circuito que integraria todos, e seria o real
decodificador de display, para cada representação criada.
• Criamos uma entrada x[4..0], que determinaria o número qual estaria
entrando, para que sua representação fossa mostrada, a partir da
saída principal.
• O circuito pode ser encontrado em Projeto Final\Display
Projeto Final
• A forma de onda para o display Hexadecimal:
Projeto Final – Alimentador de Display

• A partir da construção do último módulo, criamos agora o circuito de

alimentação dos displays, que seguia uma codificação específica,
determinada pela posição 31, a última, da memória RAM.
• A codificação era:
1. 0: Devem ser exibidos no display os seguintes registradores - A, B, Ac e CP
2. 1: Devem ser exibidos no display os conteúdos das memórias de 0 a 3
3. n (2 <= n <= 29): Devem ser exibidos no display os conteúdos das memórias de (n-1) a
(n+2)
4. 30: Devem ser exibidos no display os conteúdos das memórias (29 30 31 0)
5. 31: Devem ser exibidos no display os conteúdos das memórias (30 31 0 1)
• Por exemplo, ao entrar 01000 (8), era mostrados nos 4 displays hexadeciamis da placa o
conteúdo das memórias 7 8 9 e 10.
Projeto Final
• Para que a codificação dada anteriormente fosse seguida, foi utilizado
um decodificador de linha de 32 posições, construído junto a
memória ROM, e a entrada T[4..0], que determinaria o que seria
mostrado pelo alimentador (posição 31 RAM), a partir do
decodificador da linha.
• Utilizamos Módulos TRI – State de 5 bits, construídos durante a
implementação da RAM, para que de acordo com o Demux32, a
informação correta fosse mostrada.
• Para explicar e mostrar o funcionamento do circuito alimentador, é
necessário abrir o circuito, que se encontra em Projeto
Final\Alimentador.
Projeto Final – Contador de Programa (CP)
• Em nosso circuito final seria necessário a inclusão de um contador de
programa, para que cada instrução que estivesse armazenada nos
endereços da memória ROM, fosse realizada sequencialmente,
possibilitando o correto funcionamento do processador.
• Utilizamos o módulo contador de 4 bits previamente construído
durante o experimento 2, que contém todo o projeto. Assim,
colocamos dois contadores de 4 bits em cascata, que realizaria a
contagem de 0 a 31, se tornando um contador de módulo 32.
Projeto Final
• O módulo do contador simples de 4 bits:
• Ao colocar dois contadores em cascata, quería_
mos que a contagem fosse feita seguindo:
Projeto Final
• Assim sabendo que colocando a saída RCO do contador funcionando
como Enable do próximo contador (em cascata), a contagem se
estenderia, e utilizando as entradas Q4, Q3, Q2, Q1 e Q0, teríamos a
contagem desejada de 0 à 31.
• Além disso, teríamos de considerar as entradas Enable e Reset
sempre em nível alto, adicionar entradas para o clock, para o LoadCP,
além das 4 entradas que determinariam a posição que o contador se
encontraria caso o loadCP fosse ativado, sendo E[4..0].
Projeto Final
• O Circuito implementado então foi:
Projeto Final
• Então construímos um módulo do contador criado, e a forma de onda
para o circuito:
Projeto Final
Projeto Final - ULA
• Agora, regatamos o Módulo da ULA, construído no experimento 3,
para que as instruções Lógico – aritméticas possam ser realizadas pela
mesma, utilizando a notação de complemento de 2, e com 5 bits.
• Além disso foi necessário fazer algumas alterações no módulo de
decodificação do circuito, pela inserção de algumas instruções novas,
além de agora estarmos utilizando 5 bits, e não mais 4 bits.
• As simplificações de karnaugh, feitas no software 32x8, foram feitas
baseando – se na tabela de instruções lógico – aritméticas obtida pela
ultima dezena do RA.
Projeto Final
• A tabela com as instruções realizadas pela ULA:
Projeto Final
• Agora, recriamos cada módulo contido na ULA, para que suportasse 5
bits de instrução, e não mais 4 bits. Cada módulo, modificado foi
então:

• A visualização de cada módulo modificado,

pode ser encontrada dentro da ULA,
em Projeto Final\ULA\ULA.
Projeto Final
• Agora seguimos com a modificação do módulo decodificador, para
que suportasse as novas instruções que buscávamos poder realizar.
Primeiramente construímos uma tabela verdade para auxiliar a
construção em que tivemos:
Projeto Final
• Para cx:

• Onde A = f4, B = f3, C = f2, D = f1 e E = f0.

Projeto Final
• Para Cy:

• Onde A = f4, B = f3, C = f2, D = f1 e E = f0.

Projeto Final
• Para Zx:

• Onde A = f4, B = f3, C = f2, D = f1 e E = f0.

Projeto Final
• Para Zy:

• Onde A = f4, B = f3, C = f2, D = f1 e E = f0.

Projeto Final
• Para Carry:

• Onde A = f4, B = f3, C = f2, D = f1 e E = f0.

Projeto Final
• Para ADDC:

• Onde A = f4, B = f3, C = f2, D = f1 e E = f0.

Projeto Final
• A forma de onda para o decodificador:
Projeto Final
• Como visto foi necessário construir novos módulos para as funções
ADDC, e tanto para XOR.
• Para a função XOR, escolhemos fazê – la bit a bit, para isso
construímos um módulo simples XOR de 5 bits:
Projeto Final
• A forma de onda para o XOR:
Projeto Final
• Utilizamos uma única saída, tanto para as funções feitas pelo
somador, quanto para a XOR, porém o que selecionava a saída seriam
dois Tri – States de 5 bits, construídos na RAM, a partir de um seletor
que foi feito.
• Foram consideradas duas saídas para o seletor, a saída XOR, e a soma,
que seriam os habilitadores dos Tri – States que escreveriam na saída.
• Assim consideramos que a única vez que xor estivesse ativado, seria
quando a função xor estivesse sendo realizada, as demais a saída
soma era a ativada.
Projeto Final
• A tabela que ilustra o Funcionamento do módulo:

• Onde xor = f4’.f3’.f2.f1.f0 e soma compreende todas as demais

combinações.
Projeto Final
• O módulo pode ser visualizado construído em Projeto Final\ULA\ULA.
• A forma de onda para o mesmo é:
Projeto Final
• Para a função ADDC, sabíamos que deveria ser feira com a flag Carry
da operação anterior, então para isso, incluímos a saída ADDC no
decodificador, para quando essa função tivesse que ser realizada.
• Assim criamos um seletor de carry, tanto para o Carry do
decodificador, como para o da operação ADDC, assim seguimos a
seguinte tabela:
Projeto Final
• Realizando as simplificações de Karmaugh:

• Onde A = C, B = Carry e C = ADDC.

Projeto Final
• A forma de onda para esse módulo :

• Implementamos o seletor, logo saindo de decodificador principal,

onde a montagem pode ser vista em Projeto Final\ULA\ULA.
Projeto Final
• Para as Flags que saem da ULA, construímos um Módulo específico,
que guardaria e nos mostraria todas as flags, seguindo o mesmo
princípio do experimento 3:
Projeto Final
• Para a Flag C, especialmente, consideramos que sempre seria 0 na
função XOR, então a consideramos somente para as funções do
somador.
Projeto Final
• Com a construção de todos os módulos, finalmente implementamos a
ULA final, de modo que todas as operações propostas pudessem ser
realizadas corretamente. Houve algumas alterações em relação a
estrutura do circuito apresentado durante o experimento 3, porém
seguindo os mesmos princípios, a ULA seguis o mesmo padrão dos
módulos.
• A visualização do circuito pode ser eita em Projeto Final\ULA\ULA,
que contém todos os módulos.
Projeto Final
• A forma de onda Para ULA final:
Projeto Final
• A forma de onda Para ULA final:
Projeto Final – Decodificador de Instruções
• Agora, com a construção da ULA, foi necessário projetar um circuito,
decodificador de instruções, de modo que todas as instruções que
foram especificadas pudessem ser realizadas. Tanto as funções que
envolveriam os registradores, a ULA, a memória RAM, etc.
• Para montagem deste circuito, foi necessário pensar inicialmente no
circuito final num todo, para claramente termos a ideia de como
implementar as saídas do decodificador, realizando corretamente
todas as funções apresentadas.
• A ideia inicial foi mesclar as estruturas tanto do experimento 4 como
do 5, de modo que se tornaria mais fácil simplificar e realizar a
construção de cada saída do nosso decodificador principal.
Projeto Final
• Inicialmente obtivemos, a codificação de todas as instruções, pela
tabela seguinte:
Projeto Final
• Um panorama do circuito final pensado foi:
Projeto Final
• Inicialmente, construímos um decodificador de 3 bits, para detectar
funções cujos 3 bits iniciais eram 000, ou diferentes.
• Seguindo a Tabela temos que:
Projeto Final
• Então seria necessário somente seguir as entradas e temos que:
Projeto Final
• Agora baseando – se nos princípios do experimento 4 e 5, com Tri-
states e registradores, criamos as varias saídas, uma a uma do
decodificador de instruções.
• O que foi pensado basicamente, era escrever informações em um
barramento principal, e fazer que os demais módulos recebessem as
informações de acordo com cada função.
•
Projeto Final
• GA - Enable Registrador A:
Projeto Final
• GA:
Projeto Final
• GB – Enable Registrador B:
Projeto Final
• GB:
Projeto Final
• GAc – Enable Acumulador:
Projeto Final
• GAc:
Projeto Final
• EnA – Enable Tri – State A:
Projeto Final
• EnA:
Projeto Final
• EnAC – Enable Tri – State Ac:
Projeto Final
• EnAc:
Projeto Final
• EnRAM – Enable Tri – State RAM:
Projeto Final
• EnRAM:
Projeto Final
• EnULA – Tri – State ULA:
Projeto Final
• EnULA:
Projeto Final
• LoadCP – Load Contador de Programa
Projeto Final
• Tabela do LoadCP, com as Flags Z e V:
Projeto Final
• LoadCP:
Projeto Final
• RWAp – Registrador A determinando a posição da RAM (Tri – state):
Projeto Final
• RWAp:
Projeto Final
• RWAv – A Determina o valor na entrada da RAM:
Projeto Final
• RWAv:
Projeto Final
• RWBv - B Determina o valor na entrada da RAM
Projeto Final
• RWBv:
Projeto Final
• RWOpb – Operando Escreve no barramento principal:
Projeto Final
• RWOPb:
Projeto Final
• RWOPp – Operando determina posição da RAM:
Projeto Final
• RWOPp:
Projeto Final
• RWcp – Contador determina o pulo da contagem:
Projeto Final
• RWcp:
Projeto Final
• Rwop – Operando determina o pulo da contagem:
Projeto Final
• RWop:
Projeto Final
• RWsoma – PC + OPERANDO determina pulo da contagem:
Projeto Final
• RWsoma:
Projeto Final
• Ainda foi criada uma entrada extra, para o efeito do armazenamento
correto das FLAGS, num registrador. A saída é Active_ULA:
Projeto Final
• Ac_ULA:
Projeto Final
• Com a implementação de todos esses módulos listados acima, e
construindo blocos de cada um, sendo as saídas do decodificador, os
reunimos em um circuito principal, com uma entrada de 8 bits, que
seriam as instruções que eram possíveis de serem realizadas.
• A visualização deste módulo com mais clareza, pode ser encontrada
em Projeto Final\Circuito Final\DI.
Projeto Final
• A forma de onda para DI:
Projeto Final
Projeto Final
Projeto Final
Projeto Final
Projeto Final
Projeto Final - Flags
• Para registrar as Flags de cada operação da ULA, tanto para serem
utilizadas na operação ADDC, como nos loops BNZ e BNV, foi utilizado
um registrador de 4 bits (construído no experimento 4), com uma
pequena modificação, sendo esta um circuito que seleciona as flags.
Se a operação realizada envolve a ULA, as flags que entram naquele
momento são as armazenadas, caso contrário, as Flags armazenadas
anteriormente são mantidas.
• O circuito e sua construção é semelhante ao registrador utilizado na
RAM, com uma única mudança que são 4 bits, e não mais 5.
Projeto Final
• Por se tratar do mesmo circuito as simplificações se encontram na
seção da RAM.
• O Circuito e seu bloco:
Projeto Final
• Uma melhor visualização do circuito registrador de Flags, pode ser
feita em Projeto Final\Circuito Final\Reg_flag.
• A Entrada Condicional nesse caso utilizada, foi a saída Active_ULA, do
decodificador de instruções.
Projeto Final – Circuito Final e testes
• Assim, com todos os blocos necessários montados e testados,
implementamos a o circuito final, contendo todos os módulos, que
fazem deste circuito ser um microprocessador.
• A visualização do circuito montado, seguindo o panorama mostrado (
na etapa de construção do decodificador de instruções), pode ser
melhor vista e explicada em Projeto Final\Circuito Final\Finale.
• Assim construímos 2 roteiros de testes, para testar todas as
instruções em todas as possibilidades diferentes, que podem ser
testados na placa FPGA, e podem ser seguidos na folha impressa.
Projeto Final
• Posteriormente implementamos o programa FEEC, que também pode
ser visualizado na placa e na folha impressa.
• E o último programa feito, foi um algoritmo, baseado num loop, com
uma nova função implementada, que calculava o resto da divisão de
um número inteiro e positivo X por outro inteiro Y.
• Nesse caso os números escolhidos foram 15 e 2, o cálculo do resto da
divisão de 15 por 2, que é 1.
Projeto Final
• A nova função implementada foi BNN, que faria um loop em que o
contador receberia PC + Operando, se a Flag N = , ou seja, enquanto
os números que entrassem fossem positivos o loop aconteceria, ao
encontrar um número negativo, o loop era quebrado.
• Para implementar a função houve apenas uma substituição no
circuito final, da entrada V do decodificador de instruções, por uma
entrada N, que sairia da Flag N do registrador de Flags.
• Assim a nova função necessária foi implementada, podendo ser vista
em Projeto Final\BNN\BNN, e o algoritmo de resto da divisão pode
ser executado.