GCC113: Circuitos Digitais Data: 04 de abril de 2022

Trabalho final

Professor: Bruno de Abreu Silva e Eric Araújo Semestre 2021-2

É com enorme prazer, queridos alunos, que escrevo a especificação deste trabalho! Gostaria de dizer a
vocês que vocês precisarão ler com bastante atenção. Vocês terão a oportunidade de saber como um sistema
computacional pode ser projetado e especificado. Embora esse sistema seja relativamente simples, à primeira
vista pode ser bastante complicado e difícil de se entender. A seguir, o que vocês verão é a forma como uma
arquitetura de um processador costuma ser descrita em manuais e guias de referência. O esforço valerá a pena,
pois vocês começarão a entender, nesta atividade, a principal aplicação dos conhecimentos de circuitos digitais:
projeto de sistemas computacionais e arquitetura de computadores.

1 Processador ReMember
O processador ReMember é um processador criado para atender às demandas da disciplina GCC113 - Circuitos
Digitais durante as aulas remotas em plena pandemia de COVID-19. Seu nome é uma junção das palavras
Remote Member em homenagem a todas as pessoas que estão interagindo de forma remota com amigos, fami-
liares e também de forma profissional, no trabalho e nos estudos. Além disso, a palavra remember pode ser
traduzida em português como o verbo relembrar. É preciso também relembrar os bons momentos do passado
para termos sempre esperança de que dias melhores virão. Além disso, é preciso relembrar sempre das muitas
pessoas que infelizmente se foram, mas que em vida sempre lutaram dignamente para melhorar o mundo a sua
volta. E, por fim, devemos relembrar deste momento que estamos passando e dos erros que a nossa sociedade
está cometendo para que no futuro não cometamos os mesmos erros e que possamos aprender algo com tudo
isso. Então, ReMember é algo para ser lembrado, para ser ensinado e para ser aprendido.

O processador ReMember é um processador de 8 bits baseado no processador MIPS, muito utilizado no

ensino de Arquitetura de Computadores. Porém, por ser uma versão bastante simplificada, sua arquitetura
possui características próprias que serão detalhadas neste documento.

Características principais:
• Trabalha em complemento de dois e utiliza 8 bits para dados;
• Possui 8 registradores de propósito geral de 8 bits, R0 até R7;
• Possui uma memória de dados e uma memória de instruções;

• Cada instrução executa em apenas 1 ciclo de clock;

• Consegue endereçar 256 posições de memória;

1.1 Conjunto de instruções

O conjunto de instruções é uma das coisas que definem uma arquitetura de um processador. O ISA, Instruc-
tion Set Architecture, é um conjunto de operações suportadas pelo processador para que ele possa executar
programas com operações lógicas, aritméticas, com acesso à memória, estruturas de repetição e condicionais.
Cada instrução é representada por uma sequência de bits que o processador saberá interpretar para executar
a operação corretamente. Para facilitar a tarefa humana de programação, as instruções podem receber nomes
amigáveis, formando então uma linguagem que costuma ser chamada de assembly. A Tabela 1 apresenta o
conjunto de instruções do assembly do ReMember juntamente com uma breve descrição de seu funcionamento.

As instruções precisam ser codificadas em binário para que possam ser armazenadas na memória e posterior-
mente executadas pelo processador. Para isso, são definidos formatos para as instruções. No caso do ReMember,
existem três formatos para as instruções: Tipo R, Tipo I e Tipo J. Todos os três formatos possuem 18 bits de
tamanho, que é a quantidade de bits usada para armazenar uma instrução na memória de instruções.

1
GCC113 – Trabalho final 2

Instrução Exemplo Descrição

Soma add R0, R1, R2 O registrador R0 recebe a soma de R1 e R2
Subtração sub R0, R1, R2 R0 = R1 - R2
Multiplicação mult R0, R1, R2 R0 = R1 * R2
Divisão div R0, R1, R2 R0 = R1 - R2
Negação not R0, R1 R0 = ¬ R1
Menor que slt R0, R1, R2 Armazena 1 em R0 se R1 é menor que R2
Deslocamento à esquerda sll R0, R1, N Desloca R1 N casas para a esquerda e armazena em R0
Deslocamento à direita srl R0, R1, N Desloca R1 N casas para a direita e armazena em R0
Carregar dados da memória lw R0, R1(N) R0 recebe o conteúdo armazenado no endereço R1(N) da memória
Salvar dados na memória sw R0, R1(N) Memória salva no endereço R1(N) o conteúdo de R0
Desvio condicional beq R0, R1, ENDR Desvia o programa para ENDR se R0 == R1
Soma Imediata addI R0, R1, N R0 = R1 + N
Desvio incondicional jmp ENDR Desvia o programa para o endereço ENDR

