Tremendo bodrio de firmware hice

Off Topic Promociones y Spam
1

hice un firmware para mi propia cpu y mi propia pc que incorpora mi cpu y lo hice yo solo sin ayuda de nadie mas

; ===========================================
;       FIRMWARE BY MARKARIAN AND THE
;       PULSAR PROJECT FOR MACHINE
;       'pulsar 5024XM x32 PC'
;
; firmware para la maquina pulsar5024XM de 32 
; bits
;
; ===========================================

Assume-Org          0

SERIAL_MODE_SWITCH  Equ  0x01

; ===========================================
;           VECTORS & FUNCS
;
; vectors de dispositivos, funciones, ints
; irqs, de reset, etc
;
; ===========================================

; ===========================================
; puntero a la funcion que se ejecuta cuando
; el cpu inicia, no es de la pc es del cpu
; en general
;
_reset_vector:
    Dword           _init

; ===========================================
; vectores de dispositivos y sus irqs que
; los atienden cada vez que lo requieren
;
_devices_vector:
    Dword           alpha_button_irq ; vector del boton 'A' o mas conocido como Alpha
    Dword           beta_button_irq ; vector del boton 'B' o mas conocido como Beta
    Dword           up_button_irq ; vector del boton 'Up'
    Dword           down_button_irq ; vector del boton 'Down'
    Dword           cassete_irq ; vector del dispositivo de la disquetera de cartuchos del mmfs0 (mounted/maped FileSystem 0)

Assume-Fill         0x1F0

; ===========================================
; vectors de funciones del firmware
;
_vectors:
    Word        put_char ; coloca un caracter
    Word        put_msg ; pone un mensaje

; ===========================================
;           STAGES FIRMWARE
;
; etapas del firmware sobre su boot
;
; ===========================================

; ===========================================
; inicializa el firmware
;
_init:
    Lea-dword       firmware_on_flag
    Out-Byte        0

    ; inicializar la consola serial
    Lea-Dword       com1_cmd_mmio
    Out-Byte        SERIAL_MODE_SWITCH
                                ; no esta lista la consola serial o cuando la apagas o
                                ; depues de un comando entonces haces que el proximo
                                ; Byte que envies sea el parametro con el que enviaste 
                                ; el comando
    Add-Byte-Inm-Inm 1, 0       ; el modo de limpiar com1 y por ahora directamente 
                                ; le puedes poner el modo de print out
    Jmp-Word-Call   put_char    ; mandrlo
    Jmp-Dword-Call  fixSerial   ; si no lo sabian si mandas un caracter en estado cuando

    Jmp-Dword-Call  fixSerial   ; arregla la serial
    Lea-Dword       bootmsg     ; manda el mensaje
    Jmp-Dword-Call  put_msg     ; pone el mensaje
    Lea-dword       firmware_on_flag
    Out-Byte        1
    Lea-Dword       sga_row_mmio
    Out-Byte        45
    Lea-Dword       sga_col_mmio
    Out-Byte        45
    Lea-Dword       sga_data_mmio
    Out-Byte        0x22
    Jmp-Word-Clasic loop

; ===========================================
; el loop que el firmware tiene para ser un
; os pequeño en si mismo y esperar eventos
;
loop:
    Jmp-Word-Clasic loop2
loop2:
    Hlt                         ; espera
    Jmp-Word-Clasic loop        ; salta

fixSerial:
    Add-Byte-Inm-Inm ' ', 0
    Jmp-Word-Clasic put_char

; ===========================================
;           SERIAL FUNCS
;
; funciones para la consola serial y el puerto
; de depuracion de la PC
;
; ===========================================

; ===========================================
; manda un caracter a la consola serial
;
put_char:
    Push-Dword      Px          ; poner dword
    Lea-Dword       com1_new_mmio ; el caracter a mandar
    Out-Byte        Out         ; mandar
    Lea-Dword       Sp          ; restaurar la direccion
    Jmp-Dword-Clasic Sp         ; regresar

; ===========================================
; pone un mensaje en la consola serial
;
put_msg:
    Push-Dword      Px          ; guardar dword

