Clocked Logic em Verilog: Flip-Flops, Registers e Pipelines

O bloco de construção: Um flip-flop D

Tudo em design síncrono volta para uma pequena peça de hardware: o flip-flop D. Ele tem uma entrada de clock, uma entrada de dados e uma saída de dados. Em cada borda de subida do clock, captura o valor de D e o mantém até a próxima borda. Só isso.

Em Verilog:

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

Três linhas, um flip-flop. O <= é non-blocking, que é exatamente o comportamento de flip-flops reais (coberto em Blocking vs Non-blocking). A sensitivity posedge clk é o que o torna sequencial.

Empilhe muitos desses com lógica combinacional entre eles e você tem qualquer circuito síncrono que quisesse construir.

Um register com reset

Designs reais sempre precisam de um reset - uma forma de colocar o sistema em um estado conhecido no power-on ou sob demanda:

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

Esse é um reset síncrono - a condição de reset é avaliada em uma borda de clock como qualquer outra entrada. O sintetizador produz um flip-flop com um mux 2-para-1 em sua entrada de dados: quando reset é alto, o mux alimenta zero; caso contrário alimenta d.

Para a maioria dos designs, reset síncrono é a escolha certa. É timing mais simples, funciona bem com FPGAs e o sinal de reset pode vir de qualquer lugar - não precisa de sua própria fonte alinhada ao clock.

Um register com enable

Frequentemente você quer um register que só atualiza quando algo diz a ele. Use um if dentro do bloco clocked e confie no comportamento implícito de "manter valor anterior" do else ausente:

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;
        // Sem else - q mantem seu valor anterior, que e o que um FF faz
    end
endmodule

Esse é o canônico "register com load-enable". Aparece em todo lugar - registers de configuração, estágios de pipeline que só avançam quando o downstream está pronto, contadores que pausam e retomam. A omissão do else final é deliberada e segura dentro de um bloco clocked: um flip-flop já lembra seu valor anterior, então "não fazer nada" significa "manter".

Em um bloco combinacional o mesmo código inferiria um latch. Regras diferentes, mesma sintaxe.

Um contador

Um contador é um register cujo próximo valor é seu valor atual mais um:

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

O contador incrementa em cada ciclo de clock quando enable é alto. Depois de 16 ciclos volta para 0 (porque declaramos 4 bits e 15 + 1 dá overflow para 0). Esse wrap é intrínseco à aritmética de N bits e é exatamente como um contador de hardware real se comporta.

Um shift register

Empilhar flip-flops te dá um shift register. O truque é fazer todos os shifts em uma declaração 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

O corpo é out <= {out[WIDTH-2:0], in} - concatena os bits mais baixos do out atual com o novo in, e atribui o todo. Como é non-blocking, o RHS lê o out antigo antes do LHS atualizar. O efeito é um shift limpo de N bits em um único ciclo de clock.

Esse é o padrão de shift register em sua forma menor. Generaliza para LFSRs, transmissores seriais, deserializers - qualquer design onde dados se movem por uma cadeia de flip-flops a cada clock.

Pipelines

Um pipeline é uma cadeia de registers separados por lógica combinacional. Cada estágio processa dados do estágio anterior e alimenta o próximo:

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
            // Estagio 1: duas somas paralelas.
            stage1_ab <= a + b;
            stage1_cd <= c + d;
            // Estagio 2: combina as duas somas parciais.
            stage2    <= stage1_ab + stage1_cd;
            // Estagio 3: encaminha para a saida.
            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

Três estágios, três ciclos de latência, mas um novo resultado a cada ciclo uma vez que o pipeline esteja cheio. A latência é 3 clocks porque os dados passam por três flip-flops; o throughput é 1 operação por clock porque os três estágios trabalham simultaneamente em entradas diferentes.

É assim que designs de alta performance atingem suas metas de throughput: mantenha estágios curtos, faça pipeline mais profundo e deixe o paralelismo fazer o trabalho.

Reset assíncrono (quando você precisa)

Às vezes você não pode esperar uma borda de clock para asserir reset - o chip está sendo desligado, o clock está gated, um watchdog externo está puxando a linha. Nesses casos:

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

A sensitivity list agora tem uma borda de clock e uma borda de reset. O flip-flop responde imediatamente a qualquer um. reset_n é por convenção active-low (asserido quando baixo), que é o porquê do teste ser ~reset_n.

Reset assíncrono tem trade-offs: mais difícil de analisar timing, pode causar metaestabilidade se não for tratado cuidadosamente na des-asserção, não é portável entre todas as arquiteturas de FPGA. Use reset síncrono por padrão, assíncrono só quando o design exigir.

O que vem a seguir

Você agora consegue construir qualquer datapath síncrono. O próximo doc - Finite State Machines - junta um register clocked com uma declaração case para produzir o idioma padrão de FSM: o burro de carga de cada controlador, engine de protocolo e bloco de tomada de decisão em design digital.