Logica sincrona in Verilog: flip-flop, registri e pipeline

Il mattone di base: il flip-flop D

Tutto il progetto sincrono si riduce a un minuscolo pezzo di hardware: il flip-flop D. Ha un ingresso di clock, un ingresso dati e un'uscita dati. A ogni fronte di salita del clock cattura il valore di D e lo mantiene fino al fronte successivo. Tutto qui.

In Verilog:

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

Tre righe, un flip-flop. <= è l'assegnazione non-blocking, che corrisponde esattamente al comportamento dei flip-flop reali (vedi Blocking vs Non-blocking). È la sensibilità a posedge clk a renderlo sequenziale.

Combinane tanti con logica combinatoria in mezzo e puoi costruire qualsiasi circuito sincrono.

Un registro con reset

I progetti reali hanno sempre bisogno di un reset, cioè di un modo per portare il sistema in uno stato noto all'accensione o su richiesta:

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

Questo è un reset sincrono: la condizione di reset viene valutata sul fronte di clock come qualsiasi altro ingresso. Il sintetizzatore produce un flip-flop con un mux 2 a 1 sull'ingresso dati: quando reset è alto il mux passa zero, altrimenti passa d.

Per la maggior parte dei progetti il reset sincrono è la scelta giusta. Ha una temporizzazione più semplice, si comporta bene sulle FPGA e il segnale di reset può arrivare da qualunque punto, senza bisogno di una sorgente allineata al clock.

Un registro con enable

Spesso vuoi un registro che si aggiorni solo quando qualcosa glielo dice. Usa un if dentro il blocco sincronizzato e affidati al comportamento implicito "mantieni il valore precedente" dovuto all'assenza di 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;
        // No else - q holds its previous value, which is what a FF does
    end
endmodule

È il classico "registro con abilitazione al caricamento". Lo trovi ovunque: registri di configurazione, stadi di pipeline che avanzano solo quando lo stadio a valle è pronto, contatori che si mettono in pausa e ripartono. L'assenza dell'else finale è voluta e sicura dentro un blocco sincronizzato: un flip-flop ricorda già il valore precedente, quindi "non fare nulla" significa "mantieni".

In un blocco combinatorio lo stesso codice dedurrebbe un latch. Regole diverse, stessa sintassi.

Un contatore

Un contatore è un registro il cui valore successivo è quello attuale più 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

Il contatore si incrementa a ogni ciclo di clock quando enable è alto. Dopo 16 cicli torna a 0 (perché abbiamo dichiarato 4 bit e 15 + 1 va in overflow a 0). Questo ritorno a zero è intrinseco all'aritmetica a N bit ed è esattamente il comportamento di un contatore hardware reale.

Uno shift register

Mettendo in fila dei flip-flop ottieni uno shift register. Il trucco è fare tutti gli spostamenti in un'unica istruzione 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

Il corpo è out <= {out[WIDTH-2:0], in}: concatena i bit bassi dell'out attuale con il nuovo in e assegna il tutto. Essendo un'assegnazione non-blocking, il lato destro legge il vecchio out prima che il lato sinistro si aggiorni. L'effetto è uno spostamento pulito di N bit in un solo ciclo di clock.

Questo è il pattern dello shift register nella sua forma minima. Si generalizza a LFSR, trasmettitori seriali, deserializzatori: qualsiasi progetto in cui i dati attraversano una catena di flip-flop a ogni clock.

Pipeline

Una pipeline è una catena di registri separati da logica combinatoria. Ogni stadio elabora i dati dello stadio precedente e alimenta quello successivo:

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

Tre stadi, tre cicli di latenza, ma un nuovo risultato a ogni ciclo quando la pipeline è piena. La latenza è di 3 clock perché i dati attraversano tre flip-flop; il throughput è di 1 operazione per clock perché tutti e tre gli stadi lavorano contemporaneamente su ingressi diversi.

È così che i progetti ad alte prestazioni raggiungono i loro obiettivi di throughput: stadi brevi, pipeline più profonde e il parallelismo che fa il lavoro.

Reset asincrono (quando serve)

A volte non puoi aspettare un fronte di clock per attivare il reset: il chip si sta spegnendo, il clock è disabilitato, un watchdog esterno sta forzando la linea. In questi casi:

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

Ora la lista di sensibilità contiene sia un fronte di clock sia un fronte di reset. Il flip-flop risponde subito a entrambi. Per convenzione reset_n è attivo basso (attivo quando vale zero), ed è per questo che il test è ~reset_n.

Il reset asincrono ha dei compromessi: è più difficile da analizzare nei tempi, può causare metastabilità se il rilascio non è gestito con cura e non è portabile su tutte le architetture FPGA. Usa il reset sincrono come impostazione predefinita e quello asincrono solo quando il progetto lo richiede.

Cosa viene dopo

Ora puoi costruire qualsiasi datapath sincrono. La prossima pagina, Finite State Machines, unisce un registro sincronizzato a un'istruzione case per ottenere l'idioma standard delle FSM: il cavallo da tiro di ogni controller, motore di protocollo e blocco decisionale nel progetto digitale.