Pierwszy moduł w Verilogu: przewodnik krok po kroku

Moduł to podstawowa jednostka Veriloga

Wszystko w Verilogu mieszka wewnątrz module. Moduł obejmuje fragment układu: deklaruje, jakie sygnały wchodzą, jakie wychodzą i jakie przewody, rejestry i logika są między nimi. Każdy chip, jaki kiedykolwiek widziano, to drzewo modułów tworzących instancje innych modułów, aż do prymitywów bramek dostarczanych przez producenta.

Kształt jest zawsze taki sam:

module name(port_list);
    // deklaracje: wire, reg, parameter
    // ciało: przypisania assign, instancje, bloki always
endmodule

Kompletny moduł zbudujemy etapami.

Najmniejszy użyteczny moduł: dwuwejściowa bramka AND

Potrzebujemy czegoś prostego i samodzielnego. Dwuwejściowa bramka AND nadaje się idealnie: dwa wejścia, jedno wyjście, jedna linia logiki.

module and_gate(
    input  wire a,
    input  wire b,
    output wire y
);
    assign y = a & b;
endmodule

module test;
    reg  a, b;
    wire y;

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

    initial begin
        a = 0; b = 0; #1 $display("a=%b b=%b y=%b", a, b, y);
        a = 0; b = 1; #1 $display("a=%b b=%b y=%b", a, b, y);
        a = 1; b = 0; #1 $display("a=%b b=%b y=%b", a, b, y);
        a = 1; b = 1; #1 $display("a=%b b=%b y=%b", a, b, y);
        $finish;
    end
endmodule

Kliknij Uruchom. Powinny pojawić się cztery wiersze tablicy prawdy bramki AND. Przejdźmy przez każdy element.

Czytanie deklaracji modułu

module and_gate(
    input  wire a,
    input  wire b,
    output wire y
);

• module and_gate deklaruje moduł o nazwie and_gate. Pod tą nazwą inne moduły będą tworzyć jego instancje.
• Lista w nawiasach to lista portów, czyli sygnały widoczne z zewnątrz.
• input wire a: a to port wejściowy typu wire (sterowany z zewnątrz).
• output wire y: y to port wyjściowy sterowany przez coś wewnątrz modułu.

Jeśli chcesz pisać zwięźlej, możesz użyć input a zamiast input wire a, bo sam kierunek ustawia domyślny typ wire. Warto jednak wyrobić sobie nawyk pisania jawnie. Pełny zestaw form portów omawia strona Porty modułu.

Ciało

assign y = a & b;

To przypisanie ciągłe. Mówi "za każdym razem, gdy zmieni się a lub b, oblicz y na nowo jako bitowe AND obu sygnałów". Nie ma zegara ani timingu: ta zależność jest prawdziwa zawsze. To czysta logika kombinacyjna.

endmodule zamyka blok. Moduł jest gotowy.

Testbench

Samego and_gate nie da się uruchomić. Potrzebujesz drugiego modułu, który steruje jego wejściami i obserwuje wyjścia. To właśnie testbench, a zwyczajowo nazywa się go test, tb albo <design>_tb.

module test;
    reg  a, b;
    wire y;

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

Warto zauważyć trzy rzeczy:

• Brak listy portów. Testbench to szczyt symulacji: ponad nim nie ma niczego.
• reg a, b i wire y. Wejścia testowanego projektu (DUT) są w testbenchu typu reg, bo sterujemy nimi z bloku proceduralnego. Wyjście jest typu wire, bo steruje nim DUT.
• and_gate dut(.a(a), .b(b), .y(y)). To tworzenie instancji. Wybijamy kopię and_gate i nazywamy ją dut (popularna nazwa od "design under test"). Składnia .a(a) mówi "podłącz port instancji o nazwie a do lokalnego sygnału o nazwie a". Więcej szczegółów znajdziesz na stronie Tworzenie instancji modułów.

Pobudzenie

