Multiplexeur 4 vers 1 en Verilog : Conception et Implémentation

Qu'est-ce qu'un multiplexeur (mux) ?

Un multiplexeur ou mux en abrégé, est un élément numérique qui transfère les données de l'une des N entrées vers la sortie en fonction du signal de sélection. Le cas présenté ci-dessous est lorsque N vaut 4. Par exemple, un multiplexeur 4 bits aurait N entrées chacune de 4 bits où chaque entrée peut être transférée vers la sortie par l'utilisation d'un signal de sélection.

sel est une entrée 2 bits et peut avoir quatre valeurs. Chaque valeur sur la ligne de sélection permettra à l'une des entrées d'être envoyée vers la broche de sortie out.

sel a b c d out
0   3 7 1 9 3
1   3 7 1 9 7
2   3 7 1 9 1
3   3 7 1 9 9

Un multiplexeur 4x1 peut être implémenté de plusieurs façons ; voici deux des plus courantes :

• En utilisant une instruction assign
• En utilisant une instruction case

Utilisation de l'instruction assign

module mux_4to1_assign (
  input [3:0] a, // Entrée 4 bits appelée a
  input [3:0] b, // Entrée 4 bits appelée b
  input [3:0] c, // Entrée 4 bits appelée c
  input [3:0] d, // Entrée 4 bits appelée d
  input [1:0] sel, // Entrée sel pour sélectionner entre a,b,c,d
  output [3:0] out // Sortie 4 bits basée sur sel
);
  // Quand sel[1] est 0, (sel[0]? b:a) est sélectionné ; quand sel[1] est 1, (sel[0] ? d:c) est pris
  // Quand sel[0] est 0, a est envoyé en sortie, sinon b ; quand sel[0] est 0, c est envoyé, sinon d
  assign out = sel[1] ? (sel[0] ? d : c) : (sel[0] ? b : a);
endmodule

Le module appelé mux_4x1_assign a quatre entrées de données 4 bits, une entrée de sélection 2 bits et une sortie de données 4 bits. Le multiplexeur sélectionnera soit a, b, c, ou d en fonction du signal de sélection sel en utilisant l'instruction assign.

Utilisation de l'instruction case

Notez que le signal out est déclaré comme type reg car il est utilisé dans un bloc procédural comme always.

module mux_4to1_case (
  input [3:0] a,
  input [3:0] b,
  input [3:0] c,
  input [3:0] d,
  input [1:0] sel,
  output reg [3:0] out
);
  // Ce bloc always s'exécute chaque fois que a/b/c/d/sel change de valeur
  // Lorsque cela se produit, en fonction de la valeur dans sel, la sortie est affectée à a/b/c/d
  always @ (a or b or c or d or sel) begin
    case (sel)
      2'b00 : out <= a;
      2'b01 : out <= b;
      2'b10 : out <= c;
      2'b11 : out <= d;
    endcase
  end
endmodule

Le module appelé mux_4x1_case a quatre entrées de données 4 bits, une entrée de sélection 2 bits et une sortie de données 4 bits. Le multiplexeur sélectionnera soit a, b, c, ou d en fonction du signal de sélection sel en utilisant l'instruction case.

Schéma matériel

Les deux types de modèles de multiplexeur se synthétisent en le même matériel comme montré dans l'image ci-dessous.

Testbench

module tb_4to1_mux;
  // Déclaration des variables reg internes pour piloter les entrées de la conception
  // Déclaration des signaux wire pour collecter la sortie de la conception
  // Déclaration d'autres variables internes utilisées dans le testbench
  reg [3:0] a;
  reg [3:0] b;
  reg [3:0] c;
  reg [3:0] d;
  wire [3:0] out;
  reg [1:0] sel;
  integer i;
  // Instanciation de l'une des conceptions, ici nous utilisons la conception avec case
  // Connexion des variables du testbench déclarées ci-dessus avec celles de la conception
  mux_4to1_case mux0 (
    .a (a), .b (b), .c (c), .d (d), .sel (sel), .out (out)
  );
  // Ce bloc initial est le stimulus
  initial begin
    // Lance un moniteur en arrière-plan pour afficher les valeurs dans le log
    // chaque fois que a/b/c/d/sel/out change
    $monitor ("[%0t] sel=0x%0h a=0x%0h b=0x%0h c=0x%0h d=0x%0h out=0x%0h", $time, sel, a, b, c, d, out);
    // 1. À l'instant 0, pilote des valeurs aléatoires sur a/b/c/d et garde sel = 0
    sel <= 0;
    a <= $random;
    b <= $random;
    c <= $random;
    d <= $random;
    // 2. Change la valeur de sel toutes les 5ns
    for (i = 1; i < 4; i=i+1) begin
      #5 sel <= i;
    end
    // 3. Après l'étape 2, attend 5ns et termine la simulation
    #5 $finish;
  end
endmodule

Journal de simulation

ncsim> run
[0] sel=0x0 a=0x4 b=0x1 c=0x9 d=0x3 out=0x4
[5] sel=0x1 a=0x4 b=0x1 c=0x9 d=0x3 out=0x1
[10] sel=0x2 a=0x4 b=0x1 c=0x9 d=0x3 out=0x9
[15] sel=0x3 a=0x4 b=0x1 c=0x9 d=0x3 out=0x3
Simulation complete via $finish(1) at time 20 NS + 0