ELE3311 – SYSTÈMES LOGIQUES PROGRAMMABLES...oscillateur de 100MHz, un port via un pont USB), un...
79
Guide de laboratoire ELE3311 – SYSTÈMES LOGIQUES PROGRAMMABLES Date de publication : 10 octobre 2016
Transcript of ELE3311 – SYSTÈMES LOGIQUES PROGRAMMABLES...oscillateur de 100MHz, un port via un pont USB), un...
Guide de laboratoire
ELE3311 – SYSTÈMES LOGIQUES PROGRAMMABLES
Date de publication : 10 octobre 2016
HISTORIQUE DE RÉVISION DU DOCUMENT
Révision Date de publication
Pages affectées
Auteur Description
0.1 21-07-2016 Toutes P. Levesque V. Simard
Première version préliminaire
0.2 05-10-2016 Toutes P. Levesque V. Simard
Deuxième version préliminaire
1.0 05-10-2016 Toutes P. Levesque V. Simard
Première version
Page ii
Table des matières
1 Présentation de la carte de développement ............................................................................. 1
2 Réalisation d’un projet avec vivado ........................................................................................ 3
2.1 Flot de conception avec le logiciel Vivado ...................................................................... 3
2.2 Création d’un projet avec Vivado .................................................................................... 4
2.2.1 Configuration d’un projet pour une carte de développement ................................... 8
2.3 Ajout de sources au projet ................................................................................................ 9
2.3.1 Ajout de fichiers source VHDL ................................................................................ 9
2.3.2 Création de fichiers VHDL ..................................................................................... 10
2.3.3 Ajout de IP – CLK Wizard ..................................................................................... 12
2.4 Analyse RTL .................................................................................................................. 16
2.5 Synthèse ......................................................................................................................... 17
2.5.1 Lancement de la synthèse ....................................................................................... 17
2.5.2 Rapport de synthèse ................................................................................................ 17
2.5.3 Erreurs possibles et effets ....................................................................................... 18
2.6 Implémentation............................................................................................................... 22
2.6.1 Lancement de l’implémentation ............................................................................. 22
2.7 Programmation du FPGA ............................................................................................... 23
2.8 Simulation ...................................................................................................................... 24
2.8.1 Objectifs .................................................................................................................. 24
2.8.2 Les types de simulation ........................................................................................... 24
2.8.3 Simulation avec Vivado Simulator ......................................................................... 25
2.8.3.1 Simulation fonctionnelle ................................................................................................. 26
2.8.3.2 Simulation fonctionnelle post-synthèse et post-implémentation .................................. 29
2.8.3.3 Simulation post-synthèse et post-implémentation avec délais ...................................... 30
2.8.3.4 Simulations à privilégier .................................................................................................. 31
2.8.3.5 Problèmes lors des simulations ...................................................................................... 32
Page iii
3 Exemples ............................................................................................................................... 35
3.1 Assignation des ports de l’entité hiérarchique supérieure aux broches du FPGA ......... 35
3.2 MSA – compteur croissant et décroissant 4 bits ............................................................ 38
3.3 Pipeline de traitement ..................................................................................................... 57
3.4 Mémoire ROM ............................................................................................................... 60
3.5 Mémoire RAM ............................................................................................................... 61
4 Références ............................................................................................................................. 66
5 Assignation des broches du ARTIX-7 sur la carte Nexys Video.......................................... 67
Page iv
1 PRÉSENTATION DE LA CARTE DE DÉVELOPPEMENT
Le cœur de la plateforme de développement Nexys Video de la compagnie Digilent est le
composant programmable Artix-7 XC7A200T. Ce composant est un FPGA de la série 7 du
fabricant Xilinx qui utilise une technologie de lithographie de 28nm et qui possède beaucoup de
ressources par rapport aux autres composants de la famille Artix-7. Les FPGA Artix-7 sont
optimisés pour les applications à faible puissance et à coût réduit. En comparaison avec les autres
familles de FPGA de Xilinx, cette famille possède des performances supérieures à la famille
d’entrée de gamme Spartan-7 ; toutefois, les familles Kintex-7 (haut de gamme – optimisée pour
le ratio prix-performance) et Virtex-7 (très haut de gamme – optimisée pour les performances et
les capacités) sont plus performantes.
Le XC7A200T possède les caractéristiques suivantes :
Ressources logiques Cellules logiques (logic cells) 215 360
Tranches (Slices) 33 650 CLB Flip-Flop 269 200
Ressources de mémoire Mémoire distribuée max. 2 888 kb
Bloc RAM / FIFO 365 Capacité Bloc RAM (total) 13 140 kb
Ressources matérielles IP embarquées
Tranches DSP 740 PCIe Gen2 1
AES / HMAC 1 CAN 1
Tranceiver GTP (6.6 Gb/s max.) 16
Ressources entrées/sorties IO asymétrique (Single-ended) max. 500 IO différentiel max. 240
Ressources pour horloge CMT (1 MMCM + 1PLL) 10
Page 1
La plateforme Nexys Video est conçue pour faciliter le développement d’applications de
traitement d’audio et vidéo ; on retrouve donc des interfaces audio (Audio Codec avec line in,
line out, micro et écouteur) et vidéo (DisplayPort, entrée et sortie HDMI). Plusieurs autres
interfaces usuelles sont également disponibles sur la plateforme. Parmi celles-ci, on retrouve un
oscillateur de 100MHz, un port UART (via un pont USB), un host HID USB pour la gestion
d’un clavier et d’une souris, une interface gigabit Ethernet avec connecteur et PHY, un
connecteur microSD, un afficheur OLED, une mémoire DDR3-1600 (256Mx16b), cinq boutons
poussoirs, huit interrupteurs, huit DELs, un connecteur FMC et quelques accès pour des signaux
d’entrées-sorties dont un maximum de quatre entrées analogiques qui sont reliées au
convertisseur analogique à numérique du FPGA. Finalement, la plateforme possède également
toutes les alimentations requises pour son fonctionnement ainsi que différentes options de
configuration du FPGA. Celle qui sera principalement utilisée au laboratoire est l’interface
JTAG ; la méthode est montrée à la section 2.7.
Page 2
2 RÉALISATION D’UN PROJET AVEC VIVADO
2.1 Flot de conception avec le logiciel Vivado
Le logiciel Vivado de Xilinx est un environnement de développement qui permet de parcourir
toutes les étapes importantes impliquées durant le développement d’un projet de conception. La
version utilisée au laboratoire, Vivado HL WebPACK edition est disponible gratuitement mais
ne supporte qu’une partie des circuits programmables de la série 7 des FPGA et des SOC
(ZYNC) de Xilinx. Cette limitation ne limite pas ses fonctionnalités et le FPGA Artix-7
XC7A200T sur la plateforme du laboratoire est supporté.
Le logiciel Vivado supporte les langages de description de matériel (HDL) Verilog et VHDL,
mais seul ce dernier est utilisé pour les laboratoires. C’est effectivement le langage qui est tout
indiqué pour débuter l’apprentissage du HDL car il pousse le concepteur à considérer son design
en tant que matériel et non seulement en tant qu’algorithme, il permet de repérer rapidement les
erreurs dans le code et il est toujours déterministe. De plus, une fois les concepts de HDL acquis
avec le VHDL, il est facile d’apprendre le Verilog ; l’inverse s’avère plus difficile.
Bien qu’il ne soit d’aucun secours pour la conception qui demeure l’étape la plus importante du
flot de design, Vivado vous accompagne pour toutes les autres étapes. Il vous permet de créer
des projets et de coder tous les fichiers qui s’y rattachent. Ensuite, Vivado peut vous aider à
corriger rapidement les erreurs en compilant votre code lors d’une analyse RTL. Pour l’étape de
la synthèse, vous devez déployer des efforts pour bien comprendre les messages de Vivado afin
de vous assurer que votre description VHDL a bien été interprétée. Finalement, Vivado prend en
charge l’implémentation, génère le fichier de configuration du FPGA et fait la communication
avec le FPGA pour le programmer. Pour valider la fonctionnalité, Vivado permet également
Page 3
d’effectuer différents types de simulations : fonctionnel, post-synthèse et post-implémentation,
avec et sans délais de propagation. Le reste du présent chapitre montre le développement avec
Vivado de l’exemple de la section 3.2.
2.2 Création d’un projet avec Vivado
Créez d’abord un répertoire dans votre espace disque, ici appelé didac. Assurez-vous que vous
avez bien accès en écriture à ce répertoire. N’incluez pas d’espaces dans les noms de répertoire,
du projet ou les fichiers source. Copiez les fichiers fournis par le chargé de laboratoire pour faire
le didacticiel, ou copiez le code VHDL de la section 3.2 dans des fichiers portant les noms
spécifiés.
Démarrez le logiciel Vivado et double-cliquez sur l’icône Create New Project dans la fenêtre
initiale de Vivado et appuyez sur le bouton Next.
Page 4
Donnez un nom à votre projet, ici projet_didac, et choisissez comme emplacement votre
répertoire de projet. Cliquez sur Next.
Dans la fenêtre suivante, choisissez le type de projet RTL Project et cochez l’option Do not
specify sources at this time. Les fichiers source seront ajoutés plus tard. Cliquez sur Next.
Page 5
Choisissez la plateforme de développement du laboratoire, la Nexys Video, en sélectionnant
l’option Boards. Cliquez Next, puis Finish.
Si la plateforme n’est pas disponible, vous pouvez tout de même choisir le bon FPGA,
XC7A200tsbg484-1.
Page 6
Le logiciel crée maintenant le projet et présente la fenêtre suivante. La colonne de gauche montre
les différentes étapes du flot de conception. En haut à droite, la colonne Project Summary montre
l’état actuel du projet. Le bas de la fenêtre est consacré aux résultats des différentes étapes :
rapports et messages.
Cliquez sur Project Settings à gauche pour ouvrir la fenêtre des paramètres du projet. Changez le
langage de programmation de Verilog à VHDL en changeant l’option Target Language de
l’onglet General. L’onglet Simulation est l’endroit où le logiciel de simulation peut être modifié
; toutefois, le logiciel utilisé au cours du laboratoire est celui sélectionné par défaut, Vivado
Simulator.
Page 7
2.2.1 Configuration d’un projet pour une carte de développement
Le design d’un projet pour une plateforme spécifique comme c’est le cas au laboratoire implique
que le FPGA est déjà choisi et que les broches du FPGA sont déjà routées sur le circuit imprimé
de la carte de développement ; il est donc impossible de changer la fonctionnalité des broches qui
ne sont pas des entrées/sorties génériques ; par exemple les broches dédiées à la sortie vidéo
HDMI ne peuvent prendre d’autres fonctions. Les fichiers contenant toutes les broches dédiées
sont disponibles au laboratoire ou au chapitre 5 du présent document.
Le nom des broches doit correspondre au nom des ports de l’entité du fichier du niveau
hiérarchique supérieur (top level). Ces broches sont définies dans un fichier de contraintes de
type XDC.
Dans la colonne de gauche, dans Project Manager, cliquez sur Add sources, sélectionnez Add or
create constrainst et appuyez sur Next. Faites Add files puis choisissez le fichier didac.xdc dans
votre répertoire de projet. Cliquez sur Finish.
Vous pouvez consulter le fichier en double-cliquant dessus, dans la fenêtre Sources.
Les commentaires sont indiqués par #. Remarquez que le nom de la broche, après get_ports,
correspond au nom du signal dans le fichier du niveau hiérarchique supérieur (top level), par
exemple plus bas pb_i, alors que l’indication sur la carte de développement est donnée par
sch=btnu, ce qui signifie que le bouton physique identifié par btnu sur la carte correspond au
signal pb_i dans le fichier top level.
set_property -dict { PACKAGE_PIN F15 IOSTANDARD LVCMOS12 } [get_ports { pb_i }]; # Sch=btnu
Page 8
2.3 Ajout de sources au projet
Dans le cadre de ce cours, vous devrez ajouter des sources à votre projet principalement en
ajoutant des fichiers VHDL fournis par le chargé de laboratoire ou que vous aurez déjà édités
auparavant, ou en créant des fichiers à l’aide de l’outil de Vivado.
2.3.1 Ajout de fichiers source VHDL
Pour ajouter des sources VHDL déjà écrites à l’aide d’un autre éditeur de fichiers, cliquez sur
Add Sources, puis sélectionnez Add or create design sources et appuyez sur Next. Cliquez sur
Add files et sélectionnez les fichiers suivants :
- Antirebond_1b.vhd
- Sync_IO_1.vhd
- Divise_clk_2000.vhd
- Top_level_compteur.vhd
- Msa_compteur.vhd.
Il est possible de sélectionner plusieurs fichiers en gardant la touche Ctrl enfoncée. Après avoir
cliqué OK, la fenêtre suivante devrait apparaître.
Appuyez sur Finish.
Page 9
Les fichiers ajoutés apparaissent alors dans la fenêtre Sources, respectant la hiérarchie exprimée
en VHDL expliquée dans la section 3.2.
2.3.2 Création de fichiers VHDL
Il est également possible de créer des fichiers VHDL à l’aide du template de modules VHDL de
Vivado, en cliquant sur Create file plutôt que Add files dans la fenêtre d’ajout de sources. Vous
serez alors invités à donner un nom à votre fichier puis à définir les ports de son entité. Par
exemple, entrez fichier_test dans le champ File name, cliquez OK puis Finish et entrez les
valeurs de la figure qui suit.
Page 10
Après avoir cliqué OK, le fichier créé se trouve dans la liste de sources, mais pas dans la même
hiérarchie que les autres, puisqu’il n’est pas inclus dans le fichier top_level_compteur.vhd
ajouté précédemment.
L’éditeur de texte s’ouvre quand vous double-cliquez sur le nom du fichier, montrant le contenu
créé. Notez que vous pouvez agrandir la fenêtre en cliquant sur le symbole dans le coin droit
de la fenêtre. Vous pouvez alors écrire votre propre architecture pour vos prochains designs.
Page 11
Quand vous enregistrez le fichier, en cliquant sur à droite ou en faisant ctrl-s, le logiciel vérifie
le code pour les erreurs de syntaxe de base en VHDL, telles que les ponctuations ou les
terminaisons de structures manquantes. Ces erreurs sont indiquées dans l’onglet Messages au bas
de la fenêtre.
Dans le cadre du didacticiel, tous les fichiers source sont fournis, à l’exception du module qui
sera ajouté à la prochaine section. Vous pouvez donc enlever le fichier que vous venez de créer
en faisant un clic droit sur son nom dans la fenêtre Sources, puis en choisissant Remove files
from project.
2.3.3 Ajout de IP – CLK Wizard
Dans la hiérarchie des sources, on note que l’élément inst_clk_wiz a un point d’interrogation à
sa gauche, ce qui signifie qu’il a été instancié dans le fichier top level mais que sa source n’est
pas encore incluse dans le projet. Cet élément est un outil de gestion d’horloge qui utilise les
ressources dédiées du FPGA pour les horloges ; c’est donc un module fourni par le fabricant du
FPGA Xilinx qui est disponible dans la librairie de IP (intellectual property).
Les IP sont des modules déjà codés qu’on peut ajouter dans un design sans avoir accès au code
sous-jacent. Les processeurs embarqués, plusieurs interfaces et fonctions sont disponibles sous
forme de IP. L’usage de la plupart des modules IP est inclus avec la licence du logiciel ; par
contre, certains IP demandent une licence spéciale, indiquée par le mot Purchase dans le
catalogue.
Pour voir la liste des IP disponibles, cliquez sur IP Catalog. Une liste de plusieurs éléments
provenant de Xilinx et d’autres fabricants apparaît. Ouvrez la liste de FPGA Features and
Design, puis Clocking, et double-cliquez sur Clocking Wizard.
Page 12
Si vous voulez utiliser des options qui ne sont pas couvertes par ce didacticiel, vous avez accès à
la documentation nécessaire en cliquant sur Documentation puis Product Guide dans la fenêtre
de l’outil Clocking Wizard.
Vous voulez donc ajouter au design un outil de gestion d’horloge qui générera un signal
d’horloge clk_out1 à 16MHz pour les modules du FPGA à partir du signal entrant clk_in1 à 100
MHz, provenant de l’oscillateur avec cristal de la carte de développement. De plus, il y aura en
entrée un signal d’initialisation reset, qui est le signal d’initialisation asynchrone actif haut
global pour tout le FPGA, et une sortie locked qui, lorsque active, indique que l’horloge est bien
stable et disponible pour les autres modules.
Changez le nom du composant de clk_wiz_0 à clk_wiz afin de correspondre au nom donné dans
le fichier top_level_compteur.vhd.
Page 13
Dans l’onglet Clocking Options, assurez-vous que la primitive MMCM (mixed-mode clock
manager) est sélectionnée, ainsi que Frequency Synthesis, Phase Alignment et l’option
Balanced. La fréquence de l’horloge d’entrée doit être à 100MHz.
Changez la fréquence de sortie pour 16MHz, vérifiez que la fréquence obtenue est bien 16.000
dans la colonne Actual puis cliquez sur OK.
Page 14
La fenêtre suivante vous montre que les fichiers nécessaires à la simulation et la synthèse seront
générés. Cliquez sur Generate.
Le module clk_wiz apparaît alors dans la hiérarchie.
Notez que les sources générées sont en Verilog (clk_wiz_clk_wiz.v). Vous pouvez quand même
instancier ce module en Verilog dans un fichier VHDL : dans l’onglet IP Sources de la fenêtre
Sources, sous l’élément Instantiation Template, se trouve le fichier clk_wiz.vho qui contient la
description du component et le port map en VHDL. Dans le cas présent, le fichier
top_level_compteur.vhd contient déjà ces éléments.
Page 15
2.4 Analyse RTL
L’analyse RTL transforme en portes logiques le langage HDL. Cette étape vous permet de voir
certaines erreurs de syntaxe telles que les mauvaises connexions entre les modules, les signaux
non déclarés ou de largeur non cohérente, et bien d’autres. Les erreurs et les avertissements
(warnings) apparaissent dans l’onglet Messages. Il n’est pas nécessaire de faire l’analyse RTL
avant la synthèse ; toutefois, vous devrez quand même corriger ces erreurs et avertissements
avant de passer aux étapes suivantes.
Dans le Flow Navigator à gauche de l’écran, faites un clic droit sur RTL Analysis puis New
Elaborated Design, et cliquez OK. Une fenêtre appelée Schematic apparaît et montre les
modules sous formes de boîtes connectées. Il est possible de voir le circuit à l’intérieur des boîtes
en double-cliquant dessus. Cette vue schématique peut vous aider à bien visualiser votre top level
si vous le désirez.
Page 16
2.5 Synthèse
Lors de la synthèse, Vivado interprète votre code VHDL et décompose votre design selon les
ressources matérielles du composant programmable ciblé : le FPGA Artix-7 pour ce laboratoire.
Il est important à cette étape de vérifier, à l’aide du rapport de synthèse, comment est interprété
votre code par Vivado afin de s’assurer que l’implémentation matérielle est adéquate et
correspond bien à votre intention. Vivado possède quelques paramètres de synthèse qui visent
essentiellement à le guider dans ses choix : performance VS quantité de ressources utilisées.
2.5.1 Lancement de la synthèse
De façon générale, les paramètres utilisés pour la synthèse seront ceux par défaut du logiciel.
Lancez la synthèse en cliquant sur Run Synthesis. Vous n’avez pas besoin d’avoir fait l’étape
d’analyse RTL avant de faire la synthèse.
2.5.2 Rapport de synthèse
Il est essentiel de vérifier que le processus de synthèse s’est bien déroulé en lisant le rapport de
synthèse, appelé Vivado Synthesis Report. Ce rapport contient beaucoup d’informations qui
expliquent comment le logiciel a interprété votre code et qui peuvent vous aider à comprendre
les erreurs de codage s’il y a lieu.
Dans l’onglet Reports de la fenêtre du bas, double-cliquez sur Vivado Synthesis Report. La
fenêtre qui s’ouvre s’appelle top_level_compteur.vds; ce fichier contient le rapport de synthèse.
Vous pouvez lire ce fichier avec un éditeur de texte standard : il se trouve dans votre répertoire
de projet dans un dossier dont le nom se termine par .runs. La section 2.5.4 montre certains
messages d’erreurs courants et leur signification. Vous ne devriez évidemment pas voir d’erreurs
dans les fichiers fournis pour le didacticiel ; mais ces messages risquent d’apparaître lors de
projets futurs.
Page 17
2.5.3 Erreurs possibles et effets
a) Latchs
Les latchs sont des éléments de mémoire indésirables qui sont causés par des assignations de
signal avec des conditions incomplètes, par exemple, une condition case avec des conditions
manquantes ou une condition if sans else. Les latchs entraînent souvent un
dysfonctionnement du système et doivent être évités. S’il y en a, le rapport de synthèse contient
un avertissement :
WARNING: [Synth 8-327] inferring latch for variable XXX
Il faut impérativement éliminer les latchs en forçant une valeur aux signaux dans tous les cas
possibles.
b) Boucle combinatoire
Les boucles combinatoires sont générées quand la sortie d’un élément combinatoire boucle vers
son entrée, sans registre entre les deux. Cela indique habituellement une erreur de codage, par
exemple une erreur d’attribution dans les signaux. Par exemple, l’assignation compteur_f <=
compteur_f +1 dans un process combinatoire entraîne l’avertissement suivant :
WARNING: [Synth 8-295] found timing loop.
Il faut simplement assigner le bon signal : compteur_f <= compteur_p +1
c) Assignation de signaux de largeur différente
Le résultat d’une opération mathématique est considéré par le logiciel Vivado comme ayant un
nombre prédéterminé de bits de largeur, peu importe la valeur réelle des signaux. Le nombre de
Page 18
bits du résultat d’une multiplication est la somme des largeurs de chacun des termes, alors que le
résultat d’une addition a le même nombre de bits que le plus grand terme.
Si on veut garder le résultat sur un nombre fixe de bits, on peut utiliser un signal intermédiaire
ayant le bon nombre de bits, inter dans l’exemple suivant, et ne garder que les bits nécessaires
signal adresse : std_logic_vector(7 downto 0); signal resultat : std_logic_vector(7 downto 0); signal inter : std_logic_vector(X downto 0); inter<=std_logic_vector(unsigned(adresse)*"0101"); --inter doit avoir 8 + 4 bits de large inter<=std_logic_vector(unsigned(adresse)*4); -- inter doit avoir 8 + 8 bits de large inter<= std_logic_vector(unsigned(adresse)+"0101"); --inter doit avoir 8 bits de large resultat <= inter(7 downto 0);
Il faut évidemment s’assurer que la valeur du signal intermédiaire inter ne dépasse pas la valeur
maximale permise par la largeur du signal tronqué resultat, selon la valeur de adresse, sinon le
résultat n’est plus valide puisque des bits parmi les plus significatifs ne sont pas nuls.
Il est à noter que les signaux peuvent être élargis si on veut garder la retenue d’une addition. Par
exemple, si on croit que le résultat dépassera 8 bits, on peut ajouter un bit ‘0’ en position MSB
(la position du bit le plus significatif, pour un signal unsigned) et mettre la somme sur 9 bits :
signal somme : std_logic_vector(8 downto 0); somme<=std_logic_vector(unsigned('0'&adresse)+"11110101");
Page 19
Les mauvaises assignations entraînent des erreurs en synthèse et en simulation.
ERROR: [Synth 8-690] width mismatch in assignment; target has 16
bits, source has 12 bits
ERROR: Array sizes do not match, left array has 16 elements,
right array has 12 elements
d) Usage des librairies pour les comparaisons sur les nombres
La librairie IEEE.NUMERIC_STD permet les opérations sur des nombres signés ou non signés.
Vous ne pouvez donc pas faire une opération directement sur un std_logic_vector; il faut
forcer le logiciel à le considérer comme un signed ou unsigned.
Par exemple, la ligne if adresse>15 then génère l’erreur:
[Synth 8-944] 0 definitions of operator ">" match here
Il faut plutôt utiliser if unsigned(adresse)>15 then .
e) Signal enlevé par l’outil d’optimisation
Une sortie ou un signal interne qui n’est jamais utilisé sera éliminé au cours de la synthèse. Un
module dont aucune sortie n’est utilisée sera simplement éliminé. Ces situations surviennent
souvent lors de la synthèse d’un projet qui est à une étape préliminaire, mais elles peuvent
également indiquer des oublis du concepteur. Voici des exemples d’avertissements contenus
dans le rapport de synthèse.
WARNING: [Synth 8-3848] Net XXX in module/entity YYY does not
have driver.
Page 20
Aucune valeur n’a été attribuée à une sortie ou un autre signal qui est utilisé ailleurs dans le
module.
WARNING: [Synth 8-3332] Sequential element ( XXX ) is unused and
will be removed from module YYY.
Un élément de mémoire n’est pas utilisé ; cela peut indiquer une erreur dans l’assignation des
signaux dans le process registré.
WARNING: [Synth 8-3331] design YYY has unconnected port XXX .
Un port d’entrée n’est pas utilisé ou un port de sortie n’a pas été assigné.
f) Plusieurs drivers pour un même signal
Si la source indiquée est un fichier VHDL qui fait la connexion de modules, il peut s’agir de
deux modules dont les sorties sont connectées par erreur.
Sinon, c’est probablement un même signal qui est assigné dans deux process différents.
CRITICAL WARNING: [Synth 8-3352] multi-driven net XXX with 1st
driver pin 'YYY'
CRITICAL WARNING: [Synth 8-3352] multi-driven net XXX with 2nd
driver pin 'ZZZ'
Page 21
2.6 Implémentation
L’objectif de l’implémentation consiste à localiser l’emplacement des ressources matérielles du
composant programmable, de les configurer et de les relier afin d’obtenir les fonctionnalités
décrites par le HDL. L’implémentation est habituellement réalisée en deux étapes : le placement
et le routage. En utilisant les résultats de la synthèse, Vivado tente d’optimiser le positionnement
et les interconnexions des ressources matérielles selon les disponibilités, les fonctionnalités et les
performances ciblées en tenant compte des contraintes de l’usager (ex : attribution des pins).
2.6.1 Lancement de l’implémentation
Cliquez sur Run implementation dans la colonne du flot de conception. La progression de
l’implémentation est indiquée en haut à droite de la fenêtre.
Vous pouvez visualiser les divers rapports d’implémentation comme IO Report qui indique
l’attribution des pins conformément au fichier XDC initial ou Utilization Report pour
l’utilisation des ressources du FPGA en double-cliquant sur leur nom dans la fenêtre Reports.
Page 22
2.7 Programmation du FPGA
Après l’implémentation, on peut lancer la génération du fichier bitstream qui sera programmé
dans la mémoire du FPGA en cliquant sur Generate bitstream.
Ouvrez ensuite le Hardware Manager en cliquant sur Open New Target sous Hardware
Manager et appuyez deux fois sur Next. Une liste du matériel programmable s’affiche,
sélectionnez celui avec le nom Digilent, puis faites encore Next et Finish. L’outil de
programmation se connecte alors.
Sous Program Device, sélectionnez le FPGA et une fenêtre apparaît pour choisir le fichier
bitstream top_level_compteur.bit
Appuyez sur Program.
Le design est maintenant prêt à être testé sur la carte de développement. Vous pouvez toujours
vous référer au fichier didac.xdc pour savoir quels boutons produisent les actions. La section 3.2
explique le fonctionnement du compteur.
Page 23
2.8 Simulation
2.8.1 Objectifs
La simulation permet d’observer la réaction du design à une série d’entrées. Les simulations sont
utiles à plusieurs moments durant un projet ; toutefois, il est recommandé de faire la synthèse
d’abord afin de s’assurer que le code est bien compris comme prévu par le logiciel. La
simulation correspond alors bien au design qui sera programmé sur la carte de développement.
De toute façon, la synthèse et la simulation permettent de détecter des erreurs dans le code et
doivent être utilisées toutes les deux.
La simulation doit comporter un environnement de test qui génère les entrées du circuit qu’on
veut tester. Cet environnement de test, appelé testbench, est un fichier VHDL qui vient instancier
le module à tester, qui peut être le top level ou un sous-module. Le testbench génère également
les entrées. Le logiciel de simulation permet ensuite de visualiser les sorties du module testé. Les
logiciels de simulation offrent également de générer des entrées à la volée, sans les écrire
d’abord dans un testbench. Toutefois il est recommandé d’utiliser un testbench afin que les
simulations soient répétables et documentées.
2.8.2 Les types de simulation
La simulation comportementale (behavioral simulation) est la simulation du code VHDL avant
la synthèse ; elle n’est pas attachée à un FPGA en particulier sauf dans le cas des IP comme le
module de gestion d’horloge de la section 2.3.3, qui est un module propre à une famille de FPGA
spécifique. Elle ne permet pas de vérifier que le code a bien été synthétisé tel que désiré, mais
assure que la syntaxe VHDL est bonne.
La simulation après synthèse (post-synthesis simulation) ou après implémentation (post-
implementation simulation) simule directement les blocs physiques tels que synthétisés et non
Page 24
plus le VHDL écrit par le programmeur. À cela peuvent s’ajouter les délais correspondant aux
délais des portes logiques et dans les interconnexions (timing simulation). Ces simulations ne
sont disponibles que lorsque la synthèse ou l’implémentation ont été effectuées.
2.8.3 Simulation avec Vivado Simulator
Il existe plusieurs logiciels de simulation HDL tels que Modelsim et ActiveHDL. Le logiciel
Vivado vient avec un simulateur intégré appelé Vivado Simulator. Il est accessible dans le design
flow à gauche de la fenêtre.
Il faut tout d’abord ajouter le fichier du testbench, si ce n’est pas déjà fait. Cliquez sur Add
sources, sélectionnez l’option Add or create simulation sources et faites Next. Ajoutez le fichier
top_level_compteur_tb.vhd et faites Finish. Remarquez que le fichier devient au-dessus du top
level dans la section Simulation Sources, puisque le top level est instancié dans le testbench.
Page 25
Si vous ouvrez l’éditeur de texte en double-cliquant sur le fichier du testbench, vous pouvez
voir d’abord le nom de l’entité. Ce nom est habituellement le nom du fichier également, mais ce
n’est pas nécessaire.
ENTITY top_level_compteur_tb IS
END top_level_compteur_tb;
Et plus bas, l’instanciation de l’entité du top level (top_level_compteur) dans une instance
qui s’appelle uut. Uut, pour unit under test, est le nom classique du module testé, mais peut être
changé pour un nom plus significatif si désiré.
uut: top_level_compteur PORT MAP ( …….)
Cliquez sur Simulation Settings. Assurez-vous que le simulateur (Target Simulator) est bien
Vivado Simulator et que le module qui sera simulé (Simulation top module name) est bien le
nom de l’entité présente dans le fichier de testbench, top_level_compteur_tb.
Dans l’onglet Simulation, le premier élément xsim.simulate.runtime est la durée de simulation à
son lancement. Par défaut, ce temps est de 1000 ns, mais la fenêtre de simulation nous permettra
de recommencer ou rallonger la simulation et ajouter les signaux désirés.
2.8.3.1 Simulation fonctionnelle
En cliquant sur Run simulation, un menu déroulant apparaît pour offrir les simulations
disponibles selon l’étape où est rendu le projet. Sélectionnez la simulation fonctionnelle
(behavioral simulation). Le fichier qui sera simulé est celui au sommet de la hiérarchie, qui doit
absolument être le nom de l’entité du testbench.
Page 26
La fenêtre au centre contient le simulateur : à droite dans l’onglet Scope la hiérarchie des
modules et à gauche le résultat des simulations. Initialement, la vue montrée est zoomée sur un
curseur placé à la fin de la simulation. Appuyez sur Zoom Fit ( ) à gauche pour voir
l’ensemble de la simulation.
De plus, au lancement de la simulation, seuls les signaux du testbench sont présents. Or, il sera
utile de pouvoir analyser les signaux à l’intérieur des modules dans la hiérarchie, par exemple les
états de la machine à états. Sous le module uut (le nom qui est donné au top level dans
l’instanciation dans le testbench), les sous-modules sont présents. Faites un clic droit sur
inst_msa et sélectionnez Add to wave window. Le nom de tous les signaux internes ou externes
du module MSA sont alors ajoutés dans la fenêtre des résultats, mais leur valeur n’apparaît pas.
Il faut recommencer la simulation avec les nouveaux signaux.
Cliquez sur le symbole Restart ( ) en haut de l’écran. Changez le temps de simulation dans la
boîte à 10 ms et cliquez sur Run ( ). Vous pouvez suivre la progression de la simulation dans
le bas de la fenêtre. À tout moment durant la simulation, vous pouvez cliquer sur Zoom Fit ( )
pour voir un aperçu des signaux.
Page 27
Pour suivre plus facilement le résultat du compteur, qui est par défaut affiché en hexadécimal,
faites un clic droit sur le signal compteur_p[3:0] et sélectionnez radix, puis Unsigned Decimal.
Le résultat est maintenant en nombres entiers usuels.
En passant le curseur de la souris sur le nom du signal, le nom complet de celui-ci avec les
modules de la hiérarchie apparaît. Cliquez sur le signal bouton_i de la MSA et déplacez-le à côté
du signal pb_i du testbench, et remarquez le délai entre le bouton en entrée du système (pb_i) et
le bouton vu par la MSA (bouton_i) dû à l’antirebond.
Les symboles permettent de déplacer le curseur vers les prochaines ou dernières transitions
du signal sélectionné. Sélectionnez le signal etat_p et parcourez ses transitions. Faites un zoom
sur l’état decr intercalé entre attente et relache; cet état est très court (une seule période
d’horloge) par rapport aux autres.
Page 28
Notez que si vous désirez faire des changements au testbench ou aux modules VHDL, vous
devez relancer la simulation (menu Run – Relaunch Simulation ou sur la barre d’outils)
plutôt que de simplement faire Restart, puisqu’il faut recompiler le code qui a été modifié.
2.8.3.2 Simulation fonctionnelle post-synthèse et post-implémentation
La simulation post-synthèse vous permet de vérifier que la transformation du code VHDL en
primitives propres au FPGA choisi s’est bien déroulée. De même, la simulation fonctionnelle
post-implémentation permet de s’assurer que le placement et le routage des portes logiques n’a
pas modifié la fonctionnalité.
Sélectionnez Run Post-implementation functional simulation dans le menu déroulant de Run
Simulation. Cliquez sur l’instance inst_msa dans la fenêtre Scope ; les objets VHDL disponibles
s’affichent alors dans la fenêtre Objects. Vous constatez alors qu’il y a plus d’objets que
précédemment, dont le nom ne correspond pas exactement au code VHDL. Faites un clic droit
sur etat_p et faites Add to Wave Window. Recommencez la simulation pour 10 ms.
Page 29
Notez que les valeurs du signal etat_p n’a plus les noms donnés dans l’énumération en VHDL,
mais bien les bits d’état attribués par l’outil de synthèse. Allez vérifier dans le rapport de
synthèse en sélectionnant Synthesis dans le flot de conception à gauche et en ouvrant le Vivado
Synthesis Report. Cherchez le mot « Encoding » pour trouver la façon sont les états ont été
encodés. Vous pouvez retourner à la fenêtre de simulation en sélectionnant Simulation dans le
flot de conception.
2.8.3.3 Simulation post-synthèse et post-implémentation avec délais
Ces simulations tiennent compte des délais dans les portes logiques et dans les interconnexions
entre les modules selon l’endroit où ils sont placés dans le FPGA. Toutefois, le simulateur ne
supporte pas à ce jour les ajouts d’annotations temporelles dans les fichiers VHDL, mais
seulement en Verilog. Cela ne nous empêche pas de faire les annotations dans le résultat de
synthèse appelé netlist qui peut être en Verilog tant que notre simulateur fonctionne dans les
deux langages, ce qui est le cas pour Vivado Simulator.
Lancez la simulation en sélectionnant Run Post-Implementation Timing Simulation, ajoutez le
signal etat_p de inst_msa à la fenêtre Wave et simulez pour 10ms.
Page 30
Vous pouvez zoomer sur un changement d’état, ici de 1 à 3. Vous pouvez constater qu’il y a un
délai de plus de 3 ns entre le front montant de l’horloge clk_100mhz_i et le changement d’état
en sortie des bascules. De plus, la sortie du compteur dels_o[3 :0] passe de 0 à 15 en plusieurs
étapes.
2.8.3.4 Simulations à privilégier
Certaines situations où les délais sont critiques, par exemple dans un accélérateur de calcul
comprenant plusieurs étages fonctionnant près de la fréquence maximale du FPGA, les
simulations avec délais sont incontournables. Par contre, dans des designs plus simples, ces
simulations sont moins utiles.
Les simulations après les étapes de synthèse, placement et routage sont plus complètes car elles
sont très proches du résultat qui peut être obtenu sur la carte de développement. L’avantage de la
simulation fonctionnelle est qu’elle est plus lisible : elle contient les noms des signaux donnés
dans le code VHDL et non pas des noms dérivés par l’outil de synthèse. Pour pouvoir se fier aux
résultats de simulation fonctionnelle, il faut coder d’une façon claire pour s’assurer que l’outil de
synthèse interprète le VHDL tel qu’attendu. Des exemples de bon code VHDL se trouvent au
chapitre 3.
Page 31
2.8.3.5 Problèmes lors des simulations
a) Signaux de valeur U ou X :
Le testbench doit spécifier toutes les entrées du module à tester et uniquement les entrées et ce,
durant toute la simulation pour éviter les valeurs inconnues ou conflictuelles.
o U signifie valeur inconnue (Unknown). Il se peut que le signal n’ait pas été
initialisé (y a-t-il un reset asynchrone ? Ce signal est-il une entrée du testbench
qui n’a pas encore de valeur ?)
o X signifie un conflit entre deux signaux. Par exemple, deux modules dont la sortie
est connectée ensemble tentent de forcer une valeur différente. Dans le cas d’une
simulation, le testbench peut par erreur donner une valeur à un signal qui sort du
module testé, créant ainsi un conflit.
b) Signaux qui dépassent l’intervalle admissible
Par exemple, vous voulez accéder à un élément d’un tableau de 16 éléments avec une adresse de
8 bits, dont vous n’utilisez que les valeurs 0 à 15. À un instant donné, la valeur du compteur est
de 16 (soit 00010000), ce qui dépasse la capacité du tableau. La simulation cesse à ce moment,
montre la ligne fautive dans le fichier source et la console TCL indique : ERROR: Index 16 out of bound 0 to 15
Begin sortie<=ROM_TABLEAU(to_integer(unsigned(adresse_p(3 downto 0)))); process(rst, clk) begin if rst = '1' then etat_p <= init; adresse_p <= (others=>'0'); elsif clk'event and clk ='1' then etat_p <= etat_f; adresse_p <= adresse_f; end if; end process;
Page 32
process(adresse_p, etat_p) begin case etat_p is when init => etat_f<= etat1; adresse_f<= std_logic_vector(unsigned(adresse_p)+1); when etat1 => if unsigned(adresse_p)>15 then etat_f <= fini; adresse_f<= (others=>'0'); else etat_f<= etat1; adresse_f<=std_logic_vector(unsigned(adresse_p)+1); end if; when others => etat_f <= fini; adresse_f<= (others=>'0'); end case;
Il est probable que le circuit réel fonctionne puisque la valeur du tableau quand l’adresse est 16
n’est jamais utilisée et que seuls les 4 bits LSB sont utilisés pour l’adresse. Pour éliminer cette
différence entre la simulation et la réalité, il est conseillé de s’assurer que l’adresse ne dépasse
pas 15 (en changeant les conditions du if à l’état etat1) et de borner l’adresse d’accès à la
mémoire, en la forçant explicitement à 4 bits :
data<=ROM_TABLEAU(to_integer(unsigned(adresse_p(3 downto 0)));
c) Liste de sensibilité incomplète
Dans l’exemple précédent, si on omet de mettre adresse_p dans la liste de sensibilité du process,
la synthèse nous donne un avertissement et le fonctionnement est correct :
WARNING: [Synth 8-614] signal 'adresse_p' is read in the process
but is not in the sensitivity list
Page 33
En simulation comportementale par contre, la simulation bloque à etat1 car aucun signal présent
dans la liste de sensibilité ne change. Il faut donc s’assurer que la liste de sensibilité soit
complète.
Page 34
3 EXEMPLES
3.1 Assignation des ports de l’entité hiérarchique supérieure aux broches du FPGA
Pour communiquer avec le monde extérieur, il faut faire une correspondance entre le nom des
ports au niveau logique qui sont déclarés dans l’entité de hiérarchie supérieure (top level) et les
broches physiques du composant programmable (FPGA). Cette association est réalisée par un
fichier de paramétrisation de l’usager (extension .xdc pour le logiciel Vivado). Ce fichier est
propre au logiciel de synthèse et diffère d’un logiciel à l’autre. Par contre, cette association est
toujours présente et doit être effectuée. Il est possible de laisser l’outil de synthèse faire cette
assignation lui-même lorsque le circuit matériel qui supporte le FPGA (PCB – printed circuit
board) n’est pas encore réalisé. Dans ce cas, il est possible de récupérer cette association dans un
rapport de placement routage.
Au laboratoire, puisque le support matériel est déjà réalisé, il est très important d’effectuer
correctement l’association de tous les ports afin d’éviter que l’outil de synthèse effectue une
association conflictuelle qui risquerait d’endommager la plateforme de développement.
Pour cet exemple, nous allons donc faire l’assignation des différents interrupteurs et des DELs et
créer un fichier top_level qui relie un interrupteur à une DEL.
Page 35
SW6(M13) SW5(J16) SW4(H17) SW3(G22) SW2(G21) SW1(F21) SW0(E22)SW7(M17)
Emplacement de la balle du FPGA qui est relié à cet élément nom de la trace sur le PCB
LD7(Y13) LD6(W15) LD5(W16) LD4(W15) LD3(U16) LD2(T16) LD1(T15) LD0(T14)
8 DELs - sur la plateforme de développement
8 interrupteurs - sur la plateforme de développement
FPGA Y13 W15 W16 W15 U16 T16 T15 T14
M17 E22M13 J16 H17 G22 G21 F21
Sig_fpga(7)
Sig _fpga(6 )
Sig_ fpga(5)
Sig_fpga(4)
Sig_fpga(3)
Sig_ fpga (2 )
Sig_fpga( 1)
Sig _fpga( 0)
Fichier VHDL de hiérarchie supérieure : fpga_top_level.vhd
Description du fichier fpga_top_level.vhd
Description – A : assignation directe entre les ports d’entrées et de sorties ;
Description – B : assignation entre les ports d’entrées et sorties en passant par un signal
interne. library IEEE; use IEEE.std_logic_1164.all; use IEEE.Numeric_std.ALL; entity fpga_top_level is Port ( switch_i : in std_logic_vector(7 downto 0); led_o: out std_logic_vector(7 downto 0) ); end fpga_top_level;
Page 36
architecture arch_fpga_top_level of fpga_top_level is
Description-A Description-B
signal sig_fpga : std_logic_vector(7 downto 0);
begin
Description-A Description-B led_o <= switch_i; sig_fpga <= switch_i;
led_o <= sig_fgpa; end arch_fpga_top_level;
Description du fichier fpga_top_level.xdc
# : commentaire
Syntaxe:
set_property -dict { PACKAGE_PIN E22 IOSTANDARD LVCMOS25 } [get_ports { switch_i[0] }];
Emplacement de la balle du FPGANom du port de l’entité
Configuration du standard du Lhs
#interrupteur set_property -dict { PACKAGE_PIN E22 IOSTANDARD LVCMOS25 } [get_ports { switch_i[0] }]; set_property -dict { PACKAGE_PIN F21 IOSTANDARD LVCMOS25 } [get_ports { switch_i[1] }]; set_property -dict { PACKAGE_PIN G21 IOSTANDARD LVCMOS25 } [get_ports { switch_i[2] }]; set_property -dict { PACKAGE_PIN G22 IOSTANDARD LVCMOS25 } [get_ports { switch_i[3] }]; set_property -dict { PACKAGE_PIN H17 IOSTANDARD LVCMOS25 } [get_ports { switch_i[4] }]; set_property -dict { PACKAGE_PIN J16 IOSTANDARD LVCMOS25 } [get_ports { switch_i[5] }]; set_property -dict { PACKAGE_PIN K13 IOSTANDARD LVCMOS25 } [get_ports { switch_i[6] }]; set_property -dict { PACKAGE_PIN M17 IOSTANDARD LVCMOS25 } [get_ports { switch_i[7] }]; #DELs set_property -dict { PACKAGE_PIN T14 IOSTANDARD LVCMOS25 } [get_ports { led_o[0] }]; set_property -dict { PACKAGE_PIN T15 IOSTANDARD LVCMOS25 } [get_ports { led_o[1] }]; set_property -dict { PACKAGE_PIN T16 IOSTANDARD LVCMOS25 } [get_ports { led_o[2] }]; set_property -dict { PACKAGE_PIN U16 IOSTANDARD LVCMOS25 } [get_ports { led_o[3] }]; set_property -dict { PACKAGE_PIN V15 IOSTANDARD LVCMOS25 } [get_ports { led_o[4] }]; set_property -dict { PACKAGE_PIN W16 IOSTANDARD LVCMOS25 } [get_ports { led_o[5] }]; set_property -dict { PACKAGE_PIN W15 IOSTANDARD LVCMOS25 } [get_ports { led_o[6] }]; set_property -dict { PACKAGE_PIN Y13 IOSTANDARD LVCMOS25 } [get_ports { led_o[7] }];
Page 37
3.2 MSA – compteur croissant et décroissant 4 bits
Le diagramme d’état d’une MSA qui permet d’incrémenter ou de décrémenter la valeur d’un
compteur lorsqu’un bouton poussoir est appuyé selon la position d’un interrupteur est illustré par
la figure suivante. La valeur du compteur doit incrémenter lorsque l’interrupteur est en position
haute et décrémenter lorsqu’il est en position basse. De plus, la valeur du compteur reboucle
continuellement.
Page 38
init compteur = X"00"
attente compteur = compteur
incrcompteur = compteur + 1 decr compteur =
compteur - 1
relache compteur = compteur
bouton
inter.
bouton
bouton bouton
0
1
1 0
0 1 1 0
01
rst
Quelques particularités de cette conception sont à souligner :
• Les valeurs de l’état et de toutes les sorties sont identifiées lors d’une initialisation par le
signal reset ;
• C’est une machine de Moore : en prévision d’inclure des registres pour toutes les sorties,
il est impératif de toujours concevoir une machine de Moore ;
Page 39
• Les valeurs de toutes les sorties sont spécifiées dans chacun des états ;
• Il y a un état d’attente qui s’assure que le bouton poussoir est relâché avant de
reconsidérer que celui-ci est actif.
Description du fichier MSA_compteur.vhd library IEEE; use IEEE.std_logic_1164.all; use IEEE.Numeric_std.ALL; entity msa_compteur is Port ( rst_i : in std_logic; clk_i : in std_logic; bouton_i : in std_logic; interrupteur_i : in std_logic; dels_o: out std_logic_vector(3 downto 0) ); end msa_compteur; architecture arch_msa_compteur of msa_compteur is type etat is (init, attente, incr, decr, relache); signal etat_p, etat_f : etat; signal compteur_p, compteur_f : std_logic_vector(3 downto 0); begin -- assignation des sorties dels_o <= compteur_p; -- process registré P_sync: process(rst_i,clk_i) begin if(rst_i = '1')then etat_p <= init; compteur_p <= "0000"; elsif(clk_i'event and clk_i = '1')then etat_p <= etat_f; compteur_p<= compteur_f; end if; end process;
Page 40
-- process combinatoire P_comb: process(etat_p, bouton_i, compteur_p, interrupteur_i) begin case etat_p is when init => etat_f <= attente; compteur_f <= compteur_p; when attente => if(bouton_i = '1')then if interrupteur_i = '1' then compteur_f <= std_logic_vector(unsigned(compteur_p)+ 1); etat_f <= incr; else compteur_f <= std_logic_vector(unsigned(compteur_p)- 1); etat_f <= decr; end if; else etat_f <= attente; compteur_f <= compteur_p; end if; when decr => if(bouton_i = '0')then etat_f <= attente; compteur_f <= compteur_p; else etat_f <= relache; compteur_f <= compteur_p; end if; when incr => if(bouton_i = '0')then etat_f <= attente; compteur_f <= compteur_p; else etat_f <= relache; compteur_f <= compteur_p; end if; when others => -- relache => if(bouton_i = '0')then etat_f <= attente; compteur_f <= compteur_p;
Page 41
else etat_f <= relache; compteur_f <= compteur_p; end if; end case; end process; end arch_msa_compteur;
Le bouton poussoir, pris au niveau de la broche d’entrée du FPGA, est un signal asynchrone et
bruité ; il est donc important de le filtrer et de le synchroniser.
Filtre anti-rebond :
Le circuit anti-rebond est composé d’un registre à décalage et d’un filtre. L’état du signal bruité
est échantillonné et sauvegardé dans un registre à décalage. Ensuite, un filtre permet de valider si
les états échantillonnés sont égaux. Si tous les échantillons sont actifs (1), alors la sortie de l’anti-
rebond sera active (1) ; si tous les échantillons sont inactifs (0), alors la sortie de l’anti-rebond
sera inactive (0) ; finalement, si les échantillons ne sont pas tous identiques (présence de bruit),
alors la sortie de l’anti-rebond sera maintenue à la valeur précédente.
Page 42
b_i D
clk_i
rst_i
D
rst_i
D
rst_i
D
rst_i
b_o
clk_i
Filtre
Dépendamment de la fréquence de l’horloge et de la profondeur du registre à décalage, il est
possible de filtrer différents bruits. Pour un bouton poussoir, une période de filtrage d’environ
1ms est acceptable. Pour ce faire, il est possible d’utiliser une fréquence d’horloge de 8kHz et un
registre de décalage d’une profondeur de huit (8) (8kHz / 8 = 1kHz –> 1ms).
Description du fichier antirebond_1b.vhd library IEEE; use IEEE.std_logic_1164.all; use IEEE.Numeric_std.ALL; entity antirebond_1b is generic ( GENERIC_SW_LOGIC : std_logic := '1'-- 1=POSITIVE 0=NEGATIVE ); Port ( rst_i : in std_logic; clk_i : in std_logic; b_i : in std_logic; b_o: out std_logic ); end antirebond_1b;
Page 43
architecture arch_antirebond_1b of antirebond_1b is
Description-A signal b_shiftreg_r : std_logic_vector (7 downto 0); signal b_clean_r : std_logic;
Description-B signal b_shiftreg_p, b_shiftreg_f : std_logic_vector (7 downto 0); signal b_clean_p, b_clean_f : std_logic; begin
Description-A b_o <= b_clean_r ; debouncing_process: process(clk_i, rst_i) begin if rst_i='1' then b_shiftreg_r <= (others=>(not(GENERIC_SW_LOGIC))); b_clean_r <= not(GENERIC_SW_LOGIC); elsif clk_i'event and clk_i='1' then b_shiftreg_r <= b_shiftreg_r(6 downto 0) & b_i; if b_shiftreg_r = "11111111" then b_clean_r <= '1'; elsif b_shiftreg_r = "00000000" then b_clean_r <= '0'; else b_clean_r <= b_clean_r; end if; end if; end process;
Description-B b_o <= b_clean_p ; P_sync: process(clk_i, rst_i) begin if rst_i='1' then b_shiftreg_p <= (others=>(not(GENERIC_SW_LOGIC))); b_clean_p <= not(GENERIC_SW_LOGIC);
Page 44
elsif clk_i'event and clk_i='1' then b_shiftreg_p <= b_shiftreg_f; b_clean_p <= b_clean_f; end if; end process; b_shiftreg_f <= b_shiftreg_p(6 downto 0) & b_i; P_comb: process(b_shiftreg_p, b_clean_p) begin if b_shiftreg_p = "11111111" then b_clean_f <= '1'; elsif b_shiftreg_p = "00000000" then b_clean_f <= '0'; else b_clean_f <= b_clean_p; end if; end process; end arch_antirebond_1b;
Synchronisation :
Le circuit de synchronisation permet de réduire les probabilités de propager un état métastable
lorsque les temps de préparation (Tsu) ou de maintien (Th) ne sont pas respectés, ce qui est très
possible avec des boutons poussoirs qui sont opérés par un usager. De plus, lorsqu’un signal
franchit la frontière entre deux domaines d’horloge, il est important d’inclure un circuit de
synchronisation.
Le circuit du filtre d’anti-rebond possède un registre à l’entrée et la fréquence d’horloge est
relativement basse ; pour ces raisons, il n’est pas obligatoire d’ajouter un circuit de
Page 45
synchronisation en amont du filtre d’anti-rebond, car ce dernier agit également comme un circuit
de synchronisation. Toutefois, la sortie du filtre n’est probablement pas synchronisée à la
fréquence du reste du circuit. Par conséquent, il est important d’inclure un circuit de
synchronisation en avant du filtre d’anti-rebond pour générer un signal synchrone au reste du
design.
Le circuit de synchronisation est donc composé de trois registres. Le premier est synchronisé
avec l’horloge du signal d’entrée et les deux registres suivants sont en cascade et utilisent
l’horloge de sortie.
io_i D D D
Clk_front_end_i
Clk_back_end_i
io_o
rst_irst_irst_i
Description du fichier sync_io_1.vhd
library IEEE; use IEEE.std_logic_1164.all; use IEEE.Numeric_std.ALL; entity sync_io_1 is generic ( GENERIC_IO_LOGIC : std_logic := '1'-- 1=POSITIVE 0=NEGATIVE ); Port ( rst_i : in std_logic; --front-end clk_front_end_i : in std_logic; io_i : in std_logic; --back-end clk_back_end_i : in std_logic;
Page 46
io_o : out std_logic ); end sync_io_1; architecture arch_sync_io_1 of sync_io_1 is
Description-A signal io_shiftreg_r : std_logic_vector (2 downto 0); signal io_in_r : std_logic;
Description-B signal io_shiftreg_p, io_shiftreg_f : std_logic_vector (2 downto 0); signal io_in_p, io_in_f : std_logic; begin
Description-A io_o <= io_shiftreg_r(2); front_end_process: process(clk_front_end_i, rst_i) begin if rst_i='1' then io_in_r <= not(GENERIC_IO_LOGIC); elsif clk_front_end_i'event and clk_front_end_i='1' then io_in_r <= io_i; end if; end process; back_end_process: process(clk_back_end_i, rst_i) begin if rst_i='1' then io_shiftreg_r <= (others=>(not(GENERIC_IO_LOGIC))); elsif clk_back_end_i'event and clk_back_end_i='1' then io_shiftreg_r <= io_shiftreg_r(1 downto 0) & io_in_r; end if; end process;
Description-B io_o <= io_shiftreg_p(2); front_end_process: process(clk_front_end_i, rst_i) begin if rst_i='1' then
Page 47
io_in_p <= not(GENERIC_IO_LOGIC); elsif clk_front_end_i'event and clk_front_end_i='1' then io_in_p <= io_in_f; end if; end process; io_in_f <= io_i; back_end_process: process(clk_back_end_i, rst_i) begin if rst_i='1' then io_shiftreg_p <= (others=>(not(GENERIC_IO_LOGIC))); elsif clk_back_end_i'event and clk_back_end_i='1' then io_shiftreg_p <= io_shiftreg_f; end if; end process; io_shiftreg_f <= io_shiftreg_p(1 downto 0) & io_in_p; end arch_sync_io_1;
Division de l’horloge
Pour la synthèse d’une horloge, il est recommandé d’utiliser un module de gestion d’horloge tel
que le montre la section 2.3.2. Toutefois, pour les fréquences très basses de moins de 5 MHz, il
n’est pas possible d’utiliser ces modules. Il faut donc utiliser un diviseur d’horloge
conventionnel.
Description du fichier divise_clk_2000.vhd library IEEE; use IEEE.std_logic_1164.all; use IEEE.Numeric_std.ALL; entity divise_clk_2000 is Port (
Page 48
rst_i : in std_logic; clk_i : in std_logic; clk_o: out std_logic ); end divise_clk_2000; architecture arch_divise_clk_2000 of divise_clk_2000 is
Description-A signal cntdiv_r : std_logic_vector (11 downto 0); signal div_temp_r : std_logic;
Description-B signal cntdiv _p, cntdiv _f : std_logic_vector (11 downto 0); signal div_temp_p, div_temp_f : std_logic; begin
Description-A clk_o <= div_temp_r; process (clk_i, rst_i) begin if rst_i='1' then div_temp_r <= '0'; cntdiv_r <= (others => '0'); elsif (clk_i'event and clk_i = '1') then if unsigned(cntdiv_r) >= 1000 then -- Diviseur par 2000 div_temp_r <= not(div_temp_r); cntdiv_r <= (others => '0'); else div_temp_r <= div_temp_r; cntdiv_r <= std_logic_vector(unsigned(cntdiv_r) + 1); end if; end if; end process;
Description-B clk_o <= div_temp_p; P_sync: process (clk_i, rst_i) begin
Page 49
if rst_i='1' then div_temp_p <= '0'; cntdiv_p <= (others => '0'); elsif (clk_i'event and clk_i = '1') then div_temp_p <= div_temp_f; cntdiv_p <= cntdiv_f; end if; end process; P_comb: process(cntdiv_p, div_temp_p) begin if unsigned(cntdiv_p) >= 1000 then -- Diviseur par 2000 div_temp_f <= not(div_temp_p); cntdiv_f <= (others => '0'); else div_temp_f <= div_temp_p; cntdiv_f <= std_logic_vector(unsigned(cntdiv_p) + 1); end if; end process; end arch_divise_clk_2000;
Instanciation des modules
La description structurelle permet de relier les différents modules (MSA, anti-rebond,
synchronisation, synthétiseur d’horloge et diviseur d’horloge). Cela est fait, dans cet exemple,
par le fichier de hiérarchie supérieure top level. Les ports qui sont définis dans l’entité de ce
module seront liés à la broche physique du FPGA à l’aide du fichier de paramétrisation montré
plus bas.
Description du fichier top_level_compteur.vhd library IEEE; use IEEE.std_logic_1164.all;
entity top_level_compteur is
Page 50
Port ( rst_i : in std_logic; clk_100mhz_i : in std_logic; pb_i : in std_logic; sw_i : in std_logic; dels_o: out std_logic_vector(3 downto 0) ); end top_level_compteur; architecture arch_top_level_compteur of top_level_compteur is --section declaration component antirebond_1b port ( rst_i : in std_logic; clk_i : in std_logic; b_i : in std_logic; b_o : out std_logic ); end component; component sync_io_1 generic ( GENERIC_IO_LOGIC : std_logic :='1'-- 1=POSITIVE 0=NEGATIVE ); port ( rst_i : in std_logic; --front-end clk_front_end_i : in std_logic; io_i : in std_logic; --back-end clk_back_end_i : in std_logic; io_o : out std_logic ); end component; component clk_wiz port (-- Clock in ports clk_in1 : in std_logic; -- Clock out ports clk_out1 : out std_logic; -- Status and control signals reset : in std_logic; locked : out std_logic );
Page 51
end component; component divise_clk_2000 port ( rst_i : in STD_LOGIC; clk_i : in STD_LOGIC; clk_o : out STD_LOGIC ); end component; component msa_compteur port ( clk_i : in STD_LOGIC; rst_i : in STD_LOGIC; bouton_i : in STD_LOGIC; interrupteur_i : in STD_LOGIC; dels_o : out std_logic_vector(3 downto 0)); end component; signal clk_16mhz : std_logic; signal locked : std_logic; signal rst_sys : std_logic; signal clk8khz : std_logic; signal bouton_ar : std_logic; signal bouton_sync : std_logic; begin inst2_deb: antirebond_1b port map ( rst_i => rst_sys, b_i => pb_i, b_o => bouton_ar, clk_i => clk8khz ); Inst_sync_io: sync_io_1 generic map ( GENERIC_IO_LOGIC => '1' -- 1=POSITIVE 0=NEGATIVE ) port map ( rst_i => rst_sys, --front-end clk_front_end_i => clk8khz,
Page 52
io_i => bouton_ar, --back-end clk_back_end_i => clk_16mhz, io_o => bouton_sync ); Inst_clk_wiz: clk_wiz port map ( -- Clock in ports clk_in1 => clk_100mhz_i, -- Clock out ports clk_out1 => clk_16mhz, -- Status and control signals reset => rst_i, locked => locked ); rst_sys <= not(locked); inst_divise_clk: divise_clk_2000 port map ( rst_i => rst_sys, clk_i => clk_16mhz, clk_o => clk8khz ); Inst_msa: msa_compteur port map ( clk_i => clk_16mhz, rst_i => rst_sys, bouton_i => bouton_sync, interrupteur_i => sw_i, --pas besoin de filtre et sync dels_o => dels_o --directement relié aux DELs ); end arch_top_level_compteur;
Page 53
Description du fichier didac.xdc
#horloge set_property -dict {PACKAGE_PIN R4 IOSTANDARD LVCMOS33}[get_ports {clk_100mhz_i}]; # Sch=sysclk
#reset set_property -dict { PACKAGE_PIN D22 IOSTANDARD LVCMOS12 } [get_ports { rst_i }]; # Sch=btnd #interrupteur set_property -dict { PACKAGE_PIN E22 IOSTANDARD LVCMOS25 } [get_ports { sw_i }]; # Sch=sw[0] #bouton set_property -dict { PACKAGE_PIN F15 IOSTANDARD LVCMOS12 } [get_ports { pb_i }]; # Sch=btnu #DELs set_property -dict { PACKAGE_PIN T14 IOSTANDARD LVCMOS25} [get_ports {dels_o[0]}]; # Sch=led[0] set_property -dict { PACKAGE_PIN T15 IOSTANDARD LVCMOS25} [get_ports {dels_o[1]}]; # Sch=led[1] set_property -dict { PACKAGE_PIN T16 IOSTANDARD LVCMOS25} [get_ports {dels_o[2]}]; # Sch=led[2] set_property -dict { PACKAGE_PIN U16 IOSTANDARD LVCMOS25} [get_ports {dels_o[3]}]; # Sch=led[3]
Description du testbench top_level_compteur_tb.vhd
LIBRARY ieee; USE ieee.std_logic_1164.ALL; ENTITY top_level_compteur_tb IS END top_level_compteur_tb; ARCHITECTURE arch_top_level_compteur_tb OF top_level_compteur_tb IS -- Component Declaration for the Unit Under Test (UUT)
Page 54
COMPONENT top_level_compteur PORT( rst_i : in std_logic; clk_100mhz_i : in std_logic; pb_i : in std_logic; sw_i : in std_logic; dels_o: out std_logic_vector(3 downto 0) ); END COMPONENT; --Inputs signal rst_i : std_logic := '0'; signal clk_100mhz_i : std_logic := '0'; signal pb_i, sw_i : std_logic := '0'; --Outputs signal dels_o : std_logic_vector(3 downto 0); -- Clock period definitions constant clk_100mhz_period : time := 10 ns; BEGIN -- Instantiate the Unit Under Test (UUT) uut: top_level_compteur PORT MAP ( rst_i => rst_i, clk_100mhz_i => clk_100mhz_i, pb_i => pb_i, sw_i => sw_i, dels_o => dels_o ); -- Clock process definitions clk_100mhz_process :process begin clk_100mhz_i <= '0'; wait for clk_100mhz_period/2; clk_100mhz_i <= '1'; wait for clk_100mhz_period/2; end process; -- Stimulus process stim_proc: process begin rst_i <='1'; pb_i <= '0';
Page 55
wait for 20 us; rst_i <= '0'; pb_i <= '0'; wait for 1000 us; pb_i <= '1'; wait for 1500 us; pb_i <= '0'; wait for 1500 us; pb_i <= '1'; wait for 1500 us; pb_i <= '0'; wait for 1500 us; pb_i <= '1'; wait for 1500 us; pb_i <= '0'; wait; end process; END;
Page 56
3.3 Pipeline de traitement
La structure est tout aussi importante que l’algorithme lors d’une implémentation matérielle
d’une unité de traitement. Il faut non seulement effectuer les bonnes opérations sur les bonnes
données pour produire les bonnes sorties ; il faut en plus structurer le chemin de données pour
tenir compte des limitations physiques du matériel et en tirer le maximum de performance.
Une façon relativement simple consiste à découper l’algorithme en différentes petites sous-
étapes parallèles et séquentielles. Chacune de ces étapes constitue un étage de calcul
combinatoire élémentaire et est séparée des autres par des registres. De cette manière, le chemin
critique qui limite la fréquence maximale d’opération sera le plus court possible. De plus, il est
avantageux de paralléliser au maximum toutes les étapes indépendantes pour tirer le maximum
de la performance matérielle.
La décomposition de l’algorithme en étages de traitement registrés introduit des latences ; c’est-
à-dire qu’il y aura des délais entre la présentation des entrées et la production de la sortie
correspondante à ces entrées. Le nombre de cycle d’horloge de délais correspond au nombre
d’étages registrés. Toutefois, la performance globale du système sera meilleure avec l’utilisation
d’une fréquence d’horloge plus élevée et, selon le cas, avec la possibilité de produire une sortie
valide à chaque cycle d’horloge.
L’architecture matérielle du Artix-7 possède des tranches DSP qui incorporent un pipeline. Selon
la description VHDL et les paramètres de synthèse, l’outil de synthèse peut de plus incorporer
deux étages de registre dans la tranche DSP. Outre l’architecture physique du FPGA, il est
important de bien gérer les pipelines de traitement et les latences engendrées afin de positionner
et de récupérer les données au bon moment.
Page 57
Exemple pipeline:
D
D
D
D
D
A
B
C
ZD
8
4 4
8
9 9
6
16 16
7
6
‘0’6
MSB 2'C
Non-signé
2'C
Non-signé
‘0’MSB
92'C
2'C
2'C
2'C2'C
2'C
‘0’MSB
“sssss”MSB
9
Description du fichier pipeline_ex.vhd library IEEE; use IEEE.std_logic_1164.all; use IEEE.numeric_std.all; entity pipeline_ex is Port ( rst_i : in std_logic; clk_i : in std_logic; A_i : in std_logic_vector(7 downto 0); -- non-signe B_i : in std_logic_vector(3 downto 0); -- 2’C C_i : in std_logic_vector(5 downto 0); --non-signe Z_o: out std_logic_vector(15 downto 0) -- 2’C ); end pipeline_ex; architecture arch_pipeline_ex of pipeline_ex is --section declaration signal A_reg : std_logic_vector(7 downto 0); signal B_reg : std_logic_vector(3 downto 0); signal C_reg1, C_reg2 : std_logic_vector(5 downto 0);
Page 58
signal add_f, add_p : std_logic_vector(8 downto 0); signal mul_f, mul_p : std_logic_vector(15 downto 0); begin Z_o <= mul_p; --combinatoire mul_f <=std_logic_vector(signed(add_p)*signed(‘0’&C_reg2));
Description-A add_f <=std_logic_vector(signed(‘0’&A_reg)+signed(B_reg(3)& B_reg(3)& B_reg(3)& B_reg(3)& B_reg(3)&B_reg));
Description-B add_f <=std_logic_vector(signed(‘0’&A_reg)+signed(B_reg));
--registres P_sync: process(rst_i, clk_i) begin if rst_i=’1’ then A_reg <= (others=>’0’); B_reg <= (others=>’0’); C_reg1 <= (others=>’0’); C_reg2 <= (others=>’0’); add_p <= (others=>’0’); mul_p <= (others=>’0’); elsif clk_i’event and clk_i=’1’ then A_reg <= A_i; B_reg <= B_i; C_reg1 <= C_i; C_reg2 <= C_reg1; add_p <= add_f; mul_p <= mul_f; end if; end process; end arch_pipeline_ex;
Page 59
3.4 Mémoire ROM
Il y a principalement deux types de mémoire ROM qui peuvent être utiles lors d’une conception
d’un système logique : la ROM asynchrone et la ROM synchrone. Bien qu’il soit recommandé
d’utiliser de la ROM synchrone, il arrive quelquefois qu’une ROM asynchrone puisse être
convenable lorsque les paramètres temporels ne sont pas critiques. Par contre, lorsqu’on désire
réduire le délai de propagation dans la logique combinatoire afin d’utiliser une fréquence
d’horloge maximale, la mémoire synchrone est le seul choix. Il est important de noter que la
mémoire synchrone ajoute un cycle de latence à cause de la sortie qui est registrée.
Mémoire ROM asynchrone
Description du fichier ROM_async.vhd library IEEE; use IEEE.std_logic_1164.all; use IEEE.numeric_std.all; entity ROM_async is Port ( add_i : in std_logic_vector(4 downto 0); data_o : out std_logic_vector(15 downto 0) ); end ROM_async; architecture arch_ROM_async of ROM_async is type ROM_T is array (0 to 31) of std_logic_vector(15 downto 0); constant ROM_cst : ROM_T := ( X”0000”, X”1111”, X”2222”, X”3333”, X”4444”, X”5555”, X”6666”, X”7777”, X”8888”, X”9999”, X”AAAA”, X”BBBB”, X”CCCC”, X”DDDD”, X”EEEE”, X”FFFF”, X”0F0F”, X”E0E0”, X”0D0D”, X”C0C0”, X”0B0B”, X”A0A0”, X”0909”, X”8080”, X”0707”, X”6060”, X”0505”, X”4040”, X”0303”, X”2020”, X”0101”, X”1234”); begin data_o <= ROM_cst(to_integer(unsigned(add_i))); end ROM_async;
Page 60
Mémoire ROM synchrone
Description du fichier ROM_sync.vhd library IEEE; use IEEE.std_logic_1164.all; use IEEE.numeric_std.all; entity ROM_sync is Port ( clk_i : in std_logic; add_i : in std_logic_vector(4 downto 0); data_o : out std_logic_vector(15 downto 0) ); end ROM_async; architecture arch_ROM_sync of ROM_sync is type ROM_T is array (0 to 31) of std_logic_vector(15 downto 0); constant ROM_cst : ROM_T := ( X”0000”, X”1111”, X”2222”, X”3333”, X”4444”, X”5555”, X”6666”, X”7777”, X”8888”, X”9999”, X”AAAA”, X”BBBB”, X”CCCC”, X”DDDD”, X”EEEE”, X”FFFF”, X”0F0F”, X”E0E0”, X”0D0D”, X”C0C0”, X”0B0B”, X”A0A0”, X”0909”, X”8080”, X”0707”, X”6060”, X”0505”, X”4040”, X”0303”, X”2020”, X”0101”, X”1234”); begin P_sync: process(clk_i) begin if clk_i’event and clk_i=’1’ then data_o <= ROM_cst(to_integer(unsigned(add_i))); end if; end process; end arch_ROM_sync;
3.5 Mémoire RAM
Les exemples qui suivent présentent la description VHDL des mémoires RAM les plus
couramment utiles : la RAM synchrone, la RAM à double port synchrone (un port en lecture et
un port en écriture) et la RAM à double port complet synchrone à deux horloges.
Page 61
Les ressources matérielles de la plupart des FPGA, dont le Artix-7, permettent d’implémenter
des mémoires RAM à l’aide de RAM distribuée ou de RAM en blocs (block RAM).
Habituellement, il est préférable d’utiliser les blocs RAM pour les grandes capacités de mémoire
et d’utiliser la mémoire distribuée pour les plus petites capacités afin d’avoir localement les
données.
Le code suivant implémente une RAM synchrone à un port.
Description du fichier RAM_1p.vhd library IEEE; use IEEE.std_logic_1164.all; use IEEE.numeric_std.all; entity RAM_1p is Port ( clk_i : in std_logic; we_i : in std_logic; add_i : in std_logic_vector(4 downto 0); data_write_i : out std_logic_vector(15 downto 0); data_read_o : out std_logic_vector(15 downto 0) ); end RAM_1p; architecture arch_ RAM_1p of RAM_1p is type RAM_1p_T is array (0 to 31) of std_logic_vector(15 downto 0); signal RAM_1p : RAM_1p_T; begin P_sync: process(clk_i) begin if clk_i’event and clk_i=’1’ then if we_i =’1’ then RAM_1p(to_integer(unsigned(add_i)))<= data_write_i; end if; data_read_o <= RAM_1p (to_integer(unsigned(add_i))); end if; end process; end arch_RAM_1p;
Page 62
Le code suivant implémente une RAM synchrone avec un port en écriture (p1) et un port en
lecture (p2).
Description du fichier RAM_2p.vhd library IEEE; use IEEE.std_logic_1164.all; use IEEE.numeric_std.all; entity RAM_2p is Port ( clk_i : in std_logic; we_p1_i : in std_logic; add_p1_i : in std_logic_vector(4 downto 0); add_p2_i : in std_logic_vector(4 downto 0); data_write_p1_i : in std_logic_vector(15 downto 0); data_read_p2_o : out std_logic_vector(15 downto 0) ); end RAM_2p; architecture arch_RAM_2p of RAM_2p is type RAM_2p_T is array (0 to 31) of std_logic_vector(15 downto 0); signal RAM_2p : RAM_2p_T; begin P_sync: process(clk_i) begin if clk_i’event and clk_i=’1’ then if we_p1_i =’1’ then RAM_2p (to_integer(unsigned(add_p1_i)))<= data_write_p1_i; end if; data_read_p2_o <= RAM_2p (to_integer(unsigned(add_p2_i))); end if; end process; end arch_RAM_2p;
Page 63
Le code suivant implémente une RAM synchrone à double port complet synchrone à deux
horloges.
Description du fichier RAM_2p_full.vhd library IEEE; use IEEE.std_logic_1164.all; use IEEE.numeric_std.all; entity RAM_2p_full is Port ( clk_p1_i : in std_logic; we_p1_i : in std_logic; add_p1_i : in std_logic_vector(4 downto 0); data_write_p1_i : in std_logic_vector(15 downto 0); data_read_p1_o : out std_logic_vector(15 downto 0); clk_p2_i : in std_logic; we_p2_i : in std_logic; add_p2_i : in std_logic_vector(4 downto 0); data_write_p2_i : in std_logic_vector(15 downto 0); data_read_p2_o : out std_logic_vector(15 downto 0) ); end RAM_2p_full; architecture arch_RAM_2p_full of RAM_2p_full is type RAM_2p_full_T is array (0 to 31) of std_logic_vector(15 downto 0); shared variable RAM_2p_full : RAM_2p_full_T; begin P_sync_p1: process(clk_p1_i) begin if clk_p1_i’event and clk_p1_i=’1’ then if we_p1_i =’1’ then RAM_2p_full (to_integer(unsigned(add_p1_i))) := data_write_p1_i; end if; data_read_p1_o <= RAM_2p_full (to_integer(unsigned(add_p1_i))); end if; end process;
Page 64
P_sync_p2: process(clk_p2_i) begin if clk_p2_i’event and clk_p2_i=’1’ then if we_p2_i =’1’ then RAM_2p_full (to_integer(unsigned(add_p2_i))) := data_write_p2_i; end if; data_read_p2_o <= RAM_2p_full (to_integer(unsigned(add_p2_i))); end if; end process; end arch_RAM_2p_full;
Page 65
4 RÉFÉRENCES
Voici la liste des documents qui ont été utilisés pour la rédaction de ce guide de laboratoire.
Le guide d’utilisateur de la carte de développement disponible sur le site de Digilent :
• Nexys VideoTM FPGA Board Reference Manual
Les documents suivants concernent l’utilisation de Vivado et sont disponibles sur le site web de
Xilinx.
Flot de conception et utilisation du logiciel :
• UG892: Vivado Design Suite User Guide: Design Flow Overview
• UG906: Vivado Design Suite User Guide: Design Analysis et Closure Techniques
• UG893: Vivado Design Suite User Guide: Using the Vivado IDE
Simulation:
• UG900: Vivado Design Suite User Guide: Logic Simulation
• XAPP199 : Writing Efficient Testbenches
Utilisation des IP :
• UG896: Vivado Design Suite User Guide: Designing with IP
Utilisation du Clock Wizard :
• PG065 : LogiCORE IP Product Guide : Clocking Wizard v5.2
• UG472: 7 Series FPGAs Clocking Resources
Utilisation de cartes de développement :
• UG895: Vivado Design Suite User Guide: System-Level Design Entry
Programmation de FPGA :
• UG908 : : Vivado Design Suite User Guide: Programming and Debugging
Techniques de codage pour la synthèse efficace
• UG901: Vivado Design Suite User Guide: Synthesis
Page 66
5 ASSIGNATION DES BROCHES DU ARTIX-7 SUR LA CARTE NEXYS VIDEO
### This file is a general .xdc for the Nexys Video Rev. A ### To use it in a project: ### - uncomment the lines corresponding to used pins ### - rename the used ports (in each line, after get_ports) according to the top level signal names in the project ## Clock Signal #set_property -dict { PACKAGE_PIN R4 IOSTANDARD LVCMOS33 } [get_ports { sysclk }]; #IO_L13P_T2_MRCC_34 Sch=sysclk ## FMC Transceiver clocks (Must be set to value provided by Mezzanine card, currently set to 156.25 MHz) ## Note: This clock is attached to a MGTREFCLK pin #set_property -dict { PACKAGE_PIN E6 } [get_ports { GTP_CLK_N }]; #set_property -dict { PACKAGE_PIN F6 } [get_ports { GTP_CLK_P }]; #create_clock -add -name gtpclk0_pin -period 6.400 -waveform {0 3.200} [get_ports {GTP_CLK_P}]; #set_property -dict { PACKAGE_PIN E10 } [get_ports { FMC_MGT_CLK_N }]; #set_property -dict { PACKAGE_PIN F10 } [get_ports { FMC_MGT_CLK_P }]; #create_clock -add -name mgtclk1_pin -period 6.400 -waveform {0 3.200} [get_ports {FMC_MGT_CLK_P}]; ## LEDs #set_property -dict { PACKAGE_PIN T14 IOSTANDARD LVCMOS25 } [get_ports { led[0] }]; #IO_L15P_T2_DQS_13 Sch=led[0] #set_property -dict { PACKAGE_PIN T15 IOSTANDARD LVCMOS25 } [get_ports { led[1] }]; #IO_L15N_T2_DQS_13 Sch=led[1] #set_property -dict { PACKAGE_PIN T16 IOSTANDARD LVCMOS25 } [get_ports { led[2] }]; #IO_L17P_T2_13 Sch=led[2] #set_property -dict { PACKAGE_PIN U16 IOSTANDARD LVCMOS25 } [get_ports { led[3] }]; #IO_L17N_T2_13 Sch=led[3] #set_property -dict { PACKAGE_PIN V15 IOSTANDARD LVCMOS25 } [get_ports { led[4] }]; #IO_L14N_T2_SRCC_13 Sch=led[4] #set_property -dict { PACKAGE_PIN W16 IOSTANDARD LVCMOS25 } [get_ports { led[5] }]; #IO_L16N_T2_13 Sch=led[5] #set_property -dict { PACKAGE_PIN W15 IOSTANDARD LVCMOS25 } [get_ports { led[6] }]; #IO_L16P_T2_13 Sch=led[6] #set_property -dict { PACKAGE_PIN Y13 IOSTANDARD LVCMOS25 } [get_ports { led[7] }]; #IO_L5P_T0_13 Sch=led[7] ## Buttons #set_property -dict { PACKAGE_PIN B22 IOSTANDARD LVCMOS12 } [get_ports { btnc }]; #IO_L20N_T3_16 Sch=btnc #set_property -dict { PACKAGE_PIN D22 IOSTANDARD LVCMOS12 } [get_ports { btnd }]; #IO_L22N_T3_16 Sch=btnd #set_property -dict { PACKAGE_PIN C22 IOSTANDARD LVCMOS12 } [get_ports { btnl }]; #IO_L20P_T3_16 Sch=btnl #set_property -dict { PACKAGE_PIN D14 IOSTANDARD LVCMOS12 } [get_ports { btnr }]; #IO_L6P_T0_16 Sch=btnr #set_property -dict { PACKAGE_PIN F15 IOSTANDARD LVCMOS12 } [get_ports { btnu }]; #IO_0_16 Sch=btnu #set_property -dict { PACKAGE_PIN G4 IOSTANDARD LVCMOS12 } [get_ports { cpu_resetn }]; #IO_L12N_T1_MRCC_35 Sch=cpu_resetn
Page 67
## Switches #set_property -dict { PACKAGE_PIN E22 IOSTANDARD LVCMOS12 } [get_ports { sw[0] }]; #IO_L22P_T3_16 Sch=sw[0] #set_property -dict { PACKAGE_PIN F21 IOSTANDARD LVCMOS12 } [get_ports { sw[1] }]; #IO_25_16 Sch=sw[1] #set_property -dict { PACKAGE_PIN G21 IOSTANDARD LVCMOS12 } [get_ports { sw[2] }]; #IO_L24P_T3_16 Sch=sw[2] #set_property -dict { PACKAGE_PIN G22 IOSTANDARD LVCMOS12 } [get_ports { sw[3] }]; #IO_L24N_T3_16 Sch=sw[3] #set_property -dict { PACKAGE_PIN H17 IOSTANDARD LVCMOS12 } [get_ports { sw[4] }]; #IO_L6P_T0_15 Sch=sw[4] #set_property -dict { PACKAGE_PIN J16 IOSTANDARD LVCMOS12 } [get_ports { sw[5] }]; #IO_0_15 Sch=sw[5] #set_property -dict { PACKAGE_PIN K13 IOSTANDARD LVCMOS12 } [get_ports { sw[6] }]; #IO_L19P_T3_A22_15 Sch=sw[6] #set_property -dict { PACKAGE_PIN M17 IOSTANDARD LVCMOS12 } [get_ports { sw[7] }]; #IO_25_15 Sch=sw[7] ## OLED Display #set_property -dict { PACKAGE_PIN W22 IOSTANDARD LVCMOS33 } [get_ports { oled_dc }]; #IO_L7N_T1_D10_14 Sch=oled_dc #set_property -dict { PACKAGE_PIN U21 IOSTANDARD LVCMOS33 } [get_ports { oled_res }]; #IO_L4N_T0_D05_14 Sch=oled_res #set_property -dict { PACKAGE_PIN W21 IOSTANDARD LVCMOS33 } [get_ports { oled_sclk }]; #IO_L7P_T1_D09_14 Sch=oled_sclk #set_property -dict { PACKAGE_PIN Y22 IOSTANDARD LVCMOS33 } [get_ports { oled_sdin }]; #IO_L9N_T1_DQS_D13_14 Sch=oled_sdin #set_property -dict { PACKAGE_PIN P20 IOSTANDARD LVCMOS33 } [get_ports { oled_vbat }]; #IO_0_14 Sch=oled_vbat #set_property -dict { PACKAGE_PIN V22 IOSTANDARD LVCMOS33 } [get_ports { oled_vdd }]; #IO_L3N_T0_DQS_EMCCLK_14 Sch=oled_vdd ## HDMI in #set_property -dict { PACKAGE_PIN AA5 IOSTANDARD LVCMOS33 } [get_ports { hdmi_rx_cec }]; #IO_L10P_T1_34 Sch=hdmi_rx_cec #set_property -dict { PACKAGE_PIN W4 IOSTANDARD TMDS_33 } [get_ports { hdmi_rx_clk_n }]; #IO_L12N_T1_MRCC_34 Sch=hdmi_rx_clk_n #set_property -dict { PACKAGE_PIN V4 IOSTANDARD TMDS_33 } [get_ports { hdmi_rx_clk_p }]; #IO_L12P_T1_MRCC_34 Sch=hdmi_rx_clk_p #set_property -dict { PACKAGE_PIN AB12 IOSTANDARD LVCMOS25 } [get_ports { hdmi_rx_hpa }]; #IO_L7N_T1_13 Sch=hdmi_rx_hpa #set_property -dict { PACKAGE_PIN Y4 IOSTANDARD LVCMOS33 } [get_ports { hdmi_rx_scl }]; #IO_L11P_T1_SRCC_34 Sch=hdmi_rx_scl #set_property -dict { PACKAGE_PIN AB5 IOSTANDARD LVCMOS33 } [get_ports { hdmi_rx_sda }]; #IO_L10N_T1_34 Sch=hdmi_rx_sda #set_property -dict { PACKAGE_PIN R3 IOSTANDARD LVCMOS33 } [get_ports { hdmi_rx_txen }]; #IO_L3P_T0_DQS_34 Sch=hdmi_rx_txen #set_property -dict { PACKAGE_PIN AA3 IOSTANDARD TMDS_33 } [get_ports { hdmi_rx_n[0] }]; #IO_L9N_T1_DQS_34 Sch=hdmi_rx_n[0] #set_property -dict { PACKAGE_PIN Y3 IOSTANDARD TMDS_33 } [get_ports { hdmi_rx_p[0] }]; #IO_L9P_T1_DQS_34 Sch=hdmi_rx_p[0] #set_property -dict { PACKAGE_PIN Y2 IOSTANDARD TMDS_33 } [get_ports { hdmi_rx_n[1] }]; #IO_L4N_T0_34 Sch=hdmi_rx_n[1] #set_property -dict { PACKAGE_PIN W2 IOSTANDARD TMDS_33 } [get_ports { hdmi_rx_p[1] }]; #IO_L4P_T0_34 Sch=hdmi_rx_p[1] #set_property -dict { PACKAGE_PIN V2 IOSTANDARD TMDS_33 } [get_ports { hdmi_rx_n[2] }]; #IO_L2N_T0_34 Sch=hdmi_rx_n[2] #set_property -dict { PACKAGE_PIN U2 IOSTANDARD TMDS_33 } [get_ports { hdmi_rx_p[2] }]; #IO_L2P_T0_34 Sch=hdmi_rx_p[2]
Page 68
## HDMI out #set_property -dict { PACKAGE_PIN AA4 IOSTANDARD LVCMOS33 } [get_ports { hdmi_tx_cec }]; #IO_L11N_T1_SRCC_34 Sch=hdmi_tx_cec #set_property -dict { PACKAGE_PIN U1 IOSTANDARD TMDS_33 } [get_ports { hdmi_tx_clk_n }]; #IO_L1N_T0_34 Sch=hdmi_tx_clk_n #set_property -dict { PACKAGE_PIN T1 IOSTANDARD TMDS_33 } [get_ports { hdmi_tx_clk_p }]; #IO_L1P_T0_34 Sch=hdmi_tx_clk_p #set_property -dict { PACKAGE_PIN AB13 IOSTANDARD LVCMOS25 } [get_ports { hdmi_tx_hpd }]; #IO_L3N_T0_DQS_13 Sch=hdmi_tx_hpd #set_property -dict { PACKAGE_PIN U3 IOSTANDARD LVCMOS33 } [get_ports { hdmi_tx_rscl }]; #IO_L6P_T0_34 Sch=hdmi_tx_rscl #set_property -dict { PACKAGE_PIN V3 IOSTANDARD LVCMOS33 } [get_ports { hdmi_tx_rsda }]; #IO_L6N_T0_VREF_34 Sch=hdmi_tx_rsda #set_property -dict { PACKAGE_PIN Y1 IOSTANDARD TMDS_33 } [get_ports { hdmi_tx_n[0] }]; #IO_L5N_T0_34 Sch=hdmi_tx_n[0] #set_property -dict { PACKAGE_PIN W1 IOSTANDARD TMDS_33 } [get_ports { hdmi_tx_p[0] }]; #IO_L5P_T0_34 Sch=hdmi_tx_p[0] #set_property -dict { PACKAGE_PIN AB1 IOSTANDARD TMDS_33 } [get_ports { hdmi_tx_n[1] }]; #IO_L7N_T1_34 Sch=hdmi_tx_n[1] #set_property -dict { PACKAGE_PIN AA1 IOSTANDARD TMDS_33 } [get_ports { hdmi_tx_p[1] }]; #IO_L7P_T1_34 Sch=hdmi_tx_p[1] #set_property -dict { PACKAGE_PIN AB2 IOSTANDARD TMDS_33 } [get_ports { hdmi_tx_n[2] }]; #IO_L8N_T1_34 Sch=hdmi_tx_n[2] #set_property -dict { PACKAGE_PIN AB3 IOSTANDARD TMDS_33 } [get_ports { hdmi_tx_p[2] }]; #IO_L8P_T1_34 Sch=hdmi_tx_p[2] ## Display Port #set_property -dict { PACKAGE_PIN AB10 IOSTANDARD LVDS } [get_ports { dp_tx_aux_n }]; #IO_L8N_T1_13 Sch=dp_tx_aux_n #set_property -dict { PACKAGE_PIN AA11 IOSTANDARD LVDS } [get_ports { dp_tx_aux_n }]; #IO_L9N_T1_DQS_13 Sch=dp_tx_aux_n #set_property -dict { PACKAGE_PIN AA9 IOSTANDARD LVDS } [get_ports { dp_tx_aux_p }]; #IO_L8P_T1_13 Sch=dp_tx_aux_p #set_property -dict { PACKAGE_PIN AA10 IOSTANDARD LVDS } [get_ports { dp_tx_aux_p }]; #IO_L9P_T1_DQS_13 Sch=dp_tx_aux_p #set_property -dict { PACKAGE_PIN N15 IOSTANDARD LVCMOS33 } [get_ports { dp_tx_hpd }]; #IO_25_14 Sch=dp_tx_hpd ## Audio Codec #set_property -dict { PACKAGE_PIN T4 IOSTANDARD LVCMOS33 } [get_ports { ac_adc_sdata }]; #IO_L13N_T2_MRCC_34 Sch=ac_adc_sdata #set_property -dict { PACKAGE_PIN T5 IOSTANDARD LVCMOS33 } [get_ports { ac_bclk }]; #IO_L14P_T2_SRCC_34 Sch=ac_bclk #set_property -dict { PACKAGE_PIN W6 IOSTANDARD LVCMOS33 } [get_ports { ac_dac_sdata }]; #IO_L15P_T2_DQS_34 Sch=ac_dac_sdata #set_property -dict { PACKAGE_PIN U5 IOSTANDARD LVCMOS33 } [get_ports { ac_lrclk }]; #IO_L14N_T2_SRCC_34 Sch=ac_lrclk #set_property -dict { PACKAGE_PIN U6 IOSTANDARD LVCMOS33 } [get_ports { ac_mclk }]; #IO_L16P_T2_34 Sch=ac_mclk ## Pmod header JA #set_property -dict { PACKAGE_PIN AB22 IOSTANDARD LVCMOS33 } [get_ports { ja[0] }]; #IO_L10N_T1_D15_14 Sch=ja[1] #set_property -dict { PACKAGE_PIN AB21 IOSTANDARD LVCMOS33 } [get_ports { ja[1] }]; #IO_L10P_T1_D14_14 Sch=ja[2] #set_property -dict { PACKAGE_PIN AB20 IOSTANDARD LVCMOS33 } [get_ports { ja[2] }]; #IO_L15N_T2_DQS_DOUT_CSO_B_14 Sch=ja[3]
Page 69
#set_property -dict { PACKAGE_PIN AB18 IOSTANDARD LVCMOS33 } [get_ports { ja[3] }]; #IO_L17N_T2_A13_D29_14 Sch=ja[4] #set_property -dict { PACKAGE_PIN Y21 IOSTANDARD LVCMOS33 } [get_ports { ja[4] }]; #IO_L9P_T1_DQS_14 Sch=ja[7] #set_property -dict { PACKAGE_PIN AA21 IOSTANDARD LVCMOS33 } [get_ports { ja[5] }]; #IO_L8N_T1_D12_14 Sch=ja[8] #set_property -dict { PACKAGE_PIN AA20 IOSTANDARD LVCMOS33 } [get_ports { ja[6] }]; #IO_L8P_T1_D11_14 Sch=ja[9] #set_property -dict { PACKAGE_PIN AA18 IOSTANDARD LVCMOS33 } [get_ports { ja[7] }]; #IO_L17P_T2_A14_D30_14 Sch=ja[10] ## Pmod header JB #set_property -dict { PACKAGE_PIN V9 IOSTANDARD LVCMOS33 } [get_ports { jb[0] }]; #IO_L21P_T3_DQS_34 Sch=jb_p[1] #set_property -dict { PACKAGE_PIN V8 IOSTANDARD LVCMOS33 } [get_ports { jb[1] }]; #IO_L21N_T3_DQS_34 Sch=jb_n[1] #set_property -dict { PACKAGE_PIN V7 IOSTANDARD LVCMOS33 } [get_ports { jb[2] }]; #IO_L19P_T3_34 Sch=jb_p[2] #set_property -dict { PACKAGE_PIN W7 IOSTANDARD LVCMOS33 } [get_ports { jb[3] }]; #IO_L19N_T3_VREF_34 Sch=jb_n[2] #set_property -dict { PACKAGE_PIN W9 IOSTANDARD LVCMOS33 } [get_ports { jb[4] }]; #IO_L24P_T3_34 Sch=jb_p[3] #set_property -dict { PACKAGE_PIN Y9 IOSTANDARD LVCMOS33 } [get_ports { jb[5] }]; #IO_L24N_T3_34 Sch=jb_n[3] #set_property -dict { PACKAGE_PIN Y8 IOSTANDARD LVCMOS33 } [get_ports { jb[6] }]; #IO_L23P_T3_34 Sch=jb_p[4] #set_property -dict { PACKAGE_PIN Y7 IOSTANDARD LVCMOS33 } [get_ports { jb[7] }]; #IO_L23N_T3_34 Sch=jb_n[4] ## Pmod header JC #set_property -dict { PACKAGE_PIN Y6 IOSTANDARD LVCMOS33 } [get_ports { jc[0] }]; #IO_L18P_T2_34 Sch=jc_p[1] #set_property -dict { PACKAGE_PIN AA6 IOSTANDARD LVCMOS33 } [get_ports { jc[1] }]; #IO_L18N_T2_34 Sch=jc_n[1] #set_property -dict { PACKAGE_PIN AA8 IOSTANDARD LVCMOS33 } [get_ports { jc[2] }]; #IO_L22P_T3_34 Sch=jc_p[2] #set_property -dict { PACKAGE_PIN AB8 IOSTANDARD LVCMOS33 } [get_ports { jc[3] }]; #IO_L22N_T3_34 Sch=jc_n[2] #set_property -dict { PACKAGE_PIN R6 IOSTANDARD LVCMOS33 } [get_ports { jc[4] }]; #IO_L17P_T2_34 Sch=jc_p[3] #set_property -dict { PACKAGE_PIN T6 IOSTANDARD LVCMOS33 } [get_ports { jc[5] }]; #IO_L17N_T2_34 Sch=jc_n[3] #set_property -dict { PACKAGE_PIN AB7 IOSTANDARD LVCMOS33 } [get_ports { jc[6] }]; #IO_L20P_T3_34 Sch=jc_p[4] #set_property -dict { PACKAGE_PIN AB6 IOSTANDARD LVCMOS33 } [get_ports { jc[7] }]; #IO_L20N_T3_34 Sch=jc_n[4] ## XADC Header #set_property -dict { PACKAGE_PIN J14 IOSTANDARD LVCMOS33 } [get_ports { xa_p[0] }]; #IO_L3P_T0_DQS_AD1P_15 Sch=xa_p[1] #set_property -dict { PACKAGE_PIN H14 IOSTANDARD LVCMOS33 } [get_ports { xa_n[0] }]; #IO_L3N_T0_DQS_AD1N_15 Sch=xa_n[1] #set_property -dict { PACKAGE_PIN H13 IOSTANDARD LVCMOS33 } [get_ports { xa_p[1] }]; #IO_L1P_T0_AD0P_15 Sch=xa_p[2] #set_property -dict { PACKAGE_PIN G13 IOSTANDARD LVCMOS33 } [get_ports { xa_n[1] }]; #IO_L1N_T0_AD0N_15 Sch=xa_n[2] #set_property -dict { PACKAGE_PIN G15 IOSTANDARD LVCMOS33 } [get_ports { xa_p[2] }]; #IO_L2P_T0_AD8P_15 Sch=xa_p[3] #set_property -dict { PACKAGE_PIN G16 IOSTANDARD LVCMOS33 } [get_ports { xa_n[2] }];
Page 70
#IO_L2N_T0_AD8N_15 Sch=xa_n[3] #set_property -dict { PACKAGE_PIN J15 IOSTANDARD LVCMOS33 } [get_ports { xa_p[3] }]; #IO_L5P_T0_AD9P_15 Sch=xa_p[4] #set_property -dict { PACKAGE_PIN H15 IOSTANDARD LVCMOS33 } [get_ports { xa_n[3] }]; #IO_L5N_T0_AD9N_15 Sch=xa_n[4] ## UART #set_property -dict { PACKAGE_PIN AA19 IOSTANDARD LVCMOS33 } [get_ports { uart_rx_out }]; #IO_L15P_T2_DQS_RDWR_B_14 Sch=uart_rx_out #set_property -dict { PACKAGE_PIN V18 IOSTANDARD LVCMOS33 } [get_ports { uart_tx_in }]; #IO_L14P_T2_SRCC_14 Sch=uart_tx_in ## Ethernet #set_property -dict { PACKAGE_PIN Y14 IOSTANDARD LVCMOS25 } [get_ports { eth_int_b }]; #IO_L6N_T0_VREF_13 Sch=eth_int_b #set_property -dict { PACKAGE_PIN AA16 IOSTANDARD LVCMOS25 } [get_ports { eth_mdc }]; #IO_L1N_T0_13 Sch=eth_mdc #set_property -dict { PACKAGE_PIN Y16 IOSTANDARD LVCMOS25 } [get_ports { eth_mdio }]; #IO_L1P_T0_13 Sch=eth_mdio #set_property -dict { PACKAGE_PIN W14 IOSTANDARD LVCMOS25 } [get_ports { eth_pme_b }]; #IO_L6P_T0_13 Sch=eth_pme_b #set_property -dict { PACKAGE_PIN U7 IOSTANDARD LVCMOS33 } [get_ports { eth_rst_b }]; #IO_25_34 Sch=eth_rst_b #set_property -dict { PACKAGE_PIN V13 IOSTANDARD LVCMOS25 } [get_ports { eth_rxck }]; #IO_L13P_T2_MRCC_13 Sch=eth_rxck #set_property -dict { PACKAGE_PIN W10 IOSTANDARD LVCMOS25 } [get_ports { eth_rxctl }]; #IO_L10N_T1_13 Sch=eth_rxctl #set_property -dict { PACKAGE_PIN AB16 IOSTANDARD LVCMOS25 } [get_ports { eth_rxd[0] }]; #IO_L2P_T0_13 Sch=eth_rxd[0] #set_property -dict { PACKAGE_PIN AA15 IOSTANDARD LVCMOS25 } [get_ports { eth_rxd[1] }]; #IO_L4P_T0_13 Sch=eth_rxd[1] #set_property -dict { PACKAGE_PIN AB15 IOSTANDARD LVCMOS25 } [get_ports { eth_rxd[2] }]; #IO_L4N_T0_13 Sch=eth_rxd[2] #set_property -dict { PACKAGE_PIN AB11 IOSTANDARD LVCMOS25 } [get_ports { eth_rxd[3] }]; #IO_L7P_T1_13 Sch=eth_rxd[3] #set_property -dict { PACKAGE_PIN AA14 IOSTANDARD LVCMOS25 } [get_ports { eth_txck }]; #IO_L5N_T0_13 Sch=eth_txck #set_property -dict { PACKAGE_PIN V10 IOSTANDARD LVCMOS25 } [get_ports { eth_txctl }]; #IO_L10P_T1_13 Sch=eth_txctl #set_property -dict { PACKAGE_PIN Y12 IOSTANDARD LVCMOS25 } [get_ports { eth_txd[0] }]; #IO_L11N_T1_SRCC_13 Sch=eth_txd[0] #set_property -dict { PACKAGE_PIN W12 IOSTANDARD LVCMOS25 } [get_ports { eth_txd[1] }]; #IO_L12N_T1_MRCC_13 Sch=eth_txd[1] #set_property -dict { PACKAGE_PIN W11 IOSTANDARD LVCMOS25 } [get_ports { eth_txd[2] }]; #IO_L12P_T1_MRCC_13 Sch=eth_txd[2] #set_property -dict { PACKAGE_PIN Y11 IOSTANDARD LVCMOS25 } [get_ports { eth_txd[3] }]; #IO_L11P_T1_SRCC_13 Sch=eth_txd[3] ## Fan PWM #set_property -dict { PACKAGE_PIN U15 IOSTANDARD LVCMOS25 } [get_ports { fan_pwm }]; #IO_L14P_T2_SRCC_13 Sch=fan_pwm ## DPTI/DSPI #set_property -dict { PACKAGE_PIN Y18 IOSTANDARD LVCMOS33 } [get_ports { prog_clko }]; #IO_L13P_T2_MRCC_14 Sch=prog_clko #set_property -dict { PACKAGE_PIN U20 IOSTANDARD LVCMOS33 } [get_ports { prog_d[0]}]; #IO_L11P_T1_SRCC_14 Sch=prog_d0/sck #set_property -dict { PACKAGE_PIN P14 IOSTANDARD LVCMOS33 } [get_ports { prog_d[1] }];
Page 71
#IO_L19P_T3_A10_D26_14 Sch=prog_d1/mosi #set_property -dict { PACKAGE_PIN P15 IOSTANDARD LVCMOS33 } [get_ports { prog_d[2] }]; #IO_L22P_T3_A05_D21_14 Sch=prog_d2/miso #set_property -dict { PACKAGE_PIN U17 IOSTANDARD LVCMOS33 } [get_ports { prog_d[3]}]; #IO_L18P_T2_A12_D28_14 Sch=prog_d3/ss #set_property -dict { PACKAGE_PIN R17 IOSTANDARD LVCMOS33 } [get_ports { prog_d[4] }]; #IO_L24N_T3_A00_D16_14 Sch=prog_d[4] #set_property -dict { PACKAGE_PIN P16 IOSTANDARD LVCMOS33 } [get_ports { prog_d[5] }]; #IO_L24P_T3_A01_D17_14 Sch=prog_d[5] #set_property -dict { PACKAGE_PIN R18 IOSTANDARD LVCMOS33 } [get_ports { prog_d[6] }]; #IO_L20P_T3_A08_D24_14 Sch=prog_d[6] #set_property -dict { PACKAGE_PIN N14 IOSTANDARD LVCMOS33 } [get_ports { prog_d[7] }]; #IO_L23N_T3_A02_D18_14 Sch=prog_d[7] #set_property -dict { PACKAGE_PIN V17 IOSTANDARD LVCMOS33 } [get_ports { prog_oen }]; #IO_L16P_T2_CSI_B_14 Sch=prog_oen #set_property -dict { PACKAGE_PIN P19 IOSTANDARD LVCMOS33 } [get_ports { prog_rdn }]; #IO_L5P_T0_D06_14 Sch=prog_rdn #set_property -dict { PACKAGE_PIN N17 IOSTANDARD LVCMOS33 } [get_ports { prog_rxen }]; #IO_L21P_T3_DQS_14 Sch=prog_rxen #set_property -dict { PACKAGE_PIN P17 IOSTANDARD LVCMOS33 } [get_ports { prog_siwun }]; #IO_L21N_T3_DQS_A06_D22_14 Sch=prog_siwun #set_property -dict { PACKAGE_PIN R14 IOSTANDARD LVCMOS33 } [get_ports { prog_spien }]; #IO_L19N_T3_A09_D25_VREF_14 Sch=prog_spien #set_property -dict { PACKAGE_PIN Y19 IOSTANDARD LVCMOS33 } [get_ports { prog_txen }]; #IO_L13N_T2_MRCC_14 Sch=prog_txen #set_property -dict { PACKAGE_PIN R19 IOSTANDARD LVCMOS33 } [get_ports { prog_wrn }]; #IO_L5N_T0_D07_14 Sch=prog_wrn ## HID port #set_property -dict { PACKAGE_PIN W17 IOSTANDARD LVCMOS33 } [get_ports { ps2_clk }]; #IO_L16N_T2_A15_D31_14 Sch=ps2_clk #set_property -dict { PACKAGE_PIN N13 IOSTANDARD LVCMOS33 } [get_ports { ps2_data }]; #IO_L23P_T3_A03_D19_14 Sch=ps2_data ## QSPI #set_property -dict { PACKAGE_PIN T19 IOSTANDARD LVCMOS33 } [get_ports { qspi_cs }]; #IO_L6P_T0_FCS_B_14 Sch=qspi_cs #set_property -dict { PACKAGE_PIN P22 IOSTANDARD LVCMOS33 } [get_ports { qspi_dq[0] }]; #IO_L1P_T0_D00_MOSI_14 Sch=qspi_dq[0] #set_property -dict { PACKAGE_PIN R22 IOSTANDARD LVCMOS33 } [get_ports { qspi_dq[1] }]; #IO_L1N_T0_D01_DIN_14 Sch=qspi_dq[1] #set_property -dict { PACKAGE_PIN P21 IOSTANDARD LVCMOS33 } [get_ports { qspi_dq[2] }]; #IO_L2P_T0_D02_14 Sch=qspi_dq[2] #set_property -dict { PACKAGE_PIN R21 IOSTANDARD LVCMOS33 } [get_ports { qspi_dq[3] }]; #IO_L2N_T0_D03_14 Sch=qspi_dq[3] #set_property -dict { PACKAGE_PIN W5 IOSTANDARD LVCMOS33 } [get_ports { scl }]; #IO_L15N_T2_DQS_34 Sch=scl ## SD card #set_property -dict { PACKAGE_PIN W19 IOSTANDARD LVCMOS33 } [get_ports { sd_cclk }]; #IO_L12P_T1_MRCC_14 Sch=sd_cclk #set_property -dict { PACKAGE_PIN T18 IOSTANDARD LVCMOS33 } [get_ports { sd_cd }]; #IO_L20N_T3_A07_D23_14 Sch=sd_cd #set_property -dict { PACKAGE_PIN W20 IOSTANDARD LVCMOS33 } [get_ports { sd_cmd }]; #IO_L12N_T1_MRCC_14 Sch=sd_cmd #set_property -dict { PACKAGE_PIN V19 IOSTANDARD LVCMOS33 } [get_ports { sd_d[0] }]; #IO_L14N_T2_SRCC_14 Sch=sd_d[0] #set_property -dict { PACKAGE_PIN T21 IOSTANDARD LVCMOS33 } [get_ports { sd_d[1] }]; #IO_L4P_T0_D04_14 Sch=sd_d[1]
Page 72
#set_property -dict { PACKAGE_PIN T20 IOSTANDARD LVCMOS33 } [get_ports { sd_d[2] }]; #IO_L6N_T0_D08_VREF_14 Sch=sd_d[2] #set_property -dict { PACKAGE_PIN U18 IOSTANDARD LVCMOS33 } [get_ports { sd_d[3] }]; #IO_L18N_T2_A11_D27_14 Sch=sd_d[3] #set_property -dict { PACKAGE_PIN V20 IOSTANDARD LVCMOS33 } [get_ports { sd_reset }]; #IO_L11N_T1_SRCC_14 Sch=sd_reset #set_property -dict { PACKAGE_PIN V5 IOSTANDARD LVCMOS33 } [get_ports { sda }]; #IO_L16N_T2_34 Sch=sda ## Voltage Adjust #set_property -dict { PACKAGE_PIN AA13 IOSTANDARD LVCMOS25 } [get_ports { set_vadj[0] }]; #IO_L3P_T0_DQS_13 Sch=set_vadj[0] #set_property -dict { PACKAGE_PIN AB17 IOSTANDARD LVCMOS25 } [get_ports { set_vadj[1] }]; #IO_L2N_T0_13 Sch=set_vadj[1] #set_property -dict { PACKAGE_PIN V14 IOSTANDARD LVCMOS25 } [get_ports { vadj_en }]; #IO_L13N_T2_MRCC_13 Sch=vadj_en ## FMC #set_property -dict { PACKAGE_PIN H19 IOSTANDARD LVCMOS12 } [get_ports { fmc_clk0_m2c_n }]; #IO_L12N_T1_MRCC_15 Sch=fmc_clk0_m2c_n #set_property -dict { PACKAGE_PIN J19 IOSTANDARD LVCMOS12 } [get_ports { fmc_clk0_m2c_p }]; #IO_L12P_T1_MRCC_15 Sch=fmc_clk0_m2c_p #set_property -dict { PACKAGE_PIN C19 IOSTANDARD LVCMOS12 } [get_ports { fmc_clk1_m2c_n }]; #IO_L13N_T2_MRCC_16 Sch=fmc_clk1_m2c_n #set_property -dict { PACKAGE_PIN C18 IOSTANDARD LVCMOS12 } [get_ports { fmc_clk1_m2c_p }]; #IO_L13P_T2_MRCC_16 Sch=fmc_clk1_m2c_p #set_property -dict { PACKAGE_PIN K19 IOSTANDARD LVCMOS12 } [get_ports { fmc_la00_cc_n }]; #IO_L13N_T2_MRCC_15 Sch=fmc_la00_cc_n #set_property -dict { PACKAGE_PIN K18 IOSTANDARD LVCMOS12 } [get_ports { fmc_la00_cc_p }]; #IO_L13P_T2_MRCC_15 Sch=fmc_la00_cc_p #set_property -dict { PACKAGE_PIN J21 IOSTANDARD LVCMOS12 } [get_ports { fmc_la01_cc_n }]; #IO_L11N_T1_SRCC_15 Sch=fmc_la01_cc_n #set_property -dict { PACKAGE_PIN J20 IOSTANDARD LVCMOS12 } [get_ports { fmc_la01_cc_p }]; #IO_L11P_T1_SRCC_15 Sch=fmc_la01_cc_p #set_property -dict { PACKAGE_PIN L18 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_n[02] }]; #IO_L16N_T2_A27_15 Sch=fmc_la_n[02] #set_property -dict { PACKAGE_PIN M18 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_p[02] }]; #IO_L16P_T2_A28_15 Sch=fmc_la_p[02] #set_property -dict { PACKAGE_PIN N19 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_n[03] }]; #IO_L17N_T2_A25_15 Sch=fmc_la_n[03] #set_property -dict { PACKAGE_PIN N18 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_p[03] }]; #IO_L17P_T2_A26_15 Sch=fmc_la_p[03] #set_property -dict { PACKAGE_PIN M20 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_n[04] }]; #IO_L18N_T2_A23_15 Sch=fmc_la_n[04] #set_property -dict { PACKAGE_PIN N20 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_p[04] }]; #IO_L18P_T2_A24_15 Sch=fmc_la_p[04] #set_property -dict { PACKAGE_PIN L21 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_n[05] }]; #IO_L10N_T1_AD11N_15 Sch=fmc_la_n[05] #set_property -dict { PACKAGE_PIN M21 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_p[05] }]; #IO_L10P_T1_AD11P_15 Sch=fmc_la_p[05] #set_property -dict { PACKAGE_PIN M22 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_n[06] }]; #IO_L15N_T2_DQS_ADV_B_15 Sch=fmc_la_n[06] #set_property -dict { PACKAGE_PIN N22 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_p[06] }]; #IO_L15P_T2_DQS_15 Sch=fmc_la_p[06] #set_property -dict { PACKAGE_PIN L13 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_n[07] }]; #IO_L20N_T3_A19_15 Sch=fmc_la_n[07] #set_property -dict { PACKAGE_PIN M13 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_p[07] }]; #IO_L20P_T3_A20_15 Sch=fmc_la_p[07] #set_property -dict { PACKAGE_PIN M16 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_n[08] }]; #IO_L24N_T3_RS0_15 Sch=fmc_la_n[08]
Page 73
#set_property -dict { PACKAGE_PIN M15 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_p[08] }]; #IO_L24P_T3_RS1_15 Sch=fmc_la_p[08] #set_property -dict { PACKAGE_PIN G20 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_n[09] }]; #IO_L8N_T1_AD10N_15 Sch=fmc_la_n[09] #set_property -dict { PACKAGE_PIN H20 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_p[09] }]; #IO_L8P_T1_AD10P_15 Sch=fmc_la_p[09] #set_property -dict { PACKAGE_PIN K22 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_n[10] }]; #IO_L9N_T1_DQS_AD3N_15 Sch=fmc_la_n[10] #set_property -dict { PACKAGE_PIN K21 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_p[10] }]; #IO_L9P_T1_DQS_AD3P_15 Sch=fmc_la_p[10] #set_property -dict { PACKAGE_PIN L15 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_n[11] }]; #IO_L22N_T3_A16_15 Sch=fmc_la_n[11] #set_property -dict { PACKAGE_PIN L14 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_p[11] }]; #IO_L22P_T3_A17_15 Sch=fmc_la_p[11] #set_property -dict { PACKAGE_PIN L20 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_n[12] }]; #IO_L14N_T2_SRCC_15 Sch=fmc_la_n[12] #set_property -dict { PACKAGE_PIN L19 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_p[12] }]; #IO_L14P_T2_SRCC_15 Sch=fmc_la_p[12] #set_property -dict { PACKAGE_PIN J17 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_n[13] }]; #IO_L21N_T3_DQS_A18_15 Sch=fmc_la_n[13] #set_property -dict { PACKAGE_PIN K17 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_p[13] }]; #IO_L21P_T3_DQS_15 Sch=fmc_la_p[13] #set_property -dict { PACKAGE_PIN H22 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_n[14] }]; #IO_L7N_T1_AD2N_15 Sch=fmc_la_n[14] #set_property -dict { PACKAGE_PIN J22 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_p[14] }]; #IO_L7P_T1_AD2P_15 Sch=fmc_la_p[14] #set_property -dict { PACKAGE_PIN K16 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_n[15] }]; #IO_L23N_T3_FWE_B_15 Sch=fmc_la_n[15] #set_property -dict { PACKAGE_PIN L16 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_p[15] }]; #IO_L23P_T3_FOE_B_15 Sch=fmc_la_p[15] #set_property -dict { PACKAGE_PIN G18 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_n[16] }]; #IO_L4N_T0_15 Sch=fmc_la_n[16] #set_property -dict { PACKAGE_PIN G17 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_p[16] }]; #IO_L4P_T0_15 Sch=fmc_la_p[16] #set_property -dict { PACKAGE_PIN B18 IOSTANDARD LVCMOS12 } [get_ports { fmc_la17_cc_n }]; #IO_L11N_T1_SRCC_16 Sch=fmc_la17_cc_n #set_property -dict { PACKAGE_PIN B17 IOSTANDARD LVCMOS12 } [get_ports { fmc_la17_cc_p }]; #IO_L11P_T1_SRCC_16 Sch=fmc_la17_cc_p #set_property -dict { PACKAGE_PIN C17 IOSTANDARD LVCMOS12 } [get_ports { fmc_la18_cc_n }]; #IO_L12N_T1_MRCC_16 Sch=fmc_la18_cc_n #set_property -dict { PACKAGE_PIN D17 IOSTANDARD LVCMOS12 } [get_ports { fmc_la18_cc_p }]; #IO_L12P_T1_MRCC_16 Sch=fmc_la18_cc_p #set_property -dict { PACKAGE_PIN A19 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_n[19] }]; #IO_L17N_T2_16 Sch=fmc_la_n[19] #set_property -dict { PACKAGE_PIN A18 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_p[19] }]; #IO_L17P_T2_16 Sch=fmc_la_p[19] #set_property -dict { PACKAGE_PIN F20 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_n[20] }]; #IO_L18N_T2_16 Sch=fmc_la_n[20] #set_property -dict { PACKAGE_PIN F19 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_p[20] }]; #IO_L18P_T2_16 Sch=fmc_la_p[20] #set_property -dict { PACKAGE_PIN D19 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_n[21] }]; #IO_L14N_T2_SRCC_16 Sch=fmc_la_n[21] #set_property -dict { PACKAGE_PIN E19 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_p[21] }]; #IO_L14P_T2_SRCC_16 Sch=fmc_la_p[21] #set_property -dict { PACKAGE_PIN D21 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_n[22] }]; #IO_L23N_T3_16 Sch=fmc_la_n[22] #set_property -dict { PACKAGE_PIN E21 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_p[22] }]; #IO_L23P_T3_16 Sch=fmc_la_p[22] #set_property -dict { PACKAGE_PIN A21 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_n[23] }]; #IO_L21N_T3_DQS_16 Sch=fmc_la_n[23] #set_property -dict { PACKAGE_PIN B21 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_p[23] }]; #IO_L21P_T3_DQS_16 Sch=fmc_la_p[23]
Page 74
#set_property -dict { PACKAGE_PIN B16 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_n[24] }]; #IO_L7N_T1_16 Sch=fmc_la_n[24] #set_property -dict { PACKAGE_PIN B15 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_p[24] }]; #IO_L7P_T1_16 Sch=fmc_la_p[24] #set_property -dict { PACKAGE_PIN E17 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_n[25] }]; #IO_L2N_T0_16 Sch=fmc_la_n[25] #set_property -dict { PACKAGE_PIN F16 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_p[25] }]; #IO_L2P_T0_16 Sch=fmc_la_p[25] #set_property -dict { PACKAGE_PIN E18 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_n[26] }]; #IO_L15N_T2_DQS_16 Sch=fmc_la_n[26] #set_property -dict { PACKAGE_PIN F18 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_p[26] }]; #IO_L15P_T2_DQS_16 Sch=fmc_la_p[26] #set_property -dict { PACKAGE_PIN A20 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_n[27] }]; #IO_L16N_T2_16 Sch=fmc_la_n[27] #set_property -dict { PACKAGE_PIN B20 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_p[27] }]; #IO_L16P_T2_16 Sch=fmc_la_p[27] #set_property -dict { PACKAGE_PIN B13 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_n[28] }]; #IO_L8N_T1_16 Sch=fmc_la_n[28] #set_property -dict { PACKAGE_PIN C13 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_p[28] }]; #IO_L8P_T1_16 Sch=fmc_la_p[28] #set_property -dict { PACKAGE_PIN C15 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_n[29] }]; #IO_L3N_T0_DQS_16 Sch=fmc_la_n[29] #set_property -dict { PACKAGE_PIN C14 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_p[29] }]; #IO_L3P_T0_DQS_16 Sch=fmc_la_p[29] #set_property -dict { PACKAGE_PIN A14 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_n[30] }]; #IO_L10N_T1_16 Sch=fmc_la_n[30] #set_property -dict { PACKAGE_PIN A13 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_p[30] }]; #IO_L10P_T1_16 Sch=fmc_la_p[30] #set_property -dict { PACKAGE_PIN E14 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_n[31] }]; #IO_L4N_T0_16 Sch=fmc_la_n[31] #set_property -dict { PACKAGE_PIN E13 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_p[31] }]; #IO_L4P_T0_16 Sch=fmc_la_p[31] #set_property -dict { PACKAGE_PIN A16 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_n[32] }]; #IO_L9N_T1_DQS_16 Sch=fmc_la_n[32] #set_property -dict { PACKAGE_PIN A15 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_p[32] }]; #IO_L9P_T1_DQS_16 Sch=fmc_la_p[32] #set_property -dict { PACKAGE_PIN F14 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_n[33] }]; #IO_L1N_T0_16 Sch=fmc_la_n[33] #set_property -dict { PACKAGE_PIN F13 IOSTANDARD LVCMOS12 } [get_ports { fmc_la_p[33] }]; #IO_L1P_T0_16 Sch=fmc_la_p[33]
Page 75
