Usando '$ display' en Xilinx (verilog)

0

Estoy intentando escribir un banco de pruebas para un procesador RISC de 16 bits usando verilog en Xilinx. Tengo los siguientes módulos:

- TOP
    -datapath
       -instruction_fetch
            -program_counter
            -instruction_memory
            -instruction_register
       -MUX21
       -alu
       -MUX41
       -general_purpose_reg
       -data_memory
    -control_unit

Mi pregunta es: para que esto funcione, ¿necesito crear solo un banco de pruebas para el módulo 'TOP' y tener declaraciones '$ display' para cada módulo dentro de él?

POR EJEMPLO, si tengo que mostrar la salida del módulo alu, ¿debería tener la declaración de visualización en el banco de pruebas para TOP?

module top_test;

    // Inputs
    reg clk;
    reg rst;
    reg start;

    // Outputs
    wire [4:0] PS;
    wire [3:0] opcode;
    wire [15:0] PC;
    wire [15:0] IM_instr;
    wire [15:0] IR_instr;
    wire [14:0] CV;
    wire [15:0] R1_reg;
    wire [15:0] R2_reg;
    wire [15:0] R3_reg;
    wire [15:0] R4_reg;
    wire [15:0] R5_reg;
    wire [15:0] R6_reg;
    wire [15:0] R7_reg;
    wire [15:0] R8_reg;
    wire Z;
    wire [15:0] A_ALU;
    wire [15:0] B_ALU;

    // Instantiate the Unit Under Test (UUT)
    TOP uut (
        .clk(clk), 
        .rst(rst), 
        .start(start), 
        .PS(PS), 
        .opcode(opcode), 
        .PC(PC), 
        .IM_instr(IM_instr), 
        .IR_instr(IR_instr), 
        .CV(CV), 
        .R1_reg(R1_reg), 
        .R2_reg(R2_reg), 
        .R3_reg(R3_reg), 
        .R4_reg(R4_reg), 
        .R5_reg(R5_reg), 
        .R6_reg(R6_reg), 
        .R7_reg(R7_reg), 
        .R8_reg(R8_reg), 
        .Z(Z), 
        .A_ALU(A_ALU), 
        .B_ALU(B_ALU)
    );

    initial begin
        // Initialize Inputs
        clk = 0;
        rst = 0;
        start = 0;

        // Wait 100 ns for global reset to finish

    #100 ;
    rst = 1;

//  $display($time, " alumod A_in=%b,B_in=%b,ALU_out=%b", A_in, B_in, ALU_out); 
    end 

    always
       begin 
          #5 clk = !clk;
         end



endmodule

código del módulo alu:

module alumod(clk,rst,load_SR,ALU_opcode,A_in,B_in,ALU_out,data,carry,Z);

    input clk,rst;
    input [15:0] A_in,B_in;
   input [2:0]  ALU_opcode;
    input load_SR;

   output [16:0] ALU_out;
    output [15:0] data;
    output carry, Z;

   reg [16:0] ALU_out;
    reg Z;

    always@(ALU_opcode or A_in or B_in)

    case(ALU_opcode[2:0])

    3'b000:  ALU_out = A_in + B_in;
    3'b001:  ALU_out = A_in - B_in;
    3'b010:  ALU_out = {{16{A_in[15]}},A_in} >> B_in; //ARITHMETIC 
    3'b011:  ALU_out = A_in << B_in;            //LOGICAL LEFT SHIFT
    3'b100:  ALU_out = A_in >> B_in;            //LOGICAL RIGHT SHIFT
    3'b101: if (A_in < B_in)                                    //SLT
                    ALU_out = 1;
               else 
                    ALU_out = 0;
   3'b110:  ALU_out = ~A_in;                    //INV
    //'b111: HAMMING DISTANCE


    //default: alu_out = ;
    endcase

// Z REGISTER MODULE
always@(posedge clk or posedge rst)
        if(rst)
            Z <= 1'b0;
        else if(load_SR)
            Z <= (data == 0);
        else 
            Z <= Z;

        assign data =  ALU_out[15:0];
        assign carry =  ALU_out[16];



endmodule
    
pregunta user3344978

1 respuesta

2
  

Hice el cambio necesario y coloqué el '$ display' dentro de los módulos. Pero esta es la salida que estoy obteniendo: 0 alumod A_in=xxxxxxxxxxxxxxxx, B_in=xxxxxxxxxxxxxxxx, ALU_out=xxxxxxxxxxxxxxxxx ¿Por qué no estoy obteniendo la salida?

porque no ha proporcionado ningún valor de entrada de prueba. Por ejemplo, en su banco de pruebas A_ALU y B_ALU no están inicializados. Dado que las redes que se controlan obtienen el valor predeterminado de 'x', obtienes A_in & B_in como x's.

He simplificado su código aquí . Consulte el código de testbench donde A_ALU & Se proporcionan valores B_ALU. El '$ display' se usa en el archivo 'alumod.sv'. Después de simular, obtendrás una salida como esta:

#                  100 alumod A_in=x, B_in=x, ALU_out=x
#                  105 alumod A_in=1010, B_in=1010, ALU_out=10100
#                  110 alumod A_in=1010, B_in=10100, ALU_out=11110
#                  115 alumod A_in=1010, B_in=11110, ALU_out=101000
#                  120 alumod A_in=1010, B_in=101, ALU_out=101
#                  125 alumod A_in=1010, B_in=100, ALU_out=110

Vea, para los primeros 100 ns, los valores son x, ya que aún no están inicializados.

    
respondido por el hassansin

Lea otras preguntas en las etiquetas