initial begin
    a = 0; b = 0; #1 $display("a=%b b=%b y=%b", a, b, y);
    a = 0; b = 1; #1 $display("a=%b b=%b y=%b", a, b, y);
    a = 1; b = 0; #1 $display("a=%b b=%b y=%b", a, b, y);
    a = 1; b = 1; #1 $display("a=%b b=%b y=%b", a, b, y);
    $finish;
end

Blok initial wykonuje się raz, na początku symulacji. W jego wnętrzu:

• a = 0; b = 0; ustawia wejścia. To przypisania blokujące: kolejność ma znaczenie, a każde wykonuje się przed następnym.
• #1 przesuwa czas symulacji o 1 jednostkę. Jest to potrzebne, żeby y zdążyło się ustalić po zmianie wejść. Bez #1 $display wypisałoby poprzednią wartość y.
• $display(...) wypisuje tekst w konsoli symulacji. Ciąg formatujący działa jak printf w C: %b to zapis binarny, %d dziesiętny, %h szesnastkowy, a %t to czas symulacji.
• $finish kończy symulację. Bez niego symulator przesuwałby czas w nieskończoność, czekając na zdarzenie, które nigdy nie nadejdzie.

Spróbuj coś zepsuć

Zmień moduł w bramkę OR (zamień & na |) i uruchom ponownie. Tablica prawdy się zmieni. Teraz spróbuj XOR:

module xor_gate(
    input  wire a,
    input  wire b,
    output wire y
);
    assign y = a ^ b;
endmodule

module test;
    reg  a, b;
    wire y;

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

    initial begin
        a = 0; b = 0; #1 $display("a=%b b=%b y=%b", a, b, y);
        a = 0; b = 1; #1 $display("a=%b b=%b y=%b", a, b, y);
        a = 1; b = 0; #1 $display("a=%b b=%b y=%b", a, b, y);
        a = 1; b = 1; #1 $display("a=%b b=%b y=%b", a, b, y);
        $finish;
    end
endmodule

Ten sam szkielet. Inny operator. Na tym polega cała zabawa z logiką kombinacyjną: zadeklaruj porty, napisz przypisania assign, przejdź przez wszystkie wejścia, obserwuj wyjścia.

Moduł z dwoma wyjściami

Moduły mogą mieć więcej niż jedno wyjście. Oto półsumator: dwa wejścia, suma i przeniesienie:

module half_adder(
    input  wire a,
    input  wire b,
    output wire sum,
    output wire carry
);
    assign sum   = a ^ b;
    assign carry = a & b;
endmodule

module test;
    reg  a, b;
    wire sum, carry;

    half_adder dut(.a(a), .b(b), .sum(sum), .carry(carry));

    initial begin
        a = 0; b = 0; #1 $display("%b + %b = %b%b", a, b, carry, sum);
        a = 0; b = 1; #1 $display("%b + %b = %b%b", a, b, carry, sum);
        a = 1; b = 0; #1 $display("%b + %b = %b%b", a, b, carry, sum);
        a = 1; b = 1; #1 $display("%b + %b = %b%b", a, b, carry, sum);
        $finish;
    end
endmodule

Dwie instrukcje assign stoją obok siebie, ale działają równolegle: nie ma "najpierw oblicz sum, potem carry". Obie są prawdziwe zawsze. To współbieżność, o której mówiliśmy na stronie Sprzęt a oprogramowanie, tym razem w konkretnej postaci.

Co już wiesz

Znasz cały szkielet pliku Verilog: moduł projektu z zadeklarowanymi portami i ciałem oraz moduł testbencha, który tworzy jego instancję, steruje wejściami w bloku initial i raportuje wyniki. Prawie każdy plik źródłowy Veriloga, jaki przeczytasz, pasuje do tego szablonu. Reszta języka to już tylko bogatsza logika, sygnały wielobitowe, zachowanie taktowane zegarem i większe testbenche.

Następnie: komentarze i styl kodu, żeby moduły pozostały czytelne, gdy rosną.