Affectation avec opérateurs

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

Une fois que tu as compris l’affectation continue, tu peux 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.

Syntaxe de base

assign wire_name = expression;

L’expression peut inclure :

Opérateurs arithmétiques (+, -, *, /)
Opérateurs bit à bit (&, |, ^, ~)
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 [3:0] 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

Tu peux 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 les règles de priorité des opérateurs habituelles. Utilise des parenthèses ( ) pour clarifier ton intention :

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

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

Défi

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

À faire :

Fais en sorte que and_result soit égal à input_a AND input_b (au niveau bit à bit)
Fais en sorte que or_result soit égal à input_a OR input_b (au niveau bit à bit)
Fais en sorte que xor_result soit égal à input_a XOR input_b (au niveau bit à bit)
Fais en sorte que not_result soit égal à NOT input_a (au niveau 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 des 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