Affectation avec opérateurs

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

Une fois que vous comprenez 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 wire.

Syntaxe de base

assign wire_name = expression;

L'expression peut inclure :

Des opérateurs arithmétiques (+, -, *, /)
Des opérateurs bit à 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

Opérateurs multiples dans une seule assignation

Vous pouvez combiner plusieurs 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 explicite :

// Peu 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)

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
);
  
  // TODO: Ajoutez les instructions assign pour :
  // and_result = input_a & input_b
  // or_result  = input_a | input_b
  // xor_result = input_a ^ input_b
  // not_result = ~input_a

endmodule