O Funcionamento de um Processador Básico de 4 Bits

Prévia do material em texto

O Funcionamento de um Processador Básico de 4 Bits 
Mateus Medeiros de Souza 
Instituto de Computação – Universidade Federal do Amazonas (UFAM) – 
Manaus, AM – Brasil 
mms1@icomp.ufam.edu.br 
 
1. Descrição do Circuito 
O processador básico é composto por 1 decodificador (o dec, que atua como um 
demultiplexador), 4 portas AND, 4 Registradores, 2 multiplexadores (MUX) e uma 
ULA de 4 bits. Os componentes serão descritos em módulos: 
1- O dec é um demultiplexador 1x4, no qual é fixado na entrada o nível alto, sendo 
selecionável o nível alto em uma das suas saídas no seletor de 2 bits (que 
corresponde ao comando ​Write Reg​) conforme ilustra a Figura 1; 
 
Figura 1 – Decodificador 
2- As 4 portas AND habilitam e desabilitam o resultado de escolha do dec pelo 
comando ​Write Enable​; 
3- Os 4 registradores são implementados cada um com 4 flip-flops D (num total de 
16 flip-flops), com 4 bits cada um, conforme a Figura 2; 
 
 
Figura 2 – Disposição dos Flip-flops D 
 
 
 
4- O primeiro MUX, em contagem de pilha, habilita a seleção de 4 bits vindos de 
4 dos 16 flip-flops D dos Registradores, pelo comando ​Read RegA​, enviando à 
entrada ​A da ULA. O segundo MUX habilita a seleção de 4 bits vindos de 4 
flip-flops selecionados pelo ​comando Read RegB, enviando à entrada ​B da 
ULA; 
 
5- A ULA realiza 8 operações, sendo 4 aritméticas e 4 lógicas, selecionáveis por 
combinações das entradas ​M (Mode), e os seletores S1 e S0. Segue a tabela da 
de operações da ULA, na Tabela 1. 
 
M S1 S0 Operação Descrição 
0 0 0 F = A+B Adição 
0 0 1 F = A - B Subtração 
0 1 0 F = A + 1 Incremento 
 
0 
 
1 
 
1 
 
F = A<<1 
Deslocamento 
de um bit à 
esquerda 
1 0 0 F = A&B And bit a bit 
1 0 1 F = A | B Or bit a bit 
1 1 0 F = Ã Not bit a bit 
1 1 1 F = A ​⊕​ B Xor bit a bit 
Tabela 1 – Tabela-verdade da ULA 
O processo de montagem do processador básico é trivial, pois o trabalho 
proposto oferece o esquema lógico (o circuito está anexado junto), deixando a cargo do 
leitor qual memória implementar para o Banco de Registradores. 
2. Exemplo de Utilização 
Usando o programa assembly fornecido: ​“somar dois números menores que 16 e 
determinar o resto da divisão dessa soma por 4”. ​Devem-se tomar os seguintes 
passos: 
1. Copiar o valor do primeiro operando para um registrador (R1, por exemplo). 
2. Copiar o valor do segundo operando para outro registrador (R2, por exemplo). 
3. Somar os registradores, colocando o resultado em um terceiro registrador (R3, 
por exemplo). 
4. Copiar o divisor (número 4) para um registrador (R0, por exemplo). 
5. Subtrair 1 do número quatro (para criar uma máscara de extração do resto), 
guardando o resultado em R0. 
6. Determinar o resto, por meio de uma operação AND entre a soma (R3) e a 
máscara (R0), guardando o resultado em R1, por exemplo. 
 
 
 
Podemos observar a sequência de operações na Tabela 2: 
 