; ===========================================
; el loop de poner un mensaje en la consola
; serial
;
put_msg_loop:
    Mov-Byte                    ; obtiene el Byte
    Push-Byte       Out         ; pone el Byte en el stack
    Cmp-Byte-Inm-Sp 0           ; compara con terminador
    Mov-Byte                    ; obtiene el Byte
    Jmp-Word-Zero   put_msg_end ; si es igual terminar
    Jmp-Dword-Call  put_char    ; pone el caracter en la consola serial
    Push-Dword      Px          ; guarda la dword
    Add-Dword-Sp-Inm 1          ; suma la direccion de memoria
    Lea-Dword       Out         ; obtiene dword
    Jmp-Dword-Clasic put_msg_loop ; salta
    
; ===========================================
; el final del mensaje
;
put_msg_end:
    Lea-Dword       Sp          ; lee la dword
    Jmp-Dword-Clasic Sp         ; regresar

; ===========================================
;           FUNC BUTTONS
;
; funciones para los botones de funciones de
; la PC,
; los botones son funciones de rapido acceso}
; para navegar entre menus, seleccionar cosas,
; para confirmacion y cuadros de dialogo, entre
; otras funciones
;
; ===========================================

; ===========================================
; boton 'A'
;
alpha_button_irq:
    Push-Dword      Px
    ; ... comming soon ...
    Lea-Dword       Sp
    Jmp-Dword-Clasic Sp

; ===========================================
; boton 'B'
;
beta_button_irq:
    Push-Dword      Px
    ; ... comming soon ...
    Lea-Dword       Sp
    Jmp-Dword-Clasic Sp

; ===========================================
; boton 'UP'
;
up_button_irq:
    Push-Dword      Px
    ; ... comming soon ...
    Lea-Dword       Sp
    Jmp-Dword-Clasic Sp

; ===========================================
; boton 'DOWN'
;
down_button_irq:
    Push-Dword      Px
    ; ... comming soon ...
    Lea-Dword       Sp
    Jmp-Dword-Clasic Sp

Assume-Fill         0xFFF

; ===========================================
;           SERIAL MMIO
;
; datos de MMIO para la consola serial y mas
; cosas relacionadas con la depuracion,
; la consola serial es una parte escencial
; de la depuracion de programas y mensajes
; de logs, ya que este PC al no haber pantalla
; necesita algo para expresarse
;
; ===========================================

SERIAL_DEFAULT_VAL  Equ 0       ; valor por defecto de el caracter o dato
                                ; para indicarle a la consola serial que
                                ; no este molestando el cpu y com1          

SERIAL_UNDEF_STATU  Equ 0xFF    ; estado indefinido, si la consola serial no
                                ; funciona o el hardware no es compatible entonces
                                ; no existe puerto serial asi que nunca se actualizara

SERIAL_NON_CMD_SND  Equ 0       ; indica que no hay ningun comando que procesar y que deje
                                ; de procesar comandos hasta que actualizes esa direccion de
                                ; memoria osea la de 'serial_port_cmd'

; ===========================================
; caracter a mandar al puerto serial o datos
; de comando respectivo
;
serial_char_send:
    Byte     SERIAL_DEFAULT_VAL
; ===========================================
; mandon de comandos al puerto serial
;
serial_port_cmd:
    Byte     SERIAL_NON_CMD_SND
; ===========================================
; estado del puerto serial
;
serial_port_status:
    Byte     SERIAL_UNDEF_STATU

Assume-Fill     0x1FFF

bootmsg:
    Byte     'b', 'o', 'o', 't', 'i', 'n', 'g', ' ', 'f', 'r', 'o',  'm', ' ', 'R', 'O', 'M', 10, 0
disk_inserted:
    Byte     'c','a','s','s','e','t','e',' ','i','n','s','e','r','t','e','d', 10, 0

; ===========================================
;           CASSETE FUNCS
;
; funciones y MMIO para el cassete del disco
; principal A: alias fs0: blk0: etc
; la unidad principal del dispositivo por donde
; medio se insertan los OS, juegos baremetal
; entre otros programas de arranque post bios
;
; ===========================================

Assume-Fill     0x2FFF

