home Technologie de fabrication Équipement de fabrication
Fabrication industrielle
Internet des objets industriel | Matériaux industriels | Entretien et réparation d'équipement | Programmation industrielle |
home  MfgRobots >> Fabrication industrielle >  >> Industrial programming >> Verilog

Maîtriser le Timescale Verilog : Unités, Précision et Timing de Simulation Précis

La simulation Verilog dépend de la façon dont le temps est défini car le simulateur a besoin de savoir ce que #1 signifie en termes de temps. La directive de compilateur `timescale spécifie l'unité de temps et la précision pour les modules qui la suivent.

Syntaxe

`timescale <unité_temps>/<précision_temps>
// Exemples
`timescale 1ns/1ps
`timescale 10us/100ns
`timescale 10ns/1ns

L'unité_temps est la mesure des délais et du temps de simulation tandis que la précision_temps spécifie comment les valeurs de délai sont arrondies avant d'être utilisées en simulation.

Utilisez les constructions timescale suivantes pour utiliser différentes unités de temps dans la même conception. Rappelez-vous que les spécifications de délai dans la conception ne sont pas synthétisables et ne peuvent pas être converties en logique matérielle.

Caractère Unité
s secondes
ms millisecondes
us microsecondes
ns nanosecondes
ps picosecondes
fs femtosecondes

Les entiers dans ces spécifications peuvent être 1, 10 ou 100 et la chaîne de caractères qui spécifie l'unité peut prendre n'importe quelle valeur mentionnée dans le tableau ci-dessus.

Exemple #1 : 1ns/1ns

// Déclarer le timescale où time_unit est 1ns
// et time_precision est aussi 1ns
`timescale 1ns/1ns
module tb;
  // Pour comprendre l'effet du timescale, conduisons
  // un signal avec certaines valeurs après certains délais
  reg val;
  initial begin
    // Initialiser le signal à 0 au temps 0 unités
    val <= 0;
    // Avancer de 1 unité de temps, afficher un message et basculer val
    #1 $display ("T=%0t At time #1", $realtime);
    val <= 1;
    // Avancer de 0.49 unité de temps et basculer val
    #0.49 $display ("T=%0t At time #0.49", $realtime);
    val <= 0;
    // Avancer de 0.50 unité de temps et basculer val
    #0.50 $display ("T=%0t At time #0.50", $realtime);
    val <= 1;
    // Avancer de 0.51 unité de temps et basculer val
    #0.51 $display ("T=%0t At time #0.51", $realtime);
    val <= 0;
    // Laisser la simulation tourner pour 5 unités de temps de plus et sortir
    #5 $display ("T=%0t End of simulation", $realtime);
  end
endmodule

La première instruction de délai utilise #1 ce qui fait attendre le simulateur exactement 1 unité de temps qui est spécifiée comme 1ns avec la directive `timescale. La seconde instruction de délai utilise 0.49 qui est moins d'une demi-unité de temps. Cependant la précision du temps est spécifiée comme 1ns et donc le simulateur ne peut pas aller plus petit que 1 ns ce qui fait qu'il arrondit l'instruction de délai donnée et donne 0ns. Donc le second délai échoue à avancer le temps de simulation.

La troisième instruction de délai utilise exactement une demi-unité de temps [hl]#0.5[/lh] et encore le simulateur arrondira la valeur pour obtenir #1 qui représente une unité de temps entière. Donc cela s'affiche à T=2ns.

La quatrième instruction de délai utilise une valeur plus que la demi-unité de temps et est aussi arrondie faisant que l'instruction display soit affichée à T=3ns.

Journal de Simulation

ncsim> run
T=1 At time #1
T=1 At time #0.49
T=2 At time #0.50
T=3 At time #0.51
T=8 End of simulation
ncsim: *W,RNQUIE: Simulation is complete.

La simulation tourne pour 8ns comme prévu, mais remarquez que la forme d'onde n'a pas de divisions plus petites entre chaque nanoseconde. C'est parce que la précision du temps est la même que l'unité de temps.

Exemple #2 : 10ns/1ns

Le seul changement fait dans cet exemple comparé au précédent est que le timescale a été changé de 1ns/1ns à 10ns/1ns. Donc l'unité de temps est 10ns et la précision est à 1ns.

