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. 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-bloquante dans les blocs Always (logique séquentielle)

La non-bloquante est utilisée pour la logique séquentielle : les circuits qui utilisent une horloge et disposent d’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 ont lieu en même temps, en utilisant les valeurs antérieures au 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 simultanément
Les valeurs sont mises à jour à la fin de l’étape temporelle	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.

Fonctionnement :

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

À faire :

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

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