From 11a644a9b3fafcfff1147aba8339fe9140091d9b Mon Sep 17 00:00:00 2001 From: Zaws Date: Tue, 20 May 2025 19:20:24 -0300 Subject: [PATCH] =?UTF-8?q?Remove=20arquivos=20antigos=20e=20adiciona=20ve?= =?UTF-8?q?rs=C3=A3o=20modular=20em=20'modular/'?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .DS_Store | Bin 0 -> 6148 bytes Dockerfile => legacy/Dockerfile | 0 Emulador.c => legacy/Emulador.c | 0 LICENSE => legacy/LICENSE | 0 README.md => legacy/README.md | 0 _config.yml => legacy/_config.yml | 0 assembler.py => legacy/assembler.py | 0 .../docker-compose.yml | 0 {docs => legacy/docs}/especificacao.md | 0 header.png => legacy/header.png | Bin makefile => legacy/makefile | 0 microprog.rom => legacy/microprog.rom | Bin prog.asm => legacy/prog.asm | 0 prog2.asm => legacy/prog2.asm | 0 prog4.asm => legacy/prog4.asm | 0 prog5.asm => legacy/prog5.asm | 0 prog6.asm => legacy/prog6.asm | 0 {progs => legacy/progs}/Prog3.asm | 0 {progs => legacy/progs}/prog.asm | 0 {progs => legacy/progs}/prog2.asm | 0 {progs => legacy/progs}/prog4.asm | 0 {progs => legacy/progs}/prog5.asm | 0 modular/.DS_Store | Bin 0 -> 6148 bytes modular/README.md | 33 +++++ modular/assembler.py | 44 +++++++ modular/controle.c | 49 ++++++++ modular/controle.h | 23 ++++ modular/cpu.c | 94 ++++++++++++++ modular/cpu.h | 25 ++++ modular/gerar_microprog.py | 49 ++++++++ modular/includes/comuns.h | 9 ++ modular/interface.c | 117 ++++++++++++++++++ modular/interface.h | 8 ++ modular/main.c | 29 +++++ modular/makefile | 14 +++ modular/memoria.c | 53 ++++++++ modular/memoria.h | 18 +++ modular/microprog.rom | Bin 0 -> 4096 bytes modular/microprog.rom.py | 117 ++++++++++++++++++ modular/prog.asm | 4 + modular/programa.asm | 4 + modular/programa.bin | Bin 0 -> 30 bytes modular/simulador | Bin 0 -> 35192 bytes prog.exe | Bin 62 -> 0 bytes progs/Prog3.exe | Bin 64 -> 0 bytes progs/prog.exe | Bin 62 -> 0 bytes progs/prog2.exe | Bin 49 -> 0 bytes progs/prog4.exe | Bin 65 -> 0 bytes progs/prog5.exe | Bin 59 -> 0 bytes 49 files changed, 690 insertions(+) create mode 100644 .DS_Store rename Dockerfile => legacy/Dockerfile (100%) rename Emulador.c => legacy/Emulador.c (100%) rename LICENSE => legacy/LICENSE (100%) rename README.md => legacy/README.md (100%) rename _config.yml => legacy/_config.yml (100%) rename assembler.py => legacy/assembler.py (100%) rename docker-compose.yml => legacy/docker-compose.yml (100%) rename {docs => legacy/docs}/especificacao.md (100%) rename header.png => legacy/header.png (100%) rename makefile => legacy/makefile (100%) rename microprog.rom => legacy/microprog.rom (100%) rename prog.asm => legacy/prog.asm (100%) rename prog2.asm => legacy/prog2.asm (100%) rename prog4.asm => legacy/prog4.asm (100%) rename prog5.asm => legacy/prog5.asm (100%) rename prog6.asm => legacy/prog6.asm (100%) rename {progs => legacy/progs}/Prog3.asm (100%) rename {progs => legacy/progs}/prog.asm (100%) rename {progs => legacy/progs}/prog2.asm (100%) rename {progs => legacy/progs}/prog4.asm (100%) rename {progs => legacy/progs}/prog5.asm (100%) create mode 100644 modular/.DS_Store create mode 100644 modular/README.md create mode 100644 modular/assembler.py create mode 100644 modular/controle.c create mode 100644 modular/controle.h create mode 100644 modular/cpu.c create mode 100644 modular/cpu.h create mode 100644 modular/gerar_microprog.py create mode 100644 modular/includes/comuns.h create mode 100644 modular/interface.c create mode 100644 modular/interface.h create mode 100644 modular/main.c create mode 100644 modular/makefile create mode 100644 modular/memoria.c create mode 100644 modular/memoria.h create mode 100644 modular/microprog.rom create mode 100644 modular/microprog.rom.py create mode 100644 modular/prog.asm create mode 100644 modular/programa.asm create mode 100644 modular/programa.bin create mode 100755 modular/simulador delete mode 100644 prog.exe delete mode 100644 progs/Prog3.exe delete mode 100644 progs/prog.exe delete mode 100644 progs/prog2.exe delete mode 100644 progs/prog4.exe delete mode 100644 progs/prog5.exe diff --git a/.DS_Store b/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..4da20bd30f6911764c48a44467e7a534a85f8783 GIT binary patch literal 6148 zcmeHKK~BR!475uHL0o#|xDVjcAA~BrpdX-ZP&p(@h13JLh#zp|5xjsq58)0!Kw`YM z3hAcef~pGHl6N*TGEXA&#$vyH$^e8nmOXKi?@fDr;pdm?LF$I{MBc5o4h9{R8vDG zt&z`+?t0#&EsvkMd_F(ETP}&$cQ(7ddh$8M^YWaW0cXG&_zMP5vqiEqMIW63XTTZQ zFd*ND02Ry)TgCY4zz|yi;1K30m`g7qF~Kl5Y!$HrVGRXpC|irc8V-9fzud4@)No>J zKG^Qe)}e5`JN6IJoj6zY(HU?Cx(poYK?VJ04X7rs_uOcxCU3~aX15SJOfIo7c3A$ zXhyQ%*z>XTq}U!J;?=RMiIzlEp$W1m1(E5Z>B5{BK+ZXi)X|O({e9gQ68*&~*?UEg z^h8_gX|n(AIP51IKJyvIrrGr4M&j46FT3Zr(@iPYFm~Va+dtIpmo+ELyXp)$1I~am z;0*j21GuwAsw+kBodIXS8Te#C&WC^|7!8wRK046l5&$UA=q%8smXMfW7!8vmED+XE zpoX%Q7_8x#59SvQlcI(bTk*lR@<;K)d3EFu*_}8ldhZN419Jv0b-0xK{}#VYvB;l? z_{bS>2L2fXylC2Hg^#kk_3ZQHt_^5+Xd>d5M1eq`JpwS0bL2W3)gDBLUo=dLl11io QIM5#gnGo-sfnQ+Y9aBm$SpWb4 literal 0 HcmV?d00001 diff --git a/modular/README.md b/modular/README.md new file mode 100644 index 0000000..0da0e5b --- /dev/null +++ b/modular/README.md @@ -0,0 +1,33 @@ +# MIC-1 Simulador Modular + +Refatoração modular do simulador de microprogramação baseado na arquitetura MIC-1. + +## 🔧 O que foi feito + +- Separação do código original monolítico (`Emulador.c`) em módulos independentes +- Estrutura com `main.c`, `cpu.c`, `memoria.c`, etc. +- Suporte a microprograma binário (`microprog.rom`) +- Assembler simples em Python +- Exemplo funcional (`PUSH`, `ADD`, `PRINT`) + +## ▶️ Como usar + +### Compilar: + +```bash +make + + + + +Esse Makefile funciona dentro da pasta modular/. Use assim: + +bash +Copiar +Editar +cd modular +make +./simulador programa.bin + + + diff --git a/modular/assembler.py b/modular/assembler.py new file mode 100644 index 0000000..ee637d4 --- /dev/null +++ b/modular/assembler.py @@ -0,0 +1,44 @@ +import struct + +# Mapeamento de instruções para opcodes +INSTRUCOES = { + 'PUSH': 0x01, + 'ADD': 0x02, + 'PRINT': 0x03, +} + +def montar_instrucao(linha): + partes = linha.strip().split() + if not partes: + return [] + + instr = partes[0].upper() + + if instr == 'PUSH': + valor = int(partes[1]) + return [INSTRUCOES['PUSH'], valor] + elif instr in INSTRUCOES: + return [INSTRUCOES[instr]] + else: + raise ValueError(f"Instrução desconhecida: {instr}") + +def montar_programa(arquivo_entrada, arquivo_saida): + codigo = [] + + with open(arquivo_entrada, 'r') as fonte: + for linha in fonte: + instrucao = montar_instrucao(linha) + codigo.extend(instrucao) + + header = [0] * 20 # inicialização de 20 bytes + tamanho_total = 4 + len(header) + len(codigo) # 4 = campo de tamanho + + with open(arquivo_saida, 'wb') as f: + f.write(struct.pack('I', tamanho_total)) # Tamanho total + f.write(bytearray(header)) # Header + f.write(bytearray(codigo)) # Instruções + + print(f"Programa compilado com sucesso: {arquivo_saida}") + +if __name__ == "__main__": + montar_programa("programa.asm", "programa.bin") diff --git a/modular/controle.c b/modular/controle.c new file mode 100644 index 0000000..3bfc66d --- /dev/null +++ b/modular/controle.c @@ -0,0 +1,49 @@ +// controle.c +#include "controle.h" +#include + +// ROM com microinstruções +microinstrucao Armazenamento[512]; + +// Microinstrução atual e contador de próxima instrução +microinstrucao MIR; +palavra MPC = 0; + +// Campos extraídos da MIR +byte MIR_B, MIR_Operacao, MIR_Deslocador, MIR_MEM, MIR_pulo; +palavra MIR_C; + +// Carrega o microprograma de controle da ROM (arquivo binário) +void carregar_microprograma() { + FILE* microprog = fopen("microprog.rom", "rb"); + + if (microprog != NULL) { + fread(Armazenamento, sizeof(microinstrucao), 512, microprog); + fclose(microprog); + } else { + printf("Erro: não foi possível abrir microprog.rom\n"); + } +} + +// Extrai os campos da microinstrução atual (MIR) +void decodificar_microinstrucao() { + MIR = Armazenamento[MPC]; + + MIR_B = (MIR) & 0b1111; + MIR_MEM = (MIR >> 4) & 0b111; + MIR_C = (MIR >> 7) & 0b111111111; + MIR_Operacao = (MIR >> 16) & 0b111111; + MIR_Deslocador = (MIR >> 22) & 0b11; + MIR_pulo = (MIR >> 24) & 0b111; + MPC = (MIR >> 27) & 0b111111111; +} + +// Atualiza o MPC com base nas flags N, Z ou no valor de MBR +void pular() { + extern byte N, Z; + extern byte MBR; + + if (MIR_pulo & 0b001) MPC = MPC | (N << 8); + if (MIR_pulo & 0b010) MPC = MPC | (Z << 8); + if (MIR_pulo & 0b100) MPC = MPC | MBR; +} diff --git a/modular/controle.h b/modular/controle.h new file mode 100644 index 0000000..603855b --- /dev/null +++ b/modular/controle.h @@ -0,0 +1,23 @@ +// controle.h +#ifndef CONTROLE_H +#define CONTROLE_H + +#include "comuns.h" + +// ROM de controle: 512 microinstruções +extern microinstrucao Armazenamento[512]; + +// Microinstrução atual e próximo contador +extern microinstrucao MIR; +extern palavra MPC; + +// Funções principais do controle +void carregar_microprograma(); +void decodificar_microinstrucao(); +void pular(); + +// Campos decodificados da MIR +extern byte MIR_B, MIR_Operacao, MIR_Deslocador, MIR_MEM, MIR_pulo; +extern palavra MIR_C; + +#endif diff --git a/modular/cpu.c b/modular/cpu.c new file mode 100644 index 0000000..fdcdf13 --- /dev/null +++ b/modular/cpu.c @@ -0,0 +1,94 @@ +// cpu.c +#include "cpu.h" +#include "controle.h" +#include "memoria.h" + +// Registradores +palavra SP = 0, LV = 0, TOS = 0; +palavra OPC = 0, CPP = 0, H = 0; + +// Barramentos +palavra Barramento_B, Barramento_C; + +// Flags da ALU +byte N = 0, Z = 0; + +// Executa um ciclo de microinstrução completo +void executar_ciclo() { + decodificar_microinstrucao(); // Extrai os campos da MIR + atribuir_barramento_B(); // Define o valor no barramento B + realizar_operacao_ALU(); // Executa operação da ALU + atribuir_barramento_C(); // Escreve o resultado nos registradores + operar_memoria(); // Acessa memória se necessário + pular(); // Define a próxima microinstrução +} + +// Define Barramento_B com base no campo MIR_B +void atribuir_barramento_B() { + switch (MIR_B) { + case 0: Barramento_B = MDR; break; + case 1: Barramento_B = PC; break; + case 2: // MBR com sinal (extensão de sinal) + Barramento_B = MBR; + if (MBR & 0x80) + Barramento_B |= 0xFFFFFF00; + break; + case 3: Barramento_B = MBR; break; + case 4: Barramento_B = SP; break; + case 5: Barramento_B = LV; break; + case 6: Barramento_B = CPP; break; + case 7: Barramento_B = TOS; break; + case 8: Barramento_B = OPC; break; + default: Barramento_B = 0xFFFFFFFF; break; + } +} + +// Executa a operação da ALU e atualiza as flags +void realizar_operacao_ALU() { + switch (MIR_Operacao) { + case 12: Barramento_C = H & Barramento_B; break; + case 17: Barramento_C = 1; break; + case 18: Barramento_C = -1; break; + case 20: Barramento_C = Barramento_B; break; + case 24: Barramento_C = H; break; + case 26: Barramento_C = ~H; break; + case 28: Barramento_C = H | Barramento_B; break; + case 44: Barramento_C = ~Barramento_B; break; + case 53: Barramento_C = Barramento_B + 1; break; + case 54: Barramento_C = Barramento_B - 1; break; + case 57: Barramento_C = H + 1; break; + case 59: Barramento_C = -H; break; + case 60: Barramento_C = H + Barramento_B; break; + case 61: Barramento_C = H + Barramento_B + 1; break; + case 63: Barramento_C = Barramento_B - H; break; + default: Barramento_C = 0; break; + } + + // Flags: Z = zero, N = não-zero + if (Barramento_C) { + N = 0; + Z = 1; + } else { + N = 1; + Z = 0; + } + + // Deslocamentos + switch (MIR_Deslocador) { + case 1: Barramento_C <<= 8; break; + case 2: Barramento_C >>= 1; break; + } +} + +// Atualiza registradores com base no campo MIR_C +void atribuir_barramento_C() { + if (MIR_C & 0b000000001) MAR = Barramento_C; + if (MIR_C & 0b000000010) MDR = Barramento_C; + if (MIR_C & 0b000000100) PC = Barramento_C; + if (MIR_C & 0b000001000) SP = Barramento_C; + if (MIR_C & 0b000010000) LV = Barramento_C; + if (MIR_C & 0b000100000) CPP = Barramento_C; + if (MIR_C & 0b001000000) TOS = Barramento_C; + if (MIR_C & 0b010000000) OPC = Barramento_C; + if (MIR_C & 0b100000000) H = Barramento_C; +} diff --git a/modular/cpu.h b/modular/cpu.h new file mode 100644 index 0000000..0f4c4b7 --- /dev/null +++ b/modular/cpu.h @@ -0,0 +1,25 @@ +// cpu.h +#ifndef CPU_H +#define CPU_H + +#include "comuns.h" + +// Função principal do ciclo da CPU +void executar_ciclo(); + +// Barramento B: fonte de dados +void atribuir_barramento_B(); + +// ALU: executa operações entre H e B +void realizar_operacao_ALU(); + +// Barramento C: destino do resultado da ALU +void atribuir_barramento_C(); + +// Flags +extern byte N, Z; + +// Registradores principais +extern palavra SP, LV, TOS, OPC, CPP, H; + +#endif diff --git a/modular/gerar_microprog.py b/modular/gerar_microprog.py new file mode 100644 index 0000000..42f67b7 --- /dev/null +++ b/modular/gerar_microprog.py @@ -0,0 +1,49 @@ +import struct + +def instr(B=0, MEM=0, C=0, op=0, shift=0, jump=0, next_mpc=0): + valor = ( + (next_mpc & 0x1FF) << 27 | + (jump & 0x7) << 24 | + (shift & 0x3) << 22 | + (op & 0x3F) << 16 | + (C & 0x1FF) << 7 | + (MEM & 0x7) << 4 | + (B & 0xF) + ) + return valor + +micro = [0] * 512 + +# FETCH +micro[0] = instr(C=0b000000100, B=2, next_mpc=1) +micro[1] = instr(MEM=0b001, next_mpc=2) +micro[2] = instr(C=0b000000100, B=2, op=53, next_mpc=3) +micro[3] = instr(jump=0b100, next_mpc=0) + +# PUSH (0x01) +micro[4] = instr(C=0b000000001, B=2, next_mpc=5) +micro[5] = instr(MEM=0b001, next_mpc=6) +micro[6] = instr(C=0b000000100, B=2, op=53, next_mpc=7) +micro[7] = instr(C=0b000000010, B=2, next_mpc=8) +micro[8] = instr(C=0b000100000, B=4, next_mpc=9) +micro[9] = instr(C=0b000010000, B=4, op=53, next_mpc=10) +micro[10] = instr(C=0b000000001, B=5, next_mpc=11) +micro[11] = instr(MEM=0b100, next_mpc=12) +micro[12] = instr(C=0b001000000, B=2, next_mpc=13) +micro[13] = instr(next_mpc=0) + +# ADD (0x02) +micro[14] = instr(C=0b100000000, B=7, next_mpc=15) +micro[15] = instr(C=0b000010000, B=4, op=54, next_mpc=16) +micro[16] = instr(C=0b000000001, B=4, next_mpc=17) +micro[17] = instr(MEM=0b010, next_mpc=18) +micro[18] = instr(C=0b001000000, B=2, op=60, next_mpc=19) +micro[19] = instr(next_mpc=0) + +# PRINT (0x03) +micro[20] = instr(next_mpc=0) + +with open("microprog.rom", "wb") as f: + f.write(struct.pack("Q" * len(micro), *micro)) + +print("microprog.rom gerado com sucesso!") diff --git a/modular/includes/comuns.h b/modular/includes/comuns.h new file mode 100644 index 0000000..7a45ca3 --- /dev/null +++ b/modular/includes/comuns.h @@ -0,0 +1,9 @@ +// includes/comuns.h +#ifndef COMUNS_H +#define COMUNS_H + +typedef unsigned char byte; // 8 bits +typedef unsigned int palavra; // 32 bits +typedef unsigned long int microinstrucao; // 64 bits, usamos 36 + +#endif diff --git a/modular/interface.c b/modular/interface.c new file mode 100644 index 0000000..317cc43 --- /dev/null +++ b/modular/interface.c @@ -0,0 +1,117 @@ +// interface.c +#include +#include +#include "interface.h" +#include "memoria.h" +#include "cpu.h" +#include "controle.h" + +// Mostra pilha, área de programa e registradores +void exibir_processos() { + if (LV && SP) { + printf("\t\t PILHA DE OPERANDOS\n"); + printf("========================================\n"); + printf(" END\t BINARIO DO VALOR\t\tVALOR\n"); + + for (int i = SP; i >= LV; i--) { + palavra valor; + memcpy(&valor, &Memoria[i * 4], 4); + + if (i == SP) printf("SP ->"); + else if (i == LV) printf("LV ->"); + else printf(" "); + + printf("%X ", i); + binario(&valor, 1); // tipo 1 = palavra de 4 bytes + printf(" %d\n", valor); + } + printf("========================================\n"); + } + + if (PC >= 0x0401) { + printf("\n\t\t\tArea do Programa\n"); + printf("========================================\n"); + printf("\t\tBinario\t\t HEX END DE BYTE\n"); + + for (int i = PC - 2; i <= PC + 3; i++) { + if (i == PC) printf("Em execução >> "); + else printf("\t\t"); + + binario(&Memoria[i], 2); // tipo 2 = 1 byte + printf(" 0x%02X \t%X\n", Memoria[i], i); + } + printf("========================================\n\n"); + } + + // Exibe registradores + printf("\t\tREGISTRADORES\n"); + printf("\tBINARIO\t\t\t\tHEX\n"); + + printf("MAR: "); binario(&MAR, 3); printf("\t%x\n", MAR); + printf("MDR: "); binario(&MDR, 3); printf("\t%x\n", MDR); + printf("PC: "); binario(&PC, 3); printf("\t%x\n", PC); + printf("MBR: \t\t"); binario(&MBR, 2); printf("\t\t%x\n", MBR); + + printf("SP: "); binario(&SP, 3); printf("\t%x\n", SP); + printf("LV: "); binario(&LV, 3); printf("\t%x\n", LV); + printf("CPP: "); binario(&CPP, 3); printf("\t%x\n", CPP); + printf("TOS: "); binario(&TOS, 3); printf("\t%x\n", TOS); + printf("OPC: "); binario(&OPC, 3); printf("\t%x\n", OPC); + printf("H: "); binario(&H, 3); printf("\t%x\n", H); + + printf("MPC: \t\t"); binario(&MPC, 5); printf("\t%x\n", MPC); + printf("MIR: "); binario(&MIR, 4); printf("\n"); + + getchar(); // Pausa para passo a passo +} + +// Imprime valores em binário, com vários modos +void binario(void* valor, int tipo) { + switch (tipo) { + case 1: { // Palavra de 4 bytes (32 bits), agrupada + byte aux; + byte* v = (byte*)valor; + for (int i = 3; i >= 0; i--) { + aux = v[i]; + for (int j = 0; j < 8; j++) { + printf("%d", (aux >> 7) & 1); + aux <<= 1; + } + printf(" "); + } + } break; + + case 2: { // Byte simples (8 bits) + byte aux = *((byte*)valor); + for (int j = 0; j < 8; j++) { + printf("%d", (aux >> 7) & 1); + aux <<= 1; + } + } break; + + case 3: { // Palavra (32 bits sem espaçamento) + palavra aux = *((palavra*)valor); + for (int j = 0; j < 32; j++) { + printf("%d", (aux >> 31) & 1); + aux <<= 1; + } + } break; + + case 4: { // Microinstrução (36 bits com espaçamentos lógicos) + microinstrucao aux = *((microinstrucao*)valor); + for (int j = 0; j < 36; j++) { + if (j == 9 || j == 12 || j == 20 || j == 29 || j == 32) printf(" "); + printf("%ld", (aux >> 35) & 1); + aux <<= 1; + } + } break; + + case 5: { // Apenas os 9 bits do MPC + palavra aux = *((palavra*)valor) << 23; + for (int j = 0; j < 9; j++) { + printf("%d", (aux >> 31) & 1); + aux <<= 1; + } + } break; + } +} diff --git a/modular/interface.h b/modular/interface.h new file mode 100644 index 0000000..18f50a0 --- /dev/null +++ b/modular/interface.h @@ -0,0 +1,8 @@ +// interface.h +#ifndef INTERFACE_H +#define INTERFACE_H + +void exibir_processos(); // Mostra registradores, pilha, memória +void binario(void* valor, int tipo); // Imprime valor em binário (1 a 5 modos) + +#endif diff --git a/modular/main.c b/modular/main.c new file mode 100644 index 0000000..05fefa3 --- /dev/null +++ b/modular/main.c @@ -0,0 +1,29 @@ +// main.c +#include +#include +#include "cpu.h" +#include "memoria.h" +#include "controle.h" +#include "interface.h" + +// Função principal do simulador +int main(int argc, const char *argv[]) { + if (argc < 2) { + printf("Uso: %s \n", argv[0]); + return 1; + } + + // Carrega microprograma de controle (microprog.rom) + carregar_microprograma(); + + // Carrega programa de usuário (ex: programa.bin) + carregar_programa(argv[1]); + + // Loop principal de execução + while (1) { + exibir_processos(); // Mostrar estado atual da CPU/memória + executar_ciclo(); // Executar uma microinstrução completa + } + + return 0; +} diff --git a/modular/makefile b/modular/makefile new file mode 100644 index 0000000..0074445 --- /dev/null +++ b/modular/makefile @@ -0,0 +1,14 @@ +CC = gcc +CFLAGS = -Wall -Iincludes +OBJ = main.o cpu.o memoria.o controle.o interface.o + +all: simulador + +simulador: $(OBJ) + $(CC) -o simulador $(OBJ) + +%.o: %.c + $(CC) -c $< $(CFLAGS) + +clean: + rm -f *.o simulador diff --git a/modular/memoria.c b/modular/memoria.c new file mode 100644 index 0000000..ece9eb4 --- /dev/null +++ b/modular/memoria.c @@ -0,0 +1,53 @@ +// memoria.c +#include "memoria.h" +#include +#include + +// RAM principal +byte Memoria[100000000]; // 100MB simulados + +// Registradores de acesso à memória +palavra MAR = 0; +palavra MDR = 0; +palavra PC = 0; +byte MBR = 0; + +// Carrega um programa binário na memória +void carregar_programa(const char* caminho) { + FILE* prog = fopen(caminho, "rb"); + palavra tamanho; + byte tamanho_temp[4]; + + if (prog != NULL) { + // Lê os primeiros 4 bytes com o tamanho total do programa + fread(tamanho_temp, sizeof(byte), 4, prog); + memcpy(&tamanho, tamanho_temp, 4); + + // Lê os 20 bytes iniciais de inicialização (pode incluir SP, PC, etc.) + fread(Memoria, sizeof(byte), 20, prog); + + // Lê o restante do programa a partir do endereço 0x0401 + fread(&Memoria[0x0401], sizeof(byte), tamanho - 20, prog); + + fclose(prog); + } else { + printf("Erro: não foi possível abrir o programa %s\n", caminho); + } +} + +// Executa ações de leitura/escrita com base em MIR_MEM +void operar_memoria() { + extern byte MIR_MEM; + + // Lê MBR (1 byte) a partir de PC + if (MIR_MEM & 0b001) + MBR = Memoria[PC]; + + // Lê uma palavra (4 bytes) da memória para MDR + if (MIR_MEM & 0b010) + memcpy(&MDR, &Memoria[MAR * 4], 4); + + // Escreve uma palavra (4 bytes) de MDR para memória + if (MIR_MEM & 0b100) + memcpy(&Memoria[MAR * 4], &MDR, 4); +} diff --git a/modular/memoria.h b/modular/memoria.h new file mode 100644 index 0000000..ad59b51 --- /dev/null +++ b/modular/memoria.h @@ -0,0 +1,18 @@ +// memoria.h +#ifndef MEMORIA_H +#define MEMORIA_H + +#include "comuns.h" + +// Memória principal (RAM simulada) +extern byte Memoria[]; + +// Registradores de memória +extern palavra MAR, MDR, PC; +extern byte MBR; + +// Carregamento e acesso à memória +void carregar_programa(const char* caminho); +void operar_memoria(); + +#endif diff --git a/modular/microprog.rom b/modular/microprog.rom new file mode 100644 index 0000000000000000000000000000000000000000..2f5c4990ccf287e744f0c89ccaced10a4fe6fa48 GIT binary patch literal 4096 zcmeIup$@_@6ouiRn +#include +#include "interface.h" +#include "memoria.h" +#include "cpu.h" +#include "controle.h" + +// Mostra pilha, área de programa e registradores +void exibir_processos() { + if (LV && SP) { + printf("\t\t PILHA DE OPERANDOS\n"); + printf("========================================\n"); + printf(" END\t BINARIO DO VALOR\t\tVALOR\n"); + + for (int i = SP; i >= LV; i--) { + palavra valor; + memcpy(&valor, &Memoria[i * 4], 4); + + if (i == SP) printf("SP ->"); + else if (i == LV) printf("LV ->"); + else printf(" "); + + printf("%X ", i); + binario(&valor, 1); // tipo 1 = palavra de 4 bytes + printf(" %d\n", valor); + } + printf("========================================\n"); + } + + if (PC >= 0x0401) { + printf("\n\t\t\tArea do Programa\n"); + printf("========================================\n"); + printf("\t\tBinario\t\t HEX END DE BYTE\n"); + + for (int i = PC - 2; i <= PC + 3; i++) { + if (i == PC) printf("Em execução >> "); + else printf("\t\t"); + + binario(&Memoria[i], 2); // tipo 2 = 1 byte + printf(" 0x%02X \t%X\n", Memoria[i], i); + } + printf("========================================\n\n"); + } + + // Exibe registradores + printf("\t\tREGISTRADORES\n"); + printf("\tBINARIO\t\t\t\tHEX\n"); + + printf("MAR: "); binario(&MAR, 3); printf("\t%x\n", MAR); + printf("MDR: "); binario(&MDR, 3); printf("\t%x\n", MDR); + printf("PC: "); binario(&PC, 3); printf("\t%x\n", PC); + printf("MBR: \t\t"); binario(&MBR, 2); printf("\t\t%x\n", MBR); + + printf("SP: "); binario(&SP, 3); printf("\t%x\n", SP); + printf("LV: "); binario(&LV, 3); printf("\t%x\n", LV); + printf("CPP: "); binario(&CPP, 3); printf("\t%x\n", CPP); + printf("TOS: "); binario(&TOS, 3); printf("\t%x\n", TOS); + printf("OPC: "); binario(&OPC, 3); printf("\t%x\n", OPC); + printf("H: "); binario(&H, 3); printf("\t%x\n", H); + + printf("MPC: \t\t"); binario(&MPC, 5); printf("\t%x\n", MPC); + printf("MIR: "); binario(&MIR, 4); printf("\n"); + + getchar(); // Pausa para passo a passo +} + +// Imprime valores em binário, com vários modos +void binario(void* valor, int tipo) { + switch (tipo) { + case 1: { // Palavra de 4 bytes (32 bits), agrupada + byte aux; + byte* v = (byte*)valor; + for (int i = 3; i >= 0; i--) { + aux = v[i]; + for (int j = 0; j < 8; j++) { + printf("%d", (aux >> 7) & 1); + aux <<= 1; + } + printf(" "); + } + } break; + + case 2: { // Byte simples (8 bits) + byte aux = *((byte*)valor); + for (int j = 0; j < 8; j++) { + printf("%d", (aux >> 7) & 1); + aux <<= 1; + } + } break; + + case 3: { // Palavra (32 bits sem espaçamento) + palavra aux = *((palavra*)valor); + for (int j = 0; j < 32; j++) { + printf("%d", (aux >> 31) & 1); + aux <<= 1; + } + } break; + + case 4: { // Microinstrução (36 bits com espaçamentos lógicos) + microinstrucao aux = *((microinstrucao*)valor); + for (int j = 0; j < 36; j++) { + if (j == 9 || j == 12 || j == 20 || j == 29 || j == 32) printf(" "); + printf("%ld", (aux >> 35) & 1); + aux <<= 1; + } + } break; + + case 5: { // Apenas os 9 bits do MPC + palavra aux = *((palavra*)valor) << 23; + for (int j = 0; j < 9; j++) { + printf("%d", (aux >> 31) & 1); + aux <<= 1; + } + } break; + } +} diff --git a/modular/prog.asm b/modular/prog.asm new file mode 100644 index 0000000..b484969 --- /dev/null +++ b/modular/prog.asm @@ -0,0 +1,4 @@ +PUSH 10 +PUSH 20 +ADD +PRINT diff --git a/modular/programa.asm b/modular/programa.asm new file mode 100644 index 0000000..b484969 --- /dev/null +++ b/modular/programa.asm @@ -0,0 +1,4 @@ +PUSH 10 +PUSH 20 +ADD +PRINT diff --git a/modular/programa.bin b/modular/programa.bin new file mode 100644 index 0000000000000000000000000000000000000000..d72b6221a2d0714cd15a7ff5e9f380334641102f GIT binary patch literal 30 Qcmb1Rzz!I>7)6+v0R$lcL;wH) literal 0 HcmV?d00001 diff --git a/modular/simulador b/modular/simulador new file mode 100755 index 0000000000000000000000000000000000000000..ce2316614a0385381c46896c91fadb2dbe0a31a6 GIT binary patch literal 35192 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 V`JpwxE4aJjWNEOWZY$Q9{{en)Bgy~( literal 0 HcmV?d00001 diff --git a/prog.exe b/prog.exe deleted file mode 100644 index e97bab2c91de0e0fb98c4caf731bbbc764e5a9cc..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 62 zcmcCw0D@u$1~wqYC;%i_fCxxSaw&l@qYQ%#Ba;%743ng!Hv_K>gCrxX5`zr`yCkm? HqogDNV_^e| diff --git a/progs/Prog3.exe b/progs/Prog3.exe deleted file mode 100644 index 0823a69e185de722e86cc8cb356ac5b9bf44e858..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 64 zcmWNC!3n@H48&wNEwr!ndEnR0kqtUd_J>*sY0+%BdNDhr?dvfbj-n!+l{!A&LUB6H I;uga3186-1bN~PV diff --git a/progs/prog.exe b/progs/prog.exe deleted file mode 100644 index e97bab2c91de0e0fb98c4caf731bbbc764e5a9cc..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 62 zcmcCw0D@u$1~wqYC;%i_fCxxSaw&l@qYQ%#Ba;%743ng!Hv_K>gCrxX5`zr`yCkm? HqogDNV_^e| diff --git a/progs/prog2.exe b/progs/prog2.exe deleted file mode 100644 index 6da9334b630fa43237666a8442bec347828a57f7..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 49 xcmdO80D@u$1~wqYC;%i_7#Ns=v?P}jgCxHaqYR@A1FIyfHv^jukY