Przypisanie ciągłe w Verilogu: instrukcja assign

assign opisuje stałą prawdę

Deklaracja wire tworzy sygnał. assign opisuje, co nim steruje. Ta zależność jest ciągła: lewa strona jest równa temu, co jest po prawej stronie, w każdej chwili czasu symulacji:

wire y;
assign y = a & b;

Z tej pary linii wynikają dwie rzeczy:

• y istnieje w układzie jako przewód (wire).
• y jest w każdej chwili bitowym AND z a i b. Zmień którekolwiek wejście, a y podąży za nim.

Nie ma zegara ani zdarzenia wyzwalającego aktualizację. Symulator widzi zmianę a albo b, oznacza y jako nieaktualne i ponownie oblicza wyrażenie. W sprzęcie odpowiada to kilku bramkom AND: logika kombinacyjna, bez stanu, natychmiastowa.

Forma skrócona

Deklarację i przypisanie możesz połączyć w jednej linii:

wire y = a & b;

To to samo co dwie linie powyżej. Przydaje się dla lokalnych przewodów, które poza tym zakresem nikogo nie interesują. Wiele przewodników stylu wręcz woli formę skróconą, bo umieszcza deklarację tuż obok równania.

Czym może sterować assign

Celem assign musi być typ sieciowy. W zwykłym Verilogu to wire (albo jeden z rzadszych kuzynów, jak tri, wand, wor). Nie może to być reg. Jeśli przypadkiem zadeklarujesz cel jako reg:

reg y;
assign y = a & b;   // ERROR: cannot drive reg with assign

Kompilator ci o tym powie. Zmień cel na wire albo przenieś logikę do bloku always @(*), w którym reg jest dozwolonym celem.

Prawa strona może być czymkolwiek, co daje wartość: literałami, sygnałami, parametrami, wyrażeniami z operatorami, wywołaniami funkcji. Może łączyć wejścia o różnych szerokościach, a obowiązują standardowe reguły poszerzania.

Kiedy assign, a kiedy always

Oba mogą tworzyć logikę kombinacyjną. Wybór dotyczy głównie tego, jak czyta się kod:

• assign sprawdza się najlepiej, gdy zależność to jedno wyrażenie. Sumatory, proste multipleksery zbudowane z ?:, maski, bity parzystości, wszystko, co zapiszesz w jednej linii.
• always @(*) sprawdza się najlepiej, gdy potrzebujesz instrukcji proceduralnych. Wielowariantowe instrukcje case, zagnieżdżone if/else if, wszystko, co zyskuje na nazwanych pośrednich reg. Omawiamy to w artykule Blok always.

Oto ten sam multiplekser 4 na 1 zapisany na oba sposoby:

