Maîtriser les blocs always de Verilog : syntaxe, assignations bloquantes vs non‑bloquantes et extensions SystemVerilog

By 佐川 直弘 | Naohiro Sagawa (運営者)

※記事内に広告を含みます。Amazonアソシエイトとして適格販売により収入を得ています。

1. Introduction

Quel est le rôle du bloc always en Verilog ?

Pourquoi avons‑nous besoin du bloc always ?

• Logique combinatoire : la sortie change immédiatement lorsque les entrées changent
• Logique séquentielle : la sortie change en synchronisation avec un signal d’horloge ou des événements temporels

Modèles courants du bloc always

• (*) → Utilisé pour la logique combinatoire
• always @(posedge clk) → Logique séquentielle déclenchée sur le front montant de l’horloge
• always @(posedge clk or negedge rst) → Logique séquentielle avec remise à zéro asynchrone ou contrôle plus complexe

Objectif de cet article

• Apprendre la bonne façon d’écrire les blocs always
• Comprendre pourquoi des erreurs de synthèse surviennent
• Clarifier la différence entre = et <=
• Éviter les erreurs courantes des débutants

2. Syntaxe de base et types de blocs always

Syntaxe base du bloc always

always @(sensitivity list)
begin
  // statements
end

Utilisation de always @(*) pour la logique combinatoire

always @(*) begin
  if (a == 1'b1)
    y = b;
  else
    y = c;
end

Avantages de l’utilisation de @(*)

• Inclut automatiquement tous les signaux référencés dans la liste de sensibilité
• Empêche les divergences entre les résultats de simulation et de synthèse

Utilisation de always @(posedge clk) pour la logique séquentielle

always @(posedge clk) begin
  q <= d;
end

posedge vs negedge

• posedge : déclenché au front montant
• negedge : déclenché au front descendant

always @(posedge clk or negedge rst) avec remise à zéro asynchrone

always @(posedge clk or negedge rst) begin
  if (!rst)
    q <= 1'b0;
  else
    q <= d;
end

Avec cette description, q est immédiatement remis à zéro lorsque rst est bas, sinon il capture d au front d’horloge.

Circuits combinatoires vs séquentiels

3. Types d’affectations dans les blocs always

Deux opérateurs d’affectation en Verilog

• = : Affectation bloquante
• <= : Affectation non‑bloquante

Affectation bloquante (=)

always @(*) begin
  a = b;
  c = a;
end

Cas d’utilisation typiques

• Structures de contrôle (if, case) dans la logique combinatoire
• Logique qui ne nécessite pas de maintien d’état

Affectation non‑bloquante (<=)

always @(posedge clk) begin
  a <= b;
  c <= a;
end

Cas d’utilisation typiques

• Logique séquentielle (registres, bascules)
• Propagation d’état précise entre plusieurs signaux

Comparaison des affectations bloquantes et non‑bloquantes

Que se passe‑t‑il si on les mélange ?

always @(posedge clk) begin
  a = b;
  a <= c;
end

Directives d’utilisation

• Utilisez = dans les blocs always @(*) (combinatoire)
• Utilisez <= dans les blocs always @(posedge clk) (séquentiel)

4. Pièges courants et bonnes pratiques avec les blocs always

Erreurs dans les listes de sensibilité

Des listes de sensibilité incorrectes peuvent provoquer des bugs cachés

always @(a) begin
  if (b)
    y = 1'b1;
  else
    y = 1'b0;
end

Solution : utiliser @(*)

always @(*) begin
  if (b)
    y = 1'b1;
  else
    y = 1'b0;
end

Génération involontaire de latchs

L’absence de branches if/case crée des latchs

always @(*) begin
  if (enable)
    y = d; // y is undefined when enable == 0
end

Solution : toujours assigner une valeur

always @(*) begin
  if (enable)
    y = d;
  else
    y = 1'b0; // y is always defined
end

Conditions excessivement complexes

Erreur typique : pas de default dans une instruction case

always @(*) begin
  case(sel)
    2'b00: y = a;
    2'b01: y = b;
    2'b10: y = c;
    // 2'b11 not handled → y may be undefined
  endcase
end

Solution : ajouter une clause default

always @(*) begin
  case(sel)
    2'b00: y = a;
    2'b01: y = b;
    2'b10: y = c;
    default: y = 1'b0; // safety net
  endcase
end

Contrôler plusieurs signaux dans un même bloc

Résumé des pièges courants

5. Extensions de always en SystemVerilog

always_comb : pour la logique combinatoire

Vue d’ensemble

always_comb begin
  y = a & b;
end

Principaux avantages

• Génère automatiquement la liste de sensibilité
• Les outils avertissent’ils infèrent des verrous (latches) non intentionnels
• Empêche les conflits avec des variables déjà définies

Exemple (Verilog vs SystemVerilog)

// Verilog
always @(*) begin
  y = a | b;
end

// SystemVerilog
always_comb begin
  y = a | b;
end

always_ff : pour la logique séquentielle (bascules)

Vue d’ensemble

always_ff @(posedge clk or negedge rst_n) begin
  if (!rst_n)
    q <= 1'b0;
  else
    q <= d;
end

Principaux avantages

• N’autorise que les affectations non bloquantes ( <= )
• Les outils vérifient la correction de la liste de sensibilité
• La lisibilité du code s’améliore car il est clairement séquentiel

always_latch : pour la logique basée sur des verrous (latch)

Vue d’ensemble

always_latch begin
  if (enable)
    q = d;
end

Points à noter

• Si certaines branches omettent l’affectation, un latch est explicitement créé
• N’utilisez que lorsque les latches sont réellement nécessaires

Résumé de l’utilisation de SystemVerilog

SystemVerilog la norme

6. FAQ : Questions fréquentes sur le bloc always

• Pour 2–3 conditions simples → if est plus lisible
• Pour plusieurs états distincts → case est plus clair et exprime mieux l’intention

Q2. Que se passe‑t‑il si j’omets des signaux dans la liste de sensibilité ?

Q3. Pourquoi des latches non intentionnels apparaissent‑ils dans ma conception ?

Mauvais exemple :

always @(*) begin
  if (en)
    y = d; // y is held when en == 0
end

Solution :

always @(*) begin
  if (en)
    y = d;
  else
    y = 1'b0; // always assigned
end

Q4. Puis‑je mélanger = et <= dans le même bloc ?

• Logique combinatoire → utilisez = (bloquant)
• Logique séquentielle → utilisez <= (non bloquant)

Règle générale :

Q5. Quelle est la différence entre always_ff et always @(posedge clk) ?

Q6. Est‑il acceptable de contrôler plusieurs signaux dans un même bloc always ?

• Chaque sortie fonctionne indépendamment
• Vous mélangez logique synchrone et asynchrone

Q7. Que se passe-t-il si j’utilise <= dans une logique combinatoire ?

7. Conclusion

Les blocs always sont la base de la conception Verilog

Points clés à retenir

• Les différences et l’utilisation de always @(*) vs always @(posedge clk)
• La distinction entre les assignations = (bloquantes) et <= (non bloquantes)
• Comment éviter les erreurs courantes telles que la génération de latchs et les listes de sensibilité incomplètes
• Extensions SystemVerilog (always_comb, always_ff, always_latch) pour une conception plus sûre
• Réponses pratiques aux questions fréquentes du monde réel (FAQ)

La précision détermine la qualité

Prochaines étapes : passer à la conception de niveau supérieur

• Conception de machines à états finis (FSM)
• Architectures de pipeline et de streaming
• Développement de cœurs IP et implémentation FPGA

Réflexions finales pour les concepteurs matériels