Logique cadencée en Verilog : flip-flops, registres et pipelines

Le bloc de construction : un flip-flop D

Tout en design synchrone revient à un minuscule morceau de matériel : le flip-flop D. Il a une entrée d'horloge, une entrée de données et une sortie de données. À chaque front montant d'horloge, il capture la valeur de D et la maintient jusqu'au front suivant. C'est tout.

En Verilog :

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

Trois lignes, un flip-flop. Le <= est non-blocking, ce qui est exactement le comportement des vrais flip-flops (couvert dans Blocking vs Non-blocking). La sensibilité posedge clk est ce qui le rend séquentiel.

Empile beaucoup de ceux-ci avec de la logique combinatoire entre eux et tu as n'importe quel circuit synchrone que tu voudrais construire.

Un registre avec reset

Les vrais designs ont toujours besoin d'un reset - un moyen de mettre le système dans un état connu au power-on ou à la demande :

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

C'est un reset synchrone - la condition de reset est évaluée sur un front d'horloge comme n'importe quelle autre entrée. Le synthétiseur produit un flip-flop avec un mux 2 vers 1 sur son entrée de données : quand reset est haut, le mux alimente zéro ; sinon il alimente d.

Pour la plupart des designs, le reset synchrone est le bon choix. C'est un timing plus simple, ça joue bien avec les FPGA, et le signal de reset peut venir de n'importe où - il n'a pas besoin de sa propre source alignée sur l'horloge.

Un registre avec enable

Souvent tu veux un registre qui ne se met à jour que quand quelque chose le dit. Utilise un if à l'intérieur du bloc cadencé, et compte sur le comportement implicite « garde la valeur précédente » du else manquant :

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;
        // Pas de else - q garde sa valeur précédente, ce que fait un FF
    end
endmodule

C'est le « registre à load enable » canonique. Il apparaît partout - registres de configuration, étages de pipeline qui n'avancent que quand l'aval est prêt, compteurs qui pausent et reprennent. L'omission du dernier else est délibérée et sûre à l'intérieur d'un bloc cadencé : un flip-flop se souvient déjà de sa valeur précédente, donc « ne rien faire » veut dire « maintenir ».

Dans un bloc combinatoire le même code inférerait un latch. Règles différentes, même syntaxe.

Un compteur

Un compteur est un registre dont la prochaine valeur est sa valeur courante plus un :

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

Le compteur s'incrémente à chaque cycle d'horloge quand enable est haut. Après 16 cycles il revient à 0 (parce qu'on a déclaré 4 bits et 15 + 1 déborde à 0). Ce wrapping est intrinsèque à l'arithmétique N bits et c'est exactement comme se comporte un vrai compteur matériel.

Un registre à décalage

Empiler des flip-flops te donne un registre à décalage. L'astuce est de faire tous les décalages dans une seule instruction 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

Le corps est out <= {out[WIDTH-2:0], in} - concatène les bits bas du out courant avec le nouveau in, et assigne le tout. Comme c'est non-blocking, le RHS lit l'ancien out avant que le LHS ne se mette à jour. L'effet est un décalage N bits propre en un seul cycle d'horloge.

C'est le motif registre à décalage dans sa forme la plus petite. Il se généralise aux LFSR, émetteurs série, désérialiseurs - tout design où les données se déplacent à travers une chaîne de flip-flops à chaque horloge.

Pipelines

Un pipeline est une chaîne de registres séparés par de la logique combinatoire. Chaque étage traite les données de l'étage précédent et alimente le suivant :

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
            // Étage 1 : deux additions parallèles.
            stage1_ab <= a + b;
            stage1_cd <= c + d;
            // Étage 2 : combine les deux sommes partielles.
            stage2    <= stage1_ab + stage1_cd;
            // Étage 3 : transmet à la sortie.
            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

Trois étages, trois cycles de latence, mais un nouveau résultat chaque cycle une fois le pipeline plein. La latence est de 3 horloges parce que les données passent à travers trois flip-flops ; le débit est de 1 opération par horloge parce que les trois étages travaillent simultanément sur des entrées différentes.

C'est comme ça que les designs haute performance atteignent leurs objectifs de débit : garde les étages courts, pipeline plus profondément, et laisse le parallélisme faire le travail.

Reset asynchrone (quand tu en as besoin)

Parfois tu ne peux pas attendre un front d'horloge pour asserter le reset - la puce est en cours d'arrêt, l'horloge est gatée, un watchdog externe tire la ligne. Dans ces cas :

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

La liste de sensibilité a maintenant à la fois un front d'horloge et un front de reset. Le flip-flop répond immédiatement à l'un comme à l'autre. reset_n est par convention actif-bas (asserté quand bas), c'est pour ça que le test est ~reset_n.

Le reset asynchrone a des compromis : plus dur à analyser en timing, peut causer de la métastabilité s'il n'est pas géré soigneusement à la désassertion, pas portable sur toutes les architectures FPGA. Utilise le reset synchrone par défaut, l'async seulement quand le design l'exige.

La suite

Tu peux maintenant construire n'importe quel datapath synchrone. Le prochain document - Machines à états finis - met ensemble un registre cadencé avec une instruction case pour produire l'idiome FSM standard : le pilier de chaque contrôleur, moteur de protocole et bloc de décision en design numérique.