Lógica sincronizada por reloj en Verilog: flip-flops, registros y pipelines

El bloque fundamental: un flip-flop D

Todo en diseño síncrono vuelve a una pequeña pieza de hardware: el flip-flop D. Tiene una entrada de reloj, una entrada de datos y una salida de datos. En cada flanco de subida del reloj, captura el valor de D y lo mantiene hasta el siguiente flanco. Eso es todo.

En Verilog:

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

Tres líneas, un flip-flop. El <= es no bloqueante, que es exactamente el comportamiento de los flip-flops reales (cubierto en Blocking vs Non-blocking). La sensibilidad posedge clk es lo que lo hace secuencial.

Apila muchos de estos con lógica combinacional entre medio y tienes cualquier circuito síncrono que quieras construir.

Un registro con reset

Los diseños reales siempre necesitan un reset - una forma de poner el sistema en un estado conocido al encender o bajo 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

Ese es un reset síncrono - la condición de reset se evalúa en un flanco de reloj como cualquier otra entrada. El sintetizador produce un flip-flop con un mux 2 a 1 en su entrada de datos: cuando reset está en alto, el mux alimenta cero; si no, alimenta d.

Para la mayoría de los diseños, el reset síncrono es la elección correcta. Tiene timing más simple, va bien con FPGAs, y la señal de reset puede venir de cualquier parte - no necesita su propia fuente alineada con el reloj.

Un registro con enable

A menudo quieres un registro que solo se actualice cuando algo se lo dice. Usa un if dentro del bloque sincronizado, y confía en el comportamiento implícito "mantener el valor anterior" del 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;
        // No else - q holds its previous value, which is what a FF does
    end
endmodule

Este es el "registro con carga habilitada" canónico. Aparece por todas partes - registros de configuración, etapas de pipeline que solo avanzan cuando el downstream está listo, contadores que pausan y reanudan. La omisión del else final es deliberada y segura dentro de un bloque sincronizado: un flip-flop ya recuerda su valor anterior, así que "no hacer nada" significa "mantener".

En un bloque combinacional el mismo código inferiría un latch. Reglas distintas, misma sintaxis.

Un contador

Un contador es un registro cuyo siguiente valor es su valor actual más uno:

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

El contador se incrementa en cada ciclo de reloj cuando enable está en alto. Tras 16 ciclos vuelve a 0 (porque declaramos 4 bits y 15 + 1 desborda a 0). Ese wrap-around es intrínseco a la aritmética de N bits y es exactamente cómo se comporta un contador hardware real.

Un shift register

Apilar flip-flops te da un shift register. El truco es hacer todos los desplazamientos en una única sentencia no bloqueante:

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

El cuerpo es out <= {out[WIDTH-2:0], in} - concatena los bits inferiores del out actual con el nuevo in, y asigna todo. Como es no bloqueante, el RHS lee el out antiguo antes de que el LHS se actualice. El efecto es un shift limpio de N bits en un único ciclo de reloj.

Este es el patrón de shift register en su forma más pequeña. Se generaliza a LFSRs, transmisores serie, deserializadores - cualquier diseño donde los datos se mueven a través de una cadena de flip-flops en cada reloj.

Pipelines

Un pipeline es una cadena de registros separados por lógica combinacional. Cada etapa procesa datos de la etapa anterior y alimenta a la siguiente:

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
            // Stage 1: two parallel adds.
            stage1_ab <= a + b;
            stage1_cd <= c + d;
            // Stage 2: combine the two partial sums.
            stage2    <= stage1_ab + stage1_cd;
            // Stage 3: forward to output.
            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

Tres etapas, tres ciclos de latencia, pero un resultado nuevo cada ciclo una vez que el pipeline está lleno. La latencia es de 3 ciclos porque los datos pasan por tres flip-flops; el throughput es de 1 operación por reloj porque las tres etapas trabajan simultáneamente con entradas distintas.

Así es como los diseños de alto rendimiento alcanzan sus objetivos de throughput: mantén las etapas cortas, segmenta más profundamente y deja que el paralelismo haga el trabajo.

Reset asíncrono (cuando lo necesites)

A veces no puedes esperar a un flanco de reloj para activar el reset - el chip se está apagando, el reloj está bloqueado, un watchdog externo está tirando de la línea. En esos casos:

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

La lista de sensibilidad ahora tiene tanto un flanco de reloj como un flanco de reset. El flip-flop responde inmediatamente a cualquiera. reset_n por convención es activo en bajo (activado cuando está en bajo), por eso el test es ~reset_n.

El reset asíncrono tiene contrapartidas: análisis de tiempo más difícil, puede causar metaestabilidad si no se maneja con cuidado al desactivarse, no portable entre todas las arquitecturas FPGA. Usa reset síncrono por defecto, async solo cuando el diseño lo requiera.

Qué viene a continuación

Ya puedes construir cualquier datapath síncrono. El siguiente doc - Finite State Machines - junta un registro sincronizado con una sentencia case para producir el modismo estándar de FSM: el caballo de batalla de cada controlador, motor de protocolo y bloque de toma de decisiones en diseño digital.