Non Blocking Assignment

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. Nous allons maintenant aborder l’affectation non bloquante (<=), qui s’exécute en une seule fois, en parallèle.

L’affectation non bloquante utilise l’opérateur <=. Elle est appelée « non bloquante » parce qu’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 une affectation non bloquante

L’affectation non bloquante (<=) est utilisée pour la logique séquentielle : les 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 se produisent en même temps à l’aide des valeurs old. À la fin de l’étape temporelle, toutes les mises à jour se produisent ensemble.

Non-blocking dans les blocs Always (logique séquentielle)

Non-blocking est utilisé 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 values d'avant le edge de clock.

Résumé

Règle	Explication
Utilisez `<=` pour la logique séquentielle	`always @(posedge clk)`
Utilisez `=` pour la logique combinatoire	`always @(*)`
Non-blocking s’exécute en parallèle	All les affectations se produisent en même temps
Values se mettent à jour à l’ end de l’étape temporelle	Pas immédiatement

Défi

Terminez l’affectation non-blocking

Add les affectations non-blocking manquantes pour faire fonctionner ce registre à décalage de 2 bits.

Fonctionnement :

À chaque edge d’horloge, q1 gets d
q2 gets l’ancienne valeur de q1

À faire :

Assign d à q1 (non-blocking)
Assign q1 à q2 (non-blocking)

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
      // TODO: Ajouter la logique de décalage
      // Étape 1 : Assigner d à q1 (non-bloquant)
      // Étape 2 : Assigner q1 à q2 (non-bloquant)
    end
  end
endmodule