Bascule D

Une bascule D est un circuit qui stocke un bit et qui est mis à jour périodiquement, généralement sur le front montant d'un signal d'horloge.

Les bascules D sont créées par le synthétiseur logique lorsqu'un bloc always cadencé est utilisé. Une bascule D est la forme la plus simple d'un « bloc de logique combinatoire suivi d'une bascule » où la logique combinatoire est simplement un fil.

Créez une seule bascule D.

Déclaration du module

module top_module (
    input clk,
    input d,
    output reg q );

Écrivez votre solution ici

module top_module (
    input clk,
    input d,
    output reg q
);

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

endmodule

Bascule D sur 8 bits

Créez 8 bascules D. Toutes les bascules doivent être déclenchées par le front montant de l'horloge.

Déclaration du module

module top_module (
    input clk,
    input [7:0] d,
    output [7:0] q
);

Écrivez votre solution ici

module top_module (
    input clk,
    input [7:0] d,
    output [7:0] q
);

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

endmodule

Bascule D8 avec réinitialisation synchrone

Créez 8 bascules D avec réinitialisation synchrone active au niveau haut. Toutes les bascules doivent être déclenchées par le front montant de clk.

Déclaration du module

module top_module (
    input clk,
    input reset,
    input [7:0] d,
    output [7:0] q
);

Écrivez votre solution ici

module top_module (
    input clk,
    input reset,
    input [7:0] d,
    output [7:0] q
);

    always @(posedge clk) begin
        if (reset)
            q <= 8'b0;
        else
            q <= d;
    end

endmodule

Bascule D8 avec réinitialisation et front descendant

Créez 8 bascules D avec réinitialisation synchrone active au niveau haut. Les bascules doivent être réinitialisées à 0x34 plutôt qu'à zéro. Toutes les bascules doivent être déclenchées par le front descendant de clk.

Déclaration du module

module top_module (
    input clk,
    input reset,
    input [7:0] d,
    output [7:0] q
);

Indice : Réinitialiser un registre à '1' est parfois appelé « preset ».

Écrivez votre solution ici

module top_module (
    input clk,
    input reset,
    input [7:0] d,
    output [7:0] q
);

    always @(negedge clk) begin
        if (reset) begin
            q <= 8'h34;
        end
        else begin
            q <= d;
        end
    end

endmodule

Bascule D8 avec réinitialisation asynchrone

Créez 8 bascules D avec réinitialisation asynchrone active au niveau haut. Toutes les bascules doivent être déclenchées par le front montant de clk.

Déclaration du module

module top_module (
    input clk,
    input areset,
    input [7:0] d,
    output [7:0] q
);

Indice : La seule différence de code entre les bascules avec réinitialisation synchrone et asynchrone réside dans la liste de sensibilité.

Écrivez votre solution ici

module top_module (
    input clk,
    input areset,
    input [7:0] d,
    output [7:0] q
);

    always @(posedge clk or posedge areset) begin
        if (areset) begin
            q <= 8'b0;
        end
        else begin
            q <= d;
        end
    end

endmodule

Bascule D16 avec activation par octets

Créez 16 bascules D. Il est parfois utile de modifier uniquement une partie d'un groupe de bascules. Les entrées d'activation d'octets contrôlent si chaque octet des 16 registres doit être écrit durant ce cycle. byteena[1] contrôle l'octet supérieur d[15:8], tandis que byteena[0] contrôle l'octet inférieur d[7:0].

resetn est une réinitialisation synchrone active au niveau bas.

Toutes les bascules doivent être déclenchées par le front montant de clk.

Déclaration du module

module top_module (
    input clk,
    input resetn,
    input [1:0] byteena,
    input [15:0] d,
    output [15:0] q
);

Écrivez votre solution ici

module top_module (
    input clk,
    input resetn,
    input [1:0] byteena,
    input [15:0] d,
    output [15:0] q
);

    always @(posedge clk) begin
        if (!resetn) begin
            q <= 16'b0;
        end
        else begin
            if (byteena[1] && byteena[0]) begin
                q <= d;
            end
            else if (byteena[1]) begin
                q[15:8] <= d[15:8];
            end
            else if (byteena[0]) begin
                q[7:0] <= d[7:0];
            end
        end
    end

endmodule

Examen m2014 q4a

Implémentez le circuit suivant :

Notez qu'il s'agit d'un verrou, donc un avertissement Quartus concernant l'inférence d'un verrou est attendu.

Déclaration du module

module top_module (
    input d,
    input ena,
    output q
);

