Machine Translated by Google

Université de Californie, Davis

Département de génie électrique et informatique

CEE180 SYSTÈMES NUMÉRIQUES II Printemps 2021

Atelier 1 : Implémentation de la logique combinatoire dans le FPGA MAX10

Prélab : installez Quartus, ModelSim et SystemBuilder en suivant les instructions du document Installation de Quartus, Modelsim et SystemBuilder . Lisez 1)
Organisation de fichiers recommandée sur la page Web, et 2) Document Verilog 1 : Présentation et Verilog 2 : Notions de base axées sur l' instruction d'affectation .

Ressources : la page Web Terasic pour la carte DE10­Lite contient des liens vers des informations et des ressources pour la carte. Ces ressources comprennent :

• Manuel d'utilisation du DE­10­Lite version 1.4 • CD­ Date de sortie 24/01/2017

ROM DE10­Lite version 2.0.0 Date de sortie 24/01/2017
http://www.terasic.com.tw/cgi­bin/page/archive.pl?Language=English&CategoryNo=218&No=1021&PartNo=4

Partie 0. Flux de conception à l'aide de System Builder, Quartus Prime et ModelSim

A. Création de fichiers de projet à l'aide de System Builder

System Builder est un utilitaire Windows inclus sur le CD­ROM DE10­Lite et décrit au chapitre 4 du manuel de l'utilisateur. Cet outil génère des fichiers de projet Quartus
Prime et effectue le mappage d'affectation des broches pour les broches d'E/S sur la carte DE10­Lite.

1) Exécutez DE10_Lite_SystemBuilder.exe

2) Spécifiez le nom du projet et les périphériques d'E/S que vous utiliserez dans votre projet.

Par exemple, pour ce didacticiel, spécifiez le nom du projet comme étant majoritaire et sélectionnez les périphériques d'E/S LED, bouton, commutateur et 7
segments, comme indiqué dans la figure 1. Cliquez ensuite sur le bouton Générer pour enregistrer les fichiers du projet dans votre dossier de projet. . Une fois que tu as
généré avec succès vos fichiers de projet Quartus Prime, quittez System Builder.

Figure 1. Configuration du générateur de système

1
Machine Translated by Google

System Builder créera un ensemble de fichiers dans le répertoire de votre projet, comme le montre la figure 2. Seuls quelques­uns de ces fichiers sont pertinents pour
ce laboratoire.

Figure 2. Fichiers générés par System Builder

Le fichier majority.v est le modèle de votre fichier de conception Verilog de niveau supérieur. Le modèle généré par System Builder est illustré à la figure 3. System
Builder mappe les périphériques d'E/S avec les affectations de broches appropriées qui sont câblées sur la carte DE10­Lite. C'est une grande commodité d'utiliser System
Builder pour créer votre fichier de projet et votre fichier modèle Verilog afin que vous n'ayez pas besoin d'effectuer manuellement le mappage des broches. Les
sections de déclarations et de codage structurel sont laissées vides pour que vous puissiez les compléter.

//================================================= =======
// Ce code est généré par Terasic System Builder
//================================================= =======

majorité des modules (

//////////// SEG7 //////////

sortie [7:0] [7:0] sortie [7:0] sortie [7:0] HEX0,
[7:0] sortie sortie HEX1,
[7:0] sortie HEX2,
HEX3,
HEX4,
HEX5,

//////////// CLÉ //////////

entrée [1:0] CLÉ,

//////////// DIRIGÉ //////////

sortie [9:0] LEDR,

//////////// SW //////////
saisir [9:0] Logiciel

);

//================================================= =======
// Déclarations REG/WIRE
//================================================= =======

//================================================= =======
// Codage structurel
//================================================= =======

module final

Figure 3. Modèle Verilog de System Builder (majority.v)

Dans cet exemple, nous illustrerons la conception d'un portail majoritaire, comme décrit dans la section 3.6 de notre manuel, Digital Design – A.
Approche systémique. Nous utiliserons des interrupteurs pour les entrées et une LED pour la sortie.

2
Machine Translated by Google

B. Compilation et programmation à l'aide de Quartus Prime

• Exécutez Quartus Prime et ouvrez le fichier de projet que vous venez de créer à l'aide de System Builder.

