Affectation non bloquante

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

Dans la leçon précédente, nous avons abordé l'affectation bloquante (=), qui s'exécute étape par étape. Maintenant, nous allons aborder l'affectation non bloquante (<=), qui s'exécute d'un seul coup — en parallèle.

L'affectation non bloquante utilise l'opérateur <=. Elle est appelée « non bloquante » car elle ne bloque pas l'exécution de l'instruction suivante. Toutes les affectations non bloquantes d'un bloc s'exécutent en même temps.

Syntaxe :

variable <= expression;

Quand utiliser l'affectation non bloquante

L'affectation non bloquante (<=) est utilisée pour la logique séquentielle — des circuits qui utilisent une horloge et possèdent une mémoire. Les sorties ne changent que sur un front d'horloge (généralement le front montant).

Exemples de logique séquentielle :

Bascules
Registres
Compteurs

Machines à états
Registres à décalage

Exemple Verilog :

initial begin
  a <= 5;      // Planifié, mais pas encore exécuté
  b <= a + 2;  // Planifié, utilise l'ANCIENNE valeur de a
  c <= b * 3;  // Planifié, utilise l'ANCIENNE valeur de b
end

Les trois affectations ont lieu en même temps en utilisant les anciennes valeurs. À la fin du pas de temps, toutes les mises à jour se produisent ensemble.

Affectations non-bloquantes dans les blocs always (logique séquentielle)

L'affectation non-bloquante est utilisée pour la logique séquentielle — des circuits qui utilisent une horloge et possèdent une mémoire (bascules, registres, compteurs).

always @(posedge clk) begin
  q <= d;           // q reçoit d sur le front d'horloge
  count <= count + 1; // count s'incrémente sur le front d'horloge
end

Les deux affectations se produisent en même temps, en utilisant les valeurs d'avant le front d'horloge.

Résumé

Règle	Explication
Utilisez `<=` pour la logique séquentielle	`always @(posedge clk)`
Utilisez `=` pour la logique combinatoire	`always @(*)`
Les affectations non-bloquantes s'exécutent en parallèle	Toutes les affectations se produisent en même temps
Les valeurs sont mises à jour à la fin du pas de temps	Pas immédiatement

Défi

Complétez l'affectation non bloquante

Ajoutez les affectations non bloquantes manquantes pour faire fonctionner ce registre à décalage de 2 bits.

Comment ça fonctionne :

À chaque front d'horloge, q1 reçoit d
q2 reçoit l'ancienne valeur de q1

Ce qu'il faut faire :

Affectez d à q1 (non bloquant)
Affectez q1 à q2 (non bloquant)

Aide-mémoire

L'affectation non bloquante (<=) exécute toutes les instructions en parallèle — en utilisant les anciennes valeurs et en effectuant la mise à jour à la fin du pas de temps.

// Tous utilisent les ANCIENNES valeurs de a et b
a <= 5;
b <= a + 2;  // utilise l'ancien a
c <= b * 3;  // utilise l'ancien b

Utilisez <= pour la logique séquentielle (bascules, registres, compteurs) à l'intérieur des blocs always cadencés :

always @(posedge clk) begin
  q     <= d;           // non bloquant
  count <= count + 1;   // non bloquant
end

Affectation	Utilisation pour	Exécution
`<=`	Logique séquentielle (`posedge clk`)	En parallèle
`=`	Logique combinatoire (`always @(*)`)	Étape par étape

Essayez vous-même

module shift_register (
  input clk,
  input reset,
  input d,
  output reg q1,
  output reg q2
);
  
  always @(posedge clk or posedge reset) begin
    if (reset) begin
      q1 <= 0;
      q2 <= 0;
    end else begin
      // À FAIRE : Ajouter la logique de décalage
      // Étape 1 : Assigner d à q1 (non-bloquant)
      // Étape 2 : Assigner q1 à q2 (non-bloquant)
    end
  end
endmodule