Tworzenie instancji modułów w Verilogu: łączenie podmodułów

Moduły w modułach

Projekt w Verilogu to drzewo modułów. Moduł najwyższego poziomu (testbench albo główna obudowa układu) tworzy instancje modułów niższego poziomu, które tworzą instancje modułów jeszcze niższego poziomu, aż do prymitywów bramek dostarczanych przez producenta. Tworzenie instancji to składnia tego zagnieżdżania.

Ten kształt już znasz, bo użyliśmy go w artykule Twój pierwszy moduł:

and_gate dut(.a(a), .b(b), .y(y));

Ta linia tworzy jedną instancję and_gate, nadaje jej nazwę dut i łączy jej porty z lokalnymi sygnałami. Rozłóżmy ją na części.

Kształt instancji

module_name instance_name (port_connections);

• module_name musi zgadzać się z nazwą z deklaracji module gdzieś w projekcie. Verilog rozróżnia wielkość liter.
• instance_name to wybrana przez ciebie etykieta, zwykle opisująca rolę tej instancji. Użyjesz jej w ścieżkach hierarchicznych i w widoku przebiegów.
• port_connections łączą porty instancji z lokalnymi sygnałami. Można to zapisać na dwa sposoby.

Połączenia portów po nazwie (używaj ich)

Forma z nazwami wygląda tak:

my_module instance_name(
    .clk    (clk),
    .reset  (reset_n),
    .data_in(in_bus),
    .data_out(out_bus),
    .valid  (out_valid)
);

Każda para .port(signal) oznacza "połącz port tej instancji o nazwie port z lokalnym sygnałem o nazwie signal". Kolejność nie ma znaczenia. Jeśli dodasz nowy port do deklaracji modułu, istniejące instancje się nie zepsują, o ile nowy port ma wartość domyślną albo zaktualizujesz każde miejsce użycia.

Dwie praktyczne uwagi:

• Nazwa portu (przed nawiasem) musi dokładnie odpowiadać deklaracji modułu.
• Nazwa sygnału (w nawiasie) jest lokalna dla miejsca, w którym znajduje się instancja, zwykle modułu nadrzędnego.

Jeśli port ma zostać niepodłączony, zostaw nawias pusty: .optional_port(). Sygnał wewnątrz instancji pozostaje wtedy nieustalony (z). Niektóre narzędzia do syntezy ostrzegają, ale większość to akceptuje.

Połączenia portów po pozycji (unikaj ich)

Krótsza forma wypisuje sygnały w kolejności listy portów:

my_module instance_name(clk, reset_n, in_bus, out_bus, out_valid);

Jest krótsza, ale krucha. Zmień kolejność portów modułu (a taki refaktor naprawdę się zdarza), a każda instancja pozycyjna po cichu podłączy się źle. Nie sięgaj po styl pozycyjny, chyba że lista portów ma dokładnie jeden lub dwa elementy i raczej nigdy się nie zmieni.

Gdzie jest nadal do przyjęcia: w malutkich modułach pomocniczych, w których kolejność portów jest częścią API. Bramka o dwóch wejściach może być podłączana pozycyjnie. Kontroler pamięci z 30 portami to proszenie się o kłopoty.

Kompletny przykład hierarchiczny

// Half-adder: two inputs, sum and carry-out.
module half_adder(
    input  wire a,
    input  wire b,
    output wire sum,
    output wire carry
);
    assign sum   = a ^ b;
    assign carry = a & b;
endmodule

// Full-adder built from two half-adders + an OR gate.
module full_adder(
    input  wire a,
    input  wire b,
    input  wire cin,
    output wire sum,
    output wire cout
);
    wire sum1, carry1, carry2;

    half_adder ha0(.a(a),    .b(b), .sum(sum1), .carry(carry1));
    half_adder ha1(.a(sum1), .b(cin), .sum(sum), .carry(carry2));

    assign cout = carry1 | carry2;
endmodule

// Testbench: drive the full-adder through every input combination.
module test;
    reg  a, b, cin;
    wire sum, cout;

    full_adder dut(.a(a), .b(b), .cin(cin), .sum(sum), .cout(cout));

    initial begin
        for (integer i = 0; i < 8; i = i + 1) begin
            {a, b, cin} = i[2:0];
            #1 $display("a=%b b=%b cin=%b -> sum=%b cout=%b",
                        a, b, cin, sum, cout);
        end
        $finish;
    end
endmodule

To prawdziwa trzypoziomowa hierarchia: test → full_adder → dwie instancje half_adder. Każda instancja ma własną kopię bramek z wnętrza half_adder, a narzędzie do syntezy utworzy osobny układ dla każdej instancji.

Wiele instancji tego samego modułu

Gdy tworzysz kilka instancji tego samego modułu, każda z nich to niezależny sprzęt. Nie dzielą stanu ani bramek. Wyobraź sobie każdą instancję jako świeżą kopię odbitą z projektu.