• Sélectionnez Fichier > Ouvrir le projet et accédez au dossier dans lequel vous avez stocké vos fichiers. Sélectionnez le fichier majority.qpf.

• Double­cliquez sur l'instance d'entité majoritaire dans le volet Navigateur de projet afin d'ouvrir le modèle créé par System Builder pour votre conception de niveau
supérieur.

• Ajoutez la ligne de code suivante dans la section Codage structurel du fichier majority.v :

attribuer LEDR[1] = (SW[0]&SW[1]) | (SW[0]&SW[2]) | (SW[1]&SW[2]);

Comme décrit dans votre texte (p. 50) et dans d'autres documents, Verilog utilise les symboles &, |, ^ et ~ pour représenter les opérations logiques AND, OR, XOR et
NOT, respectivement. Le mot­clé assign est utilisé pour décrire une fonction logique combinatoire. Dans ce cas, LEDR[1] sera affirmé (logique haut) lorsqu'au moins 2
des 3 entrées de commutateur, SW[0]­SW[2], sont hautes.

Les LED « LEDR » sont actives au niveau haut, comme le montre la figure 4.

Figure 4. Extrait du schéma DE10­Lite montrant les LED actives hautes

• Une fois que vous avez entré votre code Verilog, cliquez sur Traitement > Démarrer la compilation. La conception doit être compilée avec 0 erreur.

• Sélectionnez Outils > Programmeur. Connectez votre carte DE10­Lite à votre ordinateur hôte avec le câble USB. La configuration matérielle doit être définie sur
USB­Blaster [USB­0], comme indiqué dans la figure 5. Assurez­vous que le fichier majoritaire.sof est répertorié et que la case Programme/Configurer est
cochée comme indiqué dans la figure 5. Cliquez ensuite sur Démarrer.

Figure 5. Configuration de l'outil de programmation

3
Machine Translated by Google

Vous pouvez maintenant tester la conception de la porte majoritaire sur la carte DE10­Lite en utilisant SW[0], SW[1] et SW[2] comme entrées. Lorsqu'au moins 2 des 3
entrées du commutateur sont hautes, alors la sortie LEDR[1] doit être allumée ; sinon, il devrait être éteint.

Vérifiez que la conception de la porte majoritaire fonctionne comme prévu.

C. Simulation dans ModelSim­Intel à l'aide d'un banc de test

Une technique de débogage très puissante consiste à simuler une conception à l’aide d’une simulation fonctionnelle ou temporelle. C'est une bien meilleure façon de déboguer
une conception que de télécharger et de tester sur une carte FPGA car : 1) dans une simulation fonctionnelle, vous pouvez voir les signaux internes ainsi que les signaux
d'E/S ; et 2) l'utilisation d'un banc de test évite le temps nécessaire au téléchargement répété d'une conception sur la carte FPGA.

Nous commencerons par faire une simulation fonctionnelle de la conception de la porte majoritaire à l'aide d'un banc de test. Bien qu'il soit possible de donner manuellement
des commandes de stimulation ou de dessiner des formes d'onde, la meilleure approche consiste à écrire un programme de test dans Verilog pour générer les entrées
de stimulation et surveiller les sorties.

Un exemple de banc de test pour le module de porte majoritaire est présenté dans la figure 6. Ce code de banc de test a été légèrement adapté du code donné dans la
figure 3.8 (p. 50) dans votre texte uniquement parce que les noms des signaux d'E/S sont différents pour le module de porte majoritaire. Carte DE10­Lite que les signaux
utilisés dans le texte.

module tb_majorité ;

reg [2:0] compte ;

fil fil fil [7:0] HEX0 ;

fil fil fil [7:0]HEX1 ;
fil fil fil [7:0]HEX2 ;
[7:0]HEX3 ;
[7:0]HEX4 ;
[7:0]HEX5 ;
[1:0] CLÉ ;
[9:0] LEDR ;
[9:0] SW ;

attribuer SW[2:0] = nombre ;

// La partie du banc de test qui instancie le matériel à tester