Tabela 1: Conjunto de instruções do ReMember.

1.1.1 Formato tipo R

O formato R é definido para as instruções que manipulam registradores, como é o caso das instruções aritméticas
e lógicas, basicamente realizadas pela Unidade Lógica e Aritmética. São instruções que lêem o conteúdo de dois
registradores e armazenam o resultado da operação em outro registrador. A Tabela 2 ilustra o formato R e sua
divisão em 6 campos.

17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
opcode rs rt rd shamt funct

Tabela 2: Formato R.

Os campos da instrução tipo R são:

• opcode: representa o código da operação. Cada instrução possui um código binário de 3 bits que o
representa;
• rs: é o endereço do registrador que será usado como um dos operandos da instrução;
• rt: é o endereço do registrador que será usado como outro operando da instrução;

• rd: é o endereço do registrador que será usado como o destino do resultado da operação;
• shamt: shift amount, representa a quantidade de casas de deslocamento em instruções de deslocamento;
• funct: indica a função executada pela ULA. Juntamente com o opcode, define qual a instrução a ser
executada.

1.1.2 Formato tipo I

O formato I é definido para as instruções que manipulam a memória de dados, seja leitura ou escrita, também
para a instrução addI com campo imediato, ou seja, campo com uma constante inteira com 8 bits em comple-
mento de dois e também para a instrução de desvio condicional. A Tabela 3 ilustra o formato I e sua divisão
em campos.

17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
opcode rs rt x address/imm

Tabela 3: Formato I.

Os campos da instrução tipo I são:

• opcode: representa o código da operação. Cada instrução possui um código binário de 3 bits que o
representa;
GCC113 – Trabalho final 3

• rs: para instruções de carregamento de palavra da memória para um registrador (lw - load word ) ou
armazenamento de conteúdo de um registrador em uma palavra da memória (sw - store word ) é o regis-
trador que será usado como o endereço base da posição de memória acessada. Para a instrução de soma
imediata, addI, é o endereço do registrador que será usado como operando na soma. Para a instrução de
desvio condicional (beq - branch on equal ), representa o endereço do registrador que é um dos operandos
da operação;
• rt: para a instrução lw, é o registrador que receberá o conteúdo da memória. Para a instrução sw, é o
registrador que possui o conteúdo que será salvo na memória. E, para a instrução addI, é o registrador que
receberá o resultado da soma. Para a instrução de desvio condicional (beq - branch on equal ), representa
o endereço do registrador que é um dos operandos da operação;
• x: este não é de fato um campo, é apenas 1 bit não utilizado no formato da instrução, está representado
por um don’t care, pois seu valor é irrelevante;
• address/imm: para as instruções lw e sw, representa o valor somado ao endereço base armazenado no
registrador rs para definir o endereço real a ser acessado na memória, ou seja, o endereço de memória
acessado é sempre a soma do conteúdo em rs e o valor no campo address/imm e neste caso é um inteiro
sem sinal. Para a instrução addI, este campo armazena a constante que será somada ao valor de rs e
neste caso é um inteiro com sinal. Para a instrução beq, representa o endereço da próxima instrução a ser
executada pelo programa, caso o valor armazenado nos registradores rs e rt seja igual.

1.1.3 Formato tipo J

O formato J é definido para a instrução de desvio incondicional. A Tabela 4 ilustra o formato J e sua divisão
em campos.

17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
opcode xxxxxxx address

Tabela 4: Formato J.

Os campos da instrução tipo J são:

• opcode: representa o código da operação. Cada instrução possui um código binário de 3 bits que o
representa;

• xxxxxxx: este não é de fato um campo, são 7 bits não utilizados no formato da instrução, está represen-
tado por don’t cares, pois seu valor é irrelevante;
• address: representa o endereço da próxima instrução a ser executada pelo programa.

1.2 Opcodes e exemplos de instruções

A Tabela 5 apresenta os valores de opcode e funct para cada uma das instruções do processador ReMember.

A Tabela 6 apresenta alguns exemplos de instruções em assembly e como elas podem ser traduzidas para
binário e hexadecimal. Para realizar esse processo, é necessário colocar em cada campo da instrução, seus
valores corretos. Cada registrador de R0 a R7 ssão traduzidos em binário pelo seu número, por exemplo, R0
está no endereço 000, R1 em 001, R2 em 010 e assim por diante.