adder add0(.a(a0), .b(b0), .sum(s0));
adder add1(.a(a1), .b(b1), .sum(s1));
adder add2(.a(a2), .b(b2), .sum(s2));
adder add3(.a(a3), .b(b3), .sum(s3));

To cztery osobne sumatory działające równolegle. Gdyby adder zawierał rejestr, każda instancja miałaby własną kopię tego rejestru z własnym stanem.

Pętle generate: powielanie sprzętu

Ręczne wypisanie czterech instancji jest w porządku. Wypisanie 64 jest żmudne. Blok generate pozwala, żeby to elaborator pisał za ciebie:

module bit_inverter(input wire x, output wire y);
    assign y = ~x;
endmodule

module wide_inverter #(
    parameter WIDTH = 8
)(
    input  wire [WIDTH-1:0] in,
    output wire [WIDTH-1:0] out
);
    genvar i;
    generate
        for (i = 0; i < WIDTH; i = i + 1) begin : invert_loop
            bit_inverter u_inv(.x(in[i]), .y(out[i]));
        end
    endgenerate
endmodule

module test;
    reg  [7:0] in;
    wire [7:0] out;

    wide_inverter #(.WIDTH(8)) dut(.in(in), .out(out));

    initial begin
        in = 8'b1010_1100;
        #1 $display("in =%b", in);
        $display("out=%b", out);
        $finish;
    end
endmodule

Trzy nowe elementy składni:

• genvar i deklaruje zmienną pętli, której można używać w generate. To nie jest sygnał w czasie działania: istnieje tylko na etapie elaboracji.
• generate ... endgenerate obejmuje pętlę. Niektóre narzędzia akceptują pętle generate bez jawnego słowa generate, ale jego zapisanie czyni intencję oczywistą.
• begin : invert_loop nadaje etykietę zakresowi generate. Etykieta staje się częścią hierarchicznej nazwy każdej wygenerowanej instancji (dut.invert_loop[0].u_inv, dut.invert_loop[1].u_inv itd.).

Syntezator rozwija pętlę i tworzy WIDTH kopii bit_inverter. Każda kopia to niezależny sprzęt.

Nadpisywanie parametrów przy tworzeniu instancji

Jeśli moduł ma parametry, możesz je nadpisać za pomocą #(.PARAM(value)) między nazwą modułu a nazwą instancji:

counter #(.WIDTH(16)) c16 (.clk(clk), .count(out16));
counter #(.WIDTH(32)) c32 (.clk(clk), .count(out32));

Obie instancje używają tego samego kodu counter, ale mają różne szerokości. Składnię omówiliśmy w artykule Parametry, a tutaj po prostu wpasowuje się w tworzenie instancji.

Nazwy hierarchiczne

Gdy masz już hierarchię, każdy sygnał ma ścieżkę hierarchiczną:

test.dut.ha0.sum

Czyta się to tak: w module test, wewnątrz instancji dut, wewnątrz instancji ha0, sygnał o nazwie sum. Takie ścieżki zobaczysz w przeglądarkach przebiegów, komunikatach o błędach i w wywołaniach $display, które z testbencha zaglądają głęboko do podmodułu:

$display("internal carry1 = %b", dut.carry1);

Takie odwołania hierarchiczne służą tylko testbenchom i debugowaniu. Syntezowalny RTL nie sięga do wnętrza innych modułów.

Typowe błędy

Niezgodna nazwa portu. .clk_in(clk) łączy lokalne clk z portem o nazwie clk_in. Jeśli port modułu nazywa się w rzeczywistości clk, parser ci to powie (niektóre narzędzia wyraźniej niż inne).

Niezgodna szerokość portu. Podłączenie 4-bitowego sygnału do 8-bitowego portu po cichu rozszerza go zerami, a w odwrotnym przypadku po cichu go obcina. Większość narzędzi ostrzega. Jeśli nie widzisz ostrzeżeń, poszukaj dokładniej.

Brak # przy parametrze. counter (.WIDTH(8)) c(.clk(clk)) wygląda jak nadpisanie, ale nim nie jest: parser próbuje potraktować (.WIDTH(8)) jako połączenie portu i zgłasza błąd. Poprawnie: counter #(.WIDTH(8)) c(.clk(clk)).

Powtórzona nazwa instancji. Dwie instancje w tym samym zakresie nie mogą mieć tej samej nazwy. Komunikat o błędzie jest zwykle jasny, a problemy sprawia pokusa kopiowania i wklejania.

Co dalej

Potrafisz już łączyć moduły w prawdziwą hierarchię. Następny artykuł, Przypisanie ciągłe, domyka strukturalną stronę Veriloga i dokładniej omawia instrukcję assign, której swobodnie używamy od pierwszego rozdziału.