majorité maj1 (.HEX0(HEX0), .HEX1(HEX1), .HEX2(HEX2), .HEX3(HEX3), .HEX4(HEX4), .HEX5(HEX5),

.KEY(CLÉ), .LEDR(LEDR), .SW(SW));

// La partie du banc de test qui crée les signaux d'entrée de test

nombre de début initial =
3'b000 ;
répéter (8) commencer
#100
$display("in = %b, out = %b", nombre, LEDR[1]);
compte = compte + 3'b001 ;
fin
fin
module final

Figure 6. Module Testbench – tb_majority.v

Le code de Testbench Verilog n’est pas synthétisé dans le matériel réel ; c'est uniquement à des fins de simulation. Par conséquent, il peut utiliser des constructions
Verilog non synthétisables telles que le délai (#) et les instructions initiale et $display . Le banc de test instancie le module à tester, en l'occurrence le module majoritaire
avec une instance spécifique appelée maj1, et il fournit des stimuli pour les entrées et surveille les sorties. Dans ModelSim, le visualiseur de forme d'onde est un outil pratique
pour vérifier le bon fonctionnement de un circuit.

4
Machine Translated by Google

Pour effectuer une simulation fonctionnelle à l'aide de ModelSim Intel, procédez comme suit :

1) Entrez le tb_majority.v dans un fichier dans le même répertoire de projet que majority.v.

2) Dans le répertoire de votre projet Quartus Prime, créez un nouveau sous­répertoire pour votre projet de simulation. A titre d'exemple, vous pourriez
appelez le sous­répertoire simulation.

3) Exécutez ModelSim­Intel FPGA à partir du menu Démarrer ou d'une icône du bureau. (Ne le lancez pas depuis Quartus Prime car le
testbench ne fera pas partie d'un tel projet.)

4) Sélectionnez Fichier > Nouveau > Projet pour ouvrir la boîte de dialogue Créer un projet. Donnez un nom au projet et spécifiez l'emplacement du projet comme sous­
répertoire que vous avez créé ci­dessus. Laissez les autres paramètres dans l'état par défaut. (c'est­à­dire Nom de la bibliothèque par défaut = travail, Copier
les paramètres depuis = Copier les mappages de bibliothèque). Cliquez sur OK.

5) Ensuite, une fenêtre Ajouter des éléments au projet s'ouvre. Ajoutez à la fois votre tb_majority.v et votre majority.v. Laissez le jeu ouvert sur « Référence à partir
de l'emplacement actuel ».

6) Sélectionnez Compiler > Tout compiler. Votre projet doit être compilé sans erreur.

7) Cliquez sur Simuler > Démarrer la simulation. Sélectionnez Conception > travail > tb_majority

8) Pour afficher une forme d'onde de simulation, cliquez sur Affichage > Vague. Ensuite dans la fenêtre Objets, sélectionnez le nombre, faites un clic droit dessus et
sélectionnez Ajouter une vague. Cela ajoutera le signal de comptage à votre fenêtre Wave. Développez ensuite le signal LEDR, sélectionnez LEDR[1] et ajoutez­
le à la fenêtre Wave. De cette façon, vous pouvez voir la forme d'onde des signaux d'entrée et de sortie de la porte majoritaire.

9) Vous pouvez exécuter la simulation en sélectionnant Simuler > Exécuter > Exécuter 100 ou en tapant simplement exécuter dans la fenêtre de commande.
Cela exécutera votre simulation pendant 100 unités de temps, soit 100 ps par défaut. Voir la figure 7 pour une capture d'écran de la fenêtre Wave après une
simulation de 800 ps.

Figure 7. Forme d'onde de simulation fonctionnelle pour la conception de portes majoritaires

Vous devriez également voir la sortie dans la fenêtre de la console ModelSim à partir de la commande $display dans le banc de test. La sortie de la console doit être une
version texte de la sortie de forme d'onde et doit être la même que dans la figure 3.9 de votre texte et illustrée dans la figure 8.

5
Machine Translated by Google

# entrée = 000, sortie = 0

# entrée = 001, sortie = 0
# entrée = 010, sortie = 0
# entrée = 011, sortie = 1
# entrée = 100, sortie = 0
# entrée = 101, sortie = 1
# entrée = 110, sortie = 1
# entrée = 111, sortie = 1