Ordem de execução Operação em Ling. 
Máquina 
Descrição 
1 mov R1, 5 # R1 = 5 
2 mov R2, 9 # R2 = 9 
3 add R3, R1, R2 # R3 = R1 + R2 
4 mov R0, 4 # R0 = 4 
5 mov R2, 1 # R2 = 1 
6 sub R0, R0, R2 # R0 = R0 – R2 
7 and R1, R3, R0 # R1 = R3 & R0 
Tabela 2 – Sequência de operações do processador 
A seguir, a sequência de telas (screenshots do circuito lógico) que 
correspondem a cada linha de operações da Tabela 2: 
 
1 - ​mov R1, 5: 
 
 
Figura 3 - # R1 = 5 
 
 
 
 
 
 
 
 
 
 
 
2 - ​mov R2, 9​: 
 
 
Figura 4 - #R2 = 9 
 
3 -​ add R3, R1, R2: 
 
Figura 5 - #R3 = R1 + R2 
 
 
 
4 - ​mov R0, 4: 
 
Figura 6 - #R0 = 4 
 
 
5 - ​mov R2, 1: 
 
Figura 7 - #R2 = 1 
 
 
 
6 - ​sub R0, R0, R2: 
 
Figura 8 - #R0 = R0 – R2 
 
 
7 - ​and R1, R3, R0: 
 
 
 
Figura 9 = #R1 = R3 & R0 
3. Conclusão 
O circuito do processador de 4 bits utiliza 16 flip-flops D, sendo que 4 flip-flops 
armazenam 1 palavra de 4 bits, a palavra é selecionada pelos dois multiplexadores, cuja 
seleção é feita pelos comandos ​Read ReagA e ​Read ReagB. ​Cada comando envia para 
a entrada A ou B da ULA uma palavra, executando a operação aritmética ou lógica 
(dependendo do valor do Mode), que é selecionada pelo comando ​Op ULA​. A saída F é 
enviada diretamente aos registradores, selecionando o registrador desejado pelo 
comando de seleção ​Write Reg e habilitando a escrita pelo ​Write Enable​, o qual 
transmite um pulso de clock para ‘ativar’ o registrador de destino. 
A desvantagem do projeto proposto é que o processo dos comandos é feito de 
forma manual. O ideal seria um processador que executasse comandos em série, de 
acordo com a necessidade do programa que se quer rodar. 
Para torná-lo automatizado, utilizam-se duas memórias RAMs, uma para gravar 
as instruções dos comandos (mov, Op ULA, Write Reg, Read ReagA, Read ReagB) e 
outra para substituir os registradores. 
Há um incremento de comando, o mov, no processador melhorado. No 
processador inicial, o mov era executado manualmente no registrador. No processador 
melhorado, para gravar o comando mov na RAM de instruções, algumas instruções 
precisam ser seguidas: 
➢ Selecionar nível alto no mov (o nível baixo desabilita o mov e habilita 
as outras opções); 
➢ O comando ​Op ULA​ não influencia nas instruções; 
 
 
➢ O ​Write Reg seleciona em qual célula deve ser gravado o número, na 
memória RAM de resultado; 
➢ Pelos comandos ​Read A e ​Read B forma-se uma palavra de 4 bits que é 
o número a ser gravado, e o ‘último’ bit do ​Read B é o menos 
significativo da palavra; 
➢ E por último, deve-se habilitar a escrita da memória pelo comando ​RD, 
com um pulso de baixo nível (um pulso de alto nível habilita a leitura da 
memória, usada na execução do programa), e um pulso de alto nível no 
comando de Clock. 
Por exemplo, executar o comando -mov R1 5-, que move o número binário 0101 
para a célula de memória 01, conforme Figura 10. 
 
Figura 10 – Ilustração da instrução mov R1,5 
Outra forma de registro de comando na memória de instruções é converter o 
número 1000010101 (mov R1 5) para hexadecimal, que corresponde a 215, e o 
resultado pode ser registrado diretamente na memória. 
O parâmetro (​Amount of commands​) é o número de comandos a ser executado 
na memória de instruções. 
E por último, o comando (OE clock) habilita e desabilita o funcionamento do 
processador. Sendo um flip-flop D, para desabilitar injeta-se nível baixo e habilitar, 
nível alto. 
Para o funcionamento do circuito ser automatizado, um dos aspectos importantes 
é o uso de dois contadores, e dois comparadores, destacados com as cores vermelha e 
amarela na Figura 11. 
 
 
 
