Always-блок в Verilog: комбинационная и последовательностная логика

Рабочая лошадка behavioral-Verilog

assign описывает комбинационную логику из одного уравнения. Как только нужны if/else, case или память - тянешься к always. Always-блок - это процедурный код, который перезапускается, когда меняются определённые сигналы. Сигналы, инициирующие перезапуск, - это sensitivity list.

Чаще всего встретишь две формы always:

1. always @(*) - перезапускается, когда любой читаемый в блоке сигнал меняется. Строит комбинационную логику.
2. always @(posedge clk) - перезапускается только на нарастающем фронте clk. Строит тактируемую последовательностную логику (flip-flop).

Существуют и другие формы (@(a or b), @(negedge clk), @(posedge clk or negedge reset_n)), но две выше покрывают почти каждый синтезируемый блок, который ты напишешь.

Комбинационный always @(*)

module decoder3(
    input  wire [2:0] sel,
    output reg  [7:0] out
);
    always @(*) begin
        case (sel)
            3'd0: out = 8'b0000_0001;
            3'd1: out = 8'b0000_0010;
            3'd2: out = 8'b0000_0100;
            3'd3: out = 8'b0000_1000;
            3'd4: out = 8'b0001_0000;
            3'd5: out = 8'b0010_0000;
            3'd6: out = 8'b0100_0000;
            3'd7: out = 8'b1000_0000;
            default: out = 8'b0;
        endcase
    end
endmodule

module test;
    reg [2:0] sel;
    wire [7:0] out;
    decoder3 dut(.sel(sel), .out(out));

    initial begin
        for (integer i = 0; i < 8; i = i + 1) begin
            sel = i[2:0];
            #1 $display("sel=%0d out=%b", sel, out);
        end
        $finish;
    end
endmodule

Три вещи, которые стоит заметить:

• out - это reg. Всё, чему присваивают внутри always, должно быть reg. Ключевое слово не значит "это flip-flop"; здесь оно просто значит "пишу из процедурного блока".
• always @(*). * говорит "просыпайся, когда меняется всё, что я читаю". Симулятор сам выводит sensitivity list. Можно написать список вручную - always @(sel) - но @(*) безопаснее, потому что пропущенный сигнал - классический источник багов.
• Никакого clock. Этот блок описывает комбинационную логику. Синтезатор выдаёт кусок логики, который вычисляет out из sel напрямую - без flip-flop, без clock-пина.

Случай default не опционален по сути, хотя опционален по синтаксису. Опусти его - и любое неуказанное значение оставит out со старым значением, что синтезируется в нежелательный latch. Всегда включай default.

Последовательностный always @(posedge clk)

module counter4(
    input  wire       clk,
    input  wire       reset,
    output reg  [3:0] count
);
    always @(posedge clk) begin
        if (reset) count <= 4'd0;
        else       count <= count + 4'd1;
    end
endmodule

module test;
    reg clk = 0;
    reg reset = 1;
    wire [3:0] count;

    counter4 dut(.clk(clk), .reset(reset), .count(count));

    always #5 clk = ~clk;

    initial begin
        #12 reset = 0;
        #80 $finish;
    end

    always @(posedge clk)
        $display("t=%0t count=%0d", $time, count);
endmodule

Ключевые отличия от комбинационной версии:

• always @(posedge clk). Блок перезапускается только на нарастающем фронте clk. Между фронтами ничего не происходит.
• Non-blocking присваивание <=. Внутри тактируемого блока это правильный оператор. Он говорит "запланируй count принять новое значение в конце временного шага", что и есть поведение flip-flop. Почему и альтернатива - в Blocking vs Non-blocking.
• default не нужен. if покрывает обе ветки (reset и не-reset). Риска latch нет.

Синтезатор видит этот силуэт - тактируемая sensitivity, non-blocking присваивание - и выдаёт 4-битный регистр (четыре flip-flop) плюс комбинационную логику, считающую count + 1, и mux, выбирающий между reset и инкрементом.