1.3 Banco de registradores

O banco de registradores do ReMember possui 8 registradores de 8 bits e foi projetado de forma que permite a
leitura simultânea de dois registradores e a escrita em um registrador a cada pulso de clock. Sendo assim, ele
possui as seguintes entradas e saídas:

• Read register 1: entrada de 3 bits que recebe o endereço de um dos registradores a ser lido, com 3 bits
consigo endereçar todos os 8 registradores existentes;
• Read register 2: entrada de 3 bits que recebe o endereço do outro registrador a ser lido;
GCC113 – Trabalho final 4

Instrução opcode/funct assembly Descrição Formato

Soma 000/000 add rd, rs, rt rd = rs + rt R
Subtração 000/001 sub rd, rs, rt rd = rs - rt R
Multiplicação 000/010 mult rd, rs, rt rd = rs * rt R
Divisão 000/011 div rd, rs, rt rd = rs - rt R
Negação 000/100 not rd, rs rd = ¬rs R
Menor que 000/101 slt rd, rs, rt se rs < rt, rd = 1 R
Deslocamento à esquerda 000/110 sll rd, rs, N rd = rs « N R
Deslocamento à direita 000/111 srl rd, rs, N rd = rs » N R
Carregar dados da memória 001/xxx lw rt, rs(N) rt = Memória[rs + N] I
Salvar dados na memória 010/xxx sw rt, rs(N) Memória[rs + N] = rt I
Desvio condicional 011/xxx beq rs, rt, ENDR se rs == rt, PC = ENDR I
Soma Imediata 100/xxx addI rt, rs, N rt = rs + N I
Desvio incondicional 111/xxx jmp ENDR PC = ENDR J

Tabela 5: Opcodes, funct e descrição detalhada das instruções do ReMember. PC é uma sigla para Program
Counter. PC é um registrador presente nos processadores que armazena o endereço da instrução que será
executada naquele momento no processador.

Assembly Binário Hexadecimal

add R0, R1, R2 00 0001 0100 0000 0000 01400
addI R6, R5, 7 10 0101 1100 0000 0111 25c07
lw R3, R4(20) 00 1100 0110 0001 0100 0c614
sub R1, R1, R2 00 0001 0100 0100 0001 01441

Tabela 6: Exemplos de instruções em assembly, binário e hexadecimal. Os bits foram organizados em grupos
de 4 bits de forma a facilitar a visualização do hexadecimal. Os campos don’t care de cada instrução foram
preenchidos com 0.

• Write register: entrada de 3 bits que recebe o endereço do registrador que receberá uma escrita de dados;
• Write data: entrada de 8 bits que recebe o conteúdo a ser escrito no registrador endereçado por Write
register;

• RegWrite: entrada de 1 bit que habilita a escrita no banco de registradores caso seu valor seja 1;
• CLK: entrada de clock para os flip-flops dos registradores;
• CLR: entrada de clear para os flip-flops dos registradores;

• Read data 1: saída de 8 bits com o conteúdo do registrador endereçado por Read register 1;
• Read data 2: saída de 8 bits com o conteúdo do registrador endereçado por Read register 2;

1.4 Endereçamento de Memória e Entrada/Saída

No ReMember são utilizados 8 bits para representar endereços, e sua ULA também trabalha com dados de 8 bits.
Sendo assim, é possível endereçar 256 endereços de memória. Como o ReMember possui duas memórias, uma
para armazenar as instruções do programa e outra para armazenar os dados do programa (variáveis e constantes),
é possível ter programas com até 256 instruções e memórias de dados com até 256 bytes de capacidade.

O processador ReMember trabalha com Entrada e Saída mapeada em memória em um barramento centra-
lizado. Isso significa que, para realizar comunicação com dispositivos de entrada e saída, o espaço de endereça-
mento de memória deve ser dividido entre os dispositivos. Por exemplo, caso o sistema possua um circuito com
8 LEDs de saída controlados pela CPU, ele deve ser conectado ao mesmo barramento da memória e ser mapeado
para algum endereço. Por exemplo, poderíamos deixar o último endereço de memória 255 para endereçar os 8
bits que serão enviados para os LEDs. Nesse caso, a memória de dados não poderia ter toda a sua capacidade
de 256 bytes, pois um dos bytes (o último) estaria sendo usado para endereçar o dispositivo controlador dos
LEDs.
 GCC113 – Trabalho final 5