// Déclarer le timescale où time_unit est 10ns
// et time_precision est 1ns
`timescale 10ns/1ns
// NOTE: Le banc de test est le même que dans l'exemple précédent
module tb;
  // Pour comprendre l'effet du timescale, conduisons
  // un signal avec certaines valeurs après certains délais
  reg val;
  initial begin
    // Initialiser le signal à 0 au temps 0 unités
    val <= 0;
    // Avancer de 1 unité de temps, afficher un message et basculer val
    #1 $display ("T=%0t At time #1", $realtime);
    val <= 1;
    // Avancer de 0.49 unité de temps et basculer val
    #0.49 $display ("T=%0t At time #0.49", $realtime);
    val <= 0;
    // Avancer de 0.50 unité de temps et basculer val
    #0.50 $display ("T=%0t At time #0.50", $realtime);
    val <= 1;
    // Avancer de 0.51 unité de temps et basculer val
    #0.51 $display ("T=%0t At time #0.51", $realtime);
    val <= 0;
    // Laisser la simulation tourner pour 5 unités de temps de plus et sortir
    #5 $display ("T=%0t End of simulation", $realtime);
  end
endmodule

Le temps de simulation réel est obtenu en multipliant le délai spécifié en utilisant # avec l'unité de temps et ensuite il est arrondi basé sur la précision. La première instruction de délai donnera alors 10ns et la seconde donne 14.9 qui est arrondi pour devenir 15ns.

La troisième instruction ajoute de même 5ns (0.5 * 10ns) et le temps total devient 20ns. La quatrième ajoute encore 5ns (0.51 * 10) pour avancer le temps total à 25ns.

Journal de Simulation

ncsim> run
T=10 At time #1
T=15 At time #0.49
T=20 At time #0.50
T=25 At time #0.51
T=75 End of simulation
ncsim: *W,RNQUIE: Simulation is complete.

Notez que l'unité de base dans la forme d'onde est en dizaines de nanosecondes avec une précision de 1ns.

Exemple #3 : 1ns/1ps

Le seul changement fait dans cet exemple comparé au précédent est que le timescale a été changé de 1ns/1ns à 1ns/1ps. Donc l'unité de temps est 1ns et la précision est à 1ps.

// Déclarer le timescale où time_unit est 1ns
// et time_precision est 1ps
`timescale 1ns/1ps
// NOTE: Le banc de test est le même que dans l'exemple précédent
module tb;
  // Pour comprendre l'effet du timescale, conduisons
  // un signal avec certaines valeurs après certains délais
  reg val;
  initial begin
    // Initialiser le signal à 0 au temps 0 unités
    val <= 0;
    // Avancer de 1 unité de temps, afficher un message et basculer val
    #1 $display ("T=%0t At time #1", $realtime);
    val <= 1;
    // Avancer de 0.49 unité de temps et basculer val
    #0.49 $display ("T=%0t At time #0.49", $realtime);
    val <= 0;
    // Avancer de 0.50 unité de temps et basculer val
    #0.50 $display ("T=%0t At time #0.50", $realtime);
    val <= 1;
    // Avancer de 0.51 unité de temps et basculer val
    #0.51 $display ("T=%0t At time #0.51", $realtime);
    val <= 0;
    // Laisser la simulation tourner pour 5 unités de temps de plus et sortir
    #5 $display ("T=%0t End of simulation", $realtime);
  end
endmodule

Voyez que les unités de temps ont été mises à l'échelle pour correspondre à la nouvelle valeur de précision de 1ps. Notez aussi que le temps est représenté dans la plus petite résolution qui dans ce cas est les picosecondes.

Journal de Simulation

ncsim> run
T=1000 At time #1
T=1490 At time #0.49
T=1990 At time #0.50
T=2500 At time #0.51
T=7500 End of simulation
ncsim: *W,RNQUIE: Simulation is complete.

Verilog

  • Langue C
  • VHDL
  • Verilog
  • MATLAB
  • Python
  • Java

    1. Maîtriser Verilog : Tutoriel complet pour la conception de circuits numériques
    2. Maîtriser la concaténation Verilog : Guide pratique
    3. Comprendre les affectations Verilog : Types, Syntaxe et Bonnes Pratiques
    4. Verilog Blocking vs Non-Blocking : Différences Clés Expliquées
    5. Maîtriser les Fonctions Verilog pour une Conception RTL Efficace
    6. Comprendre les Tasks Verilog : Fonctions vs Tasks, Syntaxe et Utilisation
    7. Comprendre la Sémantique d'Ordonnancement Verilog : Timing, Événements et Ordre d'Exécution
    8. Générateur d'Horloge Verilog : Guide de Conception et d'Implémentation
    9. Maîtriser les Fonctions Mathématiques Verilog pour une Conception Matérielle Efficace