Figure 8. Sortie de la console ModelSim

Partie 1. Implémentation de portes logiques combinatoires de base sur la carte DE10­Lite

En suivant l'exemple donné dans la partie 0, créez un nouveau projet et implémentez quelques portes logiques de votre choix à l'aide des commutateurs, boutons,
LED et affichages à 7 segments de la carte DE10­Lite. Téléchargez votre conception et vérifiez le bon fonctionnement. Il existe de nombreuses options de
conception possibles. Quelques exemples sont les portes AND, NAND, OR, NOR à 2, 3 ou 4 entrées. Vous pouvez également utiliser un bouton­poussoir
pour contrôler directement une LED ou un segment d'un afficheur à 7 segments. Notez que les segments de l'affichage à 7 segments sont actifs­bas, comme le
montre la figure 9, et que le bit 7 correspond au point décimal. Par exemple, afin de désactiver tous les segments de l'affichage à 7 segments HEX0 et de les
conserver, vous pouvez utiliser l'instruction assign suivante :

attribuer HEX0 = 8'b11111111 ;

Vous pouvez vérifier expérimentalement ou à partir du schéma de la carte DE10­Lite que les interrupteurs à bouton­poussoir sont actifs­bas.

Concevez un module Verilog « testbench » qui instancie une copie de votre module, exerce le circuit à travers toutes les combinaisons d'entrées possibles et
imprime les entrées et les sorties les unes à côté des autres dans un format facile à lire.

Figure 9. Extrait du schéma DE10­Lite montrant un affichage à 7 segments actif­bas. Un fonctionnement actif faible est visible car les nœuds communs sur les
broches 1 et 6 sont liés à Vcc.

Une fois que votre conception fonctionne sur la carte DE10­Lite, démontrez­la à votre TA pour votre vérification.

Partie 2. Implémentation d'un affichage décimal logique combinatoire à 7 segments pour les entrées de commutateur 4 bits

Dans cette partie, concevez un circuit combinatoire simple afin que la valeur de l'entrée du commutateur 4 bits, SW[3] – SW[0], soit affichée en décimal sur
HEX[1] et HEX[0]. Ainsi, votre écran affichera les valeurs 00, 01, 02, … 09, 10, 11, 12, 13, 14, 15 en fonction des positions de SW[3]–SW[0]. Les autres affichages
à 7 segments (HEX5–HEX2) doivent être éteints.

Effectuez les étapes suivantes et affichez tout le travail :

1) Écrivez une table de vérité pour les sorties (c'est­à­dire les segments sur les écrans HEX1 et HEX0) basée sur l'entrée 4 bits
(SW[3]–SW[0]).

2) Dessinez une carte de Karnaugh pour chaque fonction de sortie.

3) Utilisez la carte de Karnaugh pour générer des équations logiques pour chaque sortie.

4) Implémentez chaque équation logique à l'aide d'une instruction d'affectation Verilog.

5) Concevoir et mettre en œuvre un banc de test pour tester les 16 cas d'entrée.

6) Compilez votre conception Verilog et testez­la sur la carte DE10­Lite.

6
Machine Translated by Google

Plus tard, vous apprendrez d'autres façons de décrire la logique combinatoire dans Verilog, par exemple en utilisant une instruction case pour implémenter directement une table
de vérité sans résoudre les équations logiques.

Démontrez votre conception fonctionnelle sur la carte DE10­Lite à votre TA pour vérification.

Travail soumis [100 pts au total]

Soumettez les éléments suivants pour vérification et notation :

1) [60 pts] Contrôles de laboratoire

[25 pts] Démontrer la mise en œuvre de la première partie des portes logiques de base à l'aide de commutateurs et de LED

[35 pts] Démontrer la mise en œuvre de la partie II de l'affichage décimal des nombres de 00 à 15

2) [10 pts] Code source Verilog complet pour les deux exercices de laboratoire (partie I et partie II).

3) [10 pts] Table de vérité, cartes de Karnaugh et équations de sortie pour votre conception de la partie II.

4) [20 pts] Résultats imprimés des bancs de test montrant les entrées aux côtés des sorties pour les parties I et II.

2021/04/01 Publié