Indice : Les verrous sont des circuits sensibles au niveau (pas au front), donc dans un bloc always, ils utilisent des listes de sensibilité sensibles au niveau. Ce sont néanmoins des éléments séquentiels, donc ils doivent utiliser des affectations non-bloquantes. Une bascule D agit comme un fil (ou un tampon non-inverseur) lorsqu'elle est activée, et conserve la valeur actuelle lorsqu'elle est désactivée.

Écrivez votre solution ici

module top_module (
    input d,
    input ena,
    output q
);

    always @(*) begin
        if (ena)
            q <= d;
    end

endmodule

Examen m2014 q4b

Implémentez le circuit suivant :

Déclaration du module

module top_module (
    input clk,
    input d,
    input ar,
    output q
);

Écrivez votre solution ici

module top_module (
    input clk,
    input d,
    input ar,
    output q
);

    always @(posedge clk or posedge ar) begin
        if (ar) begin
            q <= 1'b0;
        end
        else begin
            q <= d;
        end
    end

endmodule

Examen m2014 q4c

Implémentez le circuit suivant :

Déclaration du module

module top_module (
    input clk,
    input d,
    input r,
    output q
);

Écrivez votre solution ici

module top_module (
    input clk,
    input d,
    input r,
    output q
);

    always @(posedge clk) begin
        if (r) begin
            q <= 1'b0;
        end
        else begin
            q <= d;
        end
    end

endmodule

Examen m2014 q4d

Implémentez le circuit suivant :

Déclaration du module

module top_module (
    input clk,
    input in,
    output out
);

Écrivez votre solution ici

module top_module (
    input clk,
    input in,
    output out
);

    always @(posedge clk) begin
        out <= in ^ out;
    end

endmodule

Mt2015 muxdff

Tiré de l'examen intermédiaire ECE253 2015 question 5

Considérez le circuit séquentiel ci-dessous :

Supposez que vous voulez implémenter du code Verilog hiérarchique pour ce circuit, en utilisant trois instantiations d'un sous-module contenant une bascule et un multiplexeur. Écrivez un module Verilog (contenant une bascule et un multiplexeur) nommé top_module pour ce sous-module.

Déclaration du module

module top_module (
    input clk,
    input L,
    input r_in,
    input q_in,
    output reg Q
);

Écrivez votre solution ici

module top_module (
    input clk,
    input L,
    input r_in,
    input q_in,
    output reg Q
);

    always @(posedge clk) begin
        Q <= L ? r_in : q_in;
    end

endmodule

Examen 2014 q4a

Considérez le circuit de registre à décalage n-bit montré ci-dessous :

Écrivez un module Verilog nommé top_module pour un étage de ce circuit, incluant à la fois la bascule et les multiplexeurs.

Déclaration du module

module top_module (
    input clk,
    input w, R, E, L,
    output Q
);

Écrivez votre solution ici

module top_module (
    input clk,
    input w, R, E, L,
    output Q
);

    always @(posedge clk) begin
        Q <= L ? R : (E ? w : Q);
    end

endmodule

Examen ece241 2014 q4

Étant donné le circuit de machine à états finis montré ci-dessous, supposez que les bascules D sont initialement réinitialisées à zéro avant que la machine ne commence.

Construisez ce circuit.

Déclaration du module

module top_module (
    input clk,
    input x,
    output z
);

Indice : Faites attention à l'état de réinitialisation. Assurez-vous que la sortie Q de chaque bascule D est réellement l'inverse de sa sortie Q, même avant le premier front d'horloge de la simulation.

Écrivez votre solution ici

module top_module (
    input clk,
    input x,
    output z
);

    reg d1, d2, d3;

    always @(posedge clk) begin
        d1 <= x ^ d1;
        d2 <= x & ~d2;
        d3 <= x | ~d3;
    end

    assign z = ~(d1 | d2 | d3);

    initial z = 1;

endmodule

Examen ece241 2013 q7

Une bascule JK a la table de vérité ci-dessous. Implémentez une bascule JK avec seulement une bascule de type D et des portes logiques. Notez : Qold est la sortie de la bascule D avant le front d'horloge positif.

Déclaration du module

module top_module (
    input clk,
    input j,
    input k,
    output Q
);

Écrivez votre solution ici

module top_module (
    input clk,
    input j,
    input k,
    output Q
);

    always @(posedge clk) begin
        Q <= (j & ~Q) | (~k & Q);
    end

endmodule

Détection de front montant

Pour chaque bit d'un vecteur de 8 bits, détectez quand le signal d'entrée passe de 0 un cycle d'horloge à 1 le cycle suivant (similaire à la détection de front montant). Le bit de sortie doit être activé le cycle après qu'une transition de 0 à 1 se produit.

Voici quelques exemples. Pour plus de clarté, in[1] et pedge[1] sont montrés séparément.

Déclaration du module

module top_module (
    input clk,
    input [7:0] in,
    output [7:0] pedge
);

Écrivez votre solution ici

module top_module (
    input clk,
    input [7:0] in,
    output [7:0] pedge
);

    reg [7:0] previous;

    always @(posedge clk) begin
        previous <= in;
        pedge <= ~previous & in;
    end

endmodule

Détection de tout front

Pour chaque bit d'un vecteur de 8 bits, détectez quand le signal d'entrée change d'un cycle d'horloge au suivant (détection de tout front). Le bit de sortie doit être activé le cycle après qu'une transition de 0 à 1 se produit.

Voici quelques exemples. Pour plus de clarté, in[1] et anyedge[1] sont montrés séparément.

Déclaration du module

module top_module (
    input clk,
    input [7:0] in,
    output [7:0] anyedge
);

Écrivez votre solution ici

module top_module (
    input clk,
    input [7:0] in,
    output [7:0] anyedge
);

    reg [7:0] previous;

    always @(posedge clk) begin
        previous <= in;
        anyedge <= previous ^ in;
    end

endmodule

Capture de front descendant

Pour chaque bit d'un vecteur de 32 bits, capturez quand le signal d'entrée passe de 1 un cycle d'horloge à 0 le cycle suivant. « Capturer » signifie que la sortie restera à 1 jusqu'à ce que le registre soit réinitialisé (réinitialisation synchrone).

Chaque bit de sortie se comporte comme une bascule SR : Le bit de sortie doit être activé (à 1) le cycle après qu'une transition de 1 à 0 se produit. Le bit de sortie doit être réinitialsié (à 0) au front d'horloge positif lorsque reset est haut. Si les deux événements ci-dessus se produisent au même moment, la réinitialisation a la priorité. Dans les 4 derniers cycles de l'exemple d'onde ci-dessous, l'événement 'reset' se produit un cycle avant l'événement 'set', donc il n'y a pas de conflit ici.

Dans l'exemple d'onde ci-dessous, reset, in[1] et out[1] sont montrés séparément pour plus de clarté.

Déclaration du module

module top_module (
    input clk,
    input reset,
    input [31:0] in,
    output [31:0] out
);

Écrivez votre solution ici

module top_module (
    input clk,
    input reset,
    input [31:0] in,
    output [31:0] out
);

    reg [31:0] delayed;

    always @(posedge clk) begin
        delayed <= in;
    end

    always @(posedge clk) begin
        if (reset)
            out <= 32'b0;
        else begin
            out <= (~in & delayed) | out;
        end
    end

endmodule

Bascule déclenchée sur les deux fronts

Vous êtes familier avec les bascules déclenchées sur le front montant de l'horloge, ou sur le front descendant. Une bascule déclenchée sur les deux fronts est déclenchée sur les deux fronts de l'horloge. Cependant, les FPGA n'ont pas de bascules déclenchées sur les deux fronts, et always @(posedge clk or negedge clk) n'est pas accepté comme liste de sensibilité légale.

Construisez un circuit qui se comporte fonctionnellement comme une bascule déclenchée sur les deux fronts :

(Note : Ce n'est pas nécessairement parfaitement équivalent : Les sorties des bascules n'ont pas de glitches, mais un circuit combinatoire plus grand qui émule ce comportement pourrait en avoir. Mais nous ignorerons ce détail ici.)

Déclaration du module

module top_module (
    input clk,
    input d,
    output q
);

Indice : Vous ne pouvez pas créer une bascule déclenchée sur les deux fronts sur un FPGA. Mais vous pouvez créer des bascules déclenchées sur le front montant ET sur le front descendant. Ce problème est un problème de conception de circuit modérément difficile, mais ne nécessite que des fonctionnalités de base du langage Verilog. (C'est un problème de conception de circuit, pas un problème de codage.) Il peut être utile de dessiner d'abord un circuit à la main avant d'essayer d'écrire le code.

Écrivez votre solution ici

module top_module (
    input clk,
    input d,
    output q
);

    reg pos_edge, neg_edge;

    always @(posedge clk)
        pos_edge <= d;

    always @(negedge clk)
        neg_edge <= d;

    assign q = pos_edge & clk | neg_edge & ~clk;

endmodule