Bloc always Verilog : logique combinatoire et séquentielle

Le pilier du Verilog comportemental

assign décrit de la logique combinatoire à équation unique. Dès que tu as besoin de if/else, case ou de mémoire, tu vas chercher always. Un bloc always est un morceau de code procédural qui se ré-exécute quand des signaux spécifiques changent. Les signaux qui déclenchent la ré-exécution sont la liste de sensibilité.

Il y a deux formes de always que tu verras le plus souvent :

1. always @(*) - se ré-exécute quand n'importe quel signal lu dans le bloc change. Construit de la logique combinatoire.
2. always @(posedge clk) - se ré-exécute seulement au front montant de clk. Construit de la logique séquentielle cadencée (flip-flops).

D'autres formes existent (@(a or b), @(negedge clk), @(posedge clk or negedge reset_n)) mais les deux ci-dessus représentent presque tous les blocs synthétisables que tu écriras.

always @(*) combinatoire

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

Trois choses à remarquer :

• out est reg. Tout ce qui est assigné à l'intérieur de always doit être reg. Le mot-clé ne veut pas dire « c'est un flip-flop » ; ici ça veut juste dire « je suis écrit depuis un bloc procédural ».
• always @(*). Le * dit « réveille-toi quand quoi que ce soit que je lis change ». Le simulateur calcule automatiquement la liste de sensibilité. Tu peux écrire la liste manuellement - always @(sel) - mais @(*) est plus sûr car oublier un signal est une source classique de bugs.
• Pas d'horloge. Ce bloc décrit de la logique combinatoire. Le synthétiseur produit une portion de logique qui calcule out à partir de sel directement - pas de flip-flop, pas de broche d'horloge nécessaire.

Le cas default n'est pas optionnel dans l'esprit même s'il est optionnel dans la syntaxe. Omets-le et n'importe quelle valeur d'entrée non spécifiée laisse out conserver sa valeur précédente - ce qui se synthétise en un latch involontaire. Inclus toujours le default.

always @(posedge clk) séquentiel

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

Les différences clés par rapport à la version combinatoire :

• always @(posedge clk). Le bloc ne se ré-exécute qu'au front montant de clk. Rien ne se passe entre les fronts.
• Assignation non-blocking <=. À l'intérieur d'un bloc cadencé, c'est le bon opérateur. Il dit « planifie count pour prendre sa nouvelle valeur à la fin du pas de temps », ce qui est exactement le comportement d'un flip-flop. Le pourquoi et l'alternative sont dans Blocking vs Non-blocking.
• Pas besoin de default. Le if couvre les deux branches (reset et non-reset). Pas de risque de latch.

Le synthétiseur voit cette forme - sensibilité cadencée, assignation non-blocking - et produit un registre 4 bits (quatre flip-flops) plus la logique combinatoire qui calcule count + 1 et le mux qui choisit entre reset et incrément.

La distinction de synthèse

Le même source de module peut décrire deux morceaux de matériel complètement différents selon la forme du bloc always :

Bloc	Matériel
always @(*) y = expr;	Logique combinatoire pure. Pas de mémoire.
always @(posedge clk) y <= expr;	Flip-flop. Capture expr une fois par cycle d'horloge.
always @(*) if (en) y = expr;	Latch - généralement un bug. Le cas « else » garde l'ancienne valeur.
always @(posedge clk) if (en) y <= expr;	Flip-flop avec enable. Ne capture que quand en est haut.

Le troisième cas est le piège du latch. Un latch est une cellule mémoire transparente qui maintient sa sortie quand l'entrée n'est pas assertée - utile dans des designs spécifiques, presque toujours un bug quand accidentel. La plupart des outils de synthèse warnent fort quand ils infèrent un latch que tu n'as pas demandé. Traite le warning comme une erreur.

Variantes de liste de sensibilité

Tu verras quelques listes de sensibilité moins courantes :

• always @(a or b or c) - liste explicite. Verilog-2001 a ajouté le séparateur , : always @(a, b, c). L'un comme l'autre marche.
• always @(posedge clk or negedge reset_n) - reset asynchrone. Le bloc tourne sur un front montant d'horloge ou un front descendant de reset. Utilisé quand le reset doit prendre effet immédiatement, sans attendre la prochaine horloge.
• always @(negedge clk) - cadencement sur front descendant. Rare ; certains designs l'utilisent pour des flip-flops « déclenchés par front descendant » qui capturent sur le front descendant au lieu du montant.

Pour les nouveaux designs, préfère always @(*) pour le combinatoire et always @(posedge clk) pour le séquentiel. Ne tends la main vers le reset asynchrone que quand le design en a vraiment besoin.

Deux blocs sont deux morceaux de matériel

Plusieurs blocs always dans le même module sont indépendants - chacun devient son propre morceau de matériel :

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

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

Le bloc cadencé produit un registre flip-flop. Le bloc combinatoire produit une porte XOR. Ils vivent côte à côte ; aucun ne connaît l'autre. Les deux sorties changent selon des plannings complètement différents.

Ce que les blocs always ne peuvent pas faire

Quelques choses qui paraissent tentantes mais ne sont pas permises :

• Assigner à un wire : la cible doit être reg. Le compilateur l'impose.
• Assigner au même reg depuis deux blocs always différents : produit un comportement indéfini en simulation et ne se synthétisera pas. Un pilote par signal.
• Lire et écrire le même signal dans le même bloc combinatoire d'une façon qui crée une boucle de feedback : always @(*) x = x + 1; est une boucle à délai zéro que le simulateur ne peut pas résoudre.

Les deux premiers, le compilateur les attrape. Le troisième n'apparaît parfois qu'à la simulation comme un hang.

La suite

Le prochain document - Bloc initial - couvre le frère de always : un bloc qui tourne exactement une fois au démarrage de la simulation. C'est le pilier des testbenches. Ensuite, les règles de blocking vs non-blocking qui décident si ton bloc cadencé fait ce que tu voulais.