Question

我在一个模块中实例化了不同的模块。我想按顺序执行它们，我有所有模块的启用和确认信号，我该怎么做？

以下是代码：

module memorycontroller(
    input  [7:0] A,
    input  [7:0] B,
    input  [1:0] adrress,
    input        clk,
    output [7:0] A_mem,
    output [7:0] B_mem
);
    reg          LMwrEnable, localmemEnable;
    integer      LMwrack,    localmemack;
    reg    [7:0] A1, B1;

    initial
    begin
      LMwrEnable     = 1;
      localmemEnable = 0;
    end

    memorywrite LMwr (
      .clk     ( clk        ), 
      .A       ( A          ), 
      .B       ( B          ), 
      .adr     ( adrress    ),
      .enable  ( LMwrEnable ),
      .ack     ( LMwrack    )
    );

    bram_tdp localmem (
      .a_clk   ( clk            ), 
      .a_wr    ( 1'b0           ), 
      .a_addr  ( adrress        ), 
      .a_din   ( A1             ), 
      .a_dout  ( A_mem          ), 
      .b_clk   ( clk            ), 
      .b_wr    ( 1'b0           ), 
      .b_addr  ( adrress+1'b1   ), 
      .b_din   ( B1             ), 
      .b_dout  ( B_mem          ),
      .enable  ( localmemEnable ),
      .ack     ( localmemack    )
    );

     always@(posedge clk)
     begin
       if(LMwrack)
         localmemEnable = 1;
     end


endmodule

在初始语句中，我在初始块中仅启用了LMwr模块，并且在其ack信号上我已经在always块中启用了localmem模块，但这给了我错误的结果。你能告诉我如何按顺序执行不同的模块吗？

以下是memorywrite模块

module memorywrite(
    input clk,
    input [7:0] A,
    input [7:0] B,
    input [1:0] adr,
     input enable,
     output ack
    );
     wire [7:0] C,C1;

 bram_tdp localmem (
    .a_clk(clk), 
    .a_wr(1'b1), 
    .a_addr(adr), 
    .a_din(A), 
    .a_dout(C), 
    .b_clk(clk), 
    .b_wr(1'b1), 
    .b_addr(adr+1'b1), 
    .b_din(B), 
    .b_dout(C1),
     .enable(enable),
     .ack(ack)
    );

endmodule

以上代码写入内存。

以下是由上述第二代码写入并由上述第一代码读取的实际存储器模块

module bram_tdp #(
    parameter DATA = 8,
    parameter ADDR = 2
) (
     input enable,
     output ack,
    // Port A
    input   wire                a_clk,
    input   wire                a_wr,
    input   wire    [ADDR-1:0]  a_addr,
    input   wire    [DATA-1:0]  a_din,
    output  reg     [DATA-1:0]  a_dout,

    // Port B
    input   wire                b_clk,
    input   wire                b_wr,
    input   wire    [ADDR-1:0]  b_addr,
    input   wire    [DATA-1:0]  b_din,
    output  reg     [DATA-1:0]  b_dout
);

// Shared memory
reg [DATA-1:0] mem [(2**ADDR)-1:0];

// Port A
always @(posedge a_clk) begin
if(enable) begin
    a_dout      <= mem[a_addr];
    if(a_wr) begin
        a_dout      <= a_din;
        mem[a_addr] <= a_din;
    end
    end
end

// Port B
always @(posedge b_clk) begin
if(enable) begin
    b_dout      <= mem[b_addr];
    if(b_wr) begin
        b_dout      <= b_din;
        mem[b_addr] <= b_din;
    end

    end
end
assign ack=1;
endmodule

这是testbench：

module mmTesting;

    // Inputs
    reg [7:0] A;
    reg [7:0] B;
    reg [1:0] adrress;
    reg clk;

    // Outputs
    wire [7:0] A_mem;
    wire [7:0] B_mem;

    // Instantiate the Unit Under Test (UUT)
    memorycontroller uut (
        .A(A), 
        .B(B), 
        .adrress(adrress), 
        .clk(clk), 
        .A_mem(A_mem), 
        .B_mem(B_mem)
    );

    initial begin
        // Initialize Inputs
        A = 0;
        B = 0;
        adrress = 0;
        clk = 0;

        // Wait 100 ns for global reset to finish
        #100;
      A = 5;
        B = 5;
        adrress = 0;

      #100 A = 6;
        B = 2;
        adrress = 1;


        // Add stimulus here

    end
     always #5 clk=!clk; 
endmodule

结果应与我写入内存的内容相同。

Answer 1

只是为了澄清Verilog是一个硬件描述，并且两个实例化（不是模块，作为一个未实例化的模块不存在）可以并行执行并存在，不像C等价物会执行另一个。

如果你有实例A和B，你只需要一个FSM（有限状态机）来启用A等待其完成信号，然后禁用A启用B，等待B完成并重复。

注意：如果注释掉的代码与问题无关，可以将其删除，最好将问题减少到重现问题所需的最少代码量。

如何在verilog中按顺序启用实例化模块

1 个答案: