Assignation avec opérateurs

Fait partie de la section Fondamentaux du Journey Verilog de Coddy — leçon 38 sur 90.

Une fois que vous avez compris l'assignation continue, vous pouvez la combiner avec des opérateurs pour créer une logique utile. L'instruction assign peut utiliser n'importe quel opérateur pour piloter un fil (wire).

Syntaxe de base

assign wire_name = expression;

L'expression peut inclure :

Des opérateurs arithmétiques (+, -, *, /)
Des opérateurs au niveau du bit (&, |, ^, ~)
Des opérateurs logiques (&&, ||, !)

Opérateurs de comparaison (>, <, ==, !=)
Opérateurs de décalage (<<, >>)
Opérateur conditionnel (? :)

Exemples avec différents opérateurs

ET bit à bit :

assign out = a & b;

Addition :

assign sum = a + b;

Comparaison :

assign is_greater = (a > b);

Conditionnel (multiplexeur) :

assign out = sel ? a : b;

Décalage :

assign shifted = data << 2;

Concaténation :

assign bus = {high_byte, low_byte};

Exemple de code

module assign_operators (
  input [3:0] a, b,
  input sel,
  output [3:0] and_out,
  output [4:0] sum_out,
  output is_equal,
  output mux_out
);
  
  assign and_out = a & b;           // ET bit à bit
  assign sum_out = a + b;           // Addition
  assign is_equal = (a == b);       // Comparaison
  assign mux_out = sel ? a : b;     // Conditionnel (multiplexeur)
  
endmodule

Plusieurs opérateurs dans une seule affectation

Vous pouvez combiner des opérateurs dans une seule expression :

assign result = (a & b) | (c ^ d);
assign final = (a + b) > (c - d);
assign parity = ^data;   // XOR de réduction (nombre impair de 1)

Priorité des opérateurs

Verilog suit la priorité standard des opérateurs. Utilisez des parenthèses ( ) pour rendre votre intention claire :

// Pas clair
assign out = a & b | c;

// Clair
assign out = (a & b) | c;

Défi

Ajoutez les instructions assign manquantes en fonction des tâches.

Ce qu'il faut faire :

Faites en sorte que and_result soit égal à input_a AND input_b (bit à bit)
Faites en sorte que or_result soit égal à input_a OR input_b (bit à bit)
Faites en sorte que xor_result soit égal à input_a XOR input_b (bit à bit)
Faites en sorte que not_result soit égal à NOT input_a (bit à bit)

Aide-mémoire

L'instruction assign prend en charge divers opérateurs pour la logique combinatoire :

assign wire_name = expression;

Types d'opérateurs :

Bit à bit : &, |, ^, ~
Arithmétique : +, -, *, /
Logique : &&, ||, !
Comparaison : >, <, ==, !=
Décalage : <<, >>
Conditionnel : ? :
Concaténation : { }

assign and_out  = a & b;          // ET bit à bit
assign sum_out  = a + b;          // Addition
assign is_equal = (a == b);       // Comparaison
assign mux_out  = sel ? a : b;    // Multiplexeur
assign bus      = {high, low};    // Concaténation
assign parity   = ^data;          // Réduction XOR

Utilisez des parenthèses pour clarifier la priorité :

assign out = (a & b) | c;

Essayez vous-même

module assign_challenge (
  input input_a,
  input input_b,
  output and_result,
  output or_result,
  output xor_result,
  output not_result
);
  
  // À FAIRE : Ajouter des instructions d'assignation pour :
  // and_result = input_a & input_b
  // or_result  = input_a | input_b
  // xor_result = input_a ^ input_b
  // not_result = ~input_a

endmodule