module mux_assign(
    input  wire [1:0]  sel,
    input  wire [3:0]  in0, in1, in2, in3,
    output wire [3:0]  out
);
    // Chain of conditional operators
    assign out = (sel == 2'd0) ? in0
               : (sel == 2'd1) ? in1
               : (sel == 2'd2) ? in2
               : in3;
endmodule

module mux_always(
    input  wire [1:0]  sel,
    input  wire [3:0]  in0, in1, in2, in3,
    output reg  [3:0]  out
);
    always @(*) begin
        case (sel)
            2'd0: out = in0;
            2'd1: out = in1;
            2'd2: out = in2;
            2'd3: out = in3;
            default: out = 4'bx;
        endcase
    end
endmodule

module test;
    reg [1:0] sel;
    wire [3:0] out_a, out_b;
    wire [3:0] in0 = 4'hA, in1 = 4'hB, in2 = 4'hC, in3 = 4'hD;

    mux_assign A(.sel(sel), .in0(in0), .in1(in1), .in2(in2), .in3(in3), .out(out_a));
    mux_always B(.sel(sel), .in0(in0), .in1(in1), .in2(in2), .in3(in3), .out(out_b));

    initial begin
        for (integer i = 0; i < 4; i = i + 1) begin
            sel = i[1:0];
            #1 $display("sel=%b out_a=%h out_b=%h", sel, out_a, out_b);
        end
        $finish;
    end
endmodule

Oba moduły syntezują się w zasadzie do tego samego multipleksera. Wersja z assign to jedna linia kodu, wersja z always to sześć. Przy czterech wariantach różnica jest niewielka, ale przy szesnastu blok case czyta się wyraźnie łatwiej.

Typowe wzorce

Zwykła logika kombinacyjna

assign sum   = a + b;
assign carry = a[7] & b[7];
assign equal = (data == 8'hFF);

Jedno wyrażenie, jeden przewód. Chleb powszedni assign.

Multiplekser 2 na 1

assign out = sel ? a : b;

Jedno wyrażenie warunkowe, które syntezator zamienia w jeden multiplekser 2 na 1. Najczystszy możliwy zapis "wybierz między a i b".

Pakowanie bitów

assign status = {error, overflow, ready, busy, 4'b0};

Konkatenacja po prawej stronie assign to sposób na spakowanie flag w bajt statusu. Wynik jest obliczany i podawany w sposób ciągły.

Wyjście trójstanowe

assign data_pin = output_enable ? data_out : 1'bz;

Gdy output_enable jest w stanie wysokim, pin jest sterowany. Gdy w niskim, pin przechodzi w stan wysokiej impedancji. To kanoniczny wzorzec na pinach układu, gdzie kilka źródeł może dzielić jeden przewód.

Współbieżność: kilka assign to nie sekwencja

Przypomnienie, które nigdy nie traci aktualności: kilka instrukcji assign w tym samym module działa równolegle. Nie tworzą sekwencji:

assign y = a & b;     // exists at all times
assign z = a | b;     // also exists at all times, independently

Kolejność w pliku nie ma znaczenia. Oba równania są prawdziwe jednocześnie. Syntezator może umieścić bramkę AND przed bramką OR albo po niej, bez znaczenia, bo obie bramki działają ciągle.

Jeśli chcesz zachowania wyglądającego na sekwencyjne, sięgasz po blok always (i zapewne zegar). To temat na inny rozdział.

Wiele źródeł: wzorzec magistrali

Jeden wire może być celem więcej niż jednego assign, ale prawie nigdy tego nie chcesz, z wyjątkiem magistral trójstanowych. Dwa źródła walczące o jeden przewód dają niezdefiniowane zachowanie:

assign y = a;
assign y = b;   // BAD - two drivers, simulator picks one or x's it out

Prawidłowy wzorzec: każde źródło zwalnia linię do z, gdy jest nieaktywne, a w danej chwili aktywne jest najwyżej jedno.

assign bus = device_a_active ? data_from_a : 1'bz;
assign bus = device_b_active ? data_from_b : 1'bz;

To działa, bo w każdej chwili najwyżej jedno z dwóch wyrażeń warunkowych daje wartość inną niż z. Faktyczna wartość przewodu pochodzi z tego źródła, które nie zwalnia linii.

W logice wewnętrznej, czyli wszędzie poza pinami układu i współdzielonymi magistralami w układzie, każdy przewód ma jedno źródło. Błędy z wieloma źródłami są paskudne do debugowania.

Czego assign nie potrafi

Do niektórych rzeczy assign jest złym narzędziem:

• Przechowywanie. assign opisuje zależności kombinacyjne i nie może wprowadzić przerzutnika. Jeśli wartość ma być pamiętana między cyklami zegara, potrzebujesz bloku always @(posedge clk).
• Wieloetapowa logika proceduralna. Wewnątrz assign nie napiszesz if/else ani case. Najbliżej jest łańcuch ?:, który powyżej trzech gałęzi robi się brzydki.
• Sterowanie rejestrami z wnętrza bloku proceduralnego. Cele typu reg wymagają przypisania proceduralnego, a nie assign.

Znajomość tych ograniczeń pozwala zdecydować, kiedy przejść na always.

Co dalej

Znasz już całą strukturalną stronę Veriloga: deklarowanie modułów, tworzenie ich instancji i łączenie logiki kombinacyjnej za pomocą assign. Następny rozdział przechodzi do bloków proceduralnych, czyli konstrukcji initial i always, w których zaczynają mieć znaczenie czas i kolejność.