1.5 Exemplo de programa escrito para o ReMember

Para que seja possível entender melhor como um processador pode ser usado para executar algoritmos, é
apresentado a seguir um exemplo de um código que calcula a média dos valores armazenados em um vetor.
1 \∗
2 Trecho de c o d i g o em l i n g u a g e m C++ para c a l c u l a r a media dos
3 v a l o r e s de um v e t o r de tamanho N
4 ∗\
5
6 int N = 8 ;
7 i n t v e t o r [N ] ;
8 vetor [ 0 ] = 3;
9 vetor [ 1 ] = 5;
10 vetor [ 2 ] = 4;
11 vetor [ 3 ] = 1;
12 vetor [ 4 ] = 7;
13 vetor [ 5 ] = 7;
14 vetor [ 6 ] = 8;
15 vetor [ 7 ] = 5;
16
17 i n t soma = 0 ;
18 f o r ( i n t i = 0 ; i < N; i ++){
19 soma += v e t o r [ i ] ;
20 }
21 soma = soma / N;

Para o código em assembly, algumas convenções são adotadas: R0 sempre armazena a constante 0; a primeira
instrução do programa é um desvio incondicional para a linha seguinte e; a última instrução do programa é um
desvio incondicional para ela mesma, assim o programa fica preso na última linha, encerrando a execução do
algoritmo. A primeira instrução jmp 1, deve ficar na posição zero da memória de instruções e está presente em
todos os programas. O mesmo código em C++ apresentado acima, pode ser escrito em assembly do ReMember
da seguinte forma, excetuando-se a linha zero explicada acima, comentários de uma linha são iniciados com #:
1 addI R5 , R0 , 8 # d e f i n e tamanho N do v e t o r e s a l v a em R5
2 sw R5 , R0 ( 0 ) # armazena N na p o s i c a o 0 da memoria de dados
3 addI R7 , R0 , 8 # s a l v a o e n d e r e c o b a s e do v e t o r em R7
4 addI R1 , R0 , 3 # Armazena o v a l o r 3 em R1
5 sw R1 , R7 ( 0 ) # S a l v a o c o n t e u d o de R1 na p o s i c a o v e t o r [ 0 ]
6 addI R1 , R0 , 5 # Armazena o v a l o r 5 em R1
7 sw R1 , R7 ( 1 ) # S a l v a o c o n t e u d o de R1 na p o s i c a o v e t o r [ 1 ]
8 addI R1 , R0 , 4 # Armazena o v a l o r 4 em R1
9 sw R1 , R7 ( 2 ) # S a l v a o c o n t e u d o de R1 na p o s i c a o v e t o r [ 2 ]
10 addI R1 , R0 , 1 # Armazena o v a l o r 1 em R1
11 sw R1 , R7 ( 3 ) # S a l v a o c o n t e u d o de R1 na p o s i c a o v e t o r [ 3 ]
12 addI R1 , R0 , 7 # Armazena o v a l o r 7 em R1
13 sw R1 , R7 ( 4 ) # S a l v a o c o n t e u d o de R1 na p o s i c a o v e t o r [ 4 ]
14 addI R1 , R0 , 7 # Armazena o v a l o r 7 em R1
15 sw R1 , R7 ( 5 ) # S a l v a o c o n t e u d o de R1 na p o s i c a o v e t o r [ 5 ]
16 addI R1 , R0 , 8 # Armazena o v a l o r 8 em R1
17 sw R1 , R7 ( 6 ) # S a l v a o c o n t e u d o de R1 na p o s i c a o v e t o r [ 6 ]
18 addI R1 , R0 , 5 # Armazena o v a l o r 5 em R1
19 sw R1 , R7 ( 7 ) # S a l v a o c o n t e u d o de R1 na p o s i c a o v e t o r [ 7 ]
20 addI R6 , R0 , 0 # i n i c i a l i z a R6 com z e r o para comecar a acumular a soma dos e l e m e n t o s do v e t o r
21 addI R4 , R0 , 0 # i n i c i a l i z a a v a r i a v e l i em R4 com z e r o
22 LOOP: s l t R1 , R4 , R5 # f a z o t e s t e do LOOP, s e R4 < R5 , R1 = 1 . Ou s e j a , s e i < N, R1 = 1
23 beq R1 , R0 , ENDLOOP # c a s o R1 == ZERO, s i g n i f i c a que i >= N, d e s v i a para ENDLOOP ( l i n h a 2 9 )
24 add R1 , R7 , R4 # R1 = R7 + R4 , ou s e j a , R1 = end . b a s e do v e t o r + d e s l o c a m e n t o
25 lw R1 , R1 ( 0 ) # R1 = Memoria [ R1 ] , R1 eh s o b r e s c r i t o com o c o n t e u d o da p o s i c a o R1 da memoria
26 add R6 , R6 , R1 # R6 = R6 + R1 , acumula a soma dos v a l o r e s do v e t o r
27 addI R4 , R4 , 1 # i n c r e m e n t a i , que e s t a em R4
28 jmp LOOP # v o l t a para o i n i c i o do LOOP ( l i n h a 2 2 )
29 ENDLOOP: d i v R6 , R6 , R5 # d i v i d e R6 po R5 # r e a l i z a a d i v i s a o da soma p e l o n . de e l e m e n t o s
30 sw R6 , R0 ( 1 ) # s a l v a a media na p o s i c a o 1 da memoria Memoria [ 1 ]
31 jmp 31 # Pula para a p r o p r i a l i n h a i n f i n i t a m e n t e , f i m do programa

