Тактируемая логика в Verilog: flip-flop, регистры и pipelines

Базовый блок: D flip-flop

Всё в синхронном проектировании сводится к одному крошечному куску железа: D flip-flop. У него есть clock-вход, data-вход и data-выход. На каждом нарастающем фронте clock он захватывает значение D и держит его до следующего фронта. Это всё.

В Verilog:

always @(posedge clk) begin
    q <= d;
end

Три строки, один flip-flop. <= - non-blocking, что ровно соответствует поведению реальных flip-flop (разбираем в Blocking vs Non-blocking). Sensitivity posedge clk делает его последовательностным.

Сложив много таких с комбинационной логикой между ними, получишь любую синхронную схему, которую захочется построить.

Регистр с reset

Реальные проекты всегда нуждаются в reset - способе привести систему в известное состояние при включении или по запросу:

module reg_with_reset #(
    parameter WIDTH = 8
)(
    input  wire             clk,
    input  wire             reset,
    input  wire [WIDTH-1:0] d,
    output reg  [WIDTH-1:0] q
);
    always @(posedge clk) begin
        if (reset) q <= 0;
        else       q <= d;
    end
endmodule

module test;
    reg clk = 0;
    reg reset = 1;
    reg [7:0] d;
    wire [7:0] q;

    reg_with_reset dut(.clk(clk), .reset(reset), .d(d), .q(q));

    always #5 clk = ~clk;

    initial begin
        d = 8'hA5;
        #20 reset = 0;
        #10 d = 8'h3C;
        #10 d = 8'hFF;
        #20 $finish;
    end

    always @(posedge clk)
        $display("t=%0t reset=%b d=%h q=%h", $time, reset, d, q);
endmodule

Это синхронный reset - условие reset вычисляется на фронте clock как любой другой вход. Синтезатор выдаёт flip-flop с 2-to-1 mux на data-входе: когда reset high, mux подаёт ноль; иначе подаёт d.

Для большинства проектов синхронный reset - правильный выбор. Проще по timing, играет хорошо с FPGA, и reset-сигнал может прийти откуда угодно - ему не нужен свой clock-выровненный источник.

Регистр с enable

Часто хочется регистр, который обновляется, только когда что-то ему скажет. Используй if внутри тактируемого блока и положись на неявное "держи прежнее значение" пропущенного else:

module reg_with_enable(
    input  wire       clk,
    input  wire       reset,
    input  wire       enable,
    input  wire [7:0] d,
    output reg  [7:0] q
);
    always @(posedge clk) begin
        if (reset)       q <= 8'd0;
        else if (enable) q <= d;
        // Нет else - q держит прежнее значение, что и делает FF
    end
endmodule

Это канонический "load-enabled-регистр". Встречается везде - конфигурационные регистры, pipeline-стадии, которые продвигаются только когда downstream готов, счётчики, которые ставятся на паузу и возобновляются. Опущение последнего else намеренно и безопасно внутри тактируемого блока: flip-flop уже помнит прежнее значение, так что "ничего не делать" значит "держать".

В комбинационном блоке тот же код вывел бы latch. Разные правила, тот же синтаксис.

Счётчик

Счётчик - регистр, чьё следующее значение - текущее плюс один:

module counter #(
    parameter WIDTH = 4
)(
    input  wire             clk,
    input  wire             reset,
    input  wire             enable,
    output reg  [WIDTH-1:0] count
);
    always @(posedge clk) begin
        if (reset)        count <= 0;
        else if (enable)  count <= count + 1;
    end
endmodule

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

    counter #(.WIDTH(4)) dut(.clk(clk), .reset(reset), .enable(enable), .count(count));

    always #5 clk = ~clk;

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

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

Счётчик инкрементируется на каждом такте, когда enable high. После 16 тактов оборачивается обратно в 0 (потому что мы объявили 4 бита, и 15 + 1 переполняется в 0). Это оборачивание - суть N-битной арифметики и ровно то, как ведёт себя настоящий аппаратный счётчик.

Shift register

Сложив flip-flop, получаешь shift register. Трюк - делать все сдвиги в одном non-blocking операторе:

module shift_register #(
    parameter WIDTH = 4
)(
    input  wire             clk,
    input  wire             reset,
    input  wire             in,
    output reg  [WIDTH-1:0] out
);
    always @(posedge clk) begin
        if (reset) out <= 0;
        else       out <= {out[WIDTH-2:0], in};
    end
endmodule

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

    shift_register #(.WIDTH(4)) dut(.clk(clk), .reset(reset), .in(in), .out(out));

    always #5 clk = ~clk;

    initial begin
        #12 reset = 0;
        in = 1; #10;
        in = 0; #10;
        in = 1; #10;
        in = 1; #10;
        in = 0; #40 $finish;
    end

    always @(posedge clk)
        $display("t=%0t in=%b out=%b", $time, in, out);
endmodule

Тело - out <= {out[WIDTH-2:0], in} - конкатенируем младшие биты текущего out с новым in и присваиваем всё это. Поскольку это non-blocking, RHS читает старое out до того, как LHS обновляется. Эффект - чистый N-битный сдвиг за один такт.

Это паттерн shift-register в самой маленькой форме. Обобщается на LFSR, serial-передатчики, deserializers - любой проект, где данные движутся через цепочку flip-flop на каждом такте.

Pipelines

Pipeline - цепочка регистров, разделённых комбинационной логикой. Каждая стадия обрабатывает данные с предыдущей и кормит следующую:

module pipelined_add(
    input  wire        clk,
    input  wire        reset,
    input  wire [7:0]  a, b, c, d,
    output reg  [9:0]  result
);
    reg [8:0] stage1_ab, stage1_cd;
    reg [9:0] stage2;

    always @(posedge clk) begin
        if (reset) begin
            stage1_ab <= 0;
            stage1_cd <= 0;
            stage2    <= 0;
            result    <= 0;
        end else begin
            // Стадия 1: два параллельных сложения.
            stage1_ab <= a + b;
            stage1_cd <= c + d;
            // Стадия 2: комбинируем две частичные суммы.
            stage2    <= stage1_ab + stage1_cd;
            // Стадия 3: пробрасываем на выход.
            result    <= stage2;
        end
    end
endmodule

module test;
    reg clk = 0;
    reg reset = 1;
    reg [7:0] a, b, c, d;
    wire [9:0] result;

    pipelined_add dut(.clk(clk), .reset(reset), .a(a), .b(b), .c(c), .d(d), .result(result));

    always #5 clk = ~clk;

    initial begin
        a = 0; b = 0; c = 0; d = 0;
        #12 reset = 0;
        a = 10; b = 20; c = 30; d = 40; #10;
        a = 1;  b = 2;  c = 3;  d = 4;  #10;
        a = 5;  b = 5;  c = 5;  d = 5;  #40;
        $finish;
    end

    always @(posedge clk)
        $display("t=%0t a=%0d b=%0d c=%0d d=%0d result=%0d", $time, a, b, c, d, result);
endmodule

Три стадии, три такта latency, но новый результат каждый такт, как только pipeline полный. Latency - 3 такта, потому что данные проходят через три flip-flop; throughput - 1 операция за такт, потому что все три стадии работают одновременно над разными входами.

Так высокопроизводительные проекты достигают целевого throughput: держи стадии короткими, делай pipeline глубже и позволь параллелизму делать работу.

Асинхронный reset (когда нужен)

Иногда нельзя ждать фронта clock, чтобы выставить reset - чип отключается, clock залочен, внешний watchdog дёргает линию. В этих случаях:

always @(posedge clk or negedge reset_n) begin
    if (~reset_n) q <= 0;
    else          q <= d;
end

В sensitivity list теперь и фронт clock, и фронт reset. Flip-flop реагирует немедленно на любое. reset_n по соглашению active-low (выставлен, когда low), поэтому проверка ~reset_n.

У асинхронного reset есть компромиссы: сложнее timing-анализ, может вызвать metastability при снятии, если не обрабатывать аккуратно, не портируется на все FPGA-архитектуры. По умолчанию - синхронный, асинхронный - только когда проект требует.

Что дальше

Теперь умеешь строить любой синхронный datapath. Следующий документ - Finite State Machines - собирает тактируемый регистр с case-оператором и даёт стандартную идиому FSM: рабочая лошадка любого контроллера, протокольного движка и блока принятия решений в цифровом проектировании.