Blocco always in Verilog: logica combinatoria e sequenziale

Il cavallo da tiro del Verilog comportamentale

assign descrive logica combinatoria fatta di una sola equazione. Appena ti servono if/else, case o memoria, passi ad always. Un blocco always è un pezzo di codice procedurale che viene rieseguito ogni volta che cambiano determinati segnali. I segnali che fanno scattare la riesecuzione formano la lista di sensibilità.

Le due forme di always che vedrai più spesso sono:

1. always @(*): si riesegue quando cambia qualsiasi segnale letto nel blocco. Costruisce logica combinatoria.
2. always @(posedge clk): si riesegue solo sul fronte di salita di clk. Costruisce logica sequenziale sincronizzata dal clock (flip-flop).

Esistono altre forme (@(a or b), @(negedge clk), @(posedge clk or negedge reset_n)), ma le due qui sopra coprono quasi tutti i blocchi sintetizzabili che scriverai.

always @(*) combinatorio

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

Tre cose da notare:

• out è reg. Tutto ciò che viene assegnato dentro always deve essere reg. La parola chiave non significa "questo è un flip-flop"; qui vuol dire solo "vengo scritto da un blocco procedurale".
• always @(*). L'asterisco * dice "svegliati ogni volta che cambia qualcosa che leggo". Il simulatore ricava da solo la lista di sensibilità. Puoi scriverla a mano, per esempio always @(sel), ma @(*) è più sicuro perché dimenticare un segnale è una classica fonte di bug.
• Nessun clock. Questo blocco descrive logica combinatoria. Il sintetizzatore produce una rete logica che calcola out direttamente da sel: niente flip-flop, nessun pin di clock.

Il caso default è facoltativo nella sintassi, ma non nella sostanza. Se lo ometti, qualsiasi valore di ingresso non previsto lascia out fermo al valore precedente, e questo si sintetizza in un latch indesiderato. Includi sempre il default.

always @(posedge clk) sequenziale

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

Le differenze principali rispetto alla versione combinatoria:

• always @(posedge clk). Il blocco si riesegue solo sul fronte di salita di clk. Tra un fronte e l'altro non succede nulla.
• Assegnazione non bloccante <=. Dentro un blocco sincronizzato dal clock, questo è l'operatore giusto. Dice "fai assumere a count il nuovo valore alla fine del passo temporale", che è esattamente il comportamento di un flip-flop. Il perché e l'alternativa sono in Blocking vs Non-blocking.
• Nessun default necessario. L'if copre entrambi i rami (reset e non reset). Nessun rischio di latch.

Il sintetizzatore riconosce questa forma (sensibilità al clock, assegnazione non bloccante) e produce un registro a 4 bit (quattro flip-flop), più la logica combinatoria che calcola count + 1 e il mux che sceglie tra reset e incremento.

La distinzione in sintesi

Lo stesso sorgente di un modulo può descrivere due pezzi di hardware completamente diversi a seconda della forma del blocco always:

Il terzo caso è la trappola del latch. Un latch è una cella di memoria trasparente che mantiene l'uscita quando l'ingresso non è attivo: utile in progetti specifici, quasi sempre un bug quando nasce per caso. La maggior parte degli strumenti di sintesi avvisa in modo evidente quando deduce un latch che non hai chiesto. Tratta l'avviso come un errore.

Varianti della lista di sensibilità

Ti capiterà di vedere alcune liste di sensibilità meno comuni:

• always @(a or b or c): lista esplicita. Verilog-2001 ha aggiunto il separatore ,: always @(a, b, c). Funzionano entrambe.
• always @(posedge clk or negedge reset_n): reset asincrono. Il blocco si esegue su un fronte di salita del clock oppure su un fronte di discesa del reset. Si usa quando il reset deve avere effetto subito, senza aspettare il clock successivo.
• always @(negedge clk): sincronizzazione sul fronte di discesa. È rara; alcuni progetti la usano per flip-flop "attivati dal fronte negativo", che catturano sul fronte di discesa invece che su quello di salita.

Nei progetti nuovi, preferisci always @(*) per la logica combinatoria e always @(posedge clk) per quella sequenziale. Usa il reset asincrono solo quando il progetto ne ha davvero bisogno.

Due blocchi sono due pezzi di hardware

Più blocchi always nello stesso modulo sono indipendenti: ognuno diventa un pezzo di hardware a sé:

module two_blocks(
    input  wire       clk,
    input  wire       reset,
    input  wire [7:0] in,
    output reg  [7:0] reg_out,    // sequenziale
    output reg  [7:0] comb_out    // combinatorio
);
    always @(posedge clk) begin
        if (reset) reg_out <= 8'd0;
        else       reg_out <= in;
    end

    always @(*) begin
        comb_out = in ^ 8'hFF;     // inversione bit a bit
    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

Il blocco sincronizzato produce un registro di flip-flop. Il blocco combinatorio produce una porta XOR. Convivono fianco a fianco e nessuno dei due sa dell'altro. Le due uscite cambiano con tempi completamente diversi.

Cosa non possono fare i blocchi always

Alcune cose sembrano allettanti ma non sono permesse:

• Assegnare un wire: la destinazione deve essere reg. Il compilatore lo impone.
• Assegnare lo stesso reg da due blocchi always diversi: in simulazione il comportamento è indefinito e il codice non si sintetizza. Un solo driver per segnale.
• Leggere e scrivere lo stesso segnale nello stesso blocco combinatorio creando un anello di retroazione: always @(*) x = x + 1; è un ciclo a ritardo zero che il simulatore non riesce a risolvere.

I primi due li intercetta il compilatore. Il terzo a volte si manifesta solo in simulazione, sotto forma di blocco del simulatore.

Cosa viene dopo

La prossima pagina, Initial Block, tratta il fratello di always: un blocco che si esegue esattamente una volta all'avvio della simulazione. È il cavallo da tiro dei testbench. Subito dopo arrivano le regole sulle assegnazioni bloccanti e non bloccanti, che decidono se il tuo blocco sincronizzato fa davvero ciò che intendevi.