Cada instrução em assembly deve ser passada para binário para que o programa possa ser carregado na
memória de instruções. Em muitos casos, a memória pode ser escrita com valores em hexadecimal, como é
o caso do simulador Logisim, para facilitar a escrita dos valores. A representação do programa acima em
hexadecimal e binário pode ser vista a seguir. Estes valores é que devem estar na memória de instruções
GCC113 – Trabalho final 6

para que o processador execute o programa, executando uma instrução a cada ciclo de clock, de acordo com a
instrução atual, endereçada pelo registrador PC, Program Counter.
linha 00: hexa 38001 bin 11 1000 0000 0000 0001
linha 01: hexa 20 a08 bin 10 0000 1010 0000 1000
linha 02: hexa 10 a00 bin 01 0000 1010 0000 0000
linha 03: hexa 20 e08 bin 10 0000 1110 0000 1000
linha 04: hexa 20203 bin 10 0000 0010 0000 0011
linha 05: hexa 17200 bin 01 0111 0010 0000 0000
linha 06: hexa 20205 bin 10 0000 0010 0000 0101
linha 07: hexa 17201 bin 01 0111 0010 0000 0001
linha 08: hexa 20204 bin 10 0000 0010 0000 0100
linha 09: hexa 17202 bin 01 0111 0010 0000 0010
linha 10: hexa 20201 bin 10 0000 0010 0000 0001
linha 11: hexa 17203 bin 01 0111 0010 0000 0011
linha 12: hexa 20207 bin 10 0000 0010 0000 0111
linha 13: hexa 17204 bin 01 0111 0010 0000 0100
linha 14: hexa 20207 bin 10 0000 0010 0000 0111
linha 15: hexa 17205 bin 01 0111 0010 0000 0101
linha 16: hexa 20208 bin 10 0000 0010 0000 1000
linha 17: hexa 17206 bin 01 0111 0010 0000 0110
linha 18: hexa 20205 bin 10 0000 0010 0000 0101
linha 19: hexa 17207 bin 01 0111 0010 0000 0111
linha 20: hexa 20 c00 bin 10 0000 1100 0000 0000
linha 21: hexa 20800 bin 10 0000 1000 0000 0000
linha 22: hexa 04 a45 bin 00 0100 1010 0100 0101
linha 23: hexa 1901 d bin 01 1001 0000 0001 1101
linha 24: hexa 07840 bin 00 0111 1000 0100 0000
linha 25: hexa 09200 bin 00 1001 0010 0000 0000
linha 26: hexa 06380 bin 00 0110 0011 1000 0000
linha 27: hexa 24801 bin 10 0100 1000 0000 0001
linha 28: hexa 38016 bin 11 1000 0000 0001 0110
linha 29: hexa 06 b83 bin 00 0110 1011 1000 0011
linha 30: hexa 10 c01 bin 01 0000 1100 0000 0001
linha 31: hexa 3801 f bin 11 1000 0000 0001 1111

2 Especificação da Atividade Avaliativa

Acesse a sala virtual da disciplina e baixe o arquivo ReMember.circ. Leia atentamente as informações da
Seção anterior deste documento e analise o circuito do processador. A memória de instrução já está preenchida
com o programa apresentado como exemplo neste documento. Simule o circuito no Logisim apenas fornecendo
os pulsos de clock para ver o programa sendo executado.

