Mots-clés : contrôle de délai, déclenchement d'événement, déclenchement sur front, déclenchement sur niveau
Verilog fournit 2 principaux types de méthodes de contrôle de temporisation : le contrôle de délai et le contrôle d'événement. Le contrôle d'événement se divise principalement en contrôle d'événement déclenché sur front et contrôle d'événement sensible au niveau.
Contrôle de délai
Le contrôle de temporisation basé sur le délai apparaît dans les expressions et spécifie l'intervalle de temps entre le début et l'achèvement de l'exécution d'une instruction.
Le délai peut être un nombre, un identifiant ou une expression.
Selon la différence de position dans l'expression, le contrôle de délai peut être subdivisé en délai régulier et délai intégré.
Délai régulier
Lorsqu'un délai régulier est rencontré, l'instruction doit attendre un certain temps, puis affecter le résultat du calcul au signal cible.
Le format est : #delay procedural_statement, par exemple :
reg value_test ; reg value_general ; #10 value_general = value_test ;
Une autre façon d'écrire cette méthode de délai consiste à utiliser directement le signe dièse#comme instruction d'exécution de délai indépendante, par exemple :
#10 ; value_ single = value_test ;
Retard intégré
Lorsqu'un retard intégré est rencontré, l'instruction enregistre d'abord le résultat du calcul, puis attend un certain temps avant de l'affecter au signal cible.
Le contrôle de retard intégré est ajouté après l'opérateur d'affectation. Par exemple :
reg value_test ; reg value_embed ; value_embed = #10 value_test ;
Il convient de noter que les effets de ces 2 méthodes de contrôle de retard sont différents.
Lorsque le côté droit de l'opérateur d'affectation dans une instruction de retard est une constante, les deux méthodes de contrôle de retard peuvent produire le même effet d'affectation retardée.
Lorsque le côté droit de l'opérateur d'affectation dans une instruction de retard est une variable, les deux méthodes de contrôle de retard peuvent produire des effets d'affectation retardée différents.
Par exemple, le code de simulation suivant :
Exemple
module test ;
reg value_test ;
reg value_general, value_embed, value_single ;
//source du signal
initial begin
value_test = 0 ;
#25 ; value_test = 1 ;
#35 ; value_test = 0 ; //absolu 60ns
#40 ; value_test = 1 ; //absolu 100ns
#10 ; value_test = 0 ; //absolu 110ns
end
//(1)contrôle de délai général
initial begin
value_general = 1;
#10 value_general = value_test ; //10ns, value_test=0
#45 value_general = value_test ; //55ns, value_test=1
#30 value_general = value_test ; //85ns, value_test=0
#20 value_general = value_test ; //105ns, value_test=1
end
//(2)contrôle de délai intégré
initial begin
value_embed = 1;
value_embed = #10 value_test ; //0ns, value_test=0
value_embed = #45 value_test ; //10ns, value_test=0
value_embed = #30 value_test ; //55ns, value_test=1
value_embed = #20 value_test ; //85ns, value_test=0
end
//(3) contrôle de délai simple
initial begin
value_single = 1;
#10 ;
value_single = value_test ; //10ns, value_test=0
#45 ;
value_single = value_test ; //55ns, value_test=1
#30 ;
value_single = value_test ; //85ns, value_test=0
#20 ;
value_single = value_test ; //105ns, value_test=1
end
always begin
#10;
if ($time >= 150) begin
$finish ;
end
end
endmodule
Les résultats de simulation sont les suivants. D'après la figure, on peut voir :
- (1) Les deux expressions du délai général produisent les mêmes résultats d'exécution.
- (2) Méthode d'affectation avec délai général : après avoir rencontré l'instruction de délai, attendre d'abord un certain temps, puis affecter l'opérande courant au signal cible. Elle ne possède pas la caractéristique de « délai inertiel » et ne manquera pas les impulsions relativement étroites.
- (3) Méthode d'affectation avec délai embarqué : après avoir rencontré l'instruction de délai, calculer d'abord le résultat du côté droit de l'expression, puis attendre un certain temps, et l'affecter au signal cible.
Ci-dessous, le processus d'affectation du délai intégré est analysé :
value_embed = #10 value_test ; //0ns, value_test=0
À 0ns, cette instruction de délai est exécutée.
Affectez d'abord 0 au signal value_embed, la sortie vaut 0 après un délai de 10ns ;
value_embed = #45 value_test ; //10ns, value_test=0
À 10ns, cette instruction de délai est exécutée.
Comme value_test vaut encore 0 à ce moment-là, la valeur de value_embed reste inchangée.
Autrement dit, jusqu'à 55ns, la valeur de value_embed reste 0.
value_embed = #30 value_test ; //55ns, value_test=1
De même, à 55ns, la valeur de value_test est 1, affectez-la à value_embed et retardez la sortie de 30ns.
Ainsi, à 85ns, value_embed produit 1.
value_embed = #20 value_test ; //85ns, value_test=0
De même, à 105ns, value_embed produit 0.
Contrôle d'événement déclenché par front
En Verilog, un événement désigne un changement de valeur d'une variable de type reg ou wire.
Le contrôle temporel déclenché par événement se divise principalement en les types suivants.
Contrôle général des événements
Le contrôle d'événement utilise le symbole@pour représenter.
La condition d'exécution de l'instruction est que la valeur du signal subisse un changement spécifique.
Le mot-clé posedge désigne une transition de front montant du signal, negedge désigne une transition de front descendant. Lorsque la direction de transition n'est pas spécifiée, les deux changements de front déclencheront les événements concernés. Par exemple :
Exemple
always @(clk) q <= d ;
//Au front montant du signal clk, exécuter q<=d, modèle de bascule D à front montant
always @(posedge clk) q <= d ;
//Au front descendant du signal clk, exécuter q<=d, modèle de bascule D à front descendant
always @(negedge clk) q <= d ;
//Calculer immédiatement la valeur de d, et l'affecter à q au front montant de clk. Ce style d'écriture n'est pas recommandé.
q = @(posedge clk) d ;
Contrôle d'événement nommé
Les utilisateurs peuvent déclarer une variable de type event et déclencher la variable pour identifier si l'événement s'est produit. Les événements nommés sont déclarés avec le mot-clé event, et le signal de déclenchement est représenté par->pour représenter. Par exemple :
Exemple
always @( posedge clk_samp) begin
-> start_receiving ; //Front montant de l'horloge d'échantillonnage comme instant de déclenchement temporel
end
always @(start_receiving) begin
data_buf = {data_if[0], data_if[1]} ; //Au moment du déclenchement, intégrer des données multidimensionnelles
end
Liste de sensibilité
Lorsque l'un quelconque de plusieurs signaux ou événements change et peut déclencher l'exécution d'une instruction, Verilog utilise une expression 'OR' pour décrire cette situation, en utilisant le mot-cléorpour connecter plusieurs événements ou signaux. La liste composée de ces événements ou signaux est appelée une 'liste de sensibilité'. Bien sûr, 'or' peut aussi être remplacé par une virgule,pour le remplacer. Par exemple :
Exemple
always @(posedge clk or negedge rstn) begin
//always @(posedge clk , negedge rstn) begin
//Vous pouvez également utiliser des virgules pour lister plusieurs déclencheurs d'événements
if(! rstn)begin
q <= 1'b ;
end
else begin
q <= d ;
end
end
Lorsqu'il y a de nombreuses variables d'entrée dans une logique combinatoire, écrire une liste de sensibilité devient fastidieux. Dans ce cas, une façon plus concise d'écrire est@*ou@(*), ce qui indique qu'il est sensible aux changements de toutes les variables d'entrée dans le bloc d'instructions. Par exemple :
Exemple
//always @(a, b, c, d, e, f, g, h, i, j, k, l, m) begin
//Les deux styles d'écriture sont équivalents
assign s = a? b+c : d ? e+f : g ? h+i : j ? k+l : m ;
end
Contrôle d'événement sensible au niveau
Le contrôle d'événement abordé précédemment nécessite tous d'attendre un changement de valeur de signal ou le déclenchement d'un événement, en utilisant@+sensitivity listpour le représenter.
Verilog prend également en charge l'utilisation d'un niveau comme signal sensible pour contrôler la synchronisation, c'est-à-dire que l'exécution des instructions suivantes doit attendre qu'une condition soit vraie. En Verilog, le mot-clé wait est utilisé pour représenter cette situation sensible au niveau. Par exemple :
Exemple
wait (start_enable) ; //Attendre le signal de départ
forever begin
//Après l'activation du signal de départ, intégrer les données sur le front montant de clk_samp
@(posedge clk_samp) ;
data_buf = {data_if[0], data_if[1]} ;
end
end
Téléchargement du code source
Téléchargement