CASSETE_READ_DOT    Equ 12  ; lee un punto en el cassete
                            ; es una respuesta a una de las 
                            ; funciones del bios

CASSETE_READ_SECTA  Equ 18  ; lee un sector del cassete indexado desde
                            ; 0 a chorrocientos millones

CASSETE_WAITING_UE  Equ 24  ; que esta pendiente que se inserto un
                            ; cassete y le esta preguntando al firmware
                            ; que quieres que haga con ese cabron
                            ; osea en espaniol estandart, que el cassete
                            ; se ha insertado hace tiempo o justo ahora y tiene
                            ; pendiente que el bios haga algo con eso

; ===========================================
; variable que indica que va a hacer el cassete
; en la irq que se llamo actualmente
;
; cassete_external_cmd_alias_que_quieres_we:
cassete_external_cmd:
    Byte 0xFF

Assume-Fill 0x4F00

; ===========================================
; variables que indican que el cassete se leyo
; o no? que ya me confundi
;
cassete_readed_sector_finish:
    Byte 0

Assume-Fill 0x4F02

; ===========================================
; variable que indica el sector a leer con read
; sector
;
cassete_readed_sector_finish:
    Word 0

; ===========================================
; variable que indica el sector que ha leido esa cosa
;
Assume-Fill 0x4FFF
;cassete_external_sector_lo_que_lello_este_men:
cassete_external_sector:
    Assume-Fill 0x51FF

; ===========================================
; funcion interna de cassete no el de para 
; obtener funciones si no datos o mas cosas
;
cassete_irq:
    Push-Dword      Px
    Push-Dword      Out
    Lea-Dword       cassete_external_cmd

    Mov-Byte
    Push-Byte       Out
    Cmp-Byte-Inm-Sp CASSETE_WAITING_UE
    Jmp-Word-Zero   cassete_fnc_inserted
    
    Mov-Byte
    Push-Byte       Out
    Cmp-Byte-Inm-Sp CASSETE_READ_SECTA
    Jmp-Word-Zero   cassete_fnc_read_sector

    Jmp-Dword-Clasic cassete_fnc_end

; ===========================================
; cuando leyo un sector
;
cassete_fnc_read_sector:
    Lea-Dword       cassete_readed_sector_finish
    Out-Byte        1
    Jmp-Dword-Clasic cassete_fnc_end

; ===========================================
; cuando se inserto un cassete
;
cassete_fnc_inserted:
    Lea-Dword       disk_inserted ; manda el mensaje
    Jmp-Dword-Call  put_msg     ; pone el mensaje
    Jmp-Dword-Clasic cassete_fnc_end

; ===========================================
; fin de la funcion de cassete
;
cassete_fnc_end:
    Add-Dword-Sp-Inm 0
    Lea-Dword       Sp
    Jmp-Dword-Clasic Sp

Assume-Fill 0x7FFF

firmware_on_flag:
    Byte     0

old_pix_x:
    Byte     0
old_pix_y:
    Byte     0

Assume-Fill 64000

; ===========================================
;           OFITIAL MMIO
;
; vectores de io de mmio para los dispositivos
; reales del PC
;
; ===========================================

alpha_mmio:
                    Byte 0   ; boton A
beta_mmio:          
                    Byte 0   ; boton B
up_mmio:            
                    Byte 0   ; boton arriba
down_mmio:          
                    Byte 0   ; boton abajo
cassete_mmio:       
                    Byte 0   ; mmio del cassete
sga_data_mmio:      
                    Byte 0   ; al ultimo de configurar el SGA row y SGA col se pone el color para esto
sga_row_mmio:       
                    Byte 0   ; posicion y de la SGA
sga_col_mmio:       
                    Byte 0   ; posicion x de la SGA
com1_new_mmio:
                    Byte 0   ; nuevo MMIO del com1
com1_cmd_mmio:
                    Byte 0   ; nuevo MMIO del com1
5 Me gusta
2

Que bueno verte de nuevo, Erick. Gracias por el aporte.

3

tambien paso el codigo verilog de mi cpu ya empaquetado, puedes ver el source en mi repo ErickStudios/pulsar32-arch-cpu: el primer procesador en la historia que implementa y crea la arquitectura pulsar de 32 bits