Figura 11 - Proposta de Automatização, com os novos implementos 
O contador sublinhado com cor amarela conta de 0 a 3, que é o necessário para 
realizar uma operação (do tipo add R3, R2, R1) e registrar na memória de resultado 
(destacada de cor laranja). Se o seu estado estiver no 11, onde o comparador está 
diretamente ligado a seus resultados, então a comparação será fixa com a entrada 11. 
Assim, enviando um nível alto para o registrador de cor vermelha, responsável pela 
troca de comandos na memória de instruções (destacada com a cor roxa). 
O comparador (destacado de cor vermelha) delimita a quantidade de comandos 
desejada pelo parâmetro ​Amount of commands​. 
A sua delimitação é, se a saída do contador (destacado de cor vermelha) for 
menor que o comando (​Amountof commands​), é enviado um nível alto, que ativa o 
buffer controlador para seleção de dados da memória de instruções (destacado de cor 
roxa). E caso isso seja negado, é enviado um nível baixo, desabilitando o buffer 
controlador (desabilitando também a memória de instruções) e o comando ​OE clock​, 
passando para o nível baixo e desabilitando a entrada de clock no circuito. Isso faz a 
execução do programa parar completamente. 
 
 
Para melhor entendimento do funcionamento dos contadores nos seus estados, 
pode-se observar na Figura 12 a máquina de estados com as cores correspondentes da 
imagem supracitada. 
 
Figura 12 - Máquina de Estados dos Contadores. Para cada ciclo completo do 
registrador amarelo, conta-se um próximo estado do contador vermelho. 
 
Considerando o seguinte problema: ​“somar dois números menores que 16 e 
determinar o resto da divisão dessa soma por 4”. Como a ULA não implementa 
divisão, é preciso pensar em uma maneira de usar as operações suportadas para fornecer 
o mesmo resultado. Como o divisor é 4, uma potência da base binária, sabemos que o 
resto da divisão por 2​𝑛𝑛 ​é dado tomando-se os ​𝑛𝑛 bits menos significativos do dividendo. 
Para tomarmos esses bits, devemos usar uma máscara e a operação lógica AND bit a bit 
(​Proposto pelo trabalho). 
Assim, para resolver o problema, escolhe-se os números 9 e 5 (exemplo do 
trabalho). Os comandos para resolvê-lo serão: 
 
mov R1, 5 # R1 = 5 
mov R2, 9 # R2 = 9 
add R3, R1, R2 # R3 = R1 + R2 
mov R0, 4 # R0 = 4 
mov R2, 1 # R2 = 1 
sub R0, R0, R2 # R0 = R0 – R2 
and R1, R3, R0 # R1 = R3 & R0 
Tabela 3 – Sequência de instruções 
 
 
 
As instruções de máquina correspondentes são estas descritas na tabela 4: 
Mnemônico mov Op ULA Write Reg Read Reg A Read Reg B 
mov R1, 5 1 000 01 01 01 
mov R2, 9 1 000 10 10 01 
add R3, R1, 
R2 
0 000 11 01 10 
mov R0, 4 1 000 00 01 00 
mov R2, 1 1 000 10 00 01 
sub R0, R0, 
R2 
0 001 00 00 10 
and R1, R3, 
R0 
0 100 01 11 00 
Tabela 4 – Instruções em Linguagem de Máquina 
Ou, passando diretamente à memória de instruções: 
0 215 229 
2 036 204 
4 221 042 
6 11c 000 
Tabela 5 – Valores correspondentes às instruções na memória 
Ao final da execução, na memória de resultado, é possível ver a soma de 9 e 5, e 
determinar o resto por 4 é 2: 
 
Figura 13 - Resultado do comando.