Разница для синтеза

Один и тот же исходник module может описать два совершенно разных куска железа в зависимости от формы always-блока:

Блок	Железо
always @(*) y = expr;	Чистая комбинационная логика. Без памяти.
always @(posedge clk) y <= expr;	Flip-flop. Захватывает expr раз за такт.
always @(*) if (en) y = expr;	Latch - обычно баг. "Else"-ветка сохраняет старое значение.
always @(posedge clk) if (en) y <= expr;	Flip-flop с enable. Захватывает только когда en high.

Третий случай - latch-ловушка. Latch - прозрачная ячейка памяти, которая держит свой выход, когда вход не выставлен - полезен в специфических проектах, почти всегда баг при случайном появлении. Большинство синтезаторов громко предупреждают, когда выводят latch, который ты не просил. Относись к warning как к ошибке.

Варианты sensitivity list

Встретишь несколько менее частых:

• always @(a or b or c) - явный список. Verilog-2001 добавил разделитель ,: always @(a, b, c). Работает и то, и то.
• always @(posedge clk or negedge reset_n) - асинхронный reset. Блок срабатывает на нарастающем фронте clock или ниспадающем фронте reset. Используется, когда reset должен сработать немедленно, не дожидаясь следующего clock.
• always @(negedge clk) - тактирование по падающему фронту. Редко; некоторые проекты используют для "negative-edge-triggered" flip-flop, захватывающих на падающем, а не на нарастающем.

Для новых проектов предпочитай always @(*) для комбинационной и always @(posedge clk) для последовательностной. К асинхронному reset тянись только когда дизайн реально требует.

Два блока - два куска железа

Несколько always-блоков в одном module независимы - каждый становится своим куском железа:

module two_blocks(
    input  wire       clk,
    input  wire       reset,
    input  wire [7:0] in,
    output reg  [7:0] reg_out,    // последовательностный
    output reg  [7:0] comb_out    // комбинационный
);
    always @(posedge clk) begin
        if (reset) reg_out <= 8'd0;
        else       reg_out <= in;
    end

    always @(*) begin
        comb_out = in ^ 8'hFF;     // побитовая инверсия
    end
endmodule

module test;
    reg clk = 0, reset = 1;
    reg [7:0] in;
    wire [7:0] reg_out, comb_out;

    two_blocks dut(.clk(clk), .reset(reset), .in(in),
                   .reg_out(reg_out), .comb_out(comb_out));

    always #5 clk = ~clk;

    initial begin
        in = 8'h00; #12 reset = 0;
        in = 8'hA5; #10;
        in = 8'h3C; #10;
        $finish;
    end

    always @(posedge clk)
        $display("t=%0t in=%h reg_out=%h comb_out=%h",
                 $time, in, reg_out, comb_out);
endmodule

Тактируемый блок даёт flip-flop-регистр. Комбинационный - XOR-вентиль. Они живут бок о бок; ни один не знает о другом. Два выхода меняются по совершенно разным графикам.

Что always-блоки не могут

Несколько вещей, выглядящих заманчиво, но запрещённых:

• Присваивать wire: цель должна быть reg. Компилятор обеспечивает.
• Присваивать одному reg из двух разных always-блоков: даёт undefined-поведение в симуляции и не синтезируется. Один driver на сигнал.
• Читать и писать один и тот же сигнал в одном комбинационном блоке так, чтобы создать петлю обратной связи: always @(*) x = x + 1; - это zero-delay-петля, которую симулятор не может разрешить.

Первые два ловит компилятор. Третье иногда проявляется только в момент симуляции как зависание.

Что дальше

Следующий документ - Initial Block - разбирает родственника always: блок, который срабатывает ровно один раз при старте симуляции. Это рабочая лошадка testbench. После - правила blocking vs non-blocking, которые определяют, делает ли твой тактируемый блок то, что ты хотел.