module device #(
    parameter BASE_ADDR = 32'h3000
)(
    input               clk,
    input               enable,
    input               reset,
    input [7:0]         data_in,
    
    output reg          irq,
    output reg [31:0]   irq_addr,
    output reg [7:0]    irq_data,
    input               irq_ack,

    input               wrt_en,
    input [31:0]        wrt_addr,
    input [7:0]         wrt_val
);

reg  [7:0]              device_buffer;
reg                     active;

always @(posedge clk) begin
    if (reset) begin
        irq = 0;
        active = 0;
        irq_addr = 0;
        irq_data = 0;
        device_buffer <= 0;
    end else begin
        if (wrt_en && (wrt_addr == BASE_ADDR)) begin
            device_buffer <= wrt_val;
        end
        
        if (enable)
            active = 1;
        if (active && !irq) begin
            irq = 1;
            irq_addr = BASE_ADDR;
            irq_data = data_in;
        end

        if (irq && irq_ack) begin
            irq = 0;
            active = 0;
        end
    end
end
endmodule
module alu(
    input       [7:0]   opcode,
    input       [31:0]  a,
    input       [31:0]  b,
    input               aluActive,
    input               clk,
    output reg  [31:0]  result
);

always @(posedge clk) begin
    if (aluActive == 1) begin
        case(opcode)
            8'h01: result = a + b;
            8'h02: result = a - b;
            8'h03: result = a * b;
            8'h04: result = a / b;
            8'h05: result = a & b;
            8'h06: result = a | b;
            8'h07: result = a ^ b;
            8'h09: result = a << b;
            8'h0A: result = a >> b;
            default: result = 0;
        endcase
    end
end

endmodule
module cpu(
    input           clk,
    input           reset,
    input           irq,
    input [31:0]    irq_addr,
    input [7:0]     irq_data,
    output reg      irq_ack,

    input [7:0]     mem_wrt_val,
    input [31:0]    mem_wrt_addr,
    input           mem_wrt_bool,

    output reg [7:0] mem_rdr_val,
    input [31:0]    mem_rdr_addr,
    input           mem_rdr_bool,

    output reg      dev_wrt_en,
    output reg [31:0] dev_wrt_addr,
    output reg [7:0]  dev_wrt_val,

    output reg      mem_wrt_ene,
    output reg [31:0] mem_wrt_addre,
    output reg [7:0]  mem_wrt_vale
);

// ============== cpu variables ==============}
reg  [7:0]          memory [0:96000]; // 64K normal mem, 32K for MMIO
reg  [31:0]         pc;
reg  [31:0]         sp;
reg  [31:0]         currentPtrAddrs;
wire [7:0]          PXB1 = currentPtrAddrs  [31:24];
wire [7:0]          PXB2 = currentPtrAddrs  [23:16];
wire [7:0]          PXB3 = currentPtrAddrs  [15:8];
wire [7:0]          PXB4 = currentPtrAddrs  [7:0];
reg  [7:0]          OprOperator;
reg  [7:0]          OprOperationBytes;
reg  [7:0]          valueRegister;
reg  [7:0]          op_id;
reg  [31:0]         a, b, result;
reg  [7:0]          ir;
reg  [7:0]          opcode;
reg  [7:0]          mode;
reg  [7:0]          operationModes;
reg  [7:0]          flags;
reg [31:0]          vector_base;
reg [31:0]          offset;
reg [31:0]          irq_vector;
reg                 quiet = 0;
reg                 paused;
reg [1:0]           CWFDD;
reg [1:0]           CWFDM;

// ============== alu components ==============
reg  [31:0]         aluA;
reg  [31:0]         aluB;
wire [31:0]         aluResult;
reg  [1:0]          aluState;
reg                 aluActive;

alu                 alu0(
    .opcode         (OprOperator),
    .a              (aluA),
    .b              (aluB),
    .aluActive      (aluActive),
    .clk            (clk),
    .result         (aluResult)
);

