Module 如何在verilog中依次启用实例化模块

我在一个模块中实例化了不同的模块。我想按顺序执行它们，我有所有模块的启用和确认信号，我如何才能做到这一点

代码如下：

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

---

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

只是为了澄清Verilog是一个硬件描述，两个实例化（不是模块，因为不存在未实例化的模块）都可以并行执行和存在，而不像C等价物那样一个接一个地执行

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

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

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