Observe que a memória de dados recebe a entrada de endereço diretamente da ULA do processador e esse
endereço pode ser qualquer valor entre 0 e 255. Porém, você deverá modificar o projeto para que a memória
somente seja selecionada para uso se o endereço estiver entre 0 e 254 (use a entrada sel da memória para isso).
Quando o endereço fornecido pela ULA for igual a 255, na realidade o sistema deverá acessar um dispositivo
chamado de controlador de LEDs. O circuito responsável por selecionar corretamente a memória de dados ou
o controlador de LEDs é o Controlador do Barramento.

O controlador de LEDs possuirá um registrador usando flip-flops D do tipo PIPO com 8 bits. Para o
processador escrever dados nesse registrador, bastará realizar uma instrução de store word (sw) para o endereço
255.

O Controlador do Barramento possui a seguinte interface:

• Entrada Address de 8 bits que recebe a saída da ULA;

• Saída RAM select de 1 bit que é verdadeira se entrada Address está entre 0 e 254 e que deverá ser conectada
à entrada sel da memória de dados;
• Saída LED select de 1 bit que é verdadeira se entrada Address é igual a 255 e que deverá ser conectada à
entrada chip select do Controlador de LEDs.

O Controlador de LEDs possui a seguinte interface:

 GCC113 – Trabalho final 7

• Entrada de 1 bit chip select. Essa entrada precisa ser verdadeira para que o valor enviado pelo processador
seja armazenado no registrador interno do controlador de LEDs;
• Entrada de 1 bit LEDWrite. Recebe o mesmo valor de MemWrite e precisa ser verdadeira para que seja
possível escrever nos LEDs;
• 8 entradas, D0 a D7, de 1 bit cada para receber os dados que chegam do banco de registradores pela saída
Register data 2;
• Entrada CLK para sincronizar o registrador interno;

• Entrada CLR para apagar o registrador interno;

• 8 saídas, Q0 a Q7, de 1 bit cada que devem ser ligadas cada uma a um LED.

Ao ligar a saída do controlador de LEDs em 8 LEDs, basta escrever dados na posição 255 usando sw para
controlar quais LEDs estão acesos e quais estão apagados. O controle do acionamento dos LEDs, portanto, será
feito totalmente via software. Esse software deverá ser projetado e estar armazenado na memória de instruções.

Após realizar as alterações do hardware, basta que você escreva o software da forma que você quiser, usando
o assembly do ReMember para que os LEDs pisquem com qualquer padrão que você desejar.

Como sugestão, implemente a seguinte sequência de instruções (passe-as para binário e depois para hexa e
só então altere o conteúdo da memória de instruções:
1 linha A: addI R2 , R0 , 0 # i n i c i a R2 com 0
2 linha B: sw R2 R0 ( 2 5 5 ) # e n v i a R2 para o c o n t r o l a d o r de LEDs
3 linha C: addI R2 , R2 , 1 # i n c r e m e n t a R2
4 linha D: sw R2 R0 ( 2 5 5 ) # e n v i a R2 para o c o n t r o l a d o r de LEDs
5 linha E: jmp C # p u l a de v o l t a para a l i n h a C e r e p e t e tudo ( l o o p i n f i n i t o )

Ao escrever seu código, substitua a letra C da instrução jmp para o número correto da linha C em seu código.

Vale ressaltar que não será necessário alterar mais nenhum componente no circuito além do que foi explicado
acima. O processador já está totalmente implementado e funcionando. Com as alterações que serão feitas, o
que estamos fazendo é apenas colocar mais um dispositivo conectado ao barramento de interconexão da CPU
com os demais componentes. Inicialmente, apenas a memória de dados estava no barramento, após a alteração
haverá dois dispositivos: a memória e o controlador de LEDs, que é um dispositivo de saída de dados. O
mesmo processo poderia ser feito para adicionar quantos dispositivos fossem necessários dentro do espaço de
endereçamento de 0 a 255.

3 CRITÉRIOS DE AVALIAÇÃO
Leia atentamente os critérios para que sua implementação esteja de acordo com o esperado.

• O hardware foi alterado corretamente? (50%);

• O software controla os LEDs gerando um padrão de acionamento corretamente? (50%);

4 ENTREGA
Os arquivos criados pelo Logisim deverão ser enviados no Campus Virtual juntamente com o relatório. O
relatório deve deixar claro como todos os itens dos critérios de avaliação foram atendidos, mostrando o projeto
de cada item do circuito. O relatório será avaliado juntamente com o circuito em cada critério de avaliação.

A entrega deverá ser feita até as 23:59 do dia 24/04. Evite começar em cima da hora.