// ============== temporaly ==============
`define         STR_INM  "INME"                 // operation mode
`define         STR_REG  "REGI"                 // register mode
`define         STR_STK  "STCK"                 // stack mode
`define         STR_UNK  "????"                 // unknown mode
integer i;

// ============== function for inms  ==============
// | read a inmediate in the text of the program  |
// |                                              |
// | #NONDEBUG #INM #FUNCTION                     |
// ------------------------------------------------
function [31:0] readINM; input [7:0] bytesLen; input [31:0] baseAddr; begin
    case (bytesLen)
        1: readINM = memory[baseAddr];
        2: readINM = {memory[baseAddr],memory[baseAddr + 1]};
        4: readINM = {memory[baseAddr],memory[baseAddr + 1],memory[baseAddr + 2],memory[baseAddr + 3]
        };
        default: readINM = 0;
    endcase
end endfunction

// ============== function for debug ==============
// | the function for convert operation modes to  |
// | human readable words for identific the opera-|
// | tions                                        |
// |                                              |
// | #DEBUG #CASTING #HUMANREADABLE               |
// ------------------------------------------------
function [31:0] castToDebug; input [3:0] modeOpr; begin 
    case (modeOpr)
        4'h0: castToDebug = `STR_INM;               // str inm
        4'h1: castToDebug = `STR_REG;               // str reg
        4'h2: castToDebug = `STR_STK;               // str stack
        default: castToDebug = `STR_UNK;            // str unknown
    endcase 
end endfunction

// ============== function for opers ==============
// | A instant function for the operations regs   |
// | , inms, stack and other modes                |
// |                                              |
// | #FASTER #STARTER                             |
// ------------------------------------------------
task operateInstant; 
input [3:0] modeOpr; 
input [7:0] bytesLen; 
output [31:0] val;
begin
    case (modeOpr)
        4'h0: begin
            val = readINM(bytesLen, pc);
            pc = pc + bytesLen;
        end
        4'h1: begin
            a = memory[pc];
            pc = pc + 1;

            case (a)
                0: val = result;
                1: val = valueRegister;
                2: val = currentPtrAddrs;
                default: val = 0;
            endcase
        end
        4'h2: begin
            val = readINM(bytesLen, sp);
            sp = sp + bytesLen;
        end
        default: val = 0;
    endcase
end endtask

task alu_check; begin
    if (aluState == 1) begin
        aluState = 2;
    end
    else if (aluState == 2) begin
        result = aluResult;
        aluActive = 0;
        aluState = 0;
    end
end endtask
task alu_reset; begin
    aluState = 0;
    aluActive = 0;
    aluA = 0;
    aluB = 0;
end endtask

task general_reset; begin
    pc <= {
        memory[0],
        memory[1],
        memory[2],
        memory[3]
    };
    sp = 95000;
    ir = 0;
    paused = 0;
end endtask
task save_dir; begin
    sp = sp - 4;
    memory[sp]     = pc[31:24];
    memory[sp + 1] = pc[23:16];
    memory[sp + 2] = pc[15:8];
    memory[sp + 3] = pc[7:0];
end endtask

task ex_lpx; begin
    mode = memory[pc];
    OprOperationBytes = memory[pc + 1];
    pc = pc + 2;

    if (!quiet) $write("ANONYMUS");
    if ((OprOperationBytes * 8) < 10) begin
        if (!quiet) $write("%0d ", OprOperationBytes * 8);
    end
    else begin
        if (!quiet) $write("%0d", OprOperationBytes * 8);
    end
    if (!quiet) $write(" LPX %s", castToDebug(mode[3:0]));
    operateInstant(mode[3:0],OprOperationBytes,a);
    if (!quiet) $write(" %0d\n", a);

    currentPtrAddrs = a;
end endtask

task write_mem_byte; 
input [31:0]    addr;
input [7:0]     val;
begin
    if (addr > 63999) begin
        CWFDD = 2;
        dev_wrt_en   = 1;
        dev_wrt_addr = addr - 64000;
        dev_wrt_val  = val;
    end
    CWFDM = 2;
    mem_wrt_ene   = 1;
    mem_wrt_addre = addr;
    mem_wrt_vale  = val;
    memory[addr] = val;
end endtask
task ex_ldx; begin
    if (!quiet) $display("REGISTER8  LDX");
    valueRegister = memory[currentPtrAddrs];
end endtask
task ex_pus; begin
    mode = memory[pc];
    OprOperationBytes = memory[pc + 1];
    pc = pc + 2;

    operateInstant(mode[3:0],OprOperationBytes,a);

    if (!quiet) $display("ANONYMUS   PUS %s %0d", castToDebug(mode[3:0]), a);

    for (i = 0; i < OprOperationBytes; i = i + 1) begin
        sp = sp - 1;
    end

    for (i = 0; i < OprOperationBytes; i = i + 1) begin
        memory[sp+i] = a >> (8*(OprOperationBytes-1-i));
    end
end endtask
task ex_opr; begin
    // fetch mode
    OprOperator = memory[pc];           // operator
    OprOperationBytes = memory[pc + 1]; // operation bytes len
    operationModes = memory[pc + 2];    // operation mode
    pc = pc + 3;                        // increment pc

    if (!quiet) $write("ANONYMUS");
    if ((OprOperationBytes * 8) < 10) begin
        if (!quiet) $write("%0d ", OprOperationBytes * 8);
    end
    else begin
        if (!quiet) $write("%0d", OprOperationBytes * 8);
    end
    if (!quiet) $write(" OPR ");

    if (!quiet) $write("%s ", castToDebug(operationModes[7:4]));
    if (!quiet) $write("%s %0d\n", castToDebug(operationModes[3:0]), OprOperator);

    if (OprOperator != 8'h08) operateInstant(operationModes[7:4],OprOperationBytes, a);
    if (OprOperator != 8'h08) operateInstant(operationModes[3:0],OprOperationBytes, b);

    case (OprOperator) 
        8'h08: begin
            result = readINM(OprOperationBytes, currentPtrAddrs); 
        end
        default: begin
            aluA = a;
            aluB = b;
            aluActive = 1;
            aluState = 1;
        end
    endcase

end endtask
task ex_cmp; begin
    // fetch mode
    OprOperationBytes = memory[pc]; // operation bytes len
    operationModes = memory[pc + 1];    // operation mode
    pc = pc + 2;                        // increment pc

    if (!quiet) $write("ANONYMUS");
    if ((OprOperationBytes * 8) < 10) begin
        if (!quiet) $write("%0d ", OprOperationBytes * 8);
    end
    else begin
        if (!quiet) $write("%0d", OprOperationBytes * 8);
    end
    if (!quiet) $write(" CMP ");

    if (!quiet) $write("%s ", castToDebug(operationModes[7:4]));
    if (!quiet) $write("%s\n", castToDebug(operationModes[3:0]));

    operateInstant(operationModes[7:4],OprOperationBytes,a);
    operateInstant(operationModes[3:0],OprOperationBytes,b);

    result = a - b;
    flags = 0;
    if (result == 0) flags[0] = 1;
    if (result[31] == 1) flags[1] = 1;
    if (result > 0 && result[31] == 0) flags[2] = 1;
end endtask
task ex_jmp; begin
    // fetch mode
    OprOperationBytes = memory[pc];     // operation bytes len
    operationModes = memory[pc + 1];    // operation mode
    mode = memory[pc + 2];              // jmp template
    pc = pc + 3;                        // increment pc

    if (!quiet) $write("ANONYMUS");
    if ((OprOperationBytes * 8) < 10) begin
        if (!quiet) $write("%0d ", OprOperationBytes * 8);
    end 
    else begin
        if (!quiet) $write("%0d", OprOperationBytes * 8);
    end
    if (!quiet) $write(" JMP ");
    if (!quiet) $write("%s ", castToDebug(operationModes[3:0]));

    operateInstant(operationModes[3:0],OprOperationBytes,a);
    if (!quiet) $write("%0d\n", a);
    case (mode)
        // normal jmp 
        8'h00: pc = a;
        // if equal jmp
        8'h01: begin if (flags[0]) pc = a;end
        // if less jmp
        8'h02: begin if (flags[1]) pc = a;end
        // if greater jmp
        8'h03: begin if (flags[2]) pc = a;end
        // call
        8'h04: begin save_dir(); pc = a; end
    endcase
end endtask
task ex_sdx; begin
    mode = memory[pc];
    OprOperationBytes = memory[pc + 1];
    pc = pc + 2;

    operateInstant(mode[3:0],OprOperationBytes, a);
    if (!quiet) $write("ANONYMUS");
    if ((OprOperationBytes * 8) < 10) begin
        if (!quiet) $write("%0d ", OprOperationBytes * 8);
    end 
    else begin
        if (!quiet) $write("%0d", OprOperationBytes * 8);
    end 
    if (!quiet) $write(" SDX %s %0d\n", castToDebug(mode[3:0]), a);

    for (i = 0; i < OprOperationBytes; i = i + 1) begin
        write_mem_byte(currentPtrAddrs + i, a >> (8*i));
    end
end endtask

task irq_check; begin
    if (!quiet) $write("%d (%8x) ",pc - 1, pc);
    if (!quiet) $display("HARDWARE   IRQ %0d %0d", irq_addr, irq_data);
    paused = 0;
    irq_ack <= 1; 
    save_dir();
    valueRegister = irq_data;
    vector_base = 4;
    offset = irq_addr * 4;
    irq_vector = {
        memory[vector_base + offset],
        memory[vector_base + offset + 1],
        memory[vector_base + offset + 2],
        memory[vector_base + offset + 3]
    };
    pc = irq_vector;
end endtask

// ============== function for clock ==============
// | This functions keeps on the machine for make |
// | it makes things                              |
// |                                              |
// | #LOOP #NONDEBUG #DEBUG                       |
// ------------------------------------------------
always @(posedge clk) begin
    // reset signal power on/restart computer
    if (reset) begin        
        general_reset();
        alu_reset();
        CWFDD = 0;
    // tick of click
    end else begin
        if (CWFDD == 1) begin
            dev_wrt_en = 0;
            CWFDD = CWFDD - 1;
        end
        else if (CWFDD != 0) begin
            CWFDD = CWFDD - 1;
        end

        if (CWFDM == 1) begin
            mem_wrt_ene = 0;
            CWFDM = CWFDM - 1;
        end
        else if (CWFDM != 0) begin
            CWFDM = CWFDM - 1;
        end
                if (sp < 50000) begin
            if (!quiet) $display("HARDWARE   STACK OVERFLOW %0d %0d", irq_addr, irq_data);
            general_reset();
            alu_reset();
        end

        if (mem_wrt_bool) begin
            memory[mem_wrt_addr] <= mem_wrt_val;
        end

        if (mem_rdr_bool) begin 
            mem_rdr_val <= memory[mem_rdr_addr]; 
        end

        // check alu
        alu_check();

        if (irq && !irq_ack) begin
            irq_check();
        end else if (!paused && !aluState) begin
        irq_ack <= 0;

        // fetch instruction
        ir = memory[pc];                           // current instruction
        pc = pc + 1;                               // increment program counter

        if (!quiet) $write("%d (%8x) ",pc - 1, pc);
        case (ir)
            // LPX = Load Pointer eXpretion
            8'h01: ex_lpx();
            // LDX = Load From memory To Data RegiXter (Data Register = valueRegister beta name)
            8'h02: ex_ldx();
            // PUS = Push Unity or regiSter
            8'h03: ex_pus();
            // OPR = Operation Propurse with Result
            8'h04: ex_opr();
            // HLT = Halt main Tread
            8'h05: begin if (!quiet) $display("NULL0      HLT"); paused = 1; end
            // CMP = Compare Multi Parse
            8'h06: ex_cmp();
            // JMP = Jump Multi Templates
            8'h07: ex_jmp();
            // SDX = Save Data RegiXters to memory
            8'h08: ex_sdx();
        endcase
    end
    end
    $fflush();
end

endmodule
2 Me gusta
4

Eso si que esta durisimo, solo he experimentado a crear mis propios programa (cree una version de postman propio) porque no me gustaba que me pidan logearme o porque eran de pago, pero no he experimentado a crear firmware propio, que bueno que implementes este tipo de proyectos