Telechargé par Mohamed RAFIK

Xilinx tutorial Spartan3 home PC

publicité
Machine Translated by Google
Conception de circuits numériques à l'aide des outils Xilinx ISE
Contenu
1. Introduction............................................... .................................................. ............................... 1
2. Dispositif logique programmable : FPGA................................................ .................................................. 2
3. Création d'un nouveau projet ................................................. .................................................. ................ 2
4. Synthèse et mise en œuvre de la conception .................................................. .................................. 11
5. Simulation fonctionnelle des conceptions combinatoires ................................................ ....................... 14
6. Préparation et téléchargement du fichier bitstream pour le FPGA Spartan : ...................................... .... 22
7. Test d'un circuit logique numérique ................................................ .................................................. ...... 27
8. Conception et simulation de circuits séquentiels à l'aide de Verilog HDL ....................................... ...... 31
9. Conception de circuits hiérarchiques à l'aide de modules ...................................... .................................... 33
Annexe­A : Modélisation du matériel Verilog ................................................ .................................................. 35
Annexe­B : Installation de Xilinx Webpack……………………………………………………………………………..…….. 42
Annexe­C – Téléchargement et installation de ModelSim PE ( version étudiant) ...................... 47
Annexe­D – Connecter Xilinx et ModelSim PE…………………………………………………………………….…… 49
I. Mise en route
Si vous souhaitez travailler sur ce tutoriel et le laboratoire chez vous, vous
devez télécharger et installer Xilinx et ModelSim. Ces outils sont gratuits
versions étudiantes. Veuillez suivre les annexes B, C et D dans cet ordre
avant de poursuivre ce didacticiel. De plus, si vous souhaitez acheter votre
propre carte Spartan3, vous pouvez le faire sur le site Web de Digilent.
Digilent propose des tarifs académiques. Veuillez noter que vous devez
télécharger et installer le logiciel Digilent Adept. Le logiciel contient les pilotes
de la carte dont vous avez besoin et fournit également l'interface pour programmer la carte.
Machine Translated by Google
1. Introduction
Xilinx Tools est une suite d'outils logiciels utilisés pour la conception de circuits numériques implémentés à l'aide de Xilinx Field
Programmable Gate Array (FPGA) ou Complex Programmable Logic Device (CPLD). La procédure de conception comprend (a)
la saisie de la conception, (b) la synthèse et la mise en œuvre de la conception, (c) la simulation fonctionnelle et (d) les tests et la
vérification. Les conceptions numériques peuvent être saisies de différentes manières à l'aide des outils de CAO ci­dessus : à
l'aide d'un outil de saisie schématique, à l'aide d'un langage de description de matériel (HDL) ­ Verilog ou VHDL ou une
combinaison des deux. Dans ce laboratoire, nous n'utiliserons que le flux de conception qui implique l'utilisation de Verilog HDL.
Les outils de CAO vous permettent de concevoir des circuits combinatoires et séquentiels à partir des spécifications de conception
Verilog HDL. Les étapes de cette procédure de conception sont énumérées ci­dessous :
1. Créez des fichiers d'entrée de conception Verilog à l'aide d'un éditeur piloté par modèle.
2. Compilez et implémentez le(s) fichier(s) de conception Verilog.
3. Créez les vecteurs de test et simulez la conception (simulation fonctionnelle) sans utiliser de PLD (FPGA ou CPLD).
4. Attribuez des broches d'entrée/sortie pour implémenter la conception sur un appareil cible.
5. Téléchargez le flux binaire sur un périphérique FPGA ou CPLD.
6. Conception de test sur un appareil FPGA/CPLD
Un fichier d'entrée Verilog dans l'environnement logiciel Xilinx se compose des segments suivants :
En­tête : nom du module, liste des ports d'entrée et de sortie.
Déclarations : ports d'entrée et de sortie, registres et fils.
Descriptions logiques : équations, machines d'état et fonctions logiques.
Fin : module de fin
Toutes vos conceptions pour ce laboratoire doivent être spécifiées dans le format d'entrée Verilog ci­dessus. Notez que le segment
de diagramme d'état n'existe pas pour les conceptions de logique combinatoire.
2. Dispositif logique programmable : FPGA
Dans ce laboratoire, les conceptions numériques seront implémentées dans la carte Basys2 dotée d'un FPGA Xilinx Spartan3E
–XC3S250E avec boîtier CP132. Cette partie FPGA appartient à la famille Spartan des FPGA.
Ces appareils viennent dans une variété de packages. Nous utiliserons des appareils emballés dans un boîtier
à 132 broches avec le numéro de pièce suivant : XC3S250E­CP132. Ce FPGA est un appareil avec environ
50K portes. Des informations détaillées sur cet appareil sont disponibles sur le site Web de Xilinx.
3. Création d'un nouveau projet
Xilinx Tools peut être démarré en cliquant sur l'icône Project Navigator sur le bureau Windows.
Cela devrait ouvrir la fenêtre Project Navigator sur votre écran. Cette fenêtre affiche (voir Figure 1) le dernier projet accédé.
Machine Translated by Google
Figure 1 : Fenêtre Xilinx Project Navigator (instantané du logiciel Xilinx ISE)
3.1 Ouvrir un projet
Sélectionnez Fichier­>Nouveau projet pour créer un nouveau projet. Cela fera apparaître une nouvelle fenêtre de
projet (Figure 2) sur le bureau. Remplissez les entrées nécessaires comme suit :
Machine Translated by Google
Figure 2 : Fenêtre de lancement d'un nouveau projet (instantané du logiciel Xilinx ISE)
Nom du projet : écrivez le nom de votre nouveau projet Emplacement du
projet : le répertoire dans lequel vous souhaitez stocker le nouveau projet (Remarque : NE spécifiez PAS l'emplacement du
projet sous la forme d'un dossier sur le bureau ou d'un dossier dans le répertoire Xilinx\bin.
Votre lecteur H: est le meilleur endroit pour le mettre. Le chemin de l'emplacement du projet ne doit PAS contenir d'espaces, par
exemple : C:\Nivash\TA\new lab\sample Exercises\o_gate ne doit PAS être utilisé)
Laissez le type de module de niveau supérieur sur HDL.
Exemple : Si le nom du projet était "o_gate", entrez "o_gate" comme nom de projet, puis cliquez sur "Suivant".
Cliquer sur SUIVANT devrait faire apparaître la fenêtre suivante :
Machine Translated by Google
Figure 3 : Dispositif et flux de conception du projet (instantané du logiciel Xilinx ISE)
Pour chacune des propriétés indiquées ci­dessous, cliquez sur la zone 'valeur' et sélectionnez dans la liste des valeurs qui
s'affichent.
o Device Family : Famille du FPGA/CPLD utilisé. Dans ce laboratoire, nous utiliserons les FPGA Spartan3E. o Appareil :
Le numéro de l'appareil réel.
Pour ce laboratoire, vous pouvez entrer XC3S250E
(ceci peut être trouvé sur la carte de prototypage ci­jointe)
o Package : Le type de package avec le nombre de broches. Le FPGA Spartan utilisé dans ce laboratoire est conditionné
dans le package CP132. o Niveau de vitesse : le
niveau de vitesse est "­4". o Outil de synthèse : XST [VHDL/
Verilog] o Simulateur : L'outil utilisé pour simuler et
vérifier la fonctionnalité de la conception.
Le simulateur Modelsim est intégré dans Xilinx ISE. Par conséquent, choisissez "Modelsim­XE Verilog" comme
simulateur ou même Xilinx ISE Simulator peut être utilisé.
o Cliquez ensuite sur SUIVANT pour enregistrer les entrées.
Tous les fichiers de projet tels que les schémas, les netlists, les fichiers Verilog, les fichiers VHDL, etc., seront stockés dans un sous­
répertoire portant le nom du projet. Un projet ne peut avoir qu'un seul fichier source HDL de premier niveau (ou schéma). Des modules
peuvent être ajoutés au projet pour créer une conception modulaire et hiérarchique (voir Section 9).
Pour ouvrir un projet existant dans Xilinx Tools, sélectionnez File­>Open Project pour afficher la liste des projets sur la machine.
Choisissez le projet que vous voulez et cliquez sur OK.
Machine Translated by Google
Cliquer sur NEXT dans la fenêtre ci­dessus fait apparaître la fenêtre suivante :
Figure 4 : Créer une nouvelle fenêtre source (instantané du logiciel Xilinx ISE)
Si vous créez un nouveau fichier source, cliquez sur NOUVELLE SOURCE.
3.2 Création d'un fichier d'entrée Verilog HDL pour une conception logique combinatoire
Dans ce laboratoire, nous entrerons dans une conception à l'aide d'une description structurelle ou RTL à l'aide de Verilog HDL.
Vous pouvez créer un fichier d'entrée Verilog HDL ( fichier .v) à l'aide de l'éditeur HDL disponible dans les outils Xilinx ISE (ou
n'importe quel éditeur de texte).
Dans la fenêtre précédente, cliquez sur la NOUVELLE SOURCE
Une fenêtre apparaît comme illustré à la figure 4. (Remarque : l'option "Ajouter au projet" est sélectionnée par défaut. Si vous ne la
sélectionnez pas, vous devrez ajouter manuellement le nouveau fichier source au projet.)
Machine Translated by Google
Figure 5 : Création du fichier source Verilog­HDL (instantané du logiciel Xilinx ISE)
Sélectionnez Module Verilog et dans la zone "Nom de fichier :", entrez le nom du fichier source Verilog que
vous allez créer. Assurez­vous également que l'option Ajouter au projet est sélectionnée afin que la source
n'ait pas besoin d'être à nouveau ajoutée au projet. Cliquez ensuite sur Suivant pour accepter les entrées.
Cela fait apparaître la fenêtre suivante (Figure 5).
Figure 6 : Fenêtre Définir la source Verilog (instantané du logiciel Xilinx ISE)
Machine Translated by Google
Dans la colonne Nom du port , entrez les noms de toutes les broches d'entrée et de sortie et spécifiez la direction en
conséquence. Un vecteur/bus peut être défini en saisissant les numéros de bit appropriés dans les colonnes MSB/LSB .
Cliquez ensuite sur Suivant> pour obtenir une fenêtre affichant toutes les informations sur la nouvelle source (Figure 6).
Si des modifications doivent être apportées, cliquez simplement sur <Retour pour revenir en arrière et apporter des
modifications. Si tout est acceptable, cliquez sur Terminer > Suivant > Suivant > Terminer pour continuer.
Figure 7 : Nouvelle fenêtre d'informations sur le projet (instantané du logiciel Xilinx ISE)
Une fois que vous avez cliqué sur Terminer, le fichier source s'affiche dans la fenêtre des sources du navigateur de
projet (Figure 1).
Si une source doit être supprimée, faites simplement un clic droit sur le fichier source dans la fenêtre Sources du projet
dans le navigateur du projet et sélectionnez Supprimer dans celui­ci. Sélectionnez ensuite Projet ­> Supprimer les
données d'implémentation dans la barre de menus du navigateur de projet pour supprimer tous les fichiers associés.
3.3 Modification du fichier source Verilog
Le fichier source sera maintenant affiché dans la fenêtre du Navigateur de projet (Figure 8). La fenêtre du fichier source
peut être utilisée comme éditeur de texte pour apporter les modifications nécessaires au fichier source. Tous
Machine Translated by Google
les broches d'entrée/sortie seront affichées. Enregistrez régulièrement votre programme Verilog en sélectionnant Fichier­>
Enregistrer dans le menu. Vous pouvez également modifier les programmes Verilog dans n'importe quel éditeur de texte et les
ajouter au répertoire du projet à l'aide de "Ajouter une source de copie".
Figure 8 : Fenêtre de l'éditeur de code source Verilog dans le navigateur de projet (à partir du logiciel Xilinx ISE)
Ajout de la logique dans le modèle de code source Verilog généré :
Un bref tutoriel Verilog est disponible en annexe­A. Par conséquent, la syntaxe du langage et la construction des
équations logiques peuvent être renvoyées à l'Appendice­A.
Le modèle de code source Verilog généré affiche le nom du module, la liste des ports ainsi que les déclarations
(entrée/sortie) pour chaque port. Le code logique combinatoire peut être ajouté au code verilog après les déclarations
et avant la ligne endmodule.
Par exemple, une sortie z dans une porte OU avec des entrées a et b peut être décrite comme,
attribuer z = a | b;
N'oubliez pas que les noms sont sensibles à la casse.
Autres constructions pour modéliser la fonction logique :
Machine Translated by Google
Une fonction logique donnée peut être modélisée de plusieurs façons dans verilog. Voici un autre exemple
dans lequel la fonction logique est implémentée sous forme de table de vérité à l'aide d'une instruction case :
module or_gate(a,b,z);
entrée
un ;
entrée b ; sortie z ;
reg z;
toujours @(a ou b)
commence
cas ({a,b})
00 : z = 1'b0 ;
01 : z = 1'b1 ;
10 : z = 1'b1 ;
11 : z = 1'b1 ;
endcase
fin
endmodule
Supposons que nous voulions décrire une porte OU. Cela peut être fait en utilisant l'équation logique comme illustré à la
figure 9a ou en utilisant l'énoncé de cas (décrivant la table de vérité) comme indiqué à la figure 9b. Ce ne sont que deux
exemples de constructions pour concevoir une fonction logique. Verilog propose de nombreuses constructions de ce type
pour modéliser efficacement les conceptions. Un bref tutoriel de Verilog est disponible dans l'Annexe­A.
Figure 9 : Description de la porte OU à l'aide de l'instruction assign (instantané du logiciel Xilinx ISE)
Machine Translated by Google
Figure 10 : Description de la porte OU à l'aide de l'instruction case (du logiciel Xilinx ISE)
4. Synthèse et mise en œuvre de la conception
La conception doit être synthétisée et mise en œuvre avant de pouvoir en vérifier l'exactitude, en exécutant une
simulation fonctionnelle ou en la téléchargeant sur la carte de prototypage. Avec le fichier Verilog de niveau
supérieur ouvert (peut être fait en double­cliquant sur ce fichier) dans la fenêtre de l'éditeur HDL dans la moitié
droite du navigateur de projet, et la vue du projet étant dans l'option de conception d'outil de vue de
, le
module peut être vue dans la vue du processus. Les utilitaires d'entrée de conception et les options Générer
un fichier de programmation sont également visibles dans la vue du processus. Le premier peut être utilisé
pour inclure des contraintes d'utilisateur, le cas échéant et le second sera discuté plus tard.
Pour synthétiser le design, double­cliquez sur l' option Synthesize Design dans la fenêtre
Processes.
Pour implémenter la conception, double­cliquez sur l' option Implémenter la conception dans la fenêtre Processus.
Il passera par des étapes telles que Translate, Map et Place & Route. Si l'une de ces étapes n'a
pas pu être effectuée ou a été effectuée avec des erreurs, elle placera une marque X devant
celle­ci, sinon une coche sera placée après chacune d'elles pour indiquer la réussite. Si tout est
fait avec succès, une coche sera placée devant l' option Implémenter la conception . S'il y a
Machine Translated by Google
avertissements, on peut voir une marque devant l'option indiquant qu'il y a des avertissements.
On peut regarder les avertissements ou les erreurs dans la fenêtre de la console présente au bas de la fenêtre du navigateur. Chaque
fois que le fichier de conception est enregistré ; toutes ces marques disparaissent demandant une nouvelle compilation.
Figure 11 : Mise en œuvre de la conception (instantané du logiciel Xilinx ISE)
Le diagramme schématique du code Verilog synthétisé peut être visualisé en double­cliquant sur View RTL Schematic sous le menu
Synthesize­XST dans la fenêtre Process. Ce serait un moyen pratique de déboguer le code si la sortie ne répond pas à nos spécifications
dans la carte de type prototype.
En double­cliquant dessus, vous ouvrez le module de niveau supérieur affichant uniquement les entrées et les sorties, comme indiqué ci­
dessous.
Machine Translated by Google
Figure 12 : Hiérarchie de niveau supérieur de la conception
En double­cliquant sur le rectangle, cela ouvre la logique interne réalisée comme indiqué ci­
dessous.
Machine Translated by Google
Figure 13 : Logique réalisée par le XilinxISE pour le code verilog
5. Simulation fonctionnelle des conceptions combinatoires
5.1 Ajout des vecteurs de test
Pour vérifier la fonctionnalité d'une conception, nous devons appliquer des vecteurs de test et simuler le circuit.
Afin d'appliquer des vecteurs de test, un fichier de banc de test est écrit. Essentiellement, il fournira toutes les
entrées au module conçu et vérifiera les sorties du module. Exemple : Pour la porte OU à 2 entrées, les étapes pour
générer le banc de test sont les suivantes :
Dans la fenêtre Sources (coin supérieur gauche), faites un clic droit sur le fichier pour lequel vous souhaitez générer
le banc de test et sélectionnez 'Nouvelle source'
Fournissez un nom pour le banc d'essai dans la zone de texte du nom de fichier et sélectionnez "Verilog test
fixture" parmi les types de fichiers dans la liste sur le côté droit, comme illustré à la figure 11.
Figure 14 : Ajout de vecteurs de test à la conception (instantané du logiciel Xilinx ISE)
Cliquez sur 'Suivant' pour continuer. Dans la fenêtre suivante sélectionnez le fichier source auquel vous souhaitez
associer le banc de test.
Machine Translated by Google
Figure 15 : Associer un module à un banc de test (instantané du logiciel Xilinx ISE)
Cliquez sur Suivant pour continuer. Dans la fenêtre suivante, cliquez sur Terminer. Vous allez maintenant recevoir un modèle
pour votre banc d'essai. S'il ne s'ouvre pas automatiquement, cliquez sur le bouton radio à côté de Simulation .
Vous devriez maintenant pouvoir visualiser votre modèle de banc de test. Le code généré serait
quelque chose comme ça:
module o_gate_tb_v ;
// Contributions
reg un;
Machine Translated by Google
rég b;
// Les sorties
fil de;
// Instanciation de l'unité sous test (UUT)
o_gate uut (
.a(a),
.b(b),
.z(z)
);
début initial
// Initialiser les entrées
un = 0 ;
b=0;
// Attendez 100 ns pour que la réinitialisation globale se termine
#100 ;
// Ajouter un stimulus ici
fin
module final
L'outil Xilinx détecte les entrées et les sorties du module que vous allez tester et
Machine Translated by Google
leur attribue des valeurs initiales. Afin de tester complètement la porte, nous fournirons tous les différents
combinaisons d'entrée. '#100' est la temporisation pendant laquelle l'entrée doit maintenir le courant
valeur. Une fois que 100 unités de temps se sont écoulées, le prochain ensemble de valeurs peut être affecté aux entrées.
Complétez le banc d'essai comme indiqué ci­dessous :
module o_gate_tb_v ;
// Contributions
reg un;
rég b;
// Les sorties
fil de;
// Instanciation de l'unité sous test (UUT)
o_gate uut (
.a(a),
.b(b),
.z(z)
);
début initial
// Initialiser les entrées
un = 0 ;
b=0;
Machine Translated by Google
// Attendez 100 ns pour que la réinitialisation globale se termine
#100 ;
un = 0 ;
b=1;
// Attendez 100 ns pour que la réinitialisation globale se termine
#100 ;
un = 1 ;
b=0;
// Attendez 100 ns pour que la réinitialisation globale se termine
#100 ;
un = 1 ;
b=1;
// Attendez 100 ns pour que la réinitialisation globale se termine
#100 ;
fin
module final
Enregistrez votre fichier de banc d'essai à l'aide du menu Fichier.
5.2 Simulation et affichage des formes d'onde de sortie
Maintenant, sous la fenêtre Processus (en vous assurant que le fichier testbench dans la fenêtre Sources est
sélectionné), développez l' onglet du simulateur ModelSim en cliquant sur le signe d'ajout à côté. Double­
cliquez sur Simuler un modèle comportemental. Vous recevrez probablement une erreur de compilateur. Ce n'est rien
Machine Translated by Google
à vous inquiéter ­ répondez "Non" lorsqu'on vous demande si vous souhaitez abandonner la simulation. Cela devrait entraîner
l'ouverture de ModelSim. Attendez qu'il termine son exécution. Si vous ne souhaitez pas recevoir l'erreur du compilateur,
cliquez avec le bouton droit sur Simuler le modèle comportemental et sélectionnez les propriétés du processus. Cochez
la case à côté de "Ignorer la vérification d'avertissement de bibliothèque pré­conforme".
Figure 16 : Simulation de la conception (instantané du logiciel Xilinx ISE)
5.3 Enregistrement des résultats de la simulation
Pour enregistrer les résultats de la simulation, accédez à la fenêtre de forme d'onde du simulateur Modelsim, cliquez sur Fichier
­> Imprimer en Postscript ­> donnez le nom de fichier et l'emplacement souhaités.
Notez que par défaut, la forme d'onde est "zoomée" au niveau de la nanoseconde. Utilisez les commandes de zoom pour afficher
la forme d'onde entière.
Sinon, une option d'impression d'écran normale peut être utilisée sur la fenêtre de forme d'onde et ensuite stockée dans Paint.
Machine Translated by Google
Figure 17 : Forme d'onde de sortie de la simulation comportementale (instantané de ModelSim)
Pour prendre des impressions pour les rapports de laboratoire, convertissez le fond noir en blanc dans Outils ­>
Modifier les préférences. Cliquez ensuite sur l'attribut Wave Windows ­> Wave Background.
Machine Translated by Google
Figure 18 : Modification de l'arrière­plan de la forme d'onde dans ModelSim
Machine Translated by Google
6. Préparation et téléchargement du fichier bitstream pour le FPGA Spartan :
Un fichier bitstream doit être préparé pour chaque conception et téléchargé sur la carte de prototypage Basys2. Cela
se fait comme suit:
Fichier de contraintes utilisateur :
o Afin de tester la conception de la carte Basys2, les entrées doivent être connectées aux interrupteurs/boutons de la
carte et les sorties doivent être connectées aux LED intégrées.
o Pour créer le fichier de contraintes, assurez­vous que le bouton radio d'implémentation est sélectionné et que votre
module verilog est mis en surbrillance. Dans la fenêtre des processus, développez User Constraints et double­
cliquez sur I/O Pin Planning (Plan Ahead) Post Synthesis.
Répondez "Oui" lorsqu'on vous demande si vous voulez créer le fichier UCF. Cela créera le fichier de contraintes
mais ouvrira également l'application Plan Ahead. Il n'entre pas dans le cadre de ce didacticiel de couvrir Planifier
à l'avance. Attendez que Plan Ahead s'ouvre complètement, puis fermez­le. Vous verrez maintenant le fichier .ucf
dans votre hiérarchie. Double­cliquez dessus pour modifier le fichier. o Attribuez des numéros de broches
aux broches d'entrée et de sortie dans le fichier de conception Verilog à l'aide d'un «fichier de contraintes utilisateur
(fichier ucf)». Les numéros de broche peuvent être attribués en consultant la section 7 de ce didacticiel.
Enregistrez ensuite le fichier de conception et implémentez à nouveau la conception.
Notez que vous ne pouvez attribuer des numéros de broches qu'au fichier Verilog de niveau supérieur. Ensuite,
la fenêtre du navigateur de projet ressemble à celle illustrée à la figure 13.
Figure 19 : Fichier de contraintes utilisateur (instantané du logiciel Xilinx ISE)
Machine Translated by Google
Pour l'exemple OR_GATE, le fichier de contraintes utilisateur utilisé est le suivant :
# Les boules P11 et L3 du FPGA sont connectées à SW0 et SW1 dans la carte Basys2 et la boule M5 du FPGA
est connectée à LED0 dans la carte Basys2.
# Liste des contraintes de porte OU ­ Commentaire
NET a LOC = "P11" ;
NET b LOC = "L3" ;
NET z LOC = "M5" ;
Dans la vue Sources, choisissez le fichier de conception principal et dans l'option Vue de processus ­> Contraintes utilisateur ­>
Modifier les contraintes, ajoutez le fichier de contraintes utilisateur pour la conception.
Ensuite, dans la fenêtre Process View (en bas à gauche), double­cliquez sur 'Générer le fichier de programmation'.
6.1 Programmation de l'appareil
Une fois le fichier de programmation (fichier de flux binaire) généré, le fichier doit être téléchargé sur l'appareil Spartan3. Cela se fait
en utilisant une autre application Adept fournie par Digilent Inc.,
Connectez la carte de démonstration au PC à l'aide du câble d'extension USB. Connectez le connecteur USB de type A au PC et
l'extrémité Mini­AB à la carte de démonstration.
Cliquez et allez dans Démarrer ­> Tous les programmes ­> Digilent ­> Adept ­> Adept
Machine Translated by Google
Figure 20 : Écran d'ouverture d'Adept après avoir connecté la carte FPGA
Si le tableau fonctionne correctement, il doit afficher les informations ci­dessus qui sont mises en évidence par la
case de couleur rouge. S'il ne s'affiche pas, il peut y avoir des problèmes avec la carte et/ou le câble.
Pour télécharger le programme, cliquez sur la commande Parcourir dans la première ligne qui indique FPGA
(XC3S250E). Naviguez jusqu'au dossier du projet et choisissez le fichier bit correspondant comme indiqué ci­
dessous et cliquez sur Ouvrir.
Machine Translated by Google
Figure 21 : Choix du fichier bitstream à télécharger
Une fois cela fait, une fenêtre d'avertissement apparaîtra si l'horloge est réglée sur CCLK qui peut être fermée en
cliquant sur Oui comme indiqué ci­dessous. Ou cela peut être corrigé en réglant la source d'horloge sur JTAG Clock
dans le paramètre Synthesize de XilinxISE.
Figure 22 : Avertissement concernant CCLK et JTAG CLK
Cliquez maintenant sur le bouton Programmer pour programmer le FPGA et s'il réussit à programmer, les informations
suivantes doivent apparaître dans la fenêtre d'état.
Machine Translated by Google
Figure 23 : Affichage de l'état de la programmation
Assurez­vous que le message « Programmation réussie » s'affiche dans la fenêtre de message.
Machine Translated by Google
7. Test d'un circuit logique numérique
Le test d'une conception téléchargée nécessite de connecter les entrées de la conception à des commutateurs ou des ports et les sorties
de la conception à des LED ou des affichages à 7 segments. Dans le cas de circuits séquentiels, la ou les entrées d'horloge doivent
également être connectées à des sources d'horloge. Ces entrées et sorties peuvent être connectées de manière appropriée sur l'établi du
Digital Lab.
La carte Basys2 utilisée dans le laboratoire de circuits numériques possède les caractéristiques suivantes qui peuvent être utilisées pour
tester la logique numérique dans la conception :
1. 8 commutateurs
­­ qui peuvent être utilisés pour piloter jusqu'à 8 entrées ­­ qui
2. 4 boutons
peuvent être utilisés comme signaux de réinitialisation (ou) commutateurs
d'entrée 3. 8 LED ­­ qui peuvent être utilisés pour afficher jusqu'à 8 sorties de conception 4. 4
écrans à sept segments ­ ­ qui peut être utilisé pour afficher quatre chiffres d'informations sur l'écran du tableau
Figure 24 : Architecture Basys2 (Source : www.digitalinc.com)
Afin d'utiliser le périphérique d'entrée/sortie respectif sur la carte, le numéro de broche du périphérique doit être correctement connecté
à l'entrée/sortie de la conception. Dans la carte Basys2, le numéro de broche de ces entrées/sorties est le suivant :
Boule FPGA
(A utiliser dans le fichier ucf)
Saisir
SW0
broche # P11
SW1
broche # L3
SW2
broche # K3
SW3
broche # B4
Changer
Machine Translated by Google
SW4
broche # G3
SW5
broche # F3
SW6
broche # E2
SW7
broche # N3
BTN0
broche # G12
BTN1
batterie # C11
BTN2
broche # M4
BTN3
broche # A7
Bouton
Broche FPGA
Encore à changer
Saisir
Horloge
(pour les dessins séquentiels
(A utiliser dans le fichier ucf)
GLK1
broche # P77
GCLK2
broche # P182
Broche FPGA
(A utiliser dans le fichier ucf)
Sortir
LD0
batterie # M5
LD1
broche # M11
LD2
broche # P7
LD3
broche # P6
LD4
broche # N5
LD5
broche # N4
LD6
broche # P4
LD7
Broche # G1
DIRIGÉ
7.1 Observation des sorties à l'aide des LED embarquées et des afficheurs à sept segments Les cartes Basys2 ont quatre afficheurs à
7 segments embarqués (voir Figure 19) qui sont connectés à la puce FPGA Spartan embarquée correspondante. Cet affichage peut être utilisé
pour observer les sorties de votre conception sans utiliser de fils supplémentaires si la conception est conforme aux affectations des broches de
l'affichage à 7 segments intégré. La figure ci­dessous montre l'afficheur 7 segments avec le
Machine Translated by Google
étiquetage conventionnel des segments individuels.
Figure 25 : Affichage à 7 segments
La carte Basys2 contient un affichage LED sept segments à anode commune à 4 chiffres. L'affichage est multiplexé, donc seuls sept signaux
cathodiques (CA, CB, CC, CD, CE, CF, CG) existent pour piloter les 28 segments de l'affichage. Quatre signaux d'activation de chiffre (AN1,
AN2, AN3, AN4) pilotent les anodes communes, et ces signaux déterminent quel chiffre les signaux de cathode illuminent.
Broche FPGA
(A utiliser dans le fichier ucf)
Sortir
Anode DEL
AN0
broche # F12
(Avoir l'habitude
AN1
broche # J12
AN2
broche # M13
AN3
broche # K14
CE
broche # L14
CC
broche # H12
CC
broche # N14
CD
batterie # N11
CE
broche # P12
FC
broche # L13
CG
broche # M12
DP
Broche # N13
Multiplex entre
quatre écrans)
Cathodes DEL
Ce schéma de connexion crée un affichage multiplexé, où la commande des signaux d'anode et des motifs de cathode correspondants
de chaque chiffre dans une succession continue et répétitive peut créer l'apparence d'un affichage à 4 chiffres. Chacun des quatre chiffres
apparaît brillant et allumé en permanence si les signaux d'activation des chiffres sont mis au niveau bas une fois toutes les 1 à 16 ms (pour
une fréquence de rafraîchissement de 1 KHz à 60 Hz).
La synchronisation de l'affichage à sept segments pour piloter les quatre affichages est illustrée ci­dessous :
Machine Translated by Google
Figure 26 : Chronogramme des affichages multiplexés à sept segments
Machine Translated by Google
8. Conception et simulation de circuits séquentiels à l'aide de Verilog HDL
La procédure de création de fichiers de conception Verilog pour les circuits séquentiels dans Xilinx ISE est la même que pour
les circuits combinatoires. La principale différence entre les conceptions combinatoires et séquentielles est la présence de
bascules (sorties ou nœuds enregistrés dans la section Déclaration d'une conception séquentielle).
8.1 Conception de circuits séquentiels
Pour les grandes machines à états complexes, il est plus facile de les spécifier en tant que programmes. Un circuit
séquentiel peut être décrit soit comme un bloc procédural, soit comme une machine à états dans Verilog.
1. Un D­flip avec réinitialisation asynchrone peut être modélisé comme un bloc procédural comme suit :
Figure 27 : D­Flip flop avec réinitialisation asynchrone
module dff_async (données, horloge, réinitialisation, q);
données d'entrée, horloge,
réinitialisation ; sortie q ;
reg q;
// la logique commence
ici toujours @(posedge clock ou negedge reset)
if(reset == 1'b0) q
<= 1'b0;
sinon q <=
données ; module final
Machine Translated by Google
2. Un D­flip avec réinitialisation synchrone peut être modélisé comme un bloc procédural comme suit :
Figure 28 : D­Flip flop avec réinitialisation synchrone
module dff_sync (données, horloge, réinitialisation, q);
données d'entrée, horloge,
réinitialisation ; sortie q ;
reg q;
// la logique commence
toujours ici @(posedge clock)
if(reset == 1'b0) q
<= 1'b0;
sinon q <=
données ; module final
8.2 Simulation de conceptions séquentielles
À l'exception du signal d'horloge supplémentaire, la simulation de conceptions séquentielles peut être effectuée à
l'aide de test_bench de la même manière que pour les circuits combinatoires. Le signal d'horloge peut être généré
dans le banc de test à l'aide d'un simple bloc initial comme suit :
module test_bench(clk)
sortie clk ;
reg clk;
clk de début
initial =
0 ; toujours
commencer #5 clk = ~clk; // La période de temps de l'horloge est de 10
unités de temps. fin
// suite de la logique
module final
Machine Translated by Google
9. Conception de circuits hiérarchiques à l'aide de modules
C'est toujours une bonne pratique de garder une conception modulaire et hiérarchique. Ceci est important pour
les conceptions de complexité modérée à élevée. [Reportez­vous à la section sur les hiérarchies et l'instanciation
dans le didacticiel Verilog à l'annexe A]. Souvent, vous utiliserez un circuit (module) encore et encore.
Au lieu de créer ces modules chaque fois que vous en avez besoin, il serait plus efficace d'en faire une cellule
ou un module. Vous pouvez ensuite utiliser ce module à chaque fois pour en avoir besoin en instanciant le
module dans votre circuit. Verilog prend en charge la conception hiérarchique en créant des instances
d'autres modules pouvant être utilisés dans une conception. Dans l'exemple représenté sur la figure 19, un circuit
d'équivalence à 4 bits est conçu à l'aide de modules de circuit d'équivalence à 1 bit.
Figure 29 : Exemple de conception de circuit hiérarchique : circuit d'équivalence 4 bits
Définition de module : une définition de module (bloc fonctionnel) est spécifiée dans un fichier, distinct du
fichier de conception de niveau supérieur utilisant le module.
module equiv (p,q,r)
entrée
p;
entrée q ; sortie r ;
attribuer r = ~(p ^ q);
module final
// la fonction d'équivalence est la fonction xnor.
Machine Translated by Google
Utilisation du module : Une conception utilisant un module inclut une déclaration d'interface de module
et une instanciation de chaque module dans la section Déclaration. L'instanciation du module "equiv"
dans le circuit d'équivalence 4 bits illustré à la Figure 21 peut être effectuée comme suit :
module equiv4bit(a3,b3,a2,b2,a1,b1,a0,b0,eq4) entrée
a3,b3,a2,b2,a1,b1,a0,b0 ; sortie
eq4 ;
equiv eq0(a0,b0,r0);
équiv eq1(a1,b1,r1);
équiv eq2(a2,b2,r2);
équiv eq3(a3,b3,r3);
attribuer eq4 = r0 & r1 & r2 & r3 ;
module final
NOTE : Pour la création du module, on peut soit utiliser l'assistant de conception fourni par le Xilinx soit
créer le nôtre.
Machine Translated by Google
Annexe A:
Modélisation matérielle Verilog :
Ceci est juste un tutoriel de niveau d'introduction au langage Verilog. Le lecteur est encouragé à
suivre les tutoriels Verilog suivants pour mieux comprendre le langage :
http://www­ee.eng.hawaii.edu/~msmith/ASICs/Files/pdf/CH11.pdf http://www.asic­
world.com/verilog/vbehave.html http://www.vol .webnexus.com/
[nécessite une inscription gratuite]
1. Module :
Un module est le bloc de construction de base de Verilog. Il est défini comme suit :
module <module_name> (<portlist>);
.
.
// composants du module
.
module final
Le <module_name> est le type de ce module. La <portlist> est la liste des connexions, ou ports, qui permet
aux données d'entrer et de sortir des modules de ce type.
Les modèles Verilog sont constitués de modules. Les modules, à leur tour, sont constitués de différents types
de composants. Ceux­ci inclus
Paramètres
Filets
Registres
Primitives et instances
Missions continues
Blocs procéduraux
Définitions des tâches/fonctions
2. Ports :
Les ports sont des structures Verilog qui transmettent des données entre deux ou plusieurs modules. Ainsi, les
ports peuvent être considérés comme des fils reliant les modules. Les connexions fournies par les ports
peuvent être d'entrée, de sortie ou bidirectionnelles (inout).
Machine Translated by Google
Instanciations de modules contiennent également des listes de ports. C'est le moyen de connecter les signaux du module parent
aux signaux du module enfant.
3. Filets :
Les réseaux sont les éléments qui relient les composants du modèle entre eux. Ils sont généralement considérés comme des fils dans
un circuit. Les réseaux sont déclarés dans des déclarations comme celle­ci :
net_type [gamme] [délai3] list_of_net_identifiers ;
Exemple:
fil w1, w2 ; tri
[31:0] bus32 ; fil
wire_number_5 = wire_number_2 & wire_number_3 ;
4. Registres :
Les registres sont des éléments de stockage. Les valeurs sont stockées dans des registres dans des instructions d'affectation
procédurale. Les registres peuvent être utilisés comme source pour une primitive ou une instance de module (c'est­à­dire que les registres
peuvent être connectés aux ports d'entrée), mais ils ne peuvent pas être pilotés de la même manière qu'un réseau.
Les registres sont déclarés dans des instructions comme celle­ci :
reg [plage] list_of_register_identifiers ;
Exemple:
reg r1, r2 ;
rég [31:0] bus32 ;
Machine Translated by Google
5. Opérateurs dans Verilog :
Les opérateurs logiques, arithmétiques et relationnels disponibles dans Verilog sont décrits dans le tableau 1.
Opérateurs unaires Verilog :
Source : Conception ASIC par Smith (http://www­ee.eng.hawaii.edu/~msmith/ASICs/Files/pdf/CH11.3.pdf)
Tableau 1 Opérateurs Verilog
6.. Missions continues :
Les affectations continues sont parfois appelées déclarations de flux de données car elles décrivent comment les
données se déplacent d'un endroit, soit un réseau ou un registre, à un autre. On les pense généralement
Machine Translated by Google
de comme représentant la logique combinatoire. En général, toute fonctionnalité logique qui peut être
implémentée au moyen d'une affectation continue peut également être implémentée à l'aide d'instances primitives.
Une affectation continue ressemble à ceci :
attribuer [délai3] list_of_net_assignments ;
Exemples:
attribuer w1 = w2 & w3 ;
attribuer #1 monnet = activer ; // mynet reçoit la valeur après 1 unité de temps.
7. Blocs procéduraux :
Les blocs procéduraux sont la partie du langage qui représente le comportement séquentiel. Un module peut avoir
autant de blocs procéduraux que nécessaire. Ces blocs sont des séquences d'instructions exécutables. Les
instructions de chaque bloc sont exécutées séquentiellement, mais les blocs eux­mêmes sont concurrents et
asynchrones par rapport aux autres blocs.
Il existe deux types de blocs procéduraux, les blocs initiaux et bloque toujours.
initiale <instruction> toujours <instruction>
Il peut y avoir de nombreux blocs initiaux et toujours dans un module. Puisqu'il peut y avoir de nombreux modules
dans un modèle, il peut y avoir de nombreux blocs initiaux et toujours dans l'ensemble du modèle. Tous les blocs
initial et always contiennent une seule instruction, qui peut être une instruction composée, par exemple
instruction de début initiale1 ; instruction2 ; ... fin
un. Bloc initial :
Tous les blocs initiaux commencent au temps 0 et exécutent l'instruction initiale. Étant donné que
l'instruction peut être une instruction composée, cela peut impliquer l'exécution de nombreuses instructions.
Il peut y avoir un moment ou un événement contrôles, ainsi que toutes les constructions de contrôle
du langage. Par conséquent, un bloc initial peut provoquer une activité pendant toute la simulation du
modèle.
Lorsque l'instruction initiale termine son exécution, le bloc initial se termine. Si l'instruction initiale est une
instruction composée, l'instruction se termine après la fin de sa dernière instruction.
Exemple:
x initial = 0 ; // une simple initialisation
Machine Translated by Google
initial begin //
une initialisation x = 1;
y=
f(x); #1x
=0;y=
// une valeur change 1 unité de temps plus tard
f(x); fin
b. Toujours bloquer :
Les blocs Always commencent également à l'instant 0. La seule différence entre un bloc always et un bloc initial
est que lorsque l'instruction always termine son exécution, elle recommence à s'exécuter. Notez que s'il n'y
a pas de contrôle de temps ou d'événement dans le bloc toujours, le temps de simulation ne peut jamais avancer
au­delà du temps 0. Exemple,
toujours
#10 horloge = ~horloge ;
8. Constructions de modélisation comportementale :
un. Construction conditionnelle if­else :
L'instruction if ­ else contrôle l'exécution d'autres instructions dans un
blocage procédural.
Syntaxe :
instructions if
(condition) ;
si (état)
déclarations ;
autre
déclarations ;
si (état)
déclarations ;
instructions else if
(condition);
................
................
autre
déclarations ;
Exemple:
// Instruction if simple if
(enable) q
<= d;
// Une instruction else if
(reset == 1'b1) q <=
0;; sinon
q <=
d;
Machine Translated by Google
// Instructions if­else­if imbriquées if
(reset == 1'b0)
counter <= 4'b0000 ;
sinon si (enable == 1'b1 && up_en == 1'b1) compteur
<= compteur + 1'b1 ;
sinon si (enable == 1'b1 && down_en == 1'b1); compteur
<= compteur ­ 1'b0 ; sinon
compteur <= compteur ; // Code redondant
b. Déclaration de cas :
L'instruction case compare une expression à une série d'observations et exécute l'instruction ou le
groupe d'instructions associé à la première observation correspondante. L'instruction case prend en
charge une ou plusieurs instructions. Plusieurs instructions peuvent être regroupées à l'aide de mots­clés
de début et de fin.
Syntaxe:
cas (<expression>)
<cas1> : <instruction>
<case2> : <instruction>
.....
par défaut : <instruction>
endcase
Exemple:
module mux (a,b,c,d,sel,y);
entrée a, b, c, d ;
entrée [1:0]
sélection ; sortie y ;
reg y;
toujours @ (a ou b ou c ou d ou sel) cas
(sel) 0 : y =
a; 1 : y =
b;2:y=
c;3:y=
ré ; par
défaut : $display("Erreur dans SEL");
endcase
module final
9. Instanciations et hiérarchies de modules :
Verilog vous permet de représenter la hiérarchie d'un dessin. Une manière plus courante de décrire les
relations hiérarchiques est la suivante :
Machine Translated by Google
On dit qu'un parent instancie un module enfant. C'est­à­dire qu'il en crée une instance pour en faire un sous­
modèle du parent. Dans cet exemple,
le système instancie comp_1, comp_2
comp_2 instancie sub_3
Les modules d'une hiérarchie ont à la fois un type et un nom. Les types de modules sont définis dans Verilog.
Il peut y avoir plusieurs instances de module du même type de module dans une même hiérarchie. La
définition de module en elle­même ne crée pas de module. Les modules sont créés en étant
instanciés dans un autre module, comme ceci :
module <module_name_1> (<portlist>);
.
.
<module_name_2> <instance_name> (<portlist>);
.
.
module final
Machine Translated by Google
Machine Translated by Google
Annexe B – Téléchargement et installation de Xilinx ISE Webpack (version étudiant)
Accédez à http://www.xilinx.com/univ/ .
ISE® WebPACK™ Outils de conception FPGA.
Dans la rubrique "étudiants", cliquez sur Télécharger gratuitement
Machine Translated by Google
Cliquez sur Télécharger le logiciel ISE WebPACK pour Windows et Linux
Cliquez sur le fichier approprié pour votre système. Le plus souvent, ce sera Windows 32 bits/64 bits
Vous serez redirigé vers le site sécurisé de Xilinx. Vous devez créer un compte afin de télécharger le fichier. Le fichier est
assez volumineux (environ 3 Go) et prendra un certain temps à télécharger. Le site Web de Xilinx vous demandera
également d'installer un gestionnaire de téléchargement. Vous remarquerez cette invite dans la barre supérieure de votre
fenêtre Internet Explorer. Installez le gestionnaire de téléchargement pour terminer
le téléchargement.
Le fichier tar que vous téléchargez peut ne pas être reconnu par votre ordinateur. Il est similaire à un fichier zip.
Le programme suggéré pour travailler avec le fichier tar est WinRAR. Un essai de ceci peut être téléchargé à http://
www.rarlab.com/download.htm
Une fois le fichier téléchargé, "décompressez" le fichier tar à l'aide de WinRAR ou du programme de votre choix. Tous
les fichiers seront extraits dans un dossier nommé "Xilinx_ISE_DS_Win_12.1_M.53d.0.4"
Machine Translated by Google
Une fois les fichiers extraits, recherchez le dossier Xilinx_ISE_DS_Win_12.1_M.53d.0.4 et double­cliquez
xsetup.exe pour commencer l'installation.
Cliquez sur suivant sur l'écran d'accueil. Acceptez les deux conditions de licence du logiciel et cliquez sur Suivant.
L'écran suivant est très important. Vous devez sélectionner la version ISE Webpack pour l'installation. Le
la sélection par défaut n'est pas correcte (System Edition). Plus tard dans l'installation, vous serez redirigé vers le site Web
de Xilinx pour obtenir un fichier de licence. Le fichier de licence que vous obtiendrez est pour le Webpack et ne fonctionnera
pour aucune autre version. Sélectionnez ISE Webpack et cliquez sur suivant.
Machine Translated by Google
Cliquez sur suivant sur les 2 écrans suivants, puis cliquez sur Installer.
Machine Translated by Google
Au fur et à mesure que l'installation se termine, le gestionnaire de configuration de licence Xilinx s'ouvrira afin que vous
puissiez obtenir la licence. Cette étape est très importante ­ cliquez sur le bouton radio à côté de "Obtenir une licence
WebPack ISE gratuite" et cliquez sur Suivant. Cliquez sur "Se connecter maintenant" dans la fenêtre qui apparaît.
Connectez­vous à Xilinx avec le nom d'utilisateur et le mot de passe que vous avez créés précédemment. Cliquez sur Suivant
en bas de l'écran d'informations. Sur l'écran suivant, assurez­vous que la licence ISE Webpack est cochée
et cliquez sur "Générer une licence verrouillée par nœud". Cliquez sur Suivant sur Générer une licence de nœud
fenêtre qui apparaît. Cliquez sur Suivant dans la fenêtre d'examen de la demande de licence. Vous pouvez
maintenant télécharger le fichier .lic depuis l'onglet "Gérer les licences".
De retour dans Xilinx License Manager, copiez la licence qui a été générée en cliquant sur le bouton copier
bouton de licence. La licence sera copiée dans le répertoire .Xilinx.
Machine Translated by Google
Annexe C – Téléchargement et installation de ModelSim PE (version étudiant)
Accédez à http://model.com/content/modelsim­pe­student­edition­hdl­simulation
Vers le bas de la page, cliquez sur l'onglet Télécharger et cliquez sur Télécharger. Vous pouvez
téléchargez également les 3 éléments sous "Documentation" pour référence.
Une nouvelle fenêtre devrait s'ouvrir, permettant avec un formulaire à remplir afin de demander une licence. Remplissez
correctement le formulaire, car le fichier de licence vous est envoyé par e­mail. Une fois le formulaire rempli, la
page suivante contiendra le lien pour télécharger le fichier de configuration. ModelSim PE Student Edition ne
fonctionnera pas correctement sans clé de licence. Après l'installation du logiciel, un nouveau navigateur s'ouvrira sur
le formulaire de demande de licence. Vous devrez remplir à nouveau le formulaire pour qu'une licence soit générée.
Il vous sera envoyé par e­mail avec les instructions pour l'activer.
Machine Translated by Google
Après avoir téléchargé les fichiers qui ont été envoyés par e­mail, vous devriez avoir quelque chose comme ceci :
Installez modelsim en double­cliquant sur modelsim­pe_student_edition.exe A la fin de
l'installation, la configuration vous connectera au site Web de Modelsim pour demander un fichier de licence si ce n'est
déjà fait. Reportez­vous au fichier install.txt pour la bonne utilisation du fichier student_license.dat
Machine Translated by Google
Annexe D – Connecter Xilinx et ModelSim PE
Pour que vos simulations s'exécutent correctement, nous devons indiquer à Xilinx quel outil de simulation nous utilisons et l'emplacement
de l'exécutable. Cela se fait dans les préférences Xilinx. Ouvrez Xilinx en double­cliquant sur l' icône Xilinx ISE Design Suite 12.1
sur votre bureau ou dans le menu Démarrer.
Autoriser Xilinx à s'ouvrir et cliquer sur Edition­>Préférences. Mettez en surbrillance les outils intégrés dans le menu
arbre à gauche. Mettez le chemin vers l'exécutable pour ModelSim dans la première ligne. La configuration typique est illustrée dans
la capture d'écran ci­dessous. Vous pouvez cliquer sur le bouton avec les 3 points pour accéder à l'emplacement où ModelSim a été
installé.
Cliquez sur OK pour accepter. Vous devriez maintenant être en mesure d'exécuter des simulations comme décrit dans le didacticiel.
Téléchargement