Mam moduł oczyszczania.

module ProcessingArray #(parameter Y=14, X=14, W=16) (  
    input                   GlobalClk,
    input           [3:0]   OpCode,
    input           [W-1:0] DataIn,
    output logic    [W-1:0] DataOut 
    );

    

    genvar x, y;
    generate
        for (y=0; y<=Y; y++) begin 
            for (x=0; x<X; x++) begin
                ProcessingElement #(.W(16)) PE(
                    .Clk(GlobalClk),
                    .OpCode(OpCode),
                    .Input(DataIn),
                    .Output(DataOut)
                );
            end
        end
    endgenerate


endmodule

Wydaje się, że jest to skompilować za pomocą modelem, ale mam problemy ze znalezieniem gładkiego sposobu podłączenia elementów tablicy do siebie. Ogólnie, połączenia są Jeśli X> Y, elementy będą podłączone w poziomie; Jeśli y> x, pionowo; Jeśli x == y, oba i po przekątnej. Oto przykład, w jaki sposób zostanie podłączony do siatki górnej lewej 3x3:

[Połączenia] [1]

Czy istnieje sposób na odniesienie (np. Przez nazywanie instancji) każdy z wygenerowanych instancji w pętlach? Gdyby było, może mógłbym zrobić kolejne wygenerowane oświadczenie, które wykonało wszystkie przypisywanie.

Jestem stosunkowo nowy w Verilog / SV, więc jeśli jest lepszy sposób, aby to zrobić, cieszę się, że jestem oświecony

Edytuj: Oto przykładowy jest przykład

module ProcessingArray #(parameter Y=14, X=14, W=16) (  
    input                   GlobalClk,
    input           [3:0]   OpCode,
    input           [W-1:0] DataIn,
    output logic    [W-1:0] DataOut 
    );

ProcessingElement #(.W(16)) PE_00(
    .Clk(GlobalClk),
    .OpCode(OpCode),
    .Input(DataIn),
    .Output(DataOut_00)
);

// For readability
wire wire00_01 = DataOut_00;
wire wire00_10 = DataOut_00;
wire wire00_11 = DataOut_00;

ProcessingElement #(.W(16)) PE_01(
    .Clk(GlobalClk),
    .OpCode(OpCode),
    .Input(wire00_01),
    .Output(DataOut_01)
);

wire wire01_02 = DataOut_01;

ProcessingElement #(.W(16)) PE_02(
    .Clk(GlobalClk),
    .OpCode(OpCode),
    .Input(wire01_02),
    .Output(wire02_elsewhere)
);

ProcessingElement #(.W(16)) PE_10(
    .Clk(GlobalClk),
    .OpCode(OpCode),
    .Input(wire00_10),
    .Output(DataOut_10)
);

wire wire10_20 = DataOut_10;

ProcessingElement #(.W(16)) PE_11(
    .Clk(GlobalClk),
    .OpCode(OpCode),
    .Input(wire00_11),
    .Output(DataOut_11)
);

wire wire11_12 = DataOut_11;
wire wire11_21 = DataOut_11;
wire wire11_22 = DataOut_11;

ProcessingElement #(.W(16)) PE_12(
    .Clk(GlobalClk),
    .OpCode(OpCode),
    .Input(wire11_12), 
    .Output(DataOut_12)
);

ProcessingElement #(.W(16)) PE_20(
    .Clk(GlobalClk),
    .OpCode(OpCode),
    .Input(DataIn), 
    .Output(DataOut_20)
);

ProcessingElement #(.W(16)) PE_21(
    .Clk(GlobalClk),
    .OpCode(OpCode),
    .Input(wire11_21), 
    .Output(DataOut_21)
);

ProcessingElement #(.W(16)) PE_22(
    .Clk(GlobalClk),
    .OpCode(OpCode),
    .Input(wire11_22), 
    .Output(DataOut)
);

endmodule
0
Jake Daly 22 listopad 2020, 18:34

1 odpowiedź

Najlepsza odpowiedź

Co możesz zrobić, jest utworzyć tablicę drutów 2-D i wykonaj warunkowe połączenia wewnątrz pętli generuj. Oto, jak wygląda kompletny przykład:

module ProcessingArray #(parameter Y=14, X=14, W=16) (  
    input                   GlobalClk,
    input           [3:0]   OpCode,
    input           [W-1:0] DataIn,
    output logic    [W-1:0] DataOut 
    );
  // internal connections
  wire [W-1:0] ConnIn[Y][X];
  wire [W-1:0] ConnOut[Y][X];
  // entry and exit connections
  assign ConnIn[0][0] = DataIn;
  assign DataOut = ConnOut[Y-1][X-1];

  for (genvar y=0; y<Y; y++) begin : row
    for (genvar x=0; x<X; x++) begin  :col
      ProcessingElement #(.W(16)) PE(
        .Clk(GlobalClk),
        .OpCode(OpCode),
        .Input(ConnIn[y][x]),
        .Output(ConnOut[y][x])
      );
      if (y<=x && x>0) assign ConnIn[y][x] = ConnOut[y][x-1]; // horizontal 
      if (x<=y && y>0) assign ConnIn[y][x] = ConnOut[y-1][x]; // vertical 
    end
  end

endmodule

module ProcessingElement #(int W) (
  input Clk,
  input           [3:0]   OpCode,
  input           [W-1:0] Input,
  output logic    [W-1:0] Output
);
  assign Output=Input+1;  // trace connectivity
  initial #1 $display("PE %m %d",Input);
endmodule

module tb;
  logic [15:0] in,out;
  logic [3:0] op;
  
  ProcessingArray PE(clk,op,in,out);
  
  initial begin
    in = 1;
    #1 $display(out);
  end
endmodule
1
dave_59 23 listopad 2020, 07:14