Este repositório contém o desenvolvimento do projeto final da disciplina de Computação Digital (PUC-Rio), ministrada pelo Prof. Wouter Caarls.

O objetivo é projetar, implementar em VHDL e testar um processador de 8 bits com arquitetura Harvard, baseado em acumulador, e seus periféricos essenciais.

O processador a ser construído segue estas especificações de alto nível:

• Arquitetura: Harvard (memórias de dados e instruções separadas)

• Modelo de Execução: Load/Store (apenas lda/sta acessam a memória) e baseado em acumulador (ACC)

• Tamanho da Palavra: 8 bits para dados e instruções

• Memórias:

  • IMEM (Instruções): ROM assíncrona de 256 palavras
  • DMEM (Dados): RAM de 256 palavras (leitura assíncrona, escrita síncrona)

• Banco de Registradores (RU): 16 registradores de 8 bits

• Registradores Especiais:

  • PC (Program Counter): r15 (rPC = "1111")
  • SP (Stack Pointer): r14 (rSP = "1110")

• Pilha (Stack): Implementada via software

• Entrada/Saída (I/O): Mapeada na memória

• Flags: Carry (C), Zero (Z), Negative (N) e Overflow (V) Apenas instruções lógicas e aritméticas atualizam as flags.

O processador acessa tanto a RAM quanto os periféricos usando endereços de 8 bits.

Os endereços de 0x00 a 0x08 da memória de dados são reservados para periféricos. O arquivo libcpu.vhd já fornece as constantes correspondentes.

• Início da Pilha (Stack): A pilha começa no topo da memória de dados (0xFF) e cresce para baixo. O SP (r14) deve ser inicializado com este valor. Constante VHDL: addr_SP = x"ff"

• Vetor de Reset: O processador começa a executar a instrução no endereço 0x00 da memória de instruções. Constante VHDL: addr_RESET = x"00"

O arquivo libcpu.vhd define constantes para todos os opcodes, facilitando o desenvolvimento da Unidade de Controle. O ISA é dividido em grupos:

• lda [rs] (Op: oLDA "0000"): acc <- MEM[rs]
• sta [rs] (Op: oSTA "0001"): MEM[rs] <- acc

• ldi c8 (Op: oLDI "0100"): acc <- c8 (valor imediato)
• b<cond> c8 (Op: oB "0101"): pc <- c8 se a condição for verdadeira Condições como bBZ, bBNZ, bBCC são definidas em libcpu.vhd.

• get rs (Op: oGET "0110"): acc <- rs
• set rd (Op: oSET "0111"): rd <- acc

• add rs (Op: oADD "1000"): acc <- acc + rs
• sub rs (Op: oSUB "1001"): acc <- acc - rs
• inc rd (Op: oINC "1010"): rd <- rd + 1
• dec rd (Op: oDEC "1011"): rd <- rd - 1

• and rs (Op: oAND "1100"): acc <- acc & rs
• or rs (Op: oOR "1101"): acc <- acc | rs
• xor rs (Op: oXOR "1110"): acc <- acc ^ rs
• shft rs (Op: oSHFT "1111"): acc <- acc << rs ou acc >> -rs

Dica: Os códigos da ALU (ex: aADD, aSUB) têm os mesmos valores que os opcodes das instruções correspondentes, simplificando o design da Unidade de Controle.

O professor fornece um pacote Python para compilar os programas sem precisar escrever binário manualmente.

• Instalação: pip install puc8a
• Assembler (as-puc8a): Converte código Assembly (.asm) em um array VHDL (ROMT) para inicializar a IMEM.
• Compilador C (cc-puc8a): Compila uma versão simplificada de C (inteiros de 8 bits) para Assembly ou VHDL.
• Macros: O assembler suporta macros (.macro), permitindo criar pseudoinstruções como push, pop, call e ret, que implementam a pilha e chamadas de sub-rotina em software.

1. Crie um repositório Git.
2. Adicione os arquivos fornecidos (projeto.pdf, libcpu.vhd).
3. Crie o arquivo README.md.
4. Instale o toolchain: pip install puc8a.

1. ALU: Módulo que recebe A, B e opcode e produz resultado e flags.
2. Banco de Registradores (RU): 16 registradores de 8 bits com portas de leitura e escrita.
3. Registradores: Crie módulos para ACCUM e FLAGS.
4. Multiplexadores (MUXes): Adicione os MUXes do diagrama de blocos (ex: entrada B da ALU).

1. Estados: Fetch e Execute.

2. Registradores: state (estado atual) e cir (Instruction Register).

3. Lógica:

   • Próximo estado: define a transição entre Fetch e Execute.
   • Saída: gera sinais de controle (reg_write_enable, alu_op, etc.).
   • Dica: defina valores padrão e sobrescreva apenas o necessário para cada instrução.

Crie o módulo cpu.vhd, que instancia e conecta o datapath e a unidade de controle, ligando as flags de volta à CU.

1. imem.vhd: ROM de instruções inicializada com o unittest.asm compilado.
2. dmem.vhd: RAM síncrona na escrita e assíncrona na leitura, com decoder interno para periféricos.

1. Crie o testbench system_tb.vhd com cpu, imem e dmem.
2. Compile o teste com as-puc8a e use o VHDL gerado.
3. Simule e depure até passar em todos os testes do unittest.asm.

1. Display de 7 Segmentos: Use hex2ssd para converter e exibir valores.
2. Teclado PS/2: Receptor que armazena o último scancode em addr_PS2_DATA.
3. Controlador LCD: Responde aos endereços addr_LCD_DATA e addr_LCD_CMD.

1. Escreva um programa (Assembly ou C) que leia dados do teclado e exiba no LCD.
2. Compile com as-puc8a ou cc-puc8a.
3. Simule, sintetize e teste na placa.

1. Tire fotos da placa funcionando.
2. Reúna os resultados dos programas.
3. Escreva o relatório.
4. Gere o arquivo .zip final.

A entrega final deve ser feita até 11/12/2025 às 23:59.

Itens a entregar:

1. Arquivo .zip: Projeto completo em VHDL, pronto para simulação e síntese.

2. Relatório .pdf (aproximadamente 10 páginas), contendo:

   • Diagrama do caminho de dados
   • Descrição das unidades (incluindo FSM da CU)
   • Programas em Assembly e C desenvolvidos
   • Resultados obtidos
   • Fotos da placa em funcionamento
   • Observações e conclusões