VHDL

See discussions, stats, and author profiles for this publication at: https://www.researchgate.
net/publication/329220722
Synthèse VHDL d’architectures
Book · November 2018
CITATIONS READS
0 492
1 author:
Ridha Ghayoula
University of Tunis El Manar
69 PUBLICATIONS 172 CITATIONS
SEE PROFILE
Some of the authors of this publication are also working on these related projects:
MICROWAVE IMAGING TECHNIQUE FOR BREAST CANCER DETECTION View project
PROJECT I : SMART ANTENNA TECHNOLOGY View project
All content following this page was uploaded by Ridha Ghayoula on 27 November 2018.
The user has requested enhancement of the downloaded file.

Cours
UNIVERSITE TUNIS EL
MANAR
Institut Supérieur d'Informatique

d'El Manar
Synthèse VHDL d’architectures
Ce cours de langage VHDL s'adresse particulièrement aux étudiants en Licences professionnelles et

recherches, en Masters et aux élèves ingénieurs. L'utilisation d'un langage VHDL évolué (Hardware
Description langage, comme VHDL ou Verilog ) dans la modélisation et la conception des circuits
intégrés numériques est aujourd'hui indispensable. Cet édition de ce cours présente le tout nouveau
standard VHDL-2008, disponible aujourd'hui sur la plupart des outils de simulation et de synthèse.
Des compléments, programmes complets et exercices corrigés. Pour découvrir l'ensemble des
possibilités offertes par le langage VHDL, le lecteur est invité à suivre des exemples qui l'amènent à
réaliser des applications faciles à implanter dans un circuit programmable. Les testes et les pièges à
éviter sont également présentés dans cette démarche d'élaboration d'un nouveau composant
numérique.
Ridha Ghayoula, Ph.d, Eng
Maître de conférences
Page | 1 © ISI 2013 Ridha Ghayoula

Table des matières
Chapitre 1 INTRODUCTION A LA SYNTHESE LOGIQUE - VHDL 4

1.1. Introduction............................................................................................................................. 4
1.2. Structure d'un programme en VHDL ..................................................................................... 4
Exercices ..................................................................................................................................... 19
Chapitre 2 STRUCTURE D’UNE DESCRIPTION VHDL 24

2.1. Introduction .......................................................................................................................... 24
2.2. les descriptions comportementales....................................................................................... 25
2.3. Modèle Flot des données ...................................................................................................... 27
2.4. les descriptions Structurelle .................................................................................................. 29
Exercices ..................................................................................................................................... 35
Chapitre 3 MACHINE A ETATS FINIS 42

3.1. Introduction .......................................................................................................................... 43
3.2. Représentation ...................................................................................................................... 43
3.3. Conception des machines à états finis.................................................................................. 46
3.4. Machines d’états finis (Finite State Machine) en VHDL ..................................................... 49
Exercices ..................................................................................................................................... 56
Chapitre 4 VERILOG 59
4.1. Introduction .......................................................................................................................... 60
4.2. Verilog ................................................................................................................................... 60
4.2.2. Valeurs Logiques ..................................................................................................................... 62
4.2.4. Codage des nombres entiers ................................................................................................. 67
4.2.6. Expressions et opérateurs ...................................................................................................... 70
4.2.7. Calcul des expressions : taille et type ................................................................................... 74
4.2.8. Directives de compilation ...................................................................................................... 78
Chapitre 5 VERILOG POUR MÉMOIRE FIFO 84

5.1. Introduction .......................................................................................................................... 85
Verilog testbench pour FIFO memory: ........................................................................................ 89
Chapitre 6 COMMANDE PWM DES MOTEURS PAR FPGA 92

6.1. Introduction .......................................................................................................................... 93
6.2. Variation de Vitesse (commande par PWM) ........................................................................ 94
6.3. FPGA et PMW ...................................................................................................................... 95
Verilog Testbench code pour PWM : ........................................................................................... 98
Chapitre 7 SYNTHESE D'UN PROCESSEUR MIPS SUR FPGA 99

7.1. Introduction ........................................................................................................................ 100
7.2. Processeur MIPS ................................................................................................................. 100
INITIATION À L’ENVIRONNEMENT DE CONCEPTION FPGA ISE14.6, Vivado,Isim,

Kintex-7,Artix-7 112
1. Objectifs ..................................................................................................................................113
2. Description de la carte FPGA XILINX Kintex-7 FPGA KC705 Evaluation Kit.....................113
3. Description de la méthodologie de conception ......................................................................116
Lab 0: Synthèse avec le logiciel Xilinx ISE design Tools 14.6 ...................................................118
Lab 1: Modélisation d’un décodeur hexadécimal pour affichage à 7 segments ....................... 136
Lab 2: Modélisation d’un Compteur/Décompteur ................................................................... 140
Lab 3: Modélisation d’un Additionneur .................................................................................... 142
Lab 4: Modélisation d’un Transcodeur ..................................................................................... 144
Lab 5: Mémoire ROM ............................................................................................................... 146
Lab 6: Mémoire RAM ................................................................................................................ 153
Lab 7: Artix-7 ............................................................................................................................. 156
Lab 8: Hello World avec Verilog & Vivado ............................................................................... 163
Lab 9: Implémentation d'un Compteur avec Artix-7 ................................................................ 170
Lab 10: Implémentation Arty Pmod VGA ................................................................................. 179
ANNEXES .................................................................................................................................181
ANNEXE 1: Master UCF Listing KC705 Board UCF Listing ..................................................181
ANNEXE 2: XDC file Artix-7 .................................................................................................. 186
Les Références Bibliographiques .............................................................................................. 190

1
INTRODUCTION A LA SYNTHESE LOGIQUE - VHDL
1.1. Introduction
L’évolution de l’industrie des circuits intégrés durant la dernière décennie a été tellement rapide
qu’il est maintenant possible d’intégrer plusieurs systèmes complexes sur une seule puce. Cette
évolution vers des niveaux d’intégration de plus en plus élevés est motivée par les besoins de
systèmes plus performants, légers, compacts et consommant un minimum de puissance. Dans de
telles circonstances, la gestion de la complexité avec les outils d’aide à la conception traditionnels
(les outils de bas niveau : masque, schématique…) devient une tâche pénible, coûteuse, voire
impossible, quand on considère les contraintes de mise en marché d’un produit. Dans le but de
mieux gérer la complexité des circuits intégrés, tout en gardant les coûts du développement dans
des limites raisonnables, d’autres outils d’aide à la conception, dits outils de synthèse, ont vu le
jour dès le début des années 1990. En effet, le but ultime de ces outils associés avec un langage de
conception et de simulation puissant, tel que le langage VHDL, est de générer le dessin des
masques d’un circuit à partir de sa description comportementale de haut niveau. Ainsi, le
concepteur peut se limiter à la conception, à la modélisation et à la simulation de son produit,
sans tenir compte des détails de mise en œuvre au niveau schématique ou du dessin des masques.
L’abréviation VHDL signifie VHSIC Hardware Description Language (VHSIC : Very High
Speed Integrated Circuit). Ce langage a été écrit dans les années 70 pour réaliser la simulation de
circuits électroniques. On l’a ensuite étendu en lui rajoutant des extensions pour permettre la
conception (synthèse) de circuits logiques programmables (P.L.D. Programmable Logic Device).
Auparavant pour décrire le fonctionnement d’un circuit électronique programmable les
techniciens et les ingénieurs utilisaient des langages de bas niveau (ABEL, PALASM,
ORCAD/PLD,..) ou plus simplement un outil de saisie de schémas.
Actuellement la densité de fonctions logiques (portes et bascules) intégrée dans les PLDs est telle
(plusieurs milliers de portes voire millions de portes) qu’il n’est plus possible d’utiliser les outils
d’hier pour développer les circuits d’aujourd’hui.
Les sociétés de développement et les ingénieurs ont voulu s’affranchir des contraintes
technologiques des circuits. Ils ont donc créé des langages dits de haut niveau à savoir VHDL et
VERILOG. Ces deux langages font abstraction des contraintes technologies des circuits PLDs.
Ils permettent au code écrit d’être portable, c’est à dire qu’une description écrite pour un circuit
peut être facilement utilisée pour un autre circuit.
1.2. Structure d'un programme en VHDL

Une description VHDL est composée de deux parties indissociables à savoir l'entité qui définit
les signaux en E/S et permet de reconnaître lors des instanciations les différences entres les
différents blocs.
L'architecture contient les instructions VHDL, et elle est décrite(comportementale). Déclaration
des bibliothèque : nommées par l'IEEE, elles contiennent les définitions des types de signaux
électroniques, des fonctions et des sous programme utiles à la définition de l'architecture.
S1
Les S2 Les
Entrees Sorties
S3
1.2.1. Déclaration des bibliothèques

La première chose à faire est de définir les librairies qui seront utilisées dans le code.
Library IEEE ;
use IEEE.std_logic_1164.all;
use IEEE.std_logic_arith.all;
Cela se fait de la manière suivante :

Tout d’abord, la librairie principale (en générale, IEEE).
ensuite, le mot clé « use », qui indique quelle package de la librairie nous allons utiliser. Après cela,
le nom du package. Enfin, le .all signifie que l’on souhaite utiliser tout ce qui se trouve dans ce
package. Lorsque le nom de la librairie est précédé de IEEE., cela signifie que c’est une librairie
qui est définie dans la norme IEEE, et que l’on retrouvera donc normalement dans tout logiciel.
A l’inverse, il faut se méfier des librairies qui ne sont pas IEEE, car elles sont en générale
spécifiques à un logiciel. Les librairies IEEE principales sont :
• IEEE.std_logic_1164
• IEEE.numeric_std
• IEEE.std_logic_arith,...
Attention, il ne faut pas utiliser les librairies numeric_std et std_logic_arith en même temps : la
librairie std_logic_arith est en fait une version améliorée de la numeric_std, développé par
synopsys, et qui a été ensuite incorporé dans la norme IEEE. Le fait d’utiliser les 2 librairies en
même temps causera un conflit lors de l’utilisation de certaines fonctions
1.2.2. Déclaration de l’entité et des entrées / sorties (I/O)

La déclaration de l'entité permet de définir le nom de la description VHDL, les entrées, les sorties
et l'instruction qui est défini est PORT
Entity nom_de_l'entite is
Port (description des signaux);
End nom_de_l'entite ;
Remarque : pour "description des signaux" on note :
Nom_du_signal : sens type ;
Exemple N°1 : Une bascule D

CLK Q
D
Bascule_D
RESET
Entity bascule is
Port ( CLOCK : in std_logic;
D : in std_logic;
RESET : in std_logic;
Q : out std_logic );
End bascule;
Remarque : Après la dernière définition de signal de l’instruction port il ne faut jamais mettre de
point virgule.
 Le nom du signal est composé de caractères : les premier caractère est une lettre, VHDL
n'est pas sensible à la casse (t/T)
 Le sens du signal :
o in = signal d'entrée
o out = signal de sortie
o inout : signal en entrée/sortie
 le type du signal : les types prédéfinis par le langage VHDL sont assez nombreux et le
langage permet la création de ses propres types ou sous types. Pour le moment, on va
utiliser std_logic pour un signal et std_logic_vector pour un bus.
Constantes: Les constantes sont utilisées pour référencer une valeur ou un type spécifique.
Elles permettent une meilleur lecture et maintenance d'une source. De tous types, elles sont
utilisées dans les entités, architectures ou packets.
Syntaxe
CONSTANT const_name {, const_name} : type := value;
Exemple N°2 : constant BUS_WIDTH : integer := 8;
Generic: La section GENERIC_DECLARATIONS dans l'entête ENTITY permet de définir

des paramètres exploitables dans l'architecture.
Cette méthode d'écriture permet une maintenance plus aisée.
Syntaxe
ENTITY entity_name IS
[generic_declarations]
[port_declarations]
END [entity_name];
Exemple N°3 :
LIBRARY ieee;
USE ieee.std_logic_1164.all;
ENTITY nor2 IS

GENERIC (tphlmin, tplhmin: time := 3.0ns; -- déclaration des temps de propagation
tphltyp : time := 8.0ns;
tplhtyp : time := 6.5ns;
tphlmax, tplhmax: time := 13.0ns);
PORT (a,b : IN std_logic;
z : OUT std_logic);
END nor2;
ARCHITECTURE behavior OF nor2 IS

BEGIN
PROCESS(a,b);
BEGIN
IF a = '0' AND b = '0' THEN -- il faut résoudre tous les cas puisque tplhtyp < > tphltyp
z <= '1' AFTER tplhmin;
ELSIF a = '0' AND b = '1' THEN
z <= '0' AFTER tphlmin;
END IF;
END PROCESS;
END behavior;
1.2.2.1. Le NOM_DU_SIGNAL.
Il est composé de caractères, le premier caractère doit être une lettre, sa longueur est quelconque,
mais elle ne doit pas dépasser une ligne de code. VHDL n’est pas sensible à la « casse », c’est à
dire qu’il ne fait pas la distinction entre les majuscules et les minuscules.
L’instruction port .
Syntaxe: NOM_DU_SIGNAL : sens type;
Exemple: CLOCK: in std_logic;
BUS : out std_logic_vector (7 downto 0);
On doit définir pour chaque signal : le NOM_DU_SIGNAL, le sens et le type.
1.2.2.2. Le SENS du signal.

- in : pour un signal en entrée.
- out : pour un signal en sortie.
- inout : pour un signal en entrée sortie
- buffer : pour un signal en sortie mais utilisé comme entrée dans la description.
In Out
D inout
Exemple
RESET buffer
1.2.2.3. Le TYPE.
Le TYPE utilisé pour les signaux d’entrées/sorties est :
- le std_logic pour un signal.
- le std_logic_vector pour un bus composé de plusieurs signaux.
Par exemple un bus bidirectionnel de 5 bits s’écrira :
LATCH : inout std_logic_vector (4 downto 0) ;
Où LATCH(4) correspond au MSB et LATCH(0) correspond au LSB.
Exemple N°1 : Faire un bus de 5 bits

BUS : inout std_logic_vector(4 downto 0);
BUS (4) est le MSB
BUS (0) est le LSB
Un signal de type std_logic peut prendre 4 valeurs :
'0' ou 'L'
'1' ou 'H'
'Z' haute impédance
'-' indifférent
Quand on a un bit on le met entre cote (')
Plus d'un bit on le met entre guillemets (")
a) Les types prédéfinis par tous les compilateurs

integer: entier négatif ou positif
natural: entier positif ou nul
positive: entier positif
bit : énuméré dont les deux seules valeurs possibles sont ‘0’ et ‘1’
bit_vector: composite tableau représentant un vecteur de bits
boolean: énuméré dont les deux valeurs possibles sont False et True
real: flottant compris entre -1.0E38 et 1.0E38
- Les types std_logic et std_logic_vector sont les plus utilisés.
b) Conversions de type
Les environnements de développement fournissent en général des paquetages comportant des
fonctions de conversion de type. Par exemple, la bibliothèque de Xilinx ISE
contient :
- conv_integer (a) pour convertir un std_logic_vector a en un integer
- conv_unsigned (x,n) pour convertir un std_logic_vect or, integer, unsigned ou signed x
en un unsigned de n bits (réalise un changement de taille)
- conv_signed (x,n) pour convertir un std_logic_vector, integer, signed ou unsigned x en
un signed de n bits (réalise un changement de taille)
- conv_std_logic_vector (x,n) pour convertir un integer, unsigned ou signed x en un
std_logic_vector de n bits
Pour utiliser ces fonctions, il suffit d’accéder au paquetage std_logic_arith de la bibliothèque ieee
1.2.2.4.Les identificateurs
Les identificateurs sont des appellations d’objets du langage (données et types).
- Ils sont constitués de caractères alphabétiques (26 lettres), numériques (10 chiffres
décimaux) et du caractère souligné _ ; les lettres accentuées sont exclues
- Le premier caractère doit être une lettre
- Les lettres majuscules et minuscules sont équivalentes
- Le dernier caractère doit être différent de _
- Deux _ à la file sont interdits
- Le nom ne doit pas être un mot réservé
- La longueur d’un mot est quelconque (mais une ligne maximum)
1.2.2.5.Les littéraux
Les littéraux sont les représentations de valeurs attribuées aux objets données et aux objets types.
- Les entiers décimaux : 1234
- Les bits ‘0’, ‘1’ -- type bit

- ‘0’, ‘1’ ,‘U’, ‘X’, ‘H’, ‘L’, ‘W’, ‘Z’, ‘-’ -- type std_logic
- Les vecteurs de bits
- -- représentation binaire “1010”
-- représentation octale O”12”
-- représentation hexadécimale X”A”
- Les caractères ‘a’
- Les chaînes de caractères “ERREUR”, “ERREUR ” & “N° ”
1.2.3. Les déclarations d'architecture

L’architecture décrit le fonctionnement souhaité pour un circuit ou une partie du circuit. En effet
le fonctionnement d’un circuit est généralement décrit par plusieurs modules VHDL. Il faut
comprendre par module le couple ENTITE/ARCHITECTURE. Trois grands formalismes
coexistent pour décrire les architectures :
 Flot de données : on écrit explicitement les fonctions booléennes que l'on veut voir
implémentées (à réserver aux plus petits circuits pour des raisons de lisibilité) ; c'est lui
qu'on a utilisé pour implémenter le demi-additionneur ;
 Structurel : on décrit le circuit comme une série de boîtes noires interconnectées au
moyen de signaux (utilisé pour des circuits moyens ou grands) ; on procèdera de cette
manière pour synthétiser un additionneur complet à l'aide de deux demi-additionneurs ;
 Comportemental: de manière très semblable à un langage de programmation
informatique, on précise le fonctionnement voulu à l'aide d'une suite d'instructions de
contrôles plus ou moins évoluées (conditions, boucles, etc.), dans un process
L’architecture établit à travers les instructions les relations entre les entrées et les sorties. On peut
avoir un fonctionnement purement combinatoire, séquentiel voire les deux séquentiel et
combinatoire.
Architecture nom_de_l'architecture of nom_de_l'entite is

Begin
… instructions … ;
End nom_de_l'architecture;
architecture nom_de_l'architecture of nom_de_l'entite is
begin
Y1 <= A and B;
Y2 <= A or B;
Y3 <= A xor B;
Y4 <= not A;
end DESCRIPTION;
Exemple N°1 : Réaliser le programme VHDL d'une porte NAND
Entity S
b (AND)
On donne : - l'affectation : <=

- les opérateurs logiques : and, not

Library ieee;
USE iee.std_logic_1164.all;
Entity NAND is
Port ( a : in std_logic;
b : in std_logic;
s : out std_logic );
End NAND;
Architecture desc_NAND of NAND is

Begin
S <= a and b;
End desc_NAND;
1.2.4. Les opérateurs.

1.2.4. 1. L’affectation simple : <=
Dans une description VHDL, c’est certainement l’opérateur le plus utilisé. En effet il permet de
modifier l’état d’un signal en fonction d’autres signaux et/ou d’autres opérateurs.
Exemple avec des portes logiques : S1 <= E2 and E1 ;

Les valeurs numériques que l’on peut affecter à un signal sont les suivantes :
- ‘1’ ou ‘H’ pour un niveau haut avec un signal de 1 bit.
- ‘0’ ou ‘L’ pour un niveau bas avec un signal de 1 bit.
- ‘Z’ pour un état haute impédance avec un signal de 1 bit.
- ‘-’ pour un état quelconque, c’est à dire ‘0’ ou ‘1’. Cette valeur est très utilisée avec les
instructions : when … else et with …. Select ….
- Pour les signaux composés de plusieurs bits on utilise les guillemets " … " , voir les exemples ci
dessous :
- Les bases numériques utilisées pour les bus peuvent être :
BINAIRE, exemple : BUS <= "1001" ; -- BUS = 9 en décimal
HEXA, exemple : BUS <= X"9" ; -- BUS = 9 en décimal
OCTAL, exemple : BUS <= O"11" ; -- BUS = 9 en décimal
1.2.4.2. Opérateur de concaténation : &
Exemple N°1 : A <= "001";

B <= "101";
C <= A & B & "01" C <= 00110101
1.2.4.3. Opérateurs logiques

Opérateur VHDL Explication
ET AND
NON ET NAND
OU OR
NON OU NOR
OU EXCLUSIF XOR
NON OU EXCLUSIF XNOR
NON NOT

DECALAGE A GAUCHE SLL Remplacement par des 0
DECALAGE A DROITE SRL Remplacement par des 0
ROTATION A GAUCHE ROL Le caractère de gauche est mis à droite
ROTATION A DROITE ROR Le caractère de droite est mis à gauche
Les opérateurs logiques ont priorités sur la concaténation.
Exemple N°2 : A <= "1010011"

Donner le résultat des opérateurs suivants :
B <= "01" & A SLL 2 B <= 011001100

C <= A SRL 3 & "11" C <= 000101011
D <= A ROL 4 D <= 0111010
E <= A ROR 2 & "00" E <= 111010000
1.2.4.4.Opérateurs d’assignation et d’association

- Assignation de variable nom_variable :=expression ;
 à l’intérieur d’un processus
- Assignation de signal (dynamique) nom_signal <=expression ;
 dans la zone d’instructions d’une architecture
- Assignation de signal (statique) signal nom_signal_interne : type_signal
:=valeur_initiale ;
 dans la zone de déclaration d’une architecture
- Association de signaux nom_signal_formel =>nom_signal_effectif ;
 connecteur de signaux dans une instanciation de composant
signal a : std_logic_vector (0 to 7);

signal b : std_logic_vector (7 downto 0);
a <= “11110000”;
b <= “11110000”;
a(0) a(1) a(2) a(3) a(4) a(5) a(6) a(7)
1 1 1 1 0 0 0 0
MSB (toujours à gauche)
b(7) b(6) b(5) b(4) b(3) b(2) b(1) b(0)
1 1 1 1 0 0 0 0
MSB (toujours à gauche)
La notation downto est la plus conventionnelle pour les applications de synthèse.
Opérateur VHDL
ADDITION +
SOUSTRACTION -
MULTIPLICATION *
DIVISION /
Remarque : l'utilisation de ces opérateurs avec des signaux de grandes tailles peut générer de
grandes structures électronique.
Exemple N°1 :
S1 <= A – 3 ; -- S1 = A – 3
-- On soustrait 3 à la valeur de l’entrée / signal A
S1 <= S1 + 1 ; -- On incrémente de 1 le signal S1
Remarque : Un commentaire débute par deux traits (signe moins) : --

1.2.4.6. Opérateurs relationnels
Il permet de modifier l'état d'un signal ou de signaux suivant le résultat d'un test ou d'une
condition. En logique combinatoire, ils sont souvent utilisés avec les instructions when, select,
with.
Opérateur VHDL
Egal =
Différent /=
Inférieur <
Inférieur ou égal <=
Supérieur >
Supérieur ou égal >=
1.2.5. Les instructions du mode concurrent
1.2.5. 1. Affectation conditionnelle
Signal <= expression when condition
else expression when condition
else expression when condition
else expression ;
Remarque : la dernière ligne "else expression" n'est pas obligatoire mais elle est fortement
conseillée.
Exemple N°1 : Réaliser le programme VHDL d'un multiplexeur 4 vers 1 avec entrée de
sélection
SEL S
E1 00 E1
E2 S 01 E2
E3 MUX 10 E3
E4 11 E4
SEL[1..0]
Library ieee;
Entity multiplex is
Port ( E1,E2,E3,E4 : in std_logic;
SEL : in std_logic_vector (1 downto 0);
S : out std_logic );
End multiplex;
Architecture desc_multiplex of multiplex is
Begin
S <= E1 when SEL = "00"
Else E2 when SEL = "01"
Else E3 when SEL = "10"
Else E4;
End desc_multiplex;
On aurais pu écrire aussi :

Library ieee;
USE iee.std_logic_1134.all

Entity multiplex is
Port ( E : in std_logic_vector (3 downto 0);
SEL : in std_logic_vector (1 downto 0);
S : out std_logic );
End multiplex;
Architecture desc_multiplex of multiplex is

Begin
S <= E(0) when SEL = "00"
Else E(1) when SEL = "01"
Else E(2) when SEL = "10"
Else E(3);
End desc_multiplex;
1.2.5.2. Affectation sélective
Cette instruction permet d'affecter différentes valeurs à un signal selon les valeurs prises par un
signal de sélection
With signal_de_selection select
signal <= expression when valeur_de_selection
expression when valeur_de_selection
expression when others;
Exemple N°1 : Réaliser le programme d'un multiplexeur 1 vers 4 avec entrée de sélection SEL et
sortie de validation Enable active sur l'état bas.
SEL S
S1 00 S1
E S2 01 S2
DEMX 10 S3
S3 11 S4
S4
en
SEL[1..0]
Library ieee;
Entity demultiplex is
Port ( SEL : in std_logic_vector (1 downto 0);
E : in std_logic
Enable : in std_logic;
S1,S2,S3,S4 : out std_logic;);
End demultiplex;
1.2.6. Les instructions du mode séquentiel
1.2.6.1. Définition d'un process
Un process est une partie de la description d'un circuit dans laquelle les instructions sont
exécutées séquentiellement. L'exécution d'un process est déclenché par un ou des changements
d'états de signaux logiques. Le nom de ces signaux est défini dans la liste de sensibilité lors de la
déclaration du process.
[nom_du_process :] Process ( liste_de_sensibilite )
Begin
… instruction_du_process … ;
End process;
Le nom du process est facultatif.
1.2.6.2. Règle de fonctionnement d'un process
A) L'exécution d'un process
 L'exécution d'un process a lieu à chaque changement d'état d'un signal de la liste de
sensibilité
 L'instruction du process s'exécute séquentiellement
 Les changements d'état des signaux par les instructions du process sont prises en compte
à la fin du process
 2 process d'une architecture ayant la même liste de sensibilité vont être exécutés en même
temps
Exemple N°1 :
Process (C,D)
Begin
A <= 2 ;
B <= A + C ;
A <= D + 1 ;
E <= A * 2 ;
End process;
A=1 A <= D + 1 ;
B=1 B <= A + C ;
C=1
D=1
E=1 E <= A * 2 ;
On commence en mettant D à 2
On trouve les résultats suivants :
A=3 B=2 E=2
Remarque : Les valeurs ne sont affectées qu'après la fin du process
Exemple N°2 : Déclaration d’une bascule D.

Library ieee;
Use ieee.std_logic_1164.all;
Use ieee.numeric_std.all;
Use ieee.std_logic_unsigned.all;
entity BASCULED is
port (
D,CLK : in std_logic;
Q : out std_logic);
end BASCULED;
architecture DESCRIPTION of BASCULED is
begin
PRO_BASCULED : process (CLK)
begin
if (CLK'event and CLK ='1') then
Q <= D;
end if;
end process PRO_BASCULED;
end DESCRIPTION;
Exemple N°3 : La bascule D avec un reset asynchrone

Complétons la description de la bascule précédente pour y ajouter un reset asynchrone.

CLK Q
D
Bascule_D
RESET
library ieee;
use ieee.std_logic_1164.all;
ENTITY Bascule_D IS
PORT ( D : IN STD_LOGIC;
clk : IN STD_LOGIC;
Q : OUT STD_LOGIC);
END Bascule_D;
ARCHITECTURE archdff OF Bascule_D IS

BEGIN
p1: PROCESS (clk,reset)
BEGIN
IF (reset='1') THEN
q <= '0';
ELSIF (clk'event AND clk='1') THEN
q <= d;
END IF;
END PROCESS p1;
END archdff;
Remarques:
- Seul le signal CLK fait partie de la liste de sensibilité. D’après les règles de fonctionnement
énoncées précédemment, seul un changement d’état du signal CLK va déclencher le process
et par conséquent évaluer les instructions de celui-ci.
- L’instruction if (CLK'event and CLK='1') then permet de détecter un front montant du
signal CLK. La détection de front est réalisée par l’attribut event appliqué à l’horloge CLK. Si on
veut un déclenchement sur un front descendant, il faut écrire l’instruction suivante : if
(CLK'event and CLK='0').
- Les bibliothèques IEEE possèdent deux instructions permettant de détecter les fronts montants
) rising_edge(CLK) ou descendants falling_edge(CLK).
- Si la condition est remplie alors le signal de sortie S sera affecté avec la valeur du signal d’entrée
D.
B) Les principales structures du mode séquentiel
 A l'intérieur d'un process, on peut utiliser des "if" et/ou des "case". L'exécution est alors
séquentielle.
 De même on peut utiliser des boucles pour contrôler l'exécution. Les "for" sont à bornes
fixes, alors que les "while" ne le sont pas.
B.1) Le fonctionnement du "If"

La combinaison IF THEN permet d'effectuer un test d'une expression logique. La suite du
déroulement dépend du résultat.
Deux imbrications sont possibles : ELSIF suivi d'un autre test et ELSE qui contrôle les résultats
FALSE.
Syntaxe : If condition then instructions ;
Elsif condition then instructions ;

Else instructions ;
End if ;
Exemple N°1: Multiplexeur
E1
S
MUX
EN
sel
LIBRARY ieee;
ENTITY mux IS
PORT (E1,E2,sel : IN std_logic;
S : OUT std_logic);
END mux;
ARCHITECTURE behavior OF mux IS
BEGIN
PROCESS (sel,E1,E2) -- liste de sensibilité
BEGIN
IF sel = '0' THEN -- test si sel vaut 0
S <= E1;
ELSIF sel = '1' THEN -- test si sel vaut 1
S<= E2;
ELSE
y <= 'X'; -- si sel n'est ni à 1 ni à 0, on affecte X à S
END IF;
END PROCESS;
END behavior;
B.2) Le fonctionnement du "Case"

On utilise CASE pour permettre le choix entre plusieurs actions. Cet instruction est très utile
dans les machines d'états. En fin de liste, on peut ajouter WHEN OTHERS qui permet de
donner une action à tous les choix qui n'ont pu être trouvés dans la liste.
Syntaxe : Case signal de selection is
When valeur_de_selection => instruction;
When valeur_de_selection => instruction;
…
When others => instruction;
End case;
Même exercice avec case :
S1
E S2
DEMX
S3
S4
en
SEL[1..0]
Library ieee;
Entity demultiplex is
Port ( SEL : in std_logic_vector (1 downto 0);
E : in std_logic

Enable : in std_logic;
S1,S2,S3,S4 : out std_logic
);
End demultiplex;
Architecture desc_demultiplex of demultiplex is
Begin
Process (SEL, ENABLE, E) --liste de sensibilité
Begin
If ENABLE = '0' then
Case SEL is
When "00" => S1 >= E ;
When "01" => S2 >= E ;
When "10" => S3 >= E ;
When others => S4 >= E ;
End case;
Else S1<='Z'; S2<='Z';S3<='Z'; S4<='Z' ;
End if ;
End process ;
End desc_demultiplex ;
B.3) Le fonctionnement du "for"

Syntaxe : FOR parametre IN intervalle (Ex : 0 to 5) LOOP
instruction;
End LOOP;
Exemple N°1 : codage de données :

Le cahier des charges est le suivant :
s0 = a0
Pour i > 0 si = ai . ai-1 + ai . ai-1
ENTITY codage IS
a : IN std_logic_vector (3 downto 0) ;
s : OUT std_logic_vector (3 downto 0) ;
END codage
Architecture archi of codage is
Begin
Process
Begin
s(0) <= a(0);
FOR I IN 1 to 3 LOOP
s(i)<=(a(i) AND a(i-1)) OR ((NOT a(i) AND NOT a(I-1));
END LOOP;
END process ;
END archi;
Exemple N°2 :
process (A)
begin
Z <= "0000";
for I in o to 3 loop
if (A = I) then

Z(I) <= '1';
end if;
end loop;
end process;
B.4) Le Fonctionnement du "After"
AFTER spécifie un temps de réponse d'un signal par rapport à son événement.
Deux modes de délai sont possibles INERTIAL (défaut) ou TRANSPORT. Le mode
INERTIAL ne propage pas les impulsions plus courtes que le temps de propagation.
Syntaxe :
sigal_name <= [INERTIAL/TRANSPORT] expression AFTER time_expression
Exemple N°1 : propage pas les impulsions plus courtes que le temps de propagation.
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
entity porte_and is
Port ( a : in STD_LOGIC;
b : in STD_LOGIC;
z : out STD_LOGIC);
end porte_and;
architecture Behavioral of porte_and is
begin
PROCESS(a,b)
BEGIN
z <= a and b AFTER 10 ns; -- temps de propagation est de 10ns
END PROCESS ;
end Behavioral;

Exercices
Exercice 1 :Compteur/Décompteur
On considère le circuit logique schématisé par la Figure suivante dont les entrées CLK, SENS,
RAZ sont des bits. La sortie du circuit est Q3..0 vecteur dont les éléments sont des bits.
CLK
Q
SENS
RAZ
CMP_DEC /
4 bits
Le fonctionnement de ce circuit est donné par la table de vérité suivante :

Inputs Outputs
RAZ SENS CLK Q(3) Q(2) Q(1) Q(0)
1 x x 0 0 0 0
0 1 Incrémentation
0 0 Décrémentation
1°) Ecrire l’entité du circuit.
2°) Ecrire l’architecture comportementale du circuit.
Exercice 2 : boite
On considère le circuit ‘boite’ décrit par sa table de vérité suivante :
Inputs Outputs
A B RAZ CLK Q
X X 1 0
0 0 0 Pas de changement
0 1 0 0
1 0 0 1
1 1 0 Haute impédance
1°) Ecrire l'entité.

2°) Proposer une architecture comportementale du système.
Exercice 3 : Binary Coded Hexadecimal

En codage BCH : (Binary Coded Hexadecimal, soit hexadécimal codé binaire en français), on
prend chaque chiffre qui compose une valeur hexadécimal, et on le code directement sur 4 bits.
Exemple : F 0 5 = 1111 0000 0101
Le but de cet exercice est d’afficher la valeur d’une entrée de 4 bit (BCH) en une valeur
hexadécimal (0, 1, ..., 9, A, B, …, F)
Exemple :
si BCH = 1110 = E en hexadécimal (=14 en décimal) alors l’afficheur 7 segment affichera la
lettre E.
si BCH = 0010 = 2 en hexadécimal alors le chiffre 2 sera afficher.
N.B.
Deux types d’afficheurs :
Anodes communes : L’allumage des segments est assuré par un état logique ‘0’
Cathodes communes : L’allumage des segments est as suré par un état logique ‘1’
Nous choisirons ici un afficheur 7 segments à catho des communes.

a
a
f b
BCH SEG
g
/ DecHex /
4 bits 7 bits
e c
d
gfedcba
BCH[3..0]  SEG[6..0]
1°) Etablir la table de vérité de la fonction. (Donner la valeur HEXA du mot de sortie).
ENTREES SORTIES Hexa
BCH(3) BCH(2) BCH(1) BCH(0) SEG(6) SEG(5) SEG(4) SEG(3) SEG(2) SEG(1) SEG(0)
0 0 0 0
0 0 0 1
0 0 1 0
0 0 1 1
0 1 0 0
0 1 0 1
0 1 1 0
0 1 1 1
1 0 0 0
1 0 0 1
1 0 1 0
1 0 1 1
1 1 0 0
1 1 0 1
1 1 1 0
1 1 1 1
2°) Donner le code VHDL de l’entité correspondante de ce décodeur Dec_Adress.
3°) Donner le code VHDL de l’architecture correspondante.
Exercice 4 : transcodeur binaire-code de gray

1°) Décrivez l’entité et l’architecture d’un transcodeur binaire-code de gray. La table de vérité
ci-dessous donne une spécification du comportement attendu.
binaire Code de gray

E2 E1 E0 S2 S1 S0
0 0 0 0 0 0
0 0 1 0 0 1
0 1 0 0 1 1
0 1 1 0 1 0
1 0 0 1 1 0
1 0 1 1 1 1
1 1 0 1 0 1
1 1 1 1 0 0

E2 E 1 E0
Transcodeur
S2 S 1 S0
2°) On souhaite décrire le comportement d’un registre répondant à la table fonctionnelle

suivante :
S1S0 Fonction
00 inchangé
01 chargement
10 Déc gauche
11 Déc droit
Tableau 1 : Table fonctionnelle de ce registre
4 bits
2 bits
IL E IR
S1..0
REGISTRE
H
Q
4 bits
Donnez l’entité et l’architecture décrivant l’interface du circuit. Les signaux d’entrée E et de sortie
Q seront considérés comme des std_logic_vector, avec un nombre de bits N paramétrable (N=4
bits). S sera également de type std_logic_vector. Le reste des signaux sera de type std_logic.
Exercice 5 : Décodeur d’adresse

Voici un schéma d’un décodeur d’adresse
CS_A
8 bits
CS_B
Dec_Adress
Adresse CS_C
Le tableau ci-dessous nous donne le plan d’adressage de ce décodeur :

Adresses (8 bits)
CS_A CS_B CS_C
En Héxa En décimal
0 à 2F 0 à 47 1 0 0
30 à 4F 48 à 79 0 1
50 à 7F 80 à127 0 0 1
80 à FF 128 à 255 0 0 0
Tableau 2 : Plan d’adressage de décodeur
1°) Donner le code VHDL de l’entité correspondante de ce décodeur Dec_Adress.

2°) Donner le code VHDL de l’architecture correspondante.

Exercice 6 : REGISTRES à décalage
Le schéma bloc d’un registre à décalage est illustré par la figure ci-dessous
D_IN D_OUT
S1
CLK
1°) Compléter ce Tableau.

clk D_IN S1 D_OUT
0 1 1
 0
 0
2°) Ecrire l’entité.
3°) Ecrire l’architecture de ce registre.
Exercice 7 : Compteur synchrone 4 bits avec retenue
Data_OUT
4 bits
CPTR Carry
CLK
1°) Ecrire un code VHDL pour ce Compteur.

Exercice 8 : Synthèse d'une bascule D avec remise à zéro.
D Q
bascule D
CLK RESET
1°) Ecrire un code VHDL pour d’une bascule D avec remise a zéro.
2°) Même exemple que précédemment mais avec des entrées de présélections de mise à zéro
RESET prioritaire sur l’entrée de mise à un SET, toutes les deux sont synchrones de l’horloge
CLK.
3°) Même exemple que précédemment mais avec des entrées de présélections, de mise à zéro
RESET prioritaire sur l’entrée de mise à un SET, toutes les deux sont asynchrones de l’horloge
CLK.
Exercice 9 : Compteur chargeable (chargement synchrone, reset

asynchrone)
Ecrire le fichier .VHD correspondant au compteur chargeable (chargement synchrone, reset
asynchrone) ci-dessous.

D Q
8 bits 8 bits
Load
CMPL
CLK
RESET

2
STRUCTURE D’UNE DESCRIPTION VHDL
2.1. Introduction
Une architecture décrit le fonctionnement du système, l'implémentation de la fonctionnalité

voulue. Son fonctionnement peut être combinatoire ou séquentiel. Pour modéliser un système
complet, on utilisera une série de paires entité-architecture.
On y définit des signaux, l'équivalent le plus proche des variables en programmation

informatique : ils servent à passer les résultats intermédiaires d'un bloc fonctionnel à un autre. On
les utilisera en pratique lors de la présentation des architectures comportementales.
 L'ARCHITECTURE décrit le fonctionnement de la boîte noire déclarée dans

l'ENTITY
 VHDL permet différents niveaux de description :
◦ Haut niveau (comportemental) : description de la fonctionnalité, sans référence
au 'hardware' sous-jacent
◦ Bas niveau (structurel) : description par utilisation et interconnexion de
'components' (par ex. portes logiques), comme pour un schéma
◦ D'une manière générale les descriptions de haut niveau favorisent la portabilité,
les descriptions de bas niveau l'efficacité
 A tout moment (y compris à l'intérieur d'une même architecture), c'est le concepteur qui
choisit le niveau de description adéquat
Une description VHDL se compose de deux parties:

I. La description de l’interface Circuit (appelée Entity) avec le monde qui l’utilise
(connexions, brochages,…) celle-ci est constituée par la liste des signaux de cette interface,
leur sens et leur nature etc.
II. La description de la réalisation du circuit (appelée Architecture) qui peut contenir quatre
formes de descriptions:
1. Comportementale (Sans référence à des structures ou des équations)
2. Temporelle ou flot des données (c’est a dire réaliser a partir des équations
booléennes )
3. Structurelle (c’est à dire réaliser a partir des composants prédéfinis)

4. Mixte (c’est à dire réaliser a partir des composants prédéfinis et des équations
booléennes)
2.2. les descriptions comportementales

Elles spécifient le comportement au moyen de formules ou de programmes d'actions. On décrit
alors l'architecture comme une suite d'instructions, comme en programmation informatique
traditionnelle. On définit des process ainsi que leur liste de sensibilité : dès qu'un symbole change
de valeur dans cette liste, le code est réexécuté. C'est utile notamment en logique séquentielle,
pour lancer le code à chaque coup de l'horloge. Les instructions sont exécutées de manière
séquentielle ; cependant, les signaux ne changent de valeur qu'à la fin du process.
On peut utiliser diverses constructions bien connues: le if-then-else, le case-is when, etc. On
dispose de plusieurs boucles, mais leur utilisation ne correspond pas à l'habitude informatique
(elles correspondent plus à une simplification de l'écriture qu'à une exécution de code répétitive
pour s'approcher du résultat final ou toute utilisation plus « traditionnelle » des boucles), de
même pour les fonctions et procédures.
Les signaux sont définis dans l'en-tête de l'architecture ; les variables ne sont valables que dans un
process. En dehors d'un process, tout se produit de manière concurrente : deux process peuvent
être exécutés simultanément. Par contre, dans un process, toutes les instructions sont exécutées
de manière séquentielle et les affectations sont réalisées à la fin.
 Modèle comportemental :
 description du fonctionnement du système :
- algorithmes, machine d’états
 algorithme proche de ceux des langages de programmation
 le temps peut intervenir :
- permet de coller à la réalité par le respect des temps de traversée
 une description haut niveau est d’abord comportementale :
- elle sert de référence pour la suite de la conception
Exemple N°1 : Additionneur 1 Bit (FA)

A B
A B Cin S Cout
0 0 0 0 0
0 0 1 1 0
0 1 0 1 0
Cout Cin 0 1 1 0 1
FA 1 0 0 1 0
1 0 1 0 1
1 1 0 0 1
1 1 1 1 1
S Tableau 2.1. Additionneur 1 Bit
Architecture comportementale of Additionneur is

begin
process(A,B,Cin)
begin
if (A ='0' and B='0' and Cin='0' ) then
Sum<='0';Cout<='0';
elsif (A ='0' and B='0' and Cin='1' ) then
Sum<='1';Cout<='0';
Sum<='1';Cout<='0';
Sum<='0';Cout<='1';

Sum<='1';Cout<='0';
Sum<='0';Cout<='1';
Sum<='0';Cout<='1';
else
Sum<='1';Cout<='1';
end if;
end process;;
end comportementale ;
Device Utilization Summary (Estimated Values)

Logic Utilization Used Available
Number of Slices 1 2448
Number of 4 input LUTs 2 4896
Number of bobded IOBs 5 66
Tableau 2.2. Résultats de synthèse
Exemple N°2 : Multiplexeur 2-1
Un multiplexeur est un sélectionneur d'entrées : en fonction de la valeur placée sur les entrées
de sélection, il choisit l'entrée de données à répercuter à la sortie. Ici, on implémente un
multiplexeur 2-1, car il dispose de quatre entrées de données et d'une sortie.
A
S
MUX2-1
B
sel
library IEEE;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
entity Mux21_comportementale is
Port ( A : in STD_LOGIC;
B : in STD_LOGIC;
Sel : in STD_LOGIC;
S : out STD_LOGIC);
end Mux21_comportementale;
architecture Behavioral of Mux21_comportementale is
process (A, B, S)
begin
S <= A WHEN (Sel='0') else
B WHEN (Sel='1') else
'X';
End process;
end Behavioral;

On peut implémenter un multiplexeur à l'aide d'une série de if, une manière très commode de
procéder pour tout qui vient de la programmation informatique.
library ieee;
entity MUX is
port(
E0, E1, E2, E3: in std_logic;
SEL: in std_logic_vector(1 downto 0);
S: out std_logic);
End MUX;
architecture CMP of MUX is
begin
process (E0, E1, E2, E3, SEL)
begin
if SEL="00" then
S <= E0;
elsif SEL="01" then
S <= E1;
elsif SEL="10" then
S <= E2;
elsif SEL="11" then
S <= E3;
Else S <= '-';
end if;
end process;
end FLOT_MUX;
2.3. Modèle Flot des données

Comme précédemment, on décrit simplement les équations booléennes que l'on veut
implémenter.
A B
A B Cin S Cout
0 0 0 0 0
0 0 1 1 0
0 1 0 1 0
Cout Cin 0 1 1 0 1
FA 1 0 0 1 0
1 0 1 0 1
1 1 0 0 1
1 1 1 1 1
S Tableau 2.1. Additionneur 1 Bit

AB AB
00 01 11 10 00 01 11 10
Cin Cin
0 0 1 0 1 0 0 0 1 0
1 1 0 1 0 1 0 1 1 1
S=A xor B xor Cin Cout=(A and B ) or Cin (A or B)
library IEEE;
entity Additionneur_FD is
B : in STD_LOGIC;
Cin : in STD_LOGIC;
S : out STD_LOGIC;
Cout : out STD_LOGIC);
end Additionneur_FD;
architecture Behavioral of Additionneur_FD is
begin
S<= A xor B xor Cin;
Cout<= (A and B) or (Cin and (A or B));
end Behavioral;
Exemple N°2 : Multiplexeur 2-1
A
S
MUX2-1
B
sel
S= NOT(Sel). A + Sel .B
library IEEE;
entity Mux21_FD is
B : in STD_LOGIC;
Sel : in STD_LOGIC;
S : out STD_LOGIC);
end Mux21_FD;
architecture Behavioral of Mux21_FD is
begin

S<= (not(sel)and A) OR (sel and B) ;
end Behavioral;
2.4. les descriptions Structurelle
VHDL permet l'assemblage de "composants" ce qui constitue une description structurelle. Ce

composant peut être appelé plusieurs fois dans un même circuit. Pour différencier ces mêmes
composants, il est nécessaire de leur donner un nom d'"instance". L'appel d'un composant se dit
aussi "instanciation"
De façon à instancier un composant il est nécessaire de connaître :
 Le prototype du composant (ses ports d'entrée et de sortie). La directive component peut

être utilisée à cette fin.
 A quelle entité et architecture est lié chaque instance de composant. Ce lien peut être
connu grâce à l'unité de configuration.
Il est important de noter :
 La déclaration du composant (directive component ) est redondante textuellement avec

celle de l'entité associée mais permet :
1. Une compilation indépendante entre l'entité associée au composant et le circuit

utilisant le composant.
2. La conception descendante. Le composant peut être déclaré avant l'entité
associée.
 La configuration est une unité de compilation optionnelle, très utile pour les gros
circuits. Par exemple pour accélérer la simulation , un même composant peut être associé
à un couple entité/architecture détaillé et synthétisable ou un autre couple plus abstrait et
plus rapide à simuler. Pour ne pas utiliser de configuration, une règle fréquente est
d'utiliser le même nom pour le composant et l'entité associée, c'est le cas pour ModelSim
et les outils de synthèse FPGA.
La description structurelle est nécessaire pour simuler un circuit dont les vecteurs stimulis sont
eux mêmes issus d'un modèle VHDL. Le modèle de plus haut niveau fait donc appel au circuit à
tester (Device Under Test) et d'un générateur de stimulis. Ces deux objets sont instanciés dans un
même circuit, généralement appelé "testbench" (mais ce n'est pas une obligation) qui est
autonome : il n'aura pas d'entrées ni de sorties.

Le mot clé component sert à déclarer le prototype d'interconnexion. La syntaxe est presque
identique à celle de l'entité :
component Nom_ component
port (
description des signaux);
end component;
Exemple N°1 :
component AND_2
port (
E1: IN std_logic;
E2: IN std_logic;
S : OUT std_logic;);
end component;
Instanciation :
L'instanciation d'un composant se fait dans le corps de l'architecture de cette façon :
<NOM_INSTANCE>:<NOM_COMPOSANT> port map (LISTE DES CONNEXIONS);
Exemple N°2
Dans cet exemple , 2 instances de composant "and2" sont appelées pour créer une porte ET à 3
entrées.
L'association des ports du composants aux signaux de l'instance se fait à l'aide de la clause port
map.
La syntaxe des associations est soit
1. par nom où chaque broche du composant est associée à un signal : cas de inst_1
2. positionnelle où l'ordre des signaux correspond à l'ordre des broches : cas de inst_2
Exemple N°1 :
entity AND_3 is
port(
e1 : in std_logic;
e2 : in std_logic;
e3 : in std_logic;
s : out std_logic);
end AND_3;
architecture arc of AND_3 is
-- signal z : bit;
component and2
port (
a : std_logic;
b : std_logic;
s : std_logic);
end component;
begin
inst1 : and2 port map (a=>e1, b=>e2 , s=>z);
inst2 : and2 port map (z, e3, s);
end arc;
VHDL supporte et encourage la conception modulaire
 Un niveau de description peut faire appel à des modules compilés indépendamment, et

les interconnecter de manière structurelle

COMPONENT 2
COMPONENT 1
 Les modules de niveaux inférieurs sont des COMPONENTs

 Si un COMPONENT est d'utilisation fréquente, il est commode de le placer dans un
PACKAGE

1. Demi Additionneur HA (Half Adder)
• Le demi additionneur est un circuit combinatoire qui permet de réaliser la somme
arithmétique de deux nombres A et B chacun sur un bit
.• A la sotie on va avoir la somme S et la retenu Cout ( Carry).
( half_adder =HA)
A B Pour trouver la structure ( le schéma ) de ce circuit on
doit en premier dresser sa table de vérité
La table de vérité associée :
A B S Cout
Cout 0 0 0 0
HA 0 1 1 0
1 0 1 0
1 1 0 1
De la table de vérité on trouve S  A.B  A.B  A  B et Cout  A.B
A S
XOR
B
AND Cout
HA

library IEEE;
ENTITY half_adder IS
PORT ( A,B: IN std_logic;
S, cout: OUT std_logic);
END half_adder ;
ARCHITECTURE beh OF half_adder IS
begin
sum <= A XOR B;
cout<= A AND B;
end beh;
2. L’additionneur complet un bit

Exemple N°1 : L’additionneur complet un bit
possède 3 entrées :
– A: le premier nombre sur un bit.
– B: le deuxième nombre sur un bit.
– Cin: le retenue entrante sur un bit.
• Il possède deux sorties :
– Si: la somme
–Cout la retenue sortante
A B
Cout Cin
FA
S  A  B  Cin et Cout  ( A.B)  Cin A  B
Si on pose X  A  B et Y  A.B
On obtient : S  X  Cin et Cout  Y  Cin.X et si on pose Z  X  Cin et T  Cin.X
On obtient : Cout  Y  T et S  Z
 On remarque que X et Y sont les sorties d’un demi additionneur (HF) ayant comme
entrées A et B
 On remarque que Z et T sont les sorties d’un demi additionneur (HF) ayant comme
entrées X et Cin

Y
A Cout
B
HA X OR
T
Z
Cin
HA S
library IEEE;
ENTITY OR_2 IS
PORT(a,b: IN std_logic;
c: OUT std_logic);
END OR_2;
ARCHITECTURE beh OF OR_2 IS
Begin
c <= a OR b;
end beh;
library IEEE;
ENTITY full_adder IS
PORT(in1,in2,cin: IN std_logic;
result,carry: OUT std_logic);
END full_adder;
ARCHITECTURE structural OF full_adder IS

COMPONENT half_adder
S,Cout: OUT std_logic);
END COMPONENT;
COMPONENT OR_2
c : OUT std_logic);
END COMPONENT;
SIGNAL X,Y,T,Z : std_logic;
BEGIN
H1 : half_adder PORT MAP(A,B, Y, X);
H2 : half_adder PORT MAP(X,cin,Z, T);
O1 : OR_2 PORT MAP(Y,T, Cout);
END structural;
Exemple N°2 : L'exemple classique de l'additionneur n bits... On utilise ici une boucle FOR
GENERATE pour instancier automatiquement les différentes primitives ainsi que les noeuds les
connectant entre elles. Notez qu'il n'est pas nécessaire de déclarer la variable de boucle mais que
l'instruction FOR GENERATE nécessite une étiquette.

entity Nbit_adder is
generic( SIZE = 4);
port (
a,b : in unsigned(SIZE-1 downto 0);
ci : in std_logic;
sum : out unsigned(SIZE-1 downto 0);
co : out std_logic);
end entity;
component FA
port( A, B, Cin : in std_logic;
S, Cout : out std_logic);
end component;
architecture arc of Nbit_adder is

signal c :unsigned (SIZE downto 0);;
begin
C(0) <= Cin;
co <= C(SIZE);
G: for I in 0 to N-1 generate
inst: FA port map(A(I), B(I), C(I), sum(I), C(I+1));
end generate G;
end arc;

Exercices
Exercice 1 : Compteur
Le comportement de cette fonction (compteur) peut être décrit comme étant la mise en cascade
d’un additionneur et un registre à chargement parallèle (8 bits).
[7:0] Q[7:0]
[7:0] D[7:0] Q[7:0]
+ Registre
1
8 bits
H
Reset
1°) Donner une description VHDL (structurelle) du circuit proposé.

2°) Proposer une description comportementale du circuit proposé (indication : utiliser les signaux
et les process)
3°) Ecrire l’entité de ce circuit.
4°) donner un code VHDL d’une porte NAND simple à deux entrées.
5°) Déduire une description de type structurelle de ce circuit (les entrées : A, B, Sortie : S)
Exercice 2: Additionneur
On désire modéliser un additionneur sur 1 bit (FA) gérant les problèmes de retenue. Ai et Bi
sont les entrées de 1 bit chacune à additionner, Cin est une retenue en entrée, Si est le résultat et
Cout la retenue de sortie
Ai Bi
Cout Cin
FA
Si
1°) Additionneur
a) Ecrire les équations des sorties Si et Cout (en utilisant des portes AND, OR et XOR).

b) Ecrire un programme en VHDL avec une description de type flot des données pour cet
additionneur (FA).
c) A partir de ce schéma, écrire en VHDL un modèle uniquement structurel de
l'additionneur 4 bits en utilisant l’additionneur 1 bit (FA) déjà décrit.
A(3) B(3) A(2) B(2) A(1) B(1) A(0) B(0)
Cout i3 i2 i1 Cin
FA FA FA FA
S(3) S(2) S(1) S(0)
d) Comme pour l'additionneur, un soustracteur peut être réalisé en cascadant les cellules de
base.
Ecrire un programme en VHDL avec une description structurelle pour ce soustracteur
(en utilisant les fils internes i1, i2, i3, b0, b1, b2 et b3).
B(3) B(2) B(1) B(0)
A(3) A(2) A(1) A(0)

b3 b2 b1 b0
Cout i3 i2 i1 ‘1’
FA FA FA FA
S(3) S(2) S(1) S(0)
2°) Pour obtenir un Additionneur Soustracteur (à N-bit), il suffit d’enchaîner ‘N’ Additionneur
Complet (à 1-bit) en série + NXORs.
Par exemple, pour N=4: Ecrire un code VHDL pour ce circuit en utilisant une description de
type structurelle.
Add_soust=C0
B(3) B(2) B(1) B(0)
XOR XOR
A(3) A(2) A(1) XOR
A(0) XOR
b3 b2 b1 b0
C4 c3 c2 c1
FA FA FA FA
S(3) S(2) S(1) S(0)

3°) MULTIPLIEUR BASIQUE À RETENUES PROPAGÉES
Ecrire un code VHDL pour le circuit Multiplieur en utilisant une description de type structurelle.
A(3) B(1) A(3) B(0) A(2) B(1) A(2) B(0) A(1) B(1) A(1) B(0) A(0) B(1) A(0) B(0)
'0'
c7 c6 c5 c4 c3 c2 c1
'0'
FA FA FA FA
A(3) B(2) A(2) B(2) A(1) B(2) A(0) B(2)
c15 c14 c13 c12 c11 c10 c9 c8
'0'
FA FA FA FA
A(3) B(3) A(2) B(3) A(1) B(3) A(0) B(3)
c23 c22 c21 c20 c19 c18 c17 c16
'0'
FA FA FA FA
P7 P6
P5 P4 P3 P2 P1 P0
Exercice 3 : Multiplexeur
Partie I :
Le schéma bloc du multiplexeur à deux entrées est illustré par la figure ci-dessous
E(0)
S
MUX2-1
E(1)
)
sel

Le fonctionnement de ce Mux2_1 est comme suit :
- Si Sel =’0’ alors S= E(0)
- Si Sel =’1’ alors S= E(1)
1°) Ecrire l’équation logique du système
2°) Donner le schéma logique du système
3°) Ecrire un code VHDL pour ce Multiplexeur en utilisant une description de type flot de
données.
Partie II :
Le schéma bloc du multiplexeur à quatre entrées est illustré par la figure ci-dessous
1°) proposer le schéma équivalent à base de Mux2_1
2°) Ecrire un code VHDL pour ce Multiplexeur en utilisant une description de type structurelle.
E(0)
E(1) S
MUX2-1
E(2)
E(3)
)
sel(1) sel(0)
3°) Utiliser une description de type flot de données pour réaliser un additionneur de 1 bit dont le
schéma bloc est illustré par la figure suivante.
Exercice 4 : circuit séquenceur

Il s’agit de réaliser le circuit séquenceur suivant :
PA1
H Q(0)
PA2
Q(1)
Sens Compteur Encodeur PB1
Q(2)
PB2
INH
Le compteur est un compteur 3 bits modulo 8. Le fonctionnement de ce circuit est donné par la
table de vérité suivante :
Inputs Outputs
Sens H Q(2) Q(1) Q(0)
1 Incrémentation
0 Décrémentation
Le fonctionnement de l’encodeur est le suivant :

Si INH=0 alors PA1= PA2= PB1 =PB2=0
Si INH=1 alors PA1, PA2, PB1, PB2 suivent le tableau suivant
Q 0 1 2 3 4 5 6 7 0 1 2
PA1 1 1 0 0 0 1 1 1 1 1 0
PA2 0 1 1 1 1 1 0 0 0 1 1
PB1 1 1 1 1 0 0 0 1 1 1 1
PB2 0 0 0 1 1 1 1 1 0 0 0

1. Ecrire un code VHDL pour le compteur en utilisant une description de type
comportementale.
2. Ecrire un code VHDL pour l’encodeur en utilisant une description de type
comportementale.
3. Ecrire un code VHDL pour ce séquenceur en utilisant une description de type
structurelle.
Exercice 5 : Additionneur générique de 2 nombres

1. Codez un additionneur générique de 2 nombres non signés sur n bits:
Réponse:
library ieee;
use ieee.numeric_std.all;
entity GEN_ADD is
generic ( n: postive :=8);
port ( A : in unsigned(n-1 downto 0);
B : in unsigned(n-1 downto 0);
S : out unsigned(n-1 downto 0));
end GEN_ADD;
architecture RTL of GEN_ADD is
begin
S <= A + B;
end RTL;

Exercice 6 : Registre générique de n bits

Codez un registre générique de n bits.
Réponse:
library ieee;
entity GEN_REG is
generic ( n : integer :=8 );
port ( CLK : in std_logic;
NRST : in std_logic;
EN : in std_logic;
D : in unsigned(n-1 downto 0);

Q : out unsigned(n-1 downto 0) );
end GEN_REG;
architecture RTL of GEN_REG is
begin
SYNC : process(CLK,NRST)
begin
if NRST='0' then
Q <= (others => '0');
elsif (CLK'event and CLK='1')then
if en='1' then
Q <= D;
end if;
end if;
end process sync;
end rtl;

Exercice 6 : Registre à décalage

On cherche à réaliser un registre à décalage sur 8 bits, possèdant une sortie supplémentaire
(match) active à 1 si le contenu du registre à décalage vaut une valeur précise (val).
Réponse:
library ieee;
entity GEN_REG is
generic ( n : integer :=8 );
port ( CLK : in std_logic;
NRST : in std_logic;
EN : in std_logic;
D : in unsigned(n-1 downto 0);
Q : out unsigned(n-1 downto 0) );
end GEN_REG;
architecture RTL of GEN_REG is
begin
SYNC : process(CLK,NRST)
begin
if NRST='0' then
Q <= (others => '0');
elsif (CLK'event and CLK='1')then
if en='1' then
Q <= D;
end if;
end if;
end process sync;
end rtl;

Exercice 7 : Unité arithmétique et logique
Le schéma de la Figure. 1 montre un exemple (74LS382) d'ALU. Les nombres A et B constituent
les deux opérandes. Le nombre C constitue le code de la fonction à réaliser. Le nombre S est le
résultat de l'opération. Re et Rs sont les retenues entrante et sortante. OVR indique qu'il y a un
dépassement. Le tableau ci-dessous résume le fonctionnement de cette ALU.
A(3) A(2) A(1) A(0) B(3) B(2) B(1) B(0) Re

C(0)
C(1)
C(2)
ALU
S(3) S(2) S(1) S(0) OVR Rs
Figure 1. Unité arithmétique et logique

C(2) C(1) C(0) Opération réalisée
0 0 0 S=0000
0 0 1 S=B moins A
0 1 0 S=A moins B Operations Arithmétiques
0 1 1 S=A plus B
1 0 0 S=A OR B
1 0 1 S=A XOR B Operations Logiques
1 1 0 S=A AND B
1 1 1 S=1111
1°) Ecrire un code VHDL pour cette Unité arithmétique et logique .
Exercice 8 : Augmentation de capacité mémoire par association de plusieurs

boîtiers
Réalisons une mémoire de 4 Mo à l'aide de 4 boîtiers mémoires de 1 Mo chacun. Une mémoire
de 1 Mo possède 20 entrées adresse (voir tableau ci-contre), A0...A19. Or, pour adresser 4 Mo il
faut 22 entrées adresse, A0...A21. Les 20 premiers bits d'adresse (A0...A19) servent d'adresser le
même octet au sein des 4 boîtiers. Les deux bits d'adresses restant (A20 et A21) permettent à
l'aide d'un décodeur 1 parmi 4 de sélectionner un boîtier.
D0...D7
boîtier boîtier boîtier boîtier

3 2 1 0
A0...A19
A0
Décodeur
(1/4) A1
Position Adresse (Hexa) Adresse(Dec)

1er boîtier 000000→0FFFFF 0→1048575
2eme boîtier 100000→1FFFFF 1048576→2097151

1°) Préciser le mapping de cet architecture minimale (partage de zone mémoire et la taille des
différents boitiers)
2°) Ecrire un code VHDL pour ce décodeur d'adresse .
3°) Exemple Boitier 1 =RAM (n=20 et m=8)
A(n-1) D(m-1)
A(1)
A(0) RAM D(1)
D(0)
CE
WE
2nx m RAM chip
CE WE Opération
0 x None
Read from memory location
1 0
selected by address lines
Write to memory location selected
1 1
by address lines
Réponse:
library IEEE;
entity memory is
Port ( CE : in STD_LOGIC;
WR : in STD_LOGIC;
A : in STD_LOGIC_VECTOR (19 downto 0);
D : BUFFER STD_LOGIC_VECTOR (7 downto 0));
end memory;
architecture Behavioral of memory is

begin
PROCESS (CE, WR)
SUBTYPE cell IS STD_LOGIC_VECTOR(7 DOWNTO 0);
TYPE memArray IS array (0 TO 159) OF cell;
VARIABLE mem: memArray; --memory contents
VARIABLE ctrl: STD_LOGIC_VECTOR(1 DOWNTO 0);
BEGIN
ctrl := CE & Wr; -- group signals for CASE decoding
CASE ctrl IS
WHEN "10" => -- read
D <= mem(CONV_INTEGER(A));-
WHEN "11" => -- write
mem(CONV_INTEGER(A)) := D;--
WHEN OTHERS =>
D <= (OTHERS => 'Z');
END CASE;
END PROCESS;
end Behavioral;

3
MACHINE A ETATS FINIS
3.1. Introduction
Une machine à états finis (Finite State Machine FSM) est une machine séquentielle caractérisée
par :
 un vecteur d’entrée.
 un vecteur de sortie.
 une séquence d’états définissant son comportement.
- La machine (également appelée automate ou séquenceur) va passer d’un état à l’autre
suivant les séquences d’entrée qu’elle reçoit. On attribue généralement à la machine un
état de départ lui permettant de débuter son fonctionnement à partir d’un point fixe.
Exemples :
- le programmateur de machine à laver : suite à la mise en marche, le programmateur
contrôle que la porte est fermée, si oui il commande l’ouverture de la vanne d’arrivée de
l’eau, quand la machine est pleine, il va actionner le tambour, etc.
- Distributeur automatique de monnaie
- Feu de circulation pour piéton
- La partie contrôle d’un processeur
3.2. Représentation
Les machines à états finis sont généralement représentées par des diagrammes d’états
permettant de visualiser les transitions entre les états. Les états sont alors représentés par des
cercles avec leur nom inscrit à l’intérieur ; les transitions entre les états sont représentées par des
arcs dirigés reliant les cercles. Les conditions (valeurs du vecteur d’entrée) enclenchant ces
transitions sont notées sur les arcs et finalement la valeur des sorties est généralement indiquée
soit sur l’arc (séparée des entrées par un trait oblique : /) ou à l’intérieur du cercle (séparée du
nom de l’état par un trait oblique : /).
- Exemple de machine à états finis où les sorties sont indiquées à l’intérieur des cercles :

E='0' E='1' E='1' E='1'
Etat 0 Etat 2
Etat 1 S<='1'
S<='0'
S<='0'
E='0'
Depart
E='0'
On trouve les éléments suivants :
• trois états : Etat 0, Etat 1 et Etat 2.
• un état de départ Etat 0.
• une entrée dont la valeur est notée sur les arcs.
• une sortie dont la valeur est associée à chaque état, respectivement 0 pour Etat 0, 0 pour
Etat 1 et 1 pour Etat 2.
• Cette machine permet de détecter une séquence de deux "1" consécutifs en entrée.
• Le concepteur qui propose cette machine n’avait au départ qu’une indication concise :
 Concevoir une machine qui dispose d'une seule entrée et une seule sortie.
La sortie vaut 1 si le système reçoit en entrée "1" puis "1". Autrement, la
sortie vaut "0".
• On peut représenter une machine à états finis avec les sorties sur les arcs :
E='1'/S<='0'
E='0'/S<='0' E='1'/S<='1'
Etat 0
Etat 1
Depart
E='0'/S<='0'
• Les éléments que l’on y trouve sont :

• deux états notés Etat 0 et Etat 1 ;
• un état de départ Etat 0 ;
• une entrée dont la valeur est notée sur les arcs.
• une sortie dont la valeur est associée à chaque transition, "0" pour les transitions de Etat 0
à Etat 0, de Etat 0 à Etat 1 et de E1 à Etat 0, "1" pour la transition de Etat 1 à Etat 1.
• Cette machine aussi permet de détecter une séquence de deux "1" consécutifs en entrée.
• Nous avons pu voir que lors de la représentation d’une machine à états finis par un
diagramme qu'il est possible d’indiquer les sorties sur les arcs ou à l’intérieur de l’état.
Cette distinction n’est pas purement graphique.
• Comme on a pu s’en rendre compte en réalisant deux machines selon les deux
conventions, les machines sont différentes : Machine de Moore et Machine de Mealy.
• Dans une machine de Moore, (le premier cas), la sortie dépend uniquement de l’état.
• Dans une machine de Mealy, (le second cas), la sortie dépend de l’état et de l’entrée.

3.2.1. Modèle de machine de Mealy
• L’état futur est calculé à partir des entrées et de l’état présent.

• Les sorties d’une machine de Mealy dépendent de l’état présent et des entrées.
• Mémorisation synchrone des états (c-à-d sur un front d’horloge).
• La sortie dépend directement de l’entrée et ceci indépendamment de l’horloge (clk).
⇒ Sortie asynchrone.
• Nombre d’états plus réduit que pour une machine de Moore.
• Il est possible de resynchroniser la sortie au besoin en ajoutant des bascules D.
Entrées Combinatoire
des états
Etat futur
CLK
Mémorisation
état (registre)
Etat présent
Combinatoire Sorties
de la sortie
Dans une machine de Mealy, la sortie dépend de l’état et de l’entrée.
3.2.2. Modèle de machine de Moore

Les sorties d’une machine de Moore dépendent de l’état présent (synchrones, elles changent sur
un front d’horloge).
des états
Etat futur
CLK
Mémorisation
état (registre)
Etat présent
de la sortie
Dans une machine de Moore, la sortie dépend uniquement de l’état.
Remarque : En général, une machine de Moore contient plus d’états et les variables d’état sont
plus complexes. Cependant, la sortie d’une machine de Moore est plus fiable puisqu’elle est
constante pendant toute une période d’horloge, indépendamment des entrées du système.

3.3. Conception des machines à états finis
Les étapes à suivre pour la conception d'une machine à états finis à partir d’un cahier des charges
sont :
a1. Construire un diagramme d’état à partir des données du problème.
a2. Construire le tableau d’état à partir du diagramme d’état.
a3. Réduire le nombre d’états nécessaires en éliminant les états équivalents.
a4. Assigner un code binaire à chaque état.
a5. Reconstruire le tableau d'état en utilisant le codage des états établi précédemment.
a6. À partir du tableau d’état, déterminer les équations booléennes d’entrées des bascules en
utilisant le tableau de Karnaugh.
a7. À partir du tableau d’état, déterminer les équations booléennes des sorties en utilisant le
tableau de Karnaugh.
a8. Construire le circuit séquentiel.
a9. Vérifier, vérifier, vérifier.
A) Bâtir un diagramme et un tableau d’état à partir des données du problème

La première étape de conception consiste à obtenir un diagramme d’état à partir des données du
problème, en respectant les principes suivants :
i. Bien lire le sujet et identifier ce qu'on vous demande.
ii. Déterminer le vecteur d'entrées et le vecteur de sorties.
iii. Commencer par construire un diagramme partiel menant à une sortie désirée du système.
iv. Ajouter au diagramme les autres chemins menant aux sorties désirées du système.
v. Vérifier le diagramme pour éviter les états inutiles.
vi. Compléter le diagramme en ajoutant des transitions pour toutes les entrées possibles à
partir de chaque état.
vii. Identifier toute condition où le circuit doit être réinitialisé à un état de départ, et annoter
le diagramme avec cette information.
viii. Vérifier le diagramme en appliquant les combinaisons d’entrées et de sorties identifiées au
début.
B) Assigner un code binaire à chaque état:

• Il faut assigner un code binaire à chaque état pour réaliser la machine à états finis.
• En règle générale, si vous avez m états, il vous faut n variables de telle façon que 2n-1 < m
≤ 2n .
• Si 2n > m, les états restant (2n - m) sont des états indéfinis.
• Exemple : 4 états  2 variables : Q0, Q1.
• Exemple : 6 états  3 variables : Q0, Q1, Q2.
• Exemple : 8 états  3 variables : Q0, Q1, Q2.
Nombre d'état Nombre de variable

2 1
3,4 2
5,6,7,8 3
9,10,11,12,13,14,15,16 4
Exemple : construire une machine à état fini pour la détection d'une séquence "0110". La
séquence doit être successive et unique. L'introduction d'une entrée fausse réinitialise la machine
à état finis et la remet à son état de départ.
Solution :
• Vecteur des entrées : 1 entrée.
• Vecteur des sorties : 1 sortie.

a1. Diagramme des états :
E='1'
E='1'
E='0' E='1' E='1' E='0'

A B C D E
S<='0' S<='0' S<='0' S<='0' S<='1'
E='0'
E='0'
Depart
E='1'
E='0'
a2. Table des états

Etat Etat Suivant
Sortie
Présent Entrée =0 Entrée =1
A B A 0
B A C 0
C A D 0
D E A 0
E A A 1
On remarque une absence d'états équivalent Ce tableau est déjà réduit.
a3. Codage des états

Nous avons 5 états  Il nous faut 3 variables : Q2, Q1 et Q0.
Table de codage :
Etat Q2 Q1 Q0
A 0 0 0
B 0 0 1
C 0 1 0
D 0 1 1
E 1 0 0
-- 1 0 1
-- 1 1 0
-- 1 1 1
On remarque l'existence de 3 états indéfinis correspondant aux combinaisons respectives de
Q2Q1Q0 : 101, 110, 111.
a4. Table des états avec codage
Etat Présent Entrée Etat Suivant Sortie

Eta Q2 Q1 Q0 X Q2+ Q1+ Q0+ S
t
0 0 0 0 0 0 1 0
A 0 0 0 1 0 0 0 0
0 0 1 0 0 0 0 0
B 0 0 1 1 0 1 0 0
0 1 0 0 0 0 0 0
C 0 1 0 1 0 1 1 0
0 1 1 0 1 0 0 0
D 0 1 1 1 0 0 0 0
1 0 0 0 0 0 0 1
E 1 0 0 1 0 0 0 1
1 0 1 0 -- -- -- --
-- 1 0 1 1 -- -- -- --

1 1 0 0 -- -- -- --
-- 1 1 0 1 -- -- -- --
1 1 1 0 -- -- -- --
-- 1 1 1 1 -- -- -- --
a5. Equation des entrées des bascules :

En dressant le tableau de karnaugh, commencer par remplir les cases relatives aux états indéfinis
par des tirets
Q0X
00 01 11 10
Q2 Q1
00 0 0 0 0
01 0 0 0 1
11 -- -- -- --
10 0 0 -- --
Q2+ = /X.Q0.Q1
Q0X
00 01 11 10
Q2 Q1
00 0 0 1 0
01 0 1 0 0
11 -- -- -- --
10 0 0 -- --
Q1+ = X.Q0./Q1 + X./Q0.Q1
Q0X
00 01 11 10
Q2 Q1
00 1 0 0 0
01 0 1 0 0
11 -- -- -- --
10 0 0 -- --
Q0+ = X./Q0.Q1 + /X./Q0./Q1./Q2
Q0X
00 01 11 10
Q2 Q1
00 0 0 0 0
01 0 0 0 0
11 -- -- -- --
10 1 1 -- --
S = Q2
a7. Schéma du circuit (Bascule D)
Q2+ = /X.Q0.Q1
Q1+ = X.Q0./Q1 + X./Q0.Q1
Q0+ = X./Q0.Q1 + /X./Q0./Q1./Q2
S = Q2

/X
Q0 Q2 S
Q1
CLK /Q2
X
Q0
/Q1
Q1
X OR
/Q0 CLK /Q1
Q1
/X
/Q0
/Q1
/Q2
Q0
OR
X
/Q0 CLK /Q0
Q1
3.4. Machines d’états finis (Finite State Machine) en VHDL
Une machine à états est l'implémentation en électronique du concept d'automate : dans un circuit
séquentiel, on mémorise une certaine forme des entrées précédentes (l'état) qui vont influencer la
sortie courante. Par exemple, pour le circuit contrôlant une lampe clignotante, on aura une
machine à états très simple : seuls deux états sont possibles (lampe allumée ou éteinte), on passe
de l'un à l'autre à chaque coup d'horloge.
On Off
Ainsi, si on veut implémenter une machine à états, il suffit de définir une série de bits définissant
l'état courant ; ainsi, à chaque coup d'horloge, on exécute un process qui va varier en fonction de
l'état courant. On préférera utiliser un signal, étant donné qu'il n'est pas utile de transmettre cette
valeur à l'extérieur ou de laisser la possibilité de l'altérer directement.
On peut donc implémenter cette lampe en VHDL. La machine à états ne contiendra que deux
états et un bit suffira pour le retenir (log2 2). La sortie O varie en même temps que le flanc
montant d'horloge et servira à actionner la lampe (ce qui est fait du signal en sortie est à gérer
manuellement à l'aide de DEL et résistances, en se basant sur les spécifications du composant
utilisé notamment en ce qui concerne le courant de sortie).
library ieee;

Entity NAME is
port( CLK: in std_logic;
O: out std_logic;
End Name;
architecture arch_NAME of NAME is

signal state: std_logic;
begin
process(CLK)
begin
if rising_edge(CLK) then
if state = '0' then
O <= '1';
state <= '1';
else
O <= '0';
state <= '0';
end if;
end if;
end process;
end arch_NAME;
3.4.1. Machine de Mealy.

Exemple N°1 : Machine de Mealy reconnaissant la séquence 10
E='1'/S<='0'
E='0'/S<='0' E='1'/S<='0'
Etat 0
Etat 1
Reset
E='0'/S<='1'
Clk
Etat 0 Etat 1 Etat 0

Etat present
A) Description avec 3 process

• Un process séquentiel de mise à jour de l’état présent par l’état futur sur les fronts montant
d’horloge (reset asynchrone inclus) :

des états
Etat futur
CLK
Mémorisation
état (registre)
Etat présent
de la sortie
type Etat is (Etat0, Etat1);

Signal Etat_present, Etat_futur : Etat := Etat0;
Sequentiel_maj_etat : process (clk, reset)

begin
if reset = '0' then
Etat_present <= Etat0;
elsif (clk'event and clk = '1' ) then
Etat_present <= Etat_futur;
end if;
end process Sequentiel_maj_etat;
des états
Etat futur
CLK
Mémorisation
état (registre)
Etat présent
de la sortie
• Un process combinatoire de calcul de l’état futur à partir des entrées et de l’état présent :
Combinatoire_sorties : process (E, Etat_present)

begin
case Etat_present is
when Etat0 =>
if E = '1' then
S <= '0';

else
S <= '0';
end if;
when Etat1 => if E = '0' then
S <= '1';
else
S <= '0';
end if;
end case;
end process Combinatoire_sorties;
B) Description avec 2 process

• Les 2 process combinatoires possèdent la même liste de sensibilité, ils peuvent donc être
regroupés en un seul process afin d’abréger l’écriture. ⇒ 2 process = 1 process séquentiel + 1
process combinatoire
Description avec 1 process
• Description la plus compacte en utilisant une variable pour l’état (en lieu et place des 2 signaux).
•A pour effet de resynchroniser la sortie de façon implicite.
• Cependant perte de lisibilité lors de l’écriture. A lors que cette description n’apporte rien en
terme de résultat de synthèse par rapport à une description 2 process. ⇒ À éviter (pt de vue
personnel cependant ...).
3.4.2. Machine de Moore

un front d’horloge).
des états
Etat futur
CLK
Mémorisation
état (registre)
Etat présent
de la sortie
Exemple N°1 : Machine de Moore reconnaissant la séquence 10

E='0' E='1' E='1' E='0'
Etat 0 Etat 2
Etat 1 S<='1'
S<='0'
S<='0'
Reset
E='1'
E='0'
Clk
Etat 0 Etat 1 Etat 2 Etat 0

Etat present
A) Description avec 3 process
des états
Etat futur
CLK
Mémorisation
état (registre)
Etat présent
de la sortie
• Un process séquentiel de mise à jour de l’état présent par l’état futur sur les fronts montant
d’horloge (reset asynchrone inclus) :
type Etat is (Etat0, Etat1, Etat2);
Signal Etat_present, Etat_futur : Etat := Etat0;
Sequentiel_maj_etat : process (clk, reset)
begin
if reset = '0' then
Etat_present <= Etat0;
elsif (clk'event and clk = '1' ) then

Etat_present <= Etat_futur;
end if;
end process Sequentiel_maj_etat;
des états
Etat futur
CLK
Mémorisation
état (registre)
Etat présent
de la sortie
Combinatoire_etats : process (E, Etat_present)
begin
Etat_futur <= Etat1;
else
end if;
when Etat1 => if E = ‘0' then
else
end if;
else
end if;
end case;
end process Combinatoire_etats;
• Un process combinatoire de calcul des sorties à partir de l’état présent :

des états
Etat futur
CLK
Mémorisation
état (registre)
Etat présent
de la sortie
Combinatoire_sorties : process (Etat_present)
begin
when Etat0 => S <= '0';
when Etat1 => S <= '0';
when Etat2 => S <= '1';
end case;
end process Combinatoire_sorties;

Exercices
Exercice 1 : Compteur/Décompteur
On considère le circuit logique schématisé par la figure suivante dont les entrées CLK, CD, RAZ
sont des bits. La sortie Q du circuit est un vecteur sur deux bits.
CLK
Q
CD Comp/Dec
2
RAZ
Si CD=0 : Compteur binaire : 0,1,2,3,0,….

Si CD=1 : Compteur binaire : 0,3,2,1,0,….
La machine d’état qui exprime les transitions de ce compteur est la suivante :
M1
00
CD=1 CD=0
M2
CD=0 01 CD=1
CD=1 CD=0
M3
10
CD=1 CD=0
M4
11
1. Identifier le vecteur d'entrée et le vecteur de sortie de cette machine à états finis.

2. Déterminer
- le nombre d’états
- le nombre de variable
3. Déterminer la Table d’états de cette machine.
4. Déterminer la Table d’états avec codage.
5. A partir de tableau de karnaugh écrire les équations des entrées de bascules.

6. Ecrire les équations de sortie.
7. Déterminer le schéma du circuit (machine à états finis)
8. Le fonctionnement de cette machine est synchronisé par un front montant de l’horloge CLK.
Ecrire un code VHDL de cette machine d’état
Exercice 2 :Détecteur de séquence

un front d’horloge). Voici un exemple d’une machine de Moore reconnaissant la séquence 10
E=’1’ E=’0’
E=’0’ E=’1’
Etat1 Etat2
reset Etat0
S=0 S=1
S=0
E=’1’
E=’0’

2. Déterminer
5. A partir de tableau de karnaugh, écrire les équations des entrées de bascules.
8. Le fonctionnement de cette machine est synchronisé par un front montant de l’horloge
CLK.
9. Ecrire un code VHDL de cette machine d’état
Exercice 3 : Machine a états finis

Soit la machine d’état suivante :
Etat0 E=0
S0=1
S1=0
Etat1
E=1 S0=1
S1=1
E=1
Etat2
E=0
S0=0
S1=0
E=0
2. Déterminer
5. A partir de tableau de karnaugh, écrire les équations des entrées de bascules.
CLK.
9. Ecrire un code VHDL de cette machine d’état
Exercice 4 : Détection de début et de fin d’impulsion.

Réalisons un système séquentiel détectant le début et la fin d’une impulsion. Le chronogramme
désiré est le suivant :
SdS
SfS
Le bilan des entrées et sorties est décrit ci-dessous, on y a ajouté la possibilité d’un reset avec
l’entrée rst.
S sds
rst FSM
sfs
clk
1. Réaliser la synthèse en vhdl de cette machine dans les deux cas suivantes.
a) Machine de Moore

S=’1’ Etat1
S=’0’ sds=1 S=’1’
reset Etat 0
Etat 2
Etat3
S=’0’
Sfs=1
a) Machine de Mealy
S='1'/sds<='1'
S<='0' S<='1'
Etat 0
Etat 1
Reset
S='0'/sfs<='1'

4
VERILOG
4.1. Introduction
Verilog est un langage de description de matériel, c'est-à-dire un langage utilisé pour décrire un
système numérique matériel, comme, par exemple, un flip-flop (bascule D) ou un
microprocesseur. Il peut modéliser un système par n'importe quelle vue, structurelle ou
comportementale, à tous les niveaux de description.
De plus il peut servir non seulement à simuler un système mais aussi à le synthétiser, c'est-à-dire
être transformé par des logiciels adaptés (synthétiseurs) en une série de portes logiques prêtes à
être gravées sur du silicium.
Verilog est l'un des trois grands langages de description de matériel utilisés majoritairement dans
l'industrie, avec VHDL et SystemC. Chaque langage a ses propres avantages et inconvénients,
ainsi que ses spécificités. Pour plus de détails, on pourra se référer à une comparaison objective
de VHDL et Verilog.
Verilog a été inventé par Gateway Design Automation Inc. aux alentours de 1984. C'était un
langage propriétaire, inspiré d'un autre HDL (HiLO) et du langage C.
Gateway a aussi produit le premier simulateur Verilog en 1985, ainsi que son successeur Verilog-
XL, toujours utilisé. En même temps, la société Synopsys développe le premier synthétiseur,
travaillant à partir de sources Verilog. En 1990, la société de CAO CAdence rachète Gateway.
Elle décide de rendre les spécifications de Verilog publiques, qui deviennent un standard IEEE
en 1995 (IEEE Std. 1364-1995). Dans le même temps, plusieurs sociétés développent des
simulateurs et des synthétiseurs, dont VCS le premier simulateur-compilateur (en comparaison,
Verilog-XL est un interpéteur).
L'essor de VHDL et les lacunes de Verilog 1995 ont poussé l'IEEE à créer une nouvelle version
du langage, Verilog 2001 puis Verilog 2005. Ces versions du langage sont maintenant acceptées
par la quasi-totalité des outils de l'industrie. Une extension de Verilog, appelée SystemVerilog est
actuellement introduite sur le marché. Elle cherche à modéliser les systèmes à un niveau encore
plus abstrait qu'actuellement, pouvant modéliser non seulement des systèmes matériels mais aussi
des systèmes logiciels (OS, ...) ainsi que des mélanges des deux.
4.2. Verilog
Verilog a une syntaxe proche de celle du C. Les types de données sont eux aussi proches de ceux
du C, avec des extensions spécifiques au matériel.

L'objectif de ce chapitre est de vous présenter les types définis par Verilog, ainsi que les
expressions utilisables. A l'issue de ce chapitre, vous serez en mesure de choisir le meilleur type
pour l'objet que vous voulez modéliser.
4.2. 1. Les conventions lexicales
Les conventions lexicales de Verilog sont les mêmes que celles utilisées en C. Un code Verilog est
composé d'une suite d'éléments :
 commentaires
 délimiteurs
 nombres
 chaînes de caractères
 identificateurs
 mots-clefs
Verilog est sensible à la casse : tous les mots clefs doivent être en minuscules.
a) Espaces
Les espaces peuvent être au choix un espace normal (\b), une tabulation (\t) ou un retour
à la ligne (\n).
Les espaces sont ignorés, sauf quand ils séparent des éléments, ou à l'intérieur des chaînes
de caractères.
b) Commentaires
Des commentaires doivent être inclus dans le code, pour augmenter la lisibilité et la
documentation.
Il en existe deux styles, comme en C :
 ligne seule : depuis un // jusqu'au prochain retour à la ligne

 lignes multiples : entre /* et */
Les commentaires à lignes multiples ne peuvent pas être imbriqués.

Un commentaire ne peut pas couper un identificateur ou un mot-clef.
Il est impératif de documenter vos codes, à l'école comme en entreprise.
c) Underscore
Les underscore "_" peuvent apparaître dans les identificateurs ou dans les nombres (sauf
en premier caractère). Ils servent surtout à augmenter la lisibilité du code.
d) Identificateurs
Ce sont les noms de variables, de signaux, de fonctions, ...
 Ils ne peuvent contenir que des lettres, des chiffres, le signe $ et le signe _ .
 Ils ne peuvent pas contenir d'espace.
 Les mots-clefs du langage ne peuvent pas être utilisés comme identificateurs.

Attention : majuscules et minuscules sont différenciées
4.2.2. Valeurs Logiques

Verilog utilise un système à 4 valeurs :
 0 : 0 logique
 1 : 1 logique
 x ou X : "inconnu", utilisé pour les signaux dont on ne connait pas la valeur
 z ou Z : "haute-impédance", utilisé pour les noeus flottants ou pour exprimer
l'indifférence
Voici quelques tables de vérité multi-valuées :
Des forces peuvent éventuellement être appliquées aux valeurs logiques pour résoudre
d'éventuels conflits en cas de pilotes (drivers) multiples. Par ordre décroissant :
 supply
 strong
 pull
 large
 weak
 medium
 small
 highz
Si deux signaux différents sont appliqués à un signal, celui de plus grande force prévaut, et la
force du résultat est alors la plus grande des deux.
Si deux signaux différents de même force sont appliqués à un signal, le résultat est inconnu (x).
Les forces de signaux sont surtout utilisées pour modéliser les transistors MOS et autres
dispositifs de très bas niveau.
4.2.3. Types de Données
a)Noeuds
Les noeuds représentent les connexions entre des éléments physiques. Ils sont principalement
utilisée en description structurelle (instanciation de portes ou de modules).
Comme dans le monde réel, leur valeur leur est assignée continuement, autrement dit ils
n'ont pas de capacité de mémorisation.
Par défaut, la valeur d'un noeud est z (sauf pour les trireg, dont la valeur par défaut est x)
Le mot clef pour déclarer un noeud est généralement wire.
A moins de le préciser, un wire est sur un seul bit. On peut cependant déclarer un ensemble de
noeuds, un bus.

Exemple :
Lors de la déclaration d'un bus, le bit de poids fort est toujours à gauche, celui de poids
faible à droite. Dans l'exemple ci-dessus, le poids fort de bus2 est numéroté 2, celui de bus1 est
numéroté 7.
On peut accéder à un élément particulier d'un bus ou à une partie de bus.

Lors de l'accès à une partie de bus, l'ordre des indices doit respecter l'ordre de déclaration.
Il existe d'autres types de noeuds :
tri
même chose que wire. La convention veut que wire est utilisé dans le cas d'un pilote
simple, tri dans le cas de pilotes multiples.
wand/triand
ce sont des ET câblés. L'affectation de signaux différent à ces noeuds se résoudra par un
ET des deux signaux.
wor/trior
même chose,en OU câblés.
supply0, supply1
déclaration d'un noeud d'alimentation, de force supply.
tri0, tri1, trireg, ...
peu usités... représentent des pull-down, pull-up, ou un réseau capacitif. On se rapportera
à la norme Verilog pour plus de détails.
Remarque : on utilise dans 99% des cas des wire.
Les wire sont par défaut non signés. Si on les veut signés, on leur adjoint le mot-clef signed (voir
ci-dessous).
b)Variables
Les variables se distinguent des noeuds par le fait qu'elles ont des capacités de mémorisation.
On ne leur assigne pas de valeur en continu, mais seulement à des moments précis. Elles gardent
alors cette valeur jusqu'à la prochaine affectation. Elles sont donc utilisées pour des
descriptions comportementalesseulement.
Les variables ont deux rôles :
 le rôle de variables au sens traditionnel du terme (le même qu'en C, Pascal, Ada)
 modéliser les signaux de communication entre processus

Attention : la version de Verilog 1995 appelle les variables "registers". Ce terme a été retiré de la
norme, et remplacé par le terme "variable", car il entrainait trop de confusions entre "registre au
sens Verilog" (un objet mémorisant) et "registre au sens matériel" (bascule D) : une variable peut
modéliser une bascule D, mais peu aussi modéliser un fil ou une fonction purement
combinatoire.
Une variable est généralement déclarée par reg.
Par défaut, un reg est sur 1 bit. Comme pour les wire, on peut en faire des bus.
Les reg sont par défaut non signés. Si on les veut signés, on leur adjoint le mot-clef signed. Ils
sont alors représentés en complément à 2.
Exercice
 Que va vous afficher le simulateur ?

 Important : Vérifez avec iverilog, Cver et Modelsim. Conclusion ?
 Comment se comportent les simulateurs avec des wire ? (l'affectation des wire se fait en
dehors des blocs initial ou always, avec le mot-clef assign. Ex: assign a = b;)
Les autres variables :
integer
similaires aux reg, mais signés. Sa taille est la taille de mots de la machine hôte,
généralement 32bits.
ils sont utilisés pour compter, alors que les reg sont utilisés pour les signaux sur 1 bit, et
généralement comme variables locales.
real
définissent des nombres réels signés, représentés selon la norme IEEE Std 754-1985, un
standard sur la représentation des flottants en double précision. peuvent être utilisés en
notation
 décimale : 1.2, 0.142, -478.34

 scientifique : 4e10, -4.30e-3
les conversion réels vers entiers se fait vers l'entier le plus proche avec la convention :
 0.5 devient 1
 -0.5 devient -1
leur valeur par défaut est 0.

Time
pour stocker des temps de simulation implémentation spécifique à chaque plate-forme,
mais au minimum 64 bits, et leur bit de poids faible est toujours à 0.
pour stocker des temps de simulation, mais sous forme flottante
implémentation spécifique à chaque plate-forme, mais au minimum 64 bits.
Paramètres
Les paramètres sont un type particulier de variables : ils définissent des constantes. Ces
constantes permettent de construire des blocs génériques. Par exemple, au lieu de coder trois
additionneurs différents (un sur 8 bits, un sur 16, un sur 32), on n'en codera qu'un seul. Les bus
internes seront définis en fonction d'un paramètre, qui pourra être modifié au moment de la
compilation pour valoir 8, 16 ou 24.
C'est une très mauvaise habitude de coder un nombre en dur dans un code quel qu'il soit. Il vaut
bien mieux définir un paramètre (ou utiliser les #define de C), et utiliser ce paramètre en lieu et
place du nombre. Les paramètres de Verilog permettent d'avoir des #define du C un peu plus
souples (ayant une portée locale seulement).
Le type des paramètres peut être explicite, implicite ou à mi-chemin entre les deux (partiellement
implicite). Les règles suivantes permettent de clarifier les choses :
 sans type et sans largeur, un paramètre a le même type que la valeur qu'on lui affecte.
 sans type et avec largeur, le paramètre est vecteur de bit non signé, quelle que soit la
valeur qu'on lui affecte.
 avec type et sans largeur, le paramètre est du type spécifié, sur une largeur permettant
d'accueillir la valeur qu'on lui affecte.
 avec type et avec largeur, le paramètre est du type spécifié.
L'utilisation des paramètres se fait comme-ceci :
Paramètres de spécification temporelle (specparam)

Pour spécifier des temps de propagation, setup, hold, etc., on utilise des paramètres d'un type
spécial : specparam. Ils diffèrent des paramètres normaux sur les points suivants :

 les paramètres d'un module, bien que représentant des constantes, peuvent être modifiés
lors de l'instanciation de ce module. Ce mécanisme sera étudié plus tard, dans la
généricité.
 les specparam ne peuvent être modifiés que par un fichier spécial, au format SDF,
permettant de rétro-annoter une netlist de façon à y inclure des temps de propagation
réels (obtenus après synthèse et/ou placement routage).
Les specparams sont déclarés soit dans un module, éventuellement dans un bloc specify.
Exemple :
Chaînes de caractères
Les chaînes de caractères sont définies comme des bus (vecteurs) de reg. Chaque caractère étant
codé sur 8 bits, une chaîne sera donc stockée sur un multiple de 8 regs.
Lors de l'affectation d'une chaîne,
 les reg non utilisés à gauche (poids forts) sont forcés à 0,

 les caractères en trop à gauche sont perdus.
Exemple :
qui produit la sortie suivante :

4.2.4. Codage des nombres entiers
En Verilog, les nombres entiers peuvent :
 être signés ou non signés

 être de taille fixée ou de taille non précisée
 avoir une base précisée ou non
La représentation générique d'un entier est [signe] [taille ' [s] base] <valeur>
 taille est un nombre décimal non signé représentant le nombre de bits de l'entier.
Si taille n'est pas précisé, la taille par défaut dépend du simulateur / synthétiseur, mais
vaut au moins 32 bits.
 base représente la base dans laquelle il faut interpréter valeur.
base peut être :
o d, D : décimal
o h, H : hexadécimal
o b, B : binaire
o o, O : octal
Si la base est l'hexadécimal, les lettres de valeur (A, B, C, D, E ou F) peuvent être en

minuscules ou majuscules.
 valeur est la valeur de l'entier (!), exprimée dans la base base.

Un underscore (_) peut être ajouté n'importe où dans valeur, sauf en première position,
pour augmenter la lisibilité du code.
valeur peut inclure les digits "z" (ou "?") ou "x". Le nombre de bit que couvre un "z" ou
un "x" dépend de la base (4 en hexa, 3 en octal, 1 en binaire).
 signe est le signe de valeur. Attention : ce n'est pas forcément le signe du nombre. Il
porte seulement sur valeur (avant troncature / expansion au bon nombre de bits). La
suite de cette partie explicite ce point important !
Chaque nombre porte, en plus de sa valeur, une information indiquant s'il est signé ou non :
comment il doit être interpété, en cas d'expansion notamment (extension de signe ou non). Les
règles suivantes déterminent si un nombre est signé ou non :
 Si base est omis, le nombre est signé

 Si base est précisé, le nombre est n'est pas signé, sauf si on a inclus le modificateur "s"
avant la base (voir exemple ci-dessous)
Si taille est plus grande que nécessaire pour représenter valeur, alors Verilog comble les bits de
gauche ainsi :
 si le nombre n'est pas signé, il comble avec des 0.

 si le nombre est signé, il suit les règle du complément à deux (extension de signe).
 dans tous les cas, si le premier digit est "z" ou "x", il comble avec des "z" ou "x".
Exemple :

4'd5 : nombre non signé sur 4 bits, valant 5
-4'd5 : nombre non signé sur 4 bits, valant 11 (-5 modulo 16)
4'sd5 : nombre signé sur 4 bits valant 5
-4'sd5 : nombre signé sur 4 bits valant -5
-5 : nombre signé sur au moins 32 bits valant -5
5 : nombre signé sur au moins 32 bits valant +5
Astuce : un petit algorithme pour bien interpréter les nombres :
1. on commence avec n = [signe]<valeur>.

2. si on n'a pas de taille, alors c'est fini, on a notre résultat. De plus, le résultat est signé.
3. si on a une taille, alors on tronque / expanse n au bon nombre de bits, en faisant une
extension de signe uniquement si 's' est spécifié.
4. on a notre résultat. De plus, si on a 's' alors le résultat est signé, sinon non.
Exercice#1 :
1. Que va afficher le code suivant ?
Exercice #2:

4.2.5.Tableaux
Comme dans tous les langages (ou presque ?), il possible de déclarer des tableaux multi-
dimensionnels. On peut déclarer des tableaux de noeuds (wire) ou de variables (reg, integer, ...).
Les éléments du tableaux peuvent être
 scalaires (sur 1 bit)

 des bus (vecteurs de n bits)
La déclaration de tableaux se fait en spécifiant l'étendue des dimensions entre crochets après le
nom de l'instance (une déclaration d'étendue avant le nom sert à déclarer un bus).
Exemple :
 reg x[11:0]; // tableau à 12 élements de reg sur 1 bit.

 reg [31:0] x [127:0]; // tableau de 128 élements, chaque élément est un vecteur (bus) de
reg 32 bits.
 reg [31:0] x [127:0][255:0]; // matrice de 256x128 élements, chaque élément est un
vecteur (bus) de reg 32 bits.
Attention : ne pas confondre un tableau de scalaires (reg xxx [7:0]) et un bus (reg [7:0] xxx). Un
bus peut être affecté en une seule instruction, tandis qu'un tableau ne peut pas : on ne peut
accédér qu'à un seul élement du tableau à la fois.
Lors d'un accès à un tableau multidimensionnel, on doit spécifier un index pour toutes les
dimensions : en d'autres termes, on ne peut pas extraire une ligne (ni une colonne) d'une matrice.
Les tableaux sont utiles pour modéliser les mémoires : une mémoire est un tableau de mots (un
mot est un vecteur de bits).
On a le droit, lors de l'accès à un tableau, de spécifier l'index par un reg (ou tout autre type
entier). Mais attention, cette construction n'est souvent pas synthétisable.

Exemple :
4.2.6. Expressions et opérateurs
Lors d'une affectation continue, on affecte à un noeud une expression, constante ou non
(comme dans l'exemple ci-dessus). Les expressions peuvent être utilisées non seulement dans les
affectation continues, mais aussi dans les autres types d'affectation que nous verrons plus tard.
C'est l'occasion de les étudier !
Une expression combine des opérateurs et des opérandes. Une opérateur (&, |, +, ...) peut agir
sur une, deux ou trois opérandes.
Les opérandes peuvent être :
 un noeud (wire) ou une variable (reg, integer, ...)

 une constante (3.5, -7, 4'b001x, ...)
 une sélection de bits dans un bus (data[4])
 une sélection d'intervalles dans un bus (data[6:2])
 une sélection d'un mot dans un tableau (mem[3])
 un appel de fonction(Fact(12))
Les opérateurs peuvent être :
 Arithmétiques : +, -, *, /, %, **
 Relationnels : >, >=, <, <=
 D'égalité : ==, !=, ===, !==
 Logiques : !, &&, ||
 Binaires : ~, &, |, ^, ^~, ~^
 De réduction : &, ~&, |, ~|, ^, ^~, ~^
 De décalage : <<, >>, >>>, <<<
 Conditionnel : ?:
 Concaténation : {}, {{}}
 Evénement : or
Tous les opérateurs ne sont pas applicables à certains types. Pour les réels, les opérateurs suivants
ne peuvent pas être utilisés :
 concaténation
 modulo
 === et !===
 binaires

 réduction
 décalages
Le résultat d'une opération logique ou relationelle sur des réels est un bit.
 Priorité des opérateurs
La priorité des opérateurs suit la convention du C.

Voici un récapitulatif des priorités des opérateurs. Des opérateurs sur la même ligne ont la même
priorité : les parenthèses sont alors nécessaires.
De toutes façons, les parenthèses sont une bonne habitude, ne serait-ce que pour rendre le code
plus lisible
+ - ! ~ (unaires) plus prioritaire

**
*/%
+ - (binaires)
<< >> <<< >>>
< <= > >=
== != === !==
& ~&
^ ^~ ~^
| ~|
&&
||
?: (conditional operator) moins prioritaire
Priorité des opérateurs
 Opérateurs arithmétiques
Les opérateurs arithmétiques sont les suivants :
Opérateur Commentaires
a+b somme
a-b différence
a*b produit
a/b division; la division entière tronque vers zéro.
a%b modulo; du signe de a
a ** b puissance (a puissance b)
+a prioritaire sur les autres (opérateur unaire)
-a prioritaire sur les autres (opérateur unaire)
On fera attention au signe des opérandes (voir ici pour plus de détails). On fera attention aussi au
nombre de bits de l'expression. Pour cela on se rapportera à la section sur la longueur en bit des
expressions.
Exemples :

 Opérateurs relationnels : Ce sont les opérateurs de comparaison. Le résultat d'une
comparaison est
 0 si la relation est fausse

 1 si la relation est vraie
 x si, du fait de bits à x ou z dans les opérandes, le résultat est ambigu.
a<b a strictement plus petit que b
a>b a strictement plus grand que b
a <= b a plus petit ou égal à b
a >= b a plus grand ou égal à b
Si les opérandes ne sont pas de la même taille et qu'au moins l'un des deux est non signé, le plus
petit est complémenté à gauche avec des 0, et la comparaison s'effectue sur des nombres non
signés.
Si les deux opérandes sont signées, la relation est interprétée normalement (comme une
comparaison sur des nombres signés...)
Si l'une des deux opérandes est un réel, l'autre opérande est automatiquement convertie en réel.
 Opérateurs d'égalité: Le résultat est 0, 1 ou x.
Les opérandes sont comparées bit à bits, en complémentant le plus petit avec des 0 si nécessaire.
Pour == et !== (égalité et non-égalité), le résultat vaut x si l'une des deux opérande contient des
x ou z.
Pour === et !=== (égalite et non-égalite), les x et z sont aussi comparés.
 Opérateurs logiques : Les opérateurs logiques ont comme résultat 0, 1 ou x.
a && b a ET b
a || b a OU b
!a NON a
Ces opérateurs travaillent sur des bits, sauf l'opérateur unaire ! qui peut accepter un type
vecteur.
Le résultat de !a vaut :

 1 si a vaut 0
 0 si a ne vaut pas 0 (s'il vaut n'importe quoi d'autre)
 x si a contient des x ou z.
 Opérateurs binaires : Les opérateurs binaires opèrent sur des bits ou des vecteurs (bus),
bit-à-bit.
& ET
| OU
^ XOR
~^ ^~ XNOR
~ NOT (bit à bit)
Si les deux opérandes n'ont pas la même taille, le plus petit est complémenté à gauche avec des 0.
 Opérateurs de réduction : Ce sont des opérateurs unaires (sur une seule opérande),
opérant sur des vecteurs. Ils opèrent en fait sur les bits du vecteur passé en argument, en
appliquant la fonction demandée à l'intégralité des bits du vecteur.
Le résultat est 0, 1 ou x. Les opérations de base sont le ET, le OU et le XOR (&, |, ^).
Chaque opération dispose de sa version complémentée : c'est le résultat de l'opération qui
est complémenté, pas les bits du vecteur.
Exemples :
Opérande & ~& | ~| ^ ~^

4'b0000 0 1 0 1 0 1
4'b1111 1 0 1 0 0 1
4'b0110 0 1 1 0 0 1
4'b0100 0 1 1 0 1 0
Si le vecteur contient un x ou un z, le résultat est x.
 Opérateurs de décalage
Ces opérateurs opèrent des décalages (à droite ou à gauche) sur les bits de l'opérande de gauche.
Le sens du décalage est donné par l'opérateur.
Le nombre de position décalées est donné par l'opérande de droite (qui est considérée comme
non signée).
>> décalage vers la droite, les bits entrants sont des 0
<< décalage vers la gauche, les bits entrants sont des 0
<<< décalage vers la gauche, les bits entrants sont des 0
>>> décalage vers la droite. Le bit entrant est
 un 0 si l'opérande est non signée

 le MSB (signe) de l'opérande si l'opérande est signée
Attention à l'opérateur >>>. Le bit entrant dépend du type de l'opérande:

 si l'opérande est signée, le bit entrant est un bit de signe (= le bit de gauche de l'opérande)
 si l'opérande n'est pas signée, le bit entrant est 0.
 Opérateur conditionnel: C'est l'équivalent du if then else, sous forme d'équation. Sa

syntaxe est la suivante : expr1 ? expr2 : expr3
 si expr1 est vraie, alors l'expression vaut expr2
 si expr1 est fausse, alors l'expression vaut expr3
 si expr1 contient des x ou z, l'expression est une combinaison bit-à-bit de expr2 et expr3
avec :
o 0 - 0 donne 0
o 1 - 1 donne 1
o les autres combinaisons donnent x
L'opérateur conditionnel est très utilisé pour modéliser les sorties de portes 3-états :
 Opérateur de concaténation
Cet opérateur permet de créer des bus à partir de bits ou de bus plus petits.
Exemple :
 Ce bus est la concaténation de 4 expressions : {a, b[3:0], w, 3’b101}.

 Il est équivalent à {a, b[3], b[2], b[1], b[0], w, 1’b1, 1’b0, 1’b1}
On peut aussi répliquer une expression.

Exemple :
 Le bus {4{w}} est équivalent à {w, w, w, w}

 De même {a, {3{b,c}}, {2{bus[1:0]}}} est équivalent à {w, b, c, b, c, b, c, bus[1], bus[0],
bus[1], bus[0]}.
Une concaténation peut être la cible d'une affectation :
4.2.7. Calcul des expressions : taille et type
Avant d'évaluer une expression, il est primordial de savoir sur combien de bits ça doit se faire.
Par exemple, lors de l'addition de deux bus de 8 bits, il est important de savoir si la somme est
effectuée sur 8 bits ou sur 9 (permettant de détecter une retenue sortante).

Le calcul du nombre de bits s'effectue en deux temps : la taille intrinsèque d'une expression, puis
un éventuel ajustement dans le cas d'une affectation
a) Première étape : taille intrinsèque des expressions
La taille intrinsèque d'une expression est déterminée par la table suivante, das laquelle :
 x, y et z représente les opérandes

 op représente l'opérateur
 L(x) représente la taille de x
Expression Taille (en bits) de l'expression

nombre constant sans taille la même que celle d'un integer
nombre constant de taille fixée la taille du nombre
x op y, avec op étant + - * / % & | ^ ^~ ou ~^ max(L(x), L(y))
op x, avec op étant + - ou ~ L(x)
x op y, avec op étant === !== == != && || > >= < 1 bit (après avoir éventuellement étendu la plus petite
ou <= des opérandes)
op x, avec op étant & ~& | ~| ^ ~^ ^~ ou ! 1 bit
x op y, avec op étant >> << ** >>> ou <<< L(x)
x?y:z max(L(y), L(z))
{x, ..., y} L(x) + ... + L(y)
{x{y, ..., z}} x*(L(y) + ... + L(z))
b) Deuxième étape : ajustement éventuel
On appelle LHS le membre de gauche d'une affectation, RHS le membre de droite. On distingue
trois cas :
 taille(LHS) = taille(RHS) : tout va bien, le membre de droite est évalué sur sa taille
intrinsèque
 taille(LHS) < taille(RHS) : le membre de droite est évalué sur sa taille intrinsèque, puis le
résultat est tronqué. Cela peut faire perdre un éventuel bit de signe !!!
 taille(LHS) > taille(RHS) : le membre de droite est évalué sur la taille du membre de
gauche.
Exercice :

Attention : malgré tout, lors de l'évaluation d'une expression, les résultats intermédiaires peuvent
perdre des bits.
Exemple :
Dans l'exemple ci-dessus, on voudrait que la somme soit calculée sur 16 bits, avec éventuellement
une retenu sortante, puis décalée de 1 bit vers la droite en faisant entrer l'éventuelle retenue.
Ce code ne fonctionne pas correctement : Expliquez pourquoi !!!
Une solution à ce problème serait de forcer le résultat intermédiaire à avoir une taille d'au moins
17 bits, ce qui peut se faire en ajoutant 0 (un entier, qui sera donc au moins sur 32 bits) :

Exercice#1:
 Trouvez une autre solution pour produire un résultat correct.
Réponse :
 Qu'affichera le code suivant ? Essayez de répondre de tête avant de simuler pour vérifier !
Signe d'une expression

En dehors de la taille d'une expression, il est important de savoir si elle sera signée ou non. Pour
cela, les règles sont simples :
 les entiers et les réels, comme on l'a déjà vu, sont signés
 si les deux opérandes sont signées alors le résultat est signée, sinon il est non signé
 sauf dans le cas d'une comparaison, où le résultat est non signé de toutes façons
 les champs de bits sont non signés, même s'ils prennent toute la largeur du vecteur !!!
Récapitulation
On rassemble le tout ! Les expressions sont calculées ainsi :
1. on calcule la taille du résultat (la taille de l'expression) comme on l'a vu plus haut
2. on calcul le type du résultat (s'il est signé ou non)
3. on propage ce type et cette taille à toutes les opérandes là où ça a un sens
4. on effectue les opérations...
Exercice #2:

2. même question avec le code ci-dessous...
4.2.8. Directives de compilation
Verilog, comme C, accepte des directives de compilation (les équivalents des #define et
#include...). Ces directives de compilation ont la forme suivante : `define et ìnclude (le premier
caractère est celui obtenu sur un clavier de PC par AltGr et 7).
Inclusion de fichiers
C'est l'équivalent du include de C : ìnclude "nom_du_fichier".
Attention : si le nom du fichier spécifie un chemin relatif, alors c'est par rapport au répertoire
d'où la simulation est lancée ! C'était le cas dans les anciens compilateurs C, mais ce
comportement a été modifié depuis. Il est resté en Verilog, les gens s'occupant de la norme ayant
eu peur de casser la sémantique des design existants.

Pour remédier à ce défaut, chaque outils propose des flags de compilation tels que INCDIR,
permettant de spécifier les répertoires où l'outil doit chercher les fichiers inclus.
Définitions
Il est possible, comme en C avec les #define, de créer des macros textes à l'aide des directives
`define et ùndef. Mais contrairement au C, ces définitions ont un scope global : dès qu'elles
sont rencontrées par le simulateur / synthétiseur, elles sont valables pour tous les fichiers lus
après. Pour éviter des warning de re-définition de macros, il suffit d'utiliser des gardes, comme en
C:
Exemple:
Attention de ne pas abuser de ce mécanisme ! Certains objets (fonctions, tâches) ont besoin
d'être ré-instanciés, par exemple les fonctions et tâches qui ont un scope local !..
Compilation conditionnelles
C'est comme en C : ìfdef, ìfndef, èlse, èlsif, èndif
Ces directives sont souvent utilisées pour séparer code synthétisable et code non synthétisable :
un attribut assez répandu étant synthesis, on peut écrire le code suivant :
Types par défaut
Par défaut, un objet non déclaré est de type wire (net sur 1 bit). Il est possible de changer ce
comportement en utilisant la directive `default_nettype <type>.
Exemple : `default_nettype none oblige à déclarer explicitement tous les nets !
Ménage...
La directive `resetall permet de remettre à zéro toutes les directives de compilation précédentes
(définitions, types par défaut etc...). On l'utilise typiquement en début de chaque fichier, suivi de
toutes les définitions qu'on souhaite appliquer à ce fichier.

En résumé
On a vu
Il y a deux types principaux d'objets :
 les noeuds (wire), utilisés en représentation structurelle uniquement.

 les variables (reg, integer), utilisés en représentation comportementale uniquement.
Tout type peut être signé ou non signé.
On peut déclarer des vecteurs (bus) et des tableaux multidimensionnels :
 reg [7:0] A; // un élément unique : un vecteur

 reg A [7:0]; // 8 élements : un tableau de bits
Les constructions à base de tableaux sont rarement correctement synthétisables.
La représentation des nombres entiers est parfois pénible si on oublie ce qu'on manipule.
Il vaut mieux parfois travailler sur des reg non signés, et faire attention lors des extensions
de signe.
Les expressions utilisables sont celles du C, en faisant attention à la taille du résultat !
Exemples :
Exemple #1 AND3
 structure d'un module simple

 assignements continus
Commençons par le plus simple des modules ou presque : une porte combinatoire AND à trois
entrées. En Verilog, comme en SystemC, les blocs sont appelés modules.
Voici une description possible d'une porte AND à 3 entrées.
Passez la souris sur les différents éléments du code pour avoir des explications sur la signification
de chaque instruction.
Solution#1

Exemple #2 Additionneur complet 1 bit
 les expressions
 concaténation de signaux pour créer un bus
Voici une description possible d'un additionneur complet 1 bit.
Rappel : un additionneur complet 1 bit a trois entrées (a, b, et cin la retenue entrante), et deux
sorties (le bit de somme s et le bit de retenue sortante cout).
Solution#2
Exemple #3
Verilog, comme tous les HDL, permet de décrire les système sous forme structurelle. C'est-à-dire,
au lieu de décrire un gros système dans un seul gros fichiers, de le séparer en sous-systèmes
(sous-modules), eux-mêmes subdivisés en sous-modules, jusqu'à obtenir des modules facilement
compréhensibles.
Nous allons ici décrire un additionneur 8 bits en assemblant des additionneurs 1 bit. On aurait
aussi pu décrire la fonctionnalité de l'additionneur 8 bits (par opposition à sa structure), cela sera vu
à la fin de cet exemple-ci.
On suppose ici que le code de l'additionneur 1 bit vu précédement est disponible, soit dans un
fichier à part, soit dans le fichier de l'additionneur 8 bits
Solution#3

Exemple #4
Plutôt que de décrire l'additionneur 8 bits sous forme d'assemblage d'additionneurs 1 bits, on
aurait pu directement décrire son comportement (sa fonctionalité). En vous inspirant du code de
l'additionneur 1 bit, écrivez une description concise de l'additionneur 8 bits.
Solution#4
Voici une réponse possible :
Exemple #5 Bascule D
 déclaration des processus

 déclenchement des processus
 un nouveau type de signal : reg
Jusqu'à présent, les modules étudiés étaient purement combinatoires. Nous allons maintenant
voir comment décrire un module séquentiel.
Solution#5

Exemple #6 Compteur 8 bits avec reset asynchrone
 liste de sensibilité multiple
Voici une description possible d'un compteur synchrone sur 8 bits, avec reset asynchrone actif à
l'état bas.
Solution#6
Exemple #7 : Registre à décalage
 concurrence et séquentialité
 affectations différées
On cherche à réaliser un registre à décalage sur 8 bits, possèdant une sortie supplémentaire
(match) active à 1 si le contenu du registre à décalage vaut une valeur précise (val).
Solution#7

Exemple #8 Comparateur
Solution#8
Exemple #9 Multiplexeur
Solution#7

5
VERILOG POUR MÉMOIRE FIFO
5.1. Introduction
Une FIFO(First In First Out ) est une ressource de mémorisation particulière dont le mécanisme
de stockage est du type premier entré, premier sorti. Par rapport à une mémoire une FIFO ne
possède pas de bus d'adresse puisque le sto ckage des données s'effectue toujours dans le même
ordre. En revanche, une FIFO possède deux bus de données unidirectionnels, les données
entrent par le bus d'entrée et sortent par le bus de sortie.
Une FIFO est caractérisée par le nombre de données qu'elle peut stocker et par leur format. A
chaque fois qu'une nouvelle donnée est sto ckée dans une FIFO, l'ensemble des données déjà
présentes dans la FIFO est décalé vers la sortie. La FIFO est pleine un signal l'indique. De la
même manière lorsque la FIFO est vide un signal l'indique. Ces signaux sont utilisés afin de
permettre aux unités accédant à la FIFO de connaître
son état. Si la FIFO est pleine, l'écriture d'une nouvelle donnée va conduire soit à l'écrasement de
la dernière donnée écrite dans la FIFO, soit à la perte de la donnée sortant de la FIFO, cela
dépendant des mécanismes de contrôle utilisés par la FIFO
5.2. Memoire FIFO

La mémoire First-In-First-Out (FIFO) avec la spécification suivante est implémentée avec le
Verilog:
- 16 étapes
- Largeur des données 8 bits
- Signaux d'état:
Plein: élevé lorsque le FIFO est complètement plus bas.
Vide: haut quand FIFO est vide, sinon trop bas.
Overflow: élevé lorsque FIFO est plein et toujours en train d'écrire des données dans
FIFO, sinon bas.
Underflow: haut lorsque FIFO est vide et toujours lire les données de FIFO, sinon bas.
Seuil: élevé lorsque le nombre de données dans FIFO est inférieur à un seuil spécifique,
sinon inférieur.

waddr[ASIZE-1:0] wclk raddr[ASIZE-1:0]
wenable 0 0
1 1
wdata[DATA_WIDTH-1:0]
wdata[DATA_WIDTH-1:0]
0 FIFO
1 stages
ASIZE-1
ASIZE-1
ASIZE-2
ASIZE-2
5.3. Code en verilog FIFO
a) FIFO_MEM
data_out[7:0]
wr
rd fifo_full
clk
fifo_empty
rst_n FIFO_MEM
fifo_threshold
data_in[7:0]
fifo_overflow
fifo_underflow
b) Memory_array

fifo_we
clk
data_out[7:0]
wptr[4:0] Memory_array
rptr[4:0]
data_in[7:0]
c) read_pointer

rd
fifo_empty rptr[4:0]
clk read_pointer fifo_rd

rst_n
d) status_signal
wr
rd
clk fifo_full
rst_n fifo_empty
status_signal
wptr[4:0] fifo_threshold
rptr[4:0] fifo_overflow
fifo_we fifo_underflow
fifo_rd
e) write_pointer

wr
fifo_full write_pointer fifo_we
clk
wptr[4:0]
rst_n
Device Utilization Summary (estimated values)

Logic Utilization Used Available Utilization
Number of Slices 27 960 2
Number of Slice Flip Flops 16 1920 0
Number of 4 input LUTs 49 1920 2
Number of bonded IOBs 25 66 37
Number of GCLKS 1 24 4
Target Device: xcv100e-8bg352
Verilog testbench pour FIFO memory:

// 1. The timescale directive
`timescale 10 ps/ 10 ps
// fpga4student.com: FPga projects, Verilog projects, VHDL projects
// Verilog project: Verilog code for FIFO memory
// Verilog Testbench code for FIFO memory
// 2. Preprocessor Directives
`define DELAY 10
// 3. Include Statements
//ìnclude "counter_define.h"
module tb_fifo_32;

// 4. Parameter definitions
parameter ENDTIME = 40000;
// 5. DUT Input regs
reg clk;
reg rst_n;
reg wr;
reg rd;
reg [7:0] data_in;
// 6. DUT Output wires
wire [7:0] data_out;
wire fifo_empty;
wire fifo_full;
wire fifo_threshold;
wire fifo_overflow;
wire fifo_underflow;
integer i;
// 7. DUT Instantiation
// fpga4student.com: FPga projects, Verilog projects, VHDL projects
fifo_mem tb (/*AUTOARG*/
// Outputs
data_out, fifo_full, fifo_empty, fifo_threshold, fifo_overflow,
fifo_underflow,
// Inputs
clk, rst_n, wr, rd, data_in );
// 8. Initial Conditions
initial
begin
clk = 1'b0;
rst_n = 1'b0;
wr = 1'b0;
rd = 1'b0;
data_in = 8'd0;
end
// 9. Generating Test Vectors
initial
begin
main;
end
task main;
fork
clock_generator;
reset_generator;
operation_process;
debug_fifo;
endsimulation;

join
endtask
task clock_generator;
begin
forever #`DELAY clk = !clk;
end
endtask
task reset_generator;
begin
#(`DELAY*2)
rst_n = 1'b1;
# 7.9
rst_n = 1'b0;
# 7.09
rst_n = 1'b1;
end
endtask
task operation_process;
begin
for (i = 0; i < 17; i = i + 1) begin: WRE
#(`DELAY*5)
wr = 1'b1;
data_in = data_in + 8'd1;
#(`DELAY*2)
wr = 1'b0;
end
#(`DELAY)
for (i = 0; i < 17; i = i + 1) begin: RDE
#(`DELAY*2)
rd = 1'b1;
#(`DELAY*2)
rd = 1'b0;
end
end
endtask
// 10. Debug fifo
task debug_fifo;
begin
$display("--------------------------------------------------------------");
$display("------------------ -----------------------------------------");
$display("----------- SIMULATION RESULT -----------------");
$display("-------------- ------------------------------------------");
$display("---------------- ------------------------------------------");
$display("--------------------------------------------------------------");
$monitor("TIME = %d, wr = %b, rd = %b, data_in = %h",$time, wr, rd, data_in);

end
endtask
// 11. Self-Checking
reg [5:0] waddr, raddr;
reg [7:0] mem[64:0];
always @ (posedge clk) begin
if (~rst_n) begin
waddr <= 6'd0;
end
else if (wr) begin
mem[waddr] <= data_in;
waddr <= waddr + 1;
end
$display("TIME = %d, data_out = %d, mem = %d",$time, data_out,mem[raddr]);
if (~rst_n) raddr <= 6'd0;
else if (rd & (~fifo_empty)) raddr <= raddr + 1;
if (rd & (~fifo_empty)) begin
if (mem[raddr]
== data_out) begin
$display("=== PASS ===== PASS ==== PASS ==== PASS ===");
if (raddr == 16) $finish;
end
else begin
$display ("=== FAIL ==== FAIL ==== FAIL ==== FAIL ===");
$display("-------------- THE SIMUALTION FINISHED ------------");
$finish;
end
end
end
//12. Determines the simulation limit
task endsimulation;
begin
#ENDTIME
$display("-------------- THE SIMUALTION FINISHED ------------");
$finish;
end
endtask
endmodule

6
COMMANDE PWM DES MOTEURS PAR FPGA
6.1. Introduction
La modulation de largeur d’impulsion permet de faire varier la vitesse d’un moteur. On souhaite
Réaliser grâce à un composant programmable du type FPGA une modulation de largeur
d’impulsion MLI ou PWM (pulse width modulation). La forme de l’onde sera très simple et non
optimisée pour réduire le taux d’harmonique.
Dans ce chapitre on va implementer un générateur d'implustion PWM sur FPGA en utilisant le
verilog.
Comment faire varier la vitesse d'un moteur ?
Rappels:
Un moteur à courant continu alimenté par une tension U peut être modélisé par une résistance r
en série avec une inductance L, E étant la force électromotrice du moteur:
L r
I
E
U
di
U  E  ri  L 7.1
dt
De plus, on sait par les lois de l'électromagnétisme que :
E  kw 7.2
La force électromotrice est proportionnelle à la vitesse
Cp  k i 7.3
Le couple est proportionnel à l'intensité

(Pulse width modulation)( Modulation en Largeur d'Impulsions) Cela consiste à alimenter le
moteur avec une tension en créneaux.
T
 La tension moyenne dépend alors du rapport cyclique 0
T
 La vitesse varie en fonction de cette tension moyenne.
M
U
En régime établi, l'intensité i est constante (donc di/dt =0) et E = U - r.I

Conséquences sur la vitesse W
E U  ri
w  7.4
K K
La vitesse de rotation w en rd/s dépend de la tension U et de i
 Pour modifier la vitesse de rotation d'un moteur, il faut faire varier la fem E en agissant
sur:
- la tension U Commande en tension
- le courant I => Commande du couple
Periode
T
U
Rapport Cyclique
T0
T
u (t )dt  U max .t 00  U max . 0
1 1 T
U moy  
T
T 0 T T
6.2. Variation de Vitesse (commande par PWM)

Quand on veut faire varier la vitesse d’un moteur, la première idée qui vient à l’esprit est de faire
varier la tension au borne du moteur mais on constate que pour des valeurs faibles de la tension
, le moteur ne tourne pas. Le moteur demande une tension minimale assez importante pour
démarrer. Si cette dernière est trop basse, les for ces électromagnétiques ne sont pas suffisantes
pour combattre le frottement. Il devient donc difficile d’ajuster la vitesse de façon précise.
La solution à ce problème est astucieuse. Il suffit de fournir au moteur une tension qui est
toujours la même soit la tension maximale ! Par contre, cette tension ne sera appliquée que par
très courtes périodes de temps. En ajustant la longueur de ces périodes de temps, on arrive à
faire avancer plus ou moins vite les moteurs. Mieux, on remarque que la vitesse des moteurs
devient proportionnelle à la longueur des périodes de temps. Contrôler la longueur des périodes
passées à la tension maximale par rapport au temps passé sans application de tens ion (tension
nulle) est donc le coeur de la solution. En réalité, cette sol ution est fort connue en controle des
systèmes et en électronique et elle porte le nom de PWM (Pulse Width Modulation).
Un signal PWM est un signal dont la période est fixe, mais le rapport cyclique varie. En d’autres
termes, t1 et t2 varient tout en conservant t1+t2=T=constante.
1
T
0.5
t1 t2
6.2. 1. L'intérêt du PMW

L'intérêt de la PWM est que la tension appliquée au moteur pendant t1 est Vcc. Celle-ci est
suffisante pour va incre les frottements et faire tourner le moteur. Mais la tension moyenne
appliquée au moteur est proportionnelle au rapport cyclique, ce qui permet d’avoir des
consignes de vitesse faibles :
VCC
VMOY  t1 
T
6.2. 2. Fréquence du PMW
La commande d'actionneurs de puissance par PWM est très liée à la notion de fréquence. Pour
que l'impression d'une va leur moyenne constante d'allumage apparaisse, il faut que l'alternance
d'allumage/extinction soit suffisamment rapide pour qu'elle ne se remarque pas.
6.3. FPGA et PMW

Le générateur Verilog PWM (modulation de largeur d'impulsion) crée un signal PWM de 10 MHz
avec un cycle de travail variable. Deux boutons qui sont débités sont utilisés pour contrôler le
cycle de service du signal PWM. Le premier bouton-poussoir consiste à augmenter de 10% le
rapport cyclique et l'autre bouton consiste à diminuer de 10% le rapport cyclique.

CLK
PWM_out
Decrease_duty
increase_duty
PWM
Code Verilog pour générateur PWM avec cycle variable:

// Verilog project: Verilog code for PWM Generator with variable Duty Cycle
// Two debounced buttons are used to control the duty cycle (step size: 10%)
module PWM_Generator_Verilog
(
clk, // 100MHz clock input
increase_duty, // input to increase 10% duty cycle
decrease_duty, // input to decrease 10% duty cycle
PWM_OUT // 10MHz PWM output signal
);
input clk;
input increase_duty;
input decrease_duty;
output PWM_OUT;
wire slow_clk_enable; // slow clock enable signal for debouncing FFs
reg[27:0] counter_debounce=0;// counter for creating slow clock enable signals
wire tmp1,tmp2,duty_inc;// temporary flip-flop signals for debouncing the increasing button
wire tmp3,tmp4,duty_dec;// temporary flip-flop signals for debouncing the decreasing button
reg[3:0] counter_PWM=0;// counter for creating 10Mhz PWM signal
reg[3:0] DUTY_CYCLE=5; // initial duty cycle is 50%
// Debouncing 2 buttons for inc/dec duty cycle
// Firstly generate slow clock enable for debouncing flip-flop (4Hz)
always @(posedge clk)
begin
counter_debounce <= counter_debounce + 1;
//if(counter_debounce>=25000000) then
// for running on FPGA -- comment when running simulation
if(counter_debounce>=1)
// for running simulation -- comment when running on FPGA
counter_debounce <= 0;
end

// assign slow_clk_enable = counter_debounce == 25000000 ?1:0;
// for running on FPGA -- comment when running simulation
assign slow_clk_enable = counter_debounce == 1 ?1:0;
// for running simulation -- comment when running on FPGA
// debouncing FFs for increasing button
DFF_PWM PWM_DFF1(clk,slow_clk_enable,increase_duty,tmp1);
DFF_PWM PWM_DFF2(clk,slow_clk_enable,tmp1, tmp2);
assign duty_inc = tmp1 & (~ tmp2) & slow_clk_enable;
// debouncing FFs for decreasing button
DFF_PWM PWM_DFF3(clk,slow_clk_enable,decrease_duty, tmp3);
DFF_PWM PWM_DFF4(clk,slow_clk_enable,tmp3, tmp4);
assign duty_dec = tmp3 & (~ tmp4) & slow_clk_enable;
// vary the duty cycle using the debounced buttons above
begin
if(duty_inc==1 && DUTY_CYCLE <= 9)
DUTY_CYCLE <= DUTY_CYCLE + 1;// increase duty cycle by 10%
else if(duty_dec==1 && DUTY_CYCLE>=1)
DUTY_CYCLE <= DUTY_CYCLE - 1;//decrease duty cycle by 10%
end
// Create 10MHz PWM signal with variable duty cycle controlled by 2 buttons
begin
counter_PWM <= counter_PWM + 1;
if(counter_PWM>=9)
counter_PWM <= 0;
end
assign PWM_OUT = counter_PWM < DUTY_CYCLE ? 1:0;
endmodule
// Debouncing DFFs for push buttons on FPGA
module DFF_PWM(clk,en,D,Q);
input clk,en,D;
output reg Q;
begin
if(en==1) // slow clock enable signal
Q <= D;
end
endmodule

Verilog Testbench code pour PWM :
`timescale 1ns / 1ps
// fpga4student.com: FPGA Projects, Verilog projects, VHDL projects
// Verilog project: Verilog testbench code for PWM Generator with variable duty cycle
module tb_PWM_Generator_Verilog;
// Inputs
reg clk;
reg increase_duty;
reg decrease_duty;
// Outputs
wire PWM_OUT;
// Instantiate the PWM Generator with variable duty cycle in Verilog
PWM_Generator_Verilog PWM_Generator_Unit(
.clk(clk),
.increase_duty(increase_duty),
.decrease_duty(decrease_duty),
.PWM_OUT(PWM_OUT)
);
// Create 100Mhz clock
initial begin
clk = 0;
forever #5 clk = ~clk;
end
initial begin
increase_duty = 0;
decrease_duty = 0;
#100;
increase_duty = 1;
#100;// increase duty cycle by 10%
increase_duty = 0;
#100;
increase_duty = 1;
increase_duty = 0;
#100;
increase_duty = 1;
increase_duty = 0;
#100;
decrease_duty = 1;
#100;//decrease duty cycle by 10%

decrease_duty = 0;
#100;
decrease_duty = 1;
decrease_duty = 0;
#100;
decrease_duty = 1;
decrease_duty = 0;
end
endmodule

7
SYNTHESE D'UN PROCESSEUR MIPS SUR FPGA
7.1. Introduction
L'architecture MIPS (de l'anglais : microprocessor without interlocked pipeline stages) est une
architecture de processeur de type Reduced instruction set computer (RISC) développée par la
société MIPS Technologies (alors appelée MIPS Computer Systems), basée à Mountain View en
Californie. Les processeurs fabriqués selon cette architecture ont surtout été utilisés dans les
systèmes SGI. On les retrouve aussi dans plusieurs systèmes embarqués, comme les ordinateurs
de poche, les routeurs Cisco et les consoles de jeux vidéo (Nintendo 64 et Sony PlayStation,
PlayStation 2 et PSP). Vers la fin des années 1990, on estimait que les processeurs dérivés de
l'architecture MIPS occupaient le tiers des processeurs RISC produits.
7.2. Processeur MIPS

Dans cette partie on va présenter tous les modules de notre prcesseur MIPS
a) Data memory

CLK pc_out[15:0]
Processeur
rset MIPS alu_result[15:0]
Code VHDL pour Data Memory du processeur MIPS:

library IEEE;
USE IEEE.numeric_std.all;
-- VHDL code for the data Memory of the MIPS Processor
entity Data_Memory_VHDL is
port (
clk: in std_logic;
mem_access_addr: in std_logic_Vector(15 downto 0);
mem_write_data: in std_logic_Vector(15 downto 0);
mem_write_en,mem_read:in std_logic;
mem_read_data: out std_logic_Vector(15 downto 0)
);
end Data_Memory_VHDL;
architecture Behavioral of Data_Memory_VHDL is

signal i: integer;
signal ram_addr: std_logic_vector(7 downto 0);
type data_mem is array (0 to 255 ) of std_logic_vector (15 downto 0);
signal RAM: data_mem :=((others=> (others=>'0')));
begin
ram_addr <= mem_access_addr(8 downto 1);

process(clk)
begin
if(rising_edge(clk)) then
if (mem_write_en='1') then
ram(to_integer(unsigned(ram_addr))) <= mem_write_data;
end if;
end if;
end process;
mem_read_data <= ram(to_integer(unsigned(ram_addr))) when (mem_read='1') else x"0000";
end Behavioral;
b) ALU
Code VHDL pour ALU du processeur MIPS:

library IEEE;
use IEEE.STD_LOGIC_signed.all;
-- VHDL code for ALU of the MIPS Processor
entity ALU_VHDL is
port(
a,b : in std_logic_vector(15 downto 0); -- src1, src2
alu_control : in std_logic_vector(2 downto 0); -- function select
alu_result: out std_logic_vector(15 downto 0); -- ALU Output Result
zero: out std_logic -- Zero Flag
);
end ALU_VHDL;
architecture Behavioral of ALU_VHDL is

signal result: std_logic_vector(15 downto 0);
begin
process(alu_control,a,b)
begin
case alu_control is
when "000" =>
result <= a + b; -- add
when "001" =>
result <= a - b; -- sub
when "010" =>
result <= a and b; -- and
when "011" =>
result <= a or b; -- or
when "100" =>
if (a<b) then
result <= x"0001";
else
result <= x"0000";
end if;
when others => result <= a + b; -- add
end case;
end process;
zero <= '1' when result=x"0000" else '0';
alu_result <= result;
end Behavioral;
c) ALU Control
Code VHDL pour ALU Control du processeur MIPS:
library IEEE;
-- VHDL code for ALU Control Unit of the MIPS Processor
entity ALU_Control_VHDL is
port(
ALU_Control: out std_logic_vector(2 downto 0);
ALUOp : in std_logic_vector(1 downto 0);
ALU_Funct : in std_logic_vector(2 downto 0)

);
end ALU_Control_VHDL;
architecture Behavioral of ALU_Control_VHDL is

begin
process(ALUOp,ALU_Funct)
begin
case ALUOp is
when "00" =>
ALU_Control <= ALU_Funct(2 downto 0);
when "01" =>
ALU_Control <= "001";
when "10" =>
when "11" =>
when others => ALU_Control <= "000";
end case;
end process;
end Behavioral;
d) Register File
Code VHDL pour le Register File du processeur MIPS:
library IEEE;
-- VHDL code for the register file of the MIPS Processor
entity register_file_VHDL is
port (
clk,rst: in std_logic;
reg_write_en: in std_logic;
reg_write_dest: in std_logic_vector(2 downto 0);
reg_write_data: in std_logic_vector(15 downto 0);
reg_read_addr_1: in std_logic_vector(2 downto 0);
reg_read_data_1: out std_logic_vector(15 downto 0);
reg_read_addr_2: in std_logic_vector(2 downto 0);
reg_read_data_2: out std_logic_vector(15 downto 0)
);
end register_file_VHDL;
architecture Behavioral of register_file_VHDL is

type reg_type is array (0 to 7 ) of std_logic_vector (15 downto 0);
signal reg_array: reg_type;
begin
process(clk,rst)
begin
if(rst='1') then

reg_array(0) <= x"0001";
reg_array(1) <= x"0002";
reg_array(2) <= x"0003";
reg_array(3) <= x"0004";
reg_array(4) <= x"0005";
reg_array(5) <= x"0006";
reg_array(6) <= x"0007";
reg_array(7) <= x"0008";
elsif(rising_edge(clk)) then
if(reg_write_en='1') then
reg_array(to_integer(unsigned(reg_write_dest))) <= reg_write_data;
end if;
end if;
end process;
reg_read_data_1 <= x"0000" when reg_read_addr_1 = "000" else

reg_array(to_integer(unsigned(reg_read_addr_1)));
reg_read_data_2 <= x"0000" when reg_read_addr_2 = "000" else
reg_array(to_integer(unsigned(reg_read_addr_2)));
end Behavioral;
e) Control Unit
Code VHDL pour Control Unit du processeur MIPS:
library IEEE;
-- VHDL code for Control Unit of the MIPS Processor
entity control_unit_VHDL is
port (
opcode: in std_logic_vector(2 downto 0);
reset: in std_logic;
reg_dst,mem_to_reg,alu_op: out std_logic_vector(1 downto 0);
jump,branch,mem_read,mem_write,alu_src,reg_write,sign_or_zero: out std_logic
);
end control_unit_VHDL;
architecture Behavioral of control_unit_VHDL is
begin
process(reset,opcode)
begin
if(reset = '1') then
reg_dst <= "00";
mem_to_reg <= "00";
alu_op <= "00";
jump <= '0';
branch <= '0';
mem_read <= '0';
mem_write <= '0';

alu_src <= '0';
reg_write <= '0';
sign_or_zero <= '1';
else
case opcode is
when "000" => -- add
reg_dst <= "01";
mem_to_reg <= "00";
alu_op <= "00";
jump <= '0';
branch <= '0';
mem_read <= '0';
mem_write <= '0';
alu_src <= '0';
reg_write <= '1';
when "001" => -- sliu
reg_dst <= "00";
mem_to_reg <= "00";
alu_op <= "10";
jump <= '0';
branch <= '0';
mem_read <= '0';
mem_write <= '0';
alu_src <= '1';
reg_write <= '1';
when "010" => -- j
reg_dst <= "00";
mem_to_reg <= "00";
alu_op <= "00";
jump <= '1';
branch <= '0';
mem_read <= '0';
mem_write <= '0';
alu_src <= '0';
reg_write <= '0';
when "011" =>-- jal
reg_dst <= "10";
mem_to_reg <= "10";
alu_op <= "00";
jump <= '1';
branch <= '0';
mem_read <= '0';
mem_write <= '0';
alu_src <= '0';
reg_write <= '1';

when "100" =>-- lw
reg_dst <= "00";
mem_to_reg <= "01";
alu_op <= "11";
jump <= '0';
branch <= '0';
mem_read <= '1';
mem_write <= '0';
alu_src <= '1';
reg_write <= '1';
when "101" => -- sw
reg_dst <= "00";
mem_to_reg <= "00";
alu_op <= "11";
jump <= '0';
branch <= '0';
mem_read <= '0';
mem_write <= '1';
alu_src <= '1';
reg_write <= '0';
when "110" => -- beq
reg_dst <= "00";
mem_to_reg <= "00";
alu_op <= "01";
jump <= '0';
branch <= '1';
mem_read <= '0';
mem_write <= '0';
alu_src <= '0';
reg_write <= '0';
when "111" =>-- addi
reg_dst <= "00";
mem_to_reg <= "00";
alu_op <= "11";
jump <= '0';
branch <= '0';
mem_read <= '0';
mem_write <= '0';
alu_src <= '1';
reg_write <= '1';
when others =>
reg_dst <= "01";
mem_to_reg <= "00";
alu_op <= "00";
jump <= '0';

branch <= '0';
mem_read <= '0';
mem_write <= '0';
alu_src <= '0';
reg_write <= '1';
end case;
end if;
end process;
end Behavioral;
f) Instruction Memory
Code VHDL pour la Mémoire d'instruction du processeur MIPS:

library IEEE;
-- VHDL code for the Instruction Memory of the MIPS Processor
entity Instruction_Memory_VHDL is
port (
pc: in std_logic_vector(15 downto 0);
instruction: out std_logic_vector(15 downto 0)
);
end Instruction_Memory_VHDL;
architecture Behavioral of Instruction_Memory_VHDL is

signal rom_addr: std_logic_vector(3 downto 0);
-- lw $3, 0($0) -- pc=0
-- Loop: sltiu $1, $3, 11= pc = 2
-- beq $1, $0, Skip = 4 --PCnext=PC_current+2+BranchAddr
-- add $4, $4, $3 = 6
-- addi $3, $3, 1 = 8
-- beq $0, $0, Loop--a
-- Skip c = 12 = 4 + 2 + br
type ROM_type is array (0 to 15 ) of std_logic_vector(15 downto 0);
constant rom_data: ROM_type:=(
"1000000110000000",
"0010110010001011",
"1100010000000011",
"0001000111000000",
"1110110110000001",
"1100000001111011",
"0000000000000000",
"0000000000000000",
"0000000000000000",
"0000000000000000",
"0000000000000000",
"0000000000000000",
"0000000000000000",

"0000000000000000",
"0000000000000000",
"0000000000000000"
);
begin
rom_addr <= pc(4 downto 1);
instruction <= rom_data(to_integer(unsigned(rom_addr))) when pc < x"0020" else x"0000";
end Behavioral;
g) Porcesseur MIPS
Code VHDL pour le processeur MIPS:
library IEEE;
use IEEE.std_logic_signed.all;
-- fpga4student.com: FPGA projects, Verilog projects, VHDL projects
-- VHDL project: VHDL code for single-cycle MIPS Processor
entity MIPS_VHDL is
port (
clk,reset: in std_logic;
pc_out, alu_result: out std_logic_vector(15 downto 0)
);
end MIPS_VHDL;
architecture Behavioral of MIPS_VHDL is

signal pc_current: std_logic_vector(15 downto 0);
signal pc_next,pc2: std_logic_vector(15 downto 0);
signal instr: std_logic_vector(15 downto 0);
signal reg_dst,mem_to_reg,alu_op: std_logic_vector(1 downto 0);
signal jump,branch,mem_read,mem_write,alu_src,reg_write: std_logic;
signal reg_write_dest: std_logic_vector(2 downto 0);
signal reg_write_data: std_logic_vector(15 downto 0);
signal reg_read_addr_1: std_logic_vector(2 downto 0);
signal reg_read_data_1: std_logic_vector(15 downto 0);
signal reg_read_addr_2: std_logic_vector(2 downto 0);
signal reg_read_data_2: std_logic_vector(15 downto 0);
signal sign_ext_im,read_data2,zero_ext_im,imm_ext: std_logic_vector(15 downto 0);
signal JRControl: std_logic;
signal ALU_Control: std_logic_vector(2 downto 0);
signal ALU_out: std_logic_vector(15 downto 0);
signal zero_flag: std_logic;
signal im_shift_1, PC_j, PC_beq, PC_4beq,PC_4beqj,PC_jr: std_logic_vector(15 downto 0);
signal beq_control: std_logic;
signal jump_shift_1: std_logic_vector(14 downto 0);
signal mem_read_data: std_logic_vector(15 downto 0);
signal no_sign_ext: std_logic_vector(15 downto 0);
signal sign_or_zero: std_logic;

signal tmp1: std_logic_vector(8 downto 0);
begin
-- PC of the MIPS Processor in VHDL
process(clk,reset)
begin
if(reset='1') then
pc_current <= x"0000";
elsif(rising_edge(clk)) then
pc_current <= pc_next;
end if;
end process;
-- PC + 2
pc2 <= pc_current + x"0002";
-- instruction memory of the MIPS Processor in VHDL
Instruction_Memory: entity work.Instruction_Memory_VHDL
port map
(
pc=> pc_current,
instruction => instr
);
-- jump shift left 1
jump_shift_1 <= instr(13 downto 0) & '0';
-- control unit of the MIPS Processor in VHDL
control: entity work.control_unit_VHDL
port map
(reset => reset,
opcode => instr(15 downto 13),
reg_dst => reg_dst,
mem_to_reg => mem_to_reg,
alu_op => alu_op,
jump => jump,
branch => branch,
mem_read => mem_read,
mem_write => mem_write,
alu_src => alu_src,
reg_write => reg_write,
sign_or_zero => sign_or_zero
);
-- multiplexer regdest
reg_write_dest <= "111" when reg_dst= "10" else
instr(6 downto 4) when reg_dst= "01" else
instr(9 downto 7);
-- register file instantiation of the MIPS Processor in VHDL
reg_read_addr_1 <= instr(12 downto 10);
reg_read_addr_2 <= instr(9 downto 7);
register_file: entity work.register_file_VHDL
port map
(
clk => clk,

rst => reset,
reg_write_en => reg_write,
reg_write_dest => reg_write_dest,
reg_write_data => reg_write_data,
reg_read_addr_1 => reg_read_addr_1,
reg_read_data_1 => reg_read_data_1,
reg_read_addr_2 => reg_read_addr_2,
reg_read_data_2 => reg_read_data_2
);
-- sign extend
tmp1 <= (others => instr(6));
sign_ext_im <= tmp1 & instr(6 downto 0);
zero_ext_im <= "000000000"& instr(6 downto 0);
imm_ext <= sign_ext_im when sign_or_zero='1' else zero_ext_im;
-- JR control unit of the MIPS Processor in VHDL
JRControl <= '1' when ((alu_op="00") and (instr(3 downto 0)="1000")) else '0';
-- ALU control unit of the MIPS Processor in VHDL
ALUControl: entity work.ALU_Control_VHDL port map
(
ALUOp => alu_op,
ALU_Funct => instr(2 downto 0),
ALU_Control => ALU_Control
);
-- multiplexer alu_src
read_data2 <= imm_ext when alu_src='1' else reg_read_data_2;
-- ALU unit of the MIPS Processor in VHDL
alu: entity work.ALU_VHDL port map
(
a => reg_read_data_1,
b => read_data2,
alu_control => ALU_Control,
alu_result => ALU_out,
zero => zero_flag
);
-- immediate shift 1
im_shift_1 <= imm_ext(14 downto 0) & '0';
no_sign_ext <= (not im_shift_1) + x"0001";
-- PC beq add
PC_beq <= (pc2 - no_sign_ext) when im_shift_1(15) = '1' else (pc2 +im_shift_1);
-- beq control
beq_control <= branch and zero_flag;
-- PC_beq
PC_4beq <= PC_beq when beq_control='1' else pc2;
-- PC_j
PC_j <= pc2(15) & jump_shift_1;
-- PC_4beqj
PC_4beqj <= PC_j when jump = '1' else PC_4beq;
-- PC_jr
PC_jr <= reg_read_data_1;

-- PC_next
pc_next <= PC_jr when (JRControl='1') else PC_4beqj;
-- data memory of the MIPS Processor in VHDL
data_memory: entity work.Data_Memory_VHDL port map
(
clk => clk,
mem_access_addr => ALU_out,
mem_write_data => reg_read_data_2,
mem_write_en => mem_write,
mem_read => mem_read,
mem_read_data => mem_read_data
);
-- write back of the MIPS Processor in VHDL
reg_write_data <= pc2 when (mem_to_reg = "10") else
mem_read_data when (mem_to_reg = "01") else ALU_out;
-- output
pc_out <= pc_current;
alu_result <= ALU_out;
end Behavioral;
Devise Utlization Summary (estimated Values)

Logic Utilization Used Available Utilization
Number of Slices 506 1200 24%
Number of Slice Flip 151 2400 6%
Flops
Number of 4 input 969 2400 40%
LUTs
Number of IOBs 34 200 17%
Number of GCLKs 1 4 25%

INITIATION À
L’ENVIRONNEMENT DE
CONCEPTION FPGA
ISE14.6, Vivado,Isim, Kintex-7,Artix-7

1. Objectifs
Le but des ces séances de travaux pratiques est d’intégrer les différentes notions vues en cours
concernant l’apprentissage du langage VHDL.
Ce langage étant fortement utilisé dans le monde industriel pour la réalisation des circuits
numériques incluant la conception et le test des entités, l’enseignement est fortement tourné vers
l’utilisation du langage pour la synthèse.
L’aspect comportemental utilisé en modélisation de systèmes numériques sera abordé lors de la
conception des modules de test (écrits aussi en VHDL).
Afin de prendre en main le langage et les différents outils logiciels que nous devrons utiliser. Ils
sont tous intégrés dans l’environnement ISE 14.6 de Xilinx qui propose à la fois éditeur de texte,
synthétiseur logique, simulateur, implémentation et programmation des composants logiques
(FPGA) que nous emploierons. Toutefois, il sera possible au cours des séances d’utiliser le
simulateur MODELSIM SE comme simulateur VHDL (Simulateur utilisé dans l’industrie) ou
bien le ISim Simulator.
Ces séances de travaux pratiques sont au nombre de sept. Elles se dérouleront en deux parties :
La première partie sera consacrée à l’apprentissage du langage pour la conception de circuits

numériques et la mise en place d’entité de test.
La conception du code VHDL doit rester générique et configurable par l’utilisateur sur le PC
sans reprogrammer le FPGA. Ainsi nous verrons comment le VHDL permet la substitution des
équations logiques pour mettre en œuvre des circuits numériques combinatoires et séquentiels et
l'écriture de testbenchs.
La deuxième partie utilisera le VHDL pour concevoir un automate numérique (machine de

Moore et machine de mealy).
Pour vérifier matériellement les différentes entités développées on va utiliser une carte FPGA
XILINX Kintex-7 FPGA KC705 Evaluation Kit.
Les objectifs Spécifiques sont:
 Apprendre le sous-ensemble du langage VHDL RTL synthétisable;

 Apprendre à utiliser le logiciel Xilinx ISE.
 Apprendre à utiliser le simulateur logique Isim.
 Apprendre à coder avec une philosophie de design .
2. Description de la carte FPGA XILINX Kintex-7 FPGA KC705 Evaluation Kit
La carte FPGA XILINX Kintex-7 offre un environnement de conception très adapté pour le
prototypage d’applications variées dont celles des systèmes numériques à usage général et des
systèmes embarqués. Cette carte est de plus idéale pour les applications de traitement vidéo et de
traitement de signal en général.

Figure 1. Carte FPGA XILINX Kintex-7 FPGA KC705 Evaluation Kit
Caractéristiques principales:
 FPGA: Kintex XC7K325T-2FFG900C

ROHS compliant KC705 kit including the XC7K325T-2FFG900C FPGA
 Configuration
A bord circuits de configuration JTAG pour activer la configuration via USB
JTAG header prévu pour une utilisation avec des câbles de téléchargement de Xilinx
comme la plate-forme câble USB II 128 Mo (1024Mo) Linear BPI en Flash pour PCIe ®
Configuration
16 Mo (128 Mo) Quad Flash SPI
 Memory
1GB DDR3 SODIMM 800MHz / 1600Mbps
128MB (1024Mb) Linear BPI Flash for PCIe® Configuration
16MB (128Mb) Quad SPI Flash
8Kb IIC EEPROM
SD Card Slot
 Communication & Réseaux
Gigabit Ethernet GMII, RGMII et SGMII
SFP / SFP + cage
Port GTX (TX, RX) avec quatre connecteurs SMA
Pour UART USB Bridge
PCI x8 connecteur de bord express
 (Display) Afficher
Sortie vidéo HDMI
Dispositif Phy / codec externe conduite d'un connecteur HDMI

Écran LCD 2x16
8x LED
 Connecteurs d'extension
FMC-HPC (Population partiel) connecteur (4 GTX Transceiver, 116 single-ended ou 58
différentiel (34 et 24 HA LA) utilisateur signaux définis)
Connecteur FMC-LPC (1 GTX Transceiver, 68 single-ended ou 34 utilisateur différentiel
signaux définis)
Vadj peut prendre en charge 1,8 V, 2,5 V, 3,3 V ou IIC
 Clocking
Oscillateur fixe avec sortie différentielle 200MHz
Utilisé comme l'horloge "système" pour le FPGA
Oscillateur Programmable avec 156.250 MHz comme la sortie par défaut
Fréquence par défaut ciblé pour les applications Ethernet mais oscillateur est
programmable pour plusieurs utilisations finales
Différentiel entrée d'horloge SMA
Différentiel SMA GTX référence entrée d'horloge
Gigue d'horloge atténué
Utilisé pour supporter les applications CPRI / OBSAI qui effectuent la récupération
d'horloge à partir d'un SFP / SFP + Module fourni par l'utilisateur
 Control & I/O
5X Push Buttons
4X DIP Switches
Diff Pair I/O (1 SMA pair)
AMS FAN Header (2 I/O)
7 I/O pins available through LCD header
 puissance
Adaptateur mural ou 12V ATX
Une capacité de tension et de mesure de courant de 2,5 V, 1,5 V, 1,2 V et, 1.0V
fournitures (IIC chemin de FPGA)
 Analog
XADC header
 Carte d'évaluation AMS 101
Figure 2. Carte d'évaluation AMS 101
 Principales caractéristiques ( Carte d'évaluation analogique)

Analog evaluation card connects to XADC header

Evaluates XADC 12-bit, 17-channel, 1 Msps dual ADCs and Analog Mixed Signal
technology
Pins and BNC mini grabbers allow for external analog input signals
On-board 16-bit DAC for analog test signals
Reference designs allow sine wave or DC test signals
Pour une description approfondie de la carte XILINX Kintex-7 FPGA, consultez le manuel
d’utilisation ainsi que la fiche technique disponible chez DIGILENT.
3. Description de la méthodologie de conception

Ce rapport propose un survol de l’outil intégré de conception ISE version 14.6 de Xilinx et de la
carte de développement FPGA Kintex-7 FPGA KC705. Les connaissances acquises à l’aide de ce
matériel pédagogique serviront à effectuer les séances de travaux pratiques prévus dans le cadre
du cours.
Documentions supplémentaire recommandée :
- Manuel d’utilisation de la carte Kintex-7
(http://www.digilentinc.com/Products/Detail.cfm?NavPath=2,719,1165&Prod=INREVIUM-
TB-7K)
- Fiche technique de la carte Kintex-7
- Manuel d’utilisation ISE version 14.6
(http://www.xilinx.com/support/documentation/sw_manuals/xilinx14_6/irn.pdf)
- Manuel d’utilisation de Isim
(http://www.xilinx.com/support/documentation/sw_manuals/xilinx11/plugin_ism.pdf)
Flow de conception FPGA

Le flot de conception du FPGA, ou design flow, en utilisant l’outil ISE est montré par la figure
suivante :

ISE Vérification
Données de Design
Schéma
Langage HDL
Simulation fonctionnelle
ISim
Synthèse
XST
Implémentation
- mapping
- placement
- Routage Simulation avec Timings
- Génération des fichiers
de configuration ISim
Programmation du FPGA Test du Système
Figure 3. Flow de conception FPGA
Le logiciel Xilinx ISE est un outil de conception de circuit pour FPGA de Xilinx. Ce logiciel
permet essentiellement d’effectuer les différentes étapes propres à la synthèse de circuits
numériques sur FPGA. Il est alors possible d’en faire l’implémentation sur les différentes
familles de puces fournies par Xilinx.
Le Navigateur de projet ISE sera utilisé comme outil de conception par excellence lors de ce
didacticiel ainsi que lors des travaux pratiques. Cet outil de Xilinx permet de créer des projets
comportant plusieurs types de fichiers (HDL, schématique, UCF, EDIF, etc.), de compiler,
d’effectuer des design rule check (DRC), de créer des contraintes d’implémentation dont des
contrainte de timings sur les horloges, de déterminer l’emplacement des broches, de créer des
bancs d’essai de simulation (testbench) et de gérer efficacement les projets d’envergure.
L'objectif de cette partie est d'énumérer et de décrire les étapes pour :

• Créer un projet dans Xilinx ISE;
• Décrire un circuit numérique à l'aide d’une description VHDL;
• Décrire un circuit numérique à l’aide d’une description hiérarchique, basée sur un schéma, et
contenant plusieurs modules décrits en VHDL dans des fichiers séparés;

INITIATION À L’ENVIRONNEMENT DE CONCEPTION FPGA
ISE14.6, Isim, Kintex-7
Lab 0: Synthèse avec le logiciel Xilinx ISE design Tools 14.6
TD
Prenons l’exemple montré par3la D
figure suivante : STRUCTURELLE
ESCRIPTION
A Porte_and S
B FPGA Kintex-7
FPGA KC705
Nous considérons un circuit simple formé par une porte ET. Afin de connecter les deux entrées
« A » et « B » au deux interrupteurs SW11(0)et SW11(1) ainsi que la sortie « S » au GPIO LEDS
(0).
Pour débuter cette partie, créez un nouveau projet ISE ayant pour cible le FPGA XILINX
Kintex-7 FPGA KC705 Evaluation Kit.
I. Synthèse avec le logiciel Xilinx ISE design Tools 14.6

1. Pour lancer la suite ISE version 14.6, double-cliquez sur l’icône du Navigateur de projet ISE,
ou
sélectionnez Start > Programs > Xilinx ISE design Tools 14.6 > ISE Design Suite 14.6 > ISE
design Tools > 32-bit ou bien 64-bit Project Navigator.

Figure 4. Synthèse avec le logiciel Xilinx ISE design Tools 14.6
2. Dans le Navigateur de projet ISE, cliquez sur File > New Project, ou cliquez sur le bouton
New Project dans la fenêtre de gauche.
3. Dans la fenêtre New Project Wizard , tapez Lab0_porte_and comme nom de projet. et
cliquez sur Next.
Notez que Lab0_porte_and est ajouté au chemin initial contenu dans le champ Location.

4. Entrez les valeurs suivantes dans la fenêtre New Project Wizard – Project Sttings.
Product Category: All
Family:Kintex7
Device: XC7k325t
Package: ffg900
Speed: -2
Synthesis Tool: XST (VHDL/Verilog)
Simulator: Isim (VHDL/Verilog)
Preferred Language: VHDL

5. Sélectionnez VHDL Module dans la boîte de dialogue Select Source Type et entrez
porte_and comme nom de fichier.
6. Vous avez créé une page de schéma vide pour porte_and. L’étape suivante consiste à ajouter
les étiquettes d’entrées/sorties comme illustré à la Figure suivante. Les étiquettes
d’entrées/sorties définissent les ports. Ces ports correspondront aux broches du symbole
représentant le module.
Tapez A et B dans le champ Inputs et tapez S dans le champ Outputs et Cliquez sur Ok.
Notez que dans le champ Direction, choisissez In pour les entrées et Out pour les sorties et ne
cochez pas les champs Bus.
Figure 9. La boîte de dialogue pour entrer les ports d’entrées/sorties du module VHDL à
créer.

7. Cliquez sur Next et ensuite sur Finish pour compléter cette étape de configuration.
Une boîte de dialogue affiche la description VHDL générée par le Wizard.
Figure 10.
8. Cliquez enfin sur Finish dans la fenêtre Project Summary.
Le fichier VHDL vide décrivant le module porte_and s’ouvre dans l’espace de travail
comme montré à la Figure 11. Ce fichier contient l’entité du module mais présente une
architecture vide à compléter.
Figure 11. Module porte_and s’ouvre dans l’espace de travail (Architecture vide)
9. Compléter la description VHDL du module porte_and.

Le code VHDL du module porte_and est maintenant complété.
- Cliquez sur File > Save.

- Sélectionnez l’item porte_and dans l’espace Hierarchy et double-cliquez sur
Synthesize-XST dans l’espace Design.
Figure 12. Module porte_and s’ouvre dans l’espace de travail (Architecture complète)
- Vérifiez les résultats dans la Console et corrigez les erreurs de syntaxe s’il y a lieu.
- Vous pouvez voir le rapport de synthèse (Figure 12)
Figure 13. Rapport de Synthèse de module porte_and
II. Simulation fonctionnelle avec Isim

Une fois l’étape de conception terminée, vous allez effectuer une simulation fonctionnelle du
projet à l’aide d’un testbench et du simulateur Isim. Pour ce faire, vous allez d’abord générer un

fichier testbench VHDL à l’aide du Navigateur de projet ISE. Ensuite, vous configurerez et
lancerez votre simulation Isim à partir du Navigateur ISE. Une fois appelé par ISE, Isim prendra
en charge la simulation et la présentation des résultats.
1. Ouvrez tout d’abord le projet Porte_and dans le Navigateur ISE, si ce n’est pas déjà fait.
Vérifiez ensuite que ISE pointe correctement sur l’outil de simulation Isim. Suivez ces étapes :
- Sélectionnez Project > Design Properties.
- Vérifiez que Isim(VHDL/Verilog) est bien le Simulator
- Cliquez sur Ok pour fermer la boîte de dialogue.
Dans le Navigateur de projet ISE, cliquez sur File > New Source, ou cliquez sur le bouton New
Project dans la fenêtre de gauche.
Figure 13. Simulation fonctionnelle avec Isim

2. Sélectionnez Verilog Test Fixture dans la boîte de dialogue Select Source Type et entrez
Test_and_sim comme nom de fichier.

Figure 14. Verilog Test Fixture
3. Cliquez sur Next.

4. Ajoutez le code suivant pour vérifier le bon fonctionnement de programme.

5. Cliquez deux fois sur Simulate Behavioral Model
Le logiciel ISim s’ouvre comme illustré à la Figure 18.

Les résultats de simulation seront affichés dans la fenêtre Default.wcfg , à droite de la fenêtre
ISim.

Figure 18. La fenêtre de simulation ISim
III. Implémentation et Test du Système

Dans cette partie, vous effectuerez la synthèse et l’implémentation du module porte_and. Vous
créez d’abord des contraintes de timing et les incorporer au projet. Vous spécifierez ensuite la
configuration des broches d’entrées/sorties à adopter et vous générerez enfin le fichier de
programmation du FPGA Kintex-7 FPGA KC705 Evaluation Kit.
L’implémentation du projet consiste à effectuer les étapes d’interprétation (translation), de
mapping, de placement & routage et de génération du fichier de programmation BIT. Tous les
outils d’implémentation du projet sont intégrés au Navigateur ISE.
Vous devez tout d’abord configurer les propriétés des outils d’implémentation. Suivez ces étapes
:
1. Sélectionnez l’onglet Design dans l’espace Hierarchy situé dans la partie supérieure gauche du
Navigateur de Projet.
2. Assurez-vous que l’item Implementation est sélectionné dans la liste View au dessus de
l’espace Hierarchy.
3. Sélectionnez l’item top level porte_and dans l’arborescence de projet.
4. Dans l’espace Processes, sous l’espace Hierarchy, cliquez avec le bouton de droite de la souris
sur l’item Implement Design. Selectionnez Process Properties.
5. La boîte de dialogue Process Properties apparaît. Sélectionnez l’item Place & Route
Properties de la liste Category de Gauche.
6. Assurez-vous que l’item Advanced est sélectionné dans la liste Property display level, dans le
bas de la boîte de dialogue.
7. Changez le Place & Route Effort Level (Overall) pour High dans la colonne Value juste à
côté.
Vous devriez avoir un résultat conforme à la Figure 19.

Figure 19. Configuration à adopter pour la boîte de dialogue Process Properties pour les
options de placement et routage.
A- Création de contraintes de timing
Les contraintes de timings du design sont entrées dans un fichier UCF (User constraints file).
ISE 14.6 met à votre disposition des outils graphiques comme le Constraints Editor et PlanAhead
pour éditer ce fichier automatiquement.
Vous allez, tout d’abord, entrer des contraintes de timing à l’aide du Constraints Editor. Ces
contraintes seront inscrites automatiquement dans un fichier UCF qui sera associé au projet en
cours.
Pour lancer le Constraints Editor :

1. Sélectionnez porte_and dans l’arborescence du projet.
2. Déployez l’item User Constraints dans la liste de l’espace Processes.
3. Double-cliquez sur l’item Create Timing Constraints.
4. Cliquez Yes sur la boîte de dialogue demandant si vous voulez créer un fichier UCF.
5. Copiez ce bloc de code à l’aide de la fonction Copy et collez-le dans votre fichier
porte_and.ucf,
NET a LOC = AA28 | IOSTANDARD=LVCMOS25; # Bank 13 VCCO - VADJ_FPGA - IO_L3N_T0_DQS_13

NET b LOC = Y28 | IOSTANDARD=LVCMOS25; # Bank 13 VCCO - VADJ_FPGA - IO_L3P_T0_DQS_13
NET s LOC = AB8 | IOSTANDARD=LVCMOS15; # Bank 33 VCCO - VCC1V5_FPGA - IO_L2N_T0_33
Remarquez que l’étape de synthèse du projet s’effectue automatiquement dans l’espace Processes.

Figure 20. Configuration à adopter pour la boîte de dialogue Process Properties pour les options
Figure 21. Configuration à adopter pour la boîte de dialogue Process Properties pour les
options de placement et routage.
B- Création du fichier de programmation
Pour réaliser les options Synthesize –XST, Implement Design et Generate Programming
File, il faut faire un clique-droit sur chacun, puis Run. Notez qu’il est également possible d’utiliser
l’option Implement Top Module pour réaliser les deux premières tâches.
Synthesize –XST : Permet de faire la synthèse du circuit en bloc configurable se retrouvant sur le
FPGA. Implement Design : Permet de faire les mapping et routage nécessaires pour placer le
tout sur le FPGA. Generate Programming File : Genere le fichier (.bit) utilisé pour programmer
le FPGA.

Ouvrer tout d’abord le projet du détecteur de séquence dans le Navigateur ISE, si ce n’est pas
déjà fait. Assurez-vous de sélectionner l’onglet Design et l’item Implementation de la liste View,
juste au-dessus de l’espace Hierarchy.
Effectuez les configurations préalables suivantes :
1. Sélectionnez porte_and dans l’arborescence du projet.
2. Cliquez avec le bouton droit de la souris sur l’item Generate Programming File.
3. Choisissez l’onglet Process Properties du menu déroulant.
4. Assurez-vous que l’item Advanced est sélectionné dans la liste Property display level dans le
bas de la boîte de dialogue.
5. Sélectionnez l’item StartUp Options dans la liste Category de gauche.
6. Sélectionnez l’item JTAG Clock pour le FPGA Start-Up Clock.
7. Cliquez sur Ok.
Fabriquez ensuite le fichier de programmation :

8. Dans l’espace Processes, double-cliquez sur l’item Generate Programming File.
Figure 22. Création du fichier de programmation.
ISE lance le programme intégré BitGen pour générer le fichier BIT qui servira à programmer le
FPGA.
Après chacune des étapes, un message de succès devrait s’afficher dans la console. Dans le cas
contraire, il faut corriger les erreurs ou inspecter les avertissements (warnings) pour vous assurer
qu’ils ne proviennent pas d’erreurs dans votre code. Idéalement, on devrait voir s’afficher les trois
crochets verts illustrés à la figure précédente.
Lors de ces différentes étapes, plusieurs données deviendront disponibles dans le Design
Summary (voir figure précédente). Vous aurez donc aisément accès, entre autres, aux ressources
utilisées et aux résultats temporels (chemin critique, etc).
C- Programmation du FPGA et vérification

Si tout s’est bien passé lors de la synthèse, un fichier porte_and.bit est maintenant placé dans
votre répertoire projet et est prêt à être chargé sur la carte FPGA XILINX Kintex-7 de
développement.
Figure 23. Carte FPGA XILINX Kintex-7 de développement.
Dans Xilinx ISE, cliquez deux fois sur Configure Target Device.

Lorsque l’outil iMPACT sera ouvert, double clik sur Boundary Scan et dans l’espace en blanc, cliquez sur
le bouton de droite et choisissez Initialize Chain.

Cliquez sur Yes si la fenêtre « Auto Assign Configuration Files Query Dialog » s’affiche. Choisissez le
fichier porte_and.bit que vous trouverez dans le dossier projet et cliquez sur Open. Si le logiciel vous
demande d’attacher un SPI ou un BPI PROM, répondez par No. Cette option sert à charger la mémoire
PROM de la planchette. Cliquez sur le symbole représentant le FPGA, puis sur le bouton de droite de la
souris. Choisissez Program … Cliquez sur OK dans la fenêtre Device Programming Properties (si elle
s’affiche), sans rien changer.

Voilà, Vous pouvez maintenant vérifier votre design sur le FPGA.

Essayez toutes les combinaisons possibles d’entrées et confirmez que les sorties sont bien conformes au
tableau de vérité de la porte and.

3.3 V
A
GPIO LEDS (0)
3.3 V SW11(0)
Porte_and S
B FPGA Kintex-7
KC705
SW11(1)

Lab 1: Modélisation d’un décodeur hexadécimal pour affichage à 7
segments
En codage BCH : (Binary Coded Hexadecimal, soit hexadécimal codé binaire en français), on
TD
prend chaque chiffre qui compose
Exemple : F 0 5 = 1111 0000 0101
3 D
une S
valeur hexadécimal,
ESCRIPTION et on le code directement sur 4 bits.
TRUCTURELLE
Le but de ce Lab est d’afficher la valeur d’une entrée de 4 bit (BCH) en une valeur hexadécimal
(0, 1, ..., 9, A, B, …, F)
Exemple :
si BCH = 1110 = E en hexadécimal (=14 en décimal) alors l’afficheur 7 segment affichera la
lettre E.
si BCH = 0010 = 2 en hexadécimal alors le chiffre 2 sera afficher.
a
a
f b
BCH SEG
g
/ DecHex /
4 bits 7 bits
e c
d
BCH abcde fg
"0010"  "1 1 0 1 1 0 1"
GPIO LEDS (0)

3.3 V SEG(0)
BHC(0)
GPIO LEDS (1)
3.3 V SW11(0) SEG(1)
BHC(1) DecHex
FPGA Kintex-7
SW11(1) BHC(2)
KC705
3.3 V SW11(2) GPIO LEDS (6)
BHC(3) SEG(6)
SW11(3)
Figure 1. Décodeur hexadécimal pour affichage à 7 segments

.
Entité :
• Une entrée BCH de 4 bits codant un entier de 0 à 15.
• Une sorties SEG de 7 bit SEG(0), ..., SEG(6), un bit par segment, valant ’1’ si le segment
correspondant doit être allumé et valant ’0’ sinon.
Architecture :

• Le comportement à décrire est purement combinatoire et doit réaliser la table de vérité du
composant.
• Nom d’architecture suggéré: bhv (pour "behaviour" - comportement).
• Le chiffre 9 peut être affiché avec les segments abcgf ou abcdgf à ’1’.
• Prévoir un affichage de la lettre d’erreur « R » si le code BCD est incorrect.
1) Donner le code VHDL de l’entité correspondante de ce décodeur hexadécimal DecHex.
2) Donner le code VHDL de l’architecture correspondante.
3) Ecrire la modification correspondante du code afin de mettre la sortie à l’état haut
impédance au lieu d’afficher la lettre « R » si le code BCD est incorrect.
4) Simulez à l’aide du testbench fourni le fonctionnement du décodeur dans sa version
séquentielle afin de valider son fonctionnement.
5) Calculez les performances du décodeur une fois synthétisée avec ISE (latence débit et
surface).
6) Vous pouvez maintenant tester votre design sur le FPGA. Vérifier toutes les
combinaisons possibles d’entrées et vérifier que les sorties sont bien conformes au
tableau de vérité.
Les entrées:
 Eight user LEDs (callout 22)
GPIO_LED_[7-0]: DS27, DS26, DS25, DS3, DS10, DS1, DS4
Figure 2. Eight user LEDs

Les entrées
 4-position user DIP Switch (callout 24)
GPIO_DIP_SW[3:0]: SW11

Figure 3. 4-position user DIP Switch
4-Poles DIP Switch

Y29 GPIO_DIP_SW0 SW11.4
W29 GPIO_DIP_SW1 SW11.3
AA28 GPIO_DIP_SW2 SW11.2
Tableau 1. GPIO Connections to FPGA U1 (4-Poles DIP Switch)
FPGA Pin (U1) Schematic net GPIO Pin

Name
Indicator LEDs (Actice High)
AB8 GPIO_LED_0 DS4.2
AA8 GPIO_LED_1 DS1.2
AC9 GPIO_LED_2 DS10.2
AE26 GPIO_LED_4 DS3.2
G19 GPIO_LED_5 DS25.2
E18 GPIO_LED_6 DS26.2
F16 GPIO_LED_7 DS27.2
Tableau 2. GPIO Connections to FPGA U1(Indicator LEDs)
Copiez ce bloc de code à l’aide de la fonction Copy et collez-le dans votre fichier DecHex.ucf,
NET BCH(0) LOC = Y29 | IOSTANDARD=LVCMOS25; # Bank 13 VCCO - VADJ_FPGA - IO_L4N_T0_13
NET BCH(1) LOC = W29 | IOSTANDARD=LVCMOS25; # Bank 13 VCCO - VADJ_FPGA - IO_L4P_T0_13
NET BCH(2) LOC = AA28 | IOSTANDARD=LVCMOS25; # Bank 13 VCCO - VADJ_FPGA - IO_L3N_T0_DQS_13
NET BCH(3) LOC = Y28 | IOSTANDARD=LVCMOS25; # Bank 13 VCCO - VADJ_FPGA - IO_L3P_T0_DQS_13
NET SEG(0) LOC = AB8 | IOSTANDARD=LVCMOS15; # Bank 33 VCCO - VCC1V5_FPGA - IO_L2N_T0_33
NET SEG(1) LOC = AA8 | IOSTANDARD=LVCMOS15; # Bank 33 VCCO - VCC1V5_FPGA - IO_L2P_T0_33
NET SEG(2) LOC = AC9 | IOSTANDARD=LVCMOS15; # Bank 33 VCCO - VCC1V5_FPGA - IO_L3N_T0_DQS_33
NET SEG(3) LOC = AB9 | IOSTANDARD=LVCMOS15; # Bank 33 VCCO - VCC1V5_FPGA - IO_L3P_T0_DQS_33
NET SEG(4) LOC = AE26 | IOSTANDARD=LVCMOS25; # Bank 13 VCCO - VADJ_FPGA - IO_25_13
NET SEG(5) LOC = G19 | IOSTANDARD=LVCMOS25; # Bank 17 VCCO - VADJ_FPGA - IO_0_17
NET SEG(6) LOC = E18 | IOSTANDARD=LVCMOS25; # Bank 17 VCCO - VADJ_FPGA - IO_25_17

Figure 4. Carte FPGA XILINX Kintex-7 de développement.

Lab 2: Modélisation d’un Compteur/Décompteur
Partie I : Modélisation d’un Compteur/Décompteur

On considère le circuit logique schématisé par la figure suivante dont les entrées CLK, SENS,
RAZ sont des bits. La sortie du circuit est Q3..0 vecteur dont les éléments sont des bits.
CLK
Q
SENS
RAZ
CMP_DEC /
4 bits
Figure 1. Compteur/Décompteur.
Le fonctionnement de ce circuit est donné par la table de vérité suivante :
Inputs Outputs
RAZ SENS CLK Q(3) Q(2) Q(1) Q(0)
1 x x 0 0 0 0
0 1 Incrémentation
0 0 Décrémentation
1) Ecrire l’entité du circuit.

2) Ecrire l’architecture comportementale du circuit.
GPIO LEDS (0)
3.3 V SEG(0)
RAZ
GPIO LEDS (1)
3.3 V SW11(0) SEG(1)
SENS CMP_DEC
FPGA Kintex-7
SW11(1)
KC705
GPIO LEDS (3)
CLK SEG(3)
Figure 2. Compteur/Décompteur (CMP_DEC FPGA Kintex-7 KC705)
3) Simulez à l’aide du ISim et fourni le fonctionnement du compteur/décompteur dans sa

version séquentielle afin de valider son fonctionnement.
4) Calculez les performances du décodeur une fois synthétisée avec ISE (latence débit et surface).
5) Vous pouvez maintenant tester votre design sur le FPGA.
Vérifier toutes les combinaisons possibles d’entrées et vérifier que les sorties sont bien
conformes au tableau de vérité.

Partie II : Modélisation d’un Compteur/Décompteur avec une machine d'états finis
Si SENS=0 : Compteur binaire : 0,1,2,3,0,….

Si SENS=1 : Compteur binaire : 0,3,2,1,0,….
La machine d’état qui exprime les transitions de ce compteur est la suivante :
Figure 3. Machine à états finis

10. Déterminer
13. A partir de tableau de karnaugh écrire les équations des entrées de bascules.
CLK.
Ecrire un code VHDL de cette machine d’état
i) Simulez à l’aide du ISim la machine.
ii) Calculez les performances du la machine à états finis une fois synthétisée avec ISE
iii) Vous pouvez maintenant tester votre design sur le FPGA. Vérifier toutes les
machine.

Lab 3: Modélisation d’un Additionneur
Partie I : Modélisation d’un Additionneur FA

On désire modéliser un additionneur sur 1 bit (FA) gérant les problèmes de retenue. Ai et Bi
sont les entrées de 1 bit chacune à additionner, Cin est une retenue en entrée, Si est le résultat et
Cout la retenue de sortie
Ai Bi
Cout Cin
FA
Si
Figure 1. Additionneur FA
e) Ecrire les équations des sorties Si et Cout (en utilisant des portes AND, OR et XOR).
f) Ecrire un programme en VHDL avec une description de type flot des données pour cet
additionneur (FA).
g) A partir de ce schéma, écrire en VHDL un modèle uniquement structurel de
l'additionneur 4 bits en utilisant l’additionneur 1 bit (FA) déjà décrit.
A3 B3 A2 B2 A1 B1 A0 B0
Cout i3 i2 i1 Cin
FA FA FA FA
S3 S2 S1 S0
Figure 2. Additionneur FA 4 bits
 Simulez à l’aide Simulez à l’aide du ISim.

 Calculez les performances du l'additionneur 4 bits une fois synthétisée avec ISE (latence
débit et surface).
 Vous pouvez maintenant tester votre design sur le FPGA. Vérifier toutes les
combinaisons possibles d’entrées et vérifier que les sorties sont bien conformes au tableau
de vérité.
N.B. Vous pouvez utiliser les entrees/sorties suivantes pour les deux cas:

Les entrées:
 Eight user LEDs (callout 22)
GPIO_LED_[7-0]: DS27, DS26, DS25, DS3, DS10, DS1, DS4
Les entrées
 4-position user DIP Switch (callout 24)
GPIO_DIP_SW[3:0]: SW11
4-Poles DIP Switch
W29 GPIO_DIP_SW1 SW11.3
AA28 GPIO_DIP_SW2 SW11.2
Tableau 1. GPIO Connections to FPGA U1 (4-Poles DIP Switch)
FPGA Pin (U1) Schematic net GPIO Pin
Name
Indicator LEDs (Actice High)
AA8 GPIO_LED_1 DS1.2
AC9 GPIO_LED_2 DS10.2
AE26 GPIO_LED_4 DS3.2
G19 GPIO_LED_5 DS25.2
E18 GPIO_LED_6 DS26.2
F16 GPIO_LED_7 DS27.2
Tableau 2. GPIO Connections to FPGA U1(Indicator LEDs)
Partie II : Modélisation d’un Soustracteur
Comme pour l'additionneur, un soustracteur peut être réalisé en cascadant les cellules de base.
Ecrire un programme en VHDL avec une description structurelle pour ce soustracteur (en
utilisant les fils internes i1, i2, i3, b0, b1, b2 et b3).
B3 B2 B1 B0
A3 A2 A1 A0
b3 b2 b1 b0
Cout i3 i2 i1 ‘1’
FA FA FA FA
S3 S2 S1 S0
Figure 3. Soustracteur 4 bits

 Simulez à l’aide Simulez à l’aide du ISim.
 Calculez les performances du décodeur une fois synthétisée avec ISE (latence débit et
surface).
 Vous pouvez maintenant tester votre design sur le FPGA. Vérifier toutes les
tableau de vérité.

Lab 4: Modélisation d’un Transcodeur
Partie I : Modélisation d’un Transcodeur

1) Décrivez l’entité et l’architecture d’un transcodeur binaire-code de gray. La table de vérité
ci-dessous donne une spécification du comportement attendu.
binaire Code de gray

E2 E1 E0 S2 S1 S0
0 0 0 0 0 0
0 0 1 0 0 1
0 1 0 0 1 1
0 1 1 0 1 0
1 0 0 1 1 0
1 0 1 1 1 1
1 1 0 1 0 1
1 1 1 1 0 0
E2 E 1 E0
Transcodeur
S2 S 1 S0
2) On souhaite décrire le comportement d’un registre répondant à la table fonctionnelle

suivante :
S1S0 Fonction
00 inchangé
01 chargement
10 Déc gauche
11 Déc droit
Tableau 1 : Table fonctionnelle de ce registre
4 bits
2 bits
IL E IR
S1..0
REGISTRE
H
Q
4 bits

Donnez l’entité et l’architecture décrivant l’interface du circuit. Les signaux d’entrée E et de sortie
Q seront considérés comme des std_logic_vector, avec un nombre de bits N paramétrable (N=4
bits). S sera également de type std_logic_vector. Le reste des signaux sera de type std_logic.
1) Simulez à l’aide du testbench fourni le fonctionnement du registre dans sa version

séquentielle afin de valider son fonctionnement.
2) Calculez les performances du registre une fois synthétisée avec ISE (latence débit et
surface).
Partie II : Modélisation d’un décodeur d'adresse

Voici un schéma d’un décodeur d’adresse
CS_A
8 bits
CS_B
Dec_Adress
Adresse CS_C
Le tableau ci-dessous nous donne le plan d’adressage de ce décodeur :

Adresses (8 bits)
CS_A CS_B CS_C
En Héxa En décimal
0 à 2F 0 à 47 1 0 0
30 à 4F 48 à 79 0 1 0
50 à 7F 80 à127 0 0 1
80 à FF 128 à 255 0 0 0
Tableau 2 : Plan d’adressage de décodeur
1) Donner le code VHDL de l’entité correspondante de ce décodeur Dec_Adress.

2) Donner le code VHDL de l’architecture correspondante.
3) Simulez à l’aide du testbench fourni le fonctionnement du décodeur d'adresse dans sa
version séquentielle afin de valider son fonctionnement.
4) Calculez les performances du décodeur d'adresse une fois synthétisée avec ISE (latence
débit et surface).
5) Une fois le fichier VHDL édité, il est conseillé de vérifier la syntaxe du design afin de
trouver des erreurs de syntaxe, de typographie :
 Vérifier que synthesis/implementation est sélectionné dans la liste déroulante de la
fenêtre sources.
 Sélectionner le fichier VHDL Dec_Adress pour afficher les processus liés dans la
fenêtre processes.
 Cliquer sur le « + » à coté de synthesize-XST.
 Double-cliquer sur le processus check syntax. Si tout va bien, un crochet vert apparaît.
Sinon, consulter les messages d’erreur dans la console au bas de l’écran.
 Corriger les erreurs s’il y a lieu, puis fermer le fichier VHDL.

logiciel Vivado Artix-7
Lab 5: Mémoire ROM
a) 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 35T
b) Création d’un projet avec Vivado ROM
Créez d’abord un répertoire dans votre espace disque, ici appelé Lab_SE. 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 pour faire le laboratoire (Partie I :
Mémoire ROM asynchrone et Partie II : Mémoire ROM synchrone )
 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.
 Donnez un nom à votre projet, ici Lab_SE, 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
 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, XC7tcsg325-1.

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.
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 Lab_SE.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),
 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 : Partie I : Mémoire ROM
asynchrone
 Appuyez sur Finish.

 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 quelque fois 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
 Mémoire ROM synchrone

Description du fichier ROM_sync.vhd

1) Simulez à l’aide du testbench ces deux codes.
2) Calculez les performances des codes suivantes:
ROM_sync.vhd et ROM_async.vhd
Création du fichier de programmation Ouvrer tout d’abord le projet du détecteur de séquence

dans le Navigateur ISE, si ce n’est pas déjà fait. Assurez-vous de sélectionner l’onglet Design et
l’item Implementation de la liste View, juste au-dessus de l’espace Hierarchy.
Effectuez les configurations préalables suivantes :
 Sélectionnez ROM_top dans l’arborescence du projet.

 Cliquez avec le bouton droit de la souris sur l’item Generate Programming File.
 Choisissez l’onglet Process Properties du menu déroulant.
 Assurez-vous que l’item Advanced est sélectionné dans la liste Property display level
dans le bas de la boîte de dialogue.
 Sélectionnez l’item StartUp Options dans la liste Category de gauche.
 Sélectionnez l’item JTAG Clock pour le FPGA Start-Up Clock.
 Cliquez sur Ok.

Fabriquez ensuite le fichier de programmation :
 Dans l’espace Processes, double-cliquez sur l’item Generate Programming File. ISE lance
le programme intégré BitGen pour générer le fichier BIT qui servira à programmer le
FPGA.
 Consultez les messages dans la Console et assurez-vous que la création du fichier s’est
bien déroulée. Un crochet devrait s’afficher à côté de Generate Programming File

Lab 6: Mémoire RAM
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.
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.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;
 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;
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);
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;
 Le code suivant implémente une RAM synchrone à double port complet synchrone à
deux horloges.
Description du fichier RAM_2p_full.vhd
library IEEE;
entity RAM_2p_full is
Port ( clk_p1_i : in std_logic;

data_read_p1_o : out std_logic_vector(15 downto 0);
clk_p2_i : in std_logic;

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
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;
P_sync_p2: process(clk_p2_i)
begin
if clk_p2_i’event and clk_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;
1) Simulez à l’aide du testbench ces trois codes.

2) Calculez les performances des codes suivantes:
RAM_1p.vhd, RAM_2p.vhd et RAM_2p_full.vhd

VIVADO,ARTIX-7
Lab 7: Artix-7
 Arty A7: Artix-7 FPGA Development
C'une carte a base de circuit 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. 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.
Arty est une plate-forme de développement prête à l'emploi conçue autour Artix-7 ™ (FPGA) de
Xilinx. Il a été conçu spécifiquement pour être utilisé comme système de traitement souple
MicroBlaze. Lorsqu'il est utilisé dans ce contexte, Arty devient une plate-forme de traitement
incroyablement flexible, capable de s'adapter à tous les besoins de votre projet. Contrairement à
d'autres ordinateurs à carte unique, Arty n'est pas lié à un seul ensemble de périphériques de
traitement; un instant, il s'agit d'une centrale de communication remplie de UART, SPI, IIC et
Ethernet MAC, et ensuite d'un chronométreur méticuleux avec une douzaine de minuteries 32
bits. De plus, avec les en-têtes d'expansion universellement répandus (en-têtes Arduino ™ R3 et
nos en-têtes Pmod ™), Arty deviendra l'outil le plus adaptable de votre boîte à outils de projet.

Le but de ce lab est de prendre l'exemple simple du projet et de programmer notre FPGA afin
de pouvoir contrôler une seule LED avec un seul commutateur. Ensuite, nous allons prendre le
même programme et le développer pour que plusieurs commutateurs contrôlent plusieurs LED.
Le circuit numérique que nous construisons à partir du projet 1 s'appelle led_sw. Avec ce projet,
le FPGA reçoit un signal d'entrée, en l'occurrence d'un commutateur intégré, qui peut être
logique haut, «1» ou logique bas, «0». L'entrée est alors transmise directement à une DEL intégrée
qui affiche la logique correspondante en étant «allumé» (un niveau logique haut) ou «désactivé»
(un niveau logique bas). Le commutateur et le voyant intégrés sont tous deux connectés à leurs
propres ports sur le FPGA et sont spécifiés dans le fichier de contraintes (pour Vivado, il s’agit
du fichier XDC).
L'échelle de temps 1ns / 1ps de la partie échelle de temps fournit une durée de base suivie d'une
résolution temporelle minimale. D'une manière générale, ceci n'est utilisé que pendant la
simulation et si des retards sont spécifiquement implémentés dans le HDL, ce que nous ne
faisons ni l'un ni l'autre, mais qui fait néanmoins partie intégrante des modules Verilog.
La partie module
La partie assigner affecte led = sw; définit ce que fait notre «boîte noire». Plusieurs instructions
d'affectation peuvent être utilisées en fonction des besoins, ainsi que d'autres moyens de définir
ce que fait notre «boîte noire» (ce que nous verrons dans un didacticiel ultérieur).
Le module endmodule est le mot-clé qui indique la fin de notre définition du contenu de notre
module (notre boîte noire). D'autres modules pourraient alors être créés avec leur propre
ensemble d'entrées et de sorties, assigner des instructions et, bien sûr, les modules de fin.

Programmation de notre FPGA
 Ouvrez Vivado sur le premier écran et cliquez sur le bouton «Créer un nouveau projet». Si
vous avez déjà parcouru le Guide de démarrage avec Vivado, beaucoup de choses vous
seront familières (ou presque identiques). Vous pouvez suivre si vous voulez, ou si vous
sentez que vous pouvez programmer vous-même votre tableau sans le guide, n'hésitez
pas à le faire (pour confirmer que vous avez bien compris), puis passez aux multiples
commutateurs. et section de LED.
1) Sur l’écran d’ouverture, cliquez sur le bouton Créer un nouveau projet.

2) Vous rencontrerez ensuite des instructions conviviales de Xilinx sur la manière de créer un
nouveau projet. Cliquez sur Suivant.
3) Ici, nous nommerons notre projet et choisirons où enregistrer notre fichier de projet sur notre
ordinateur. Il est essentiel qu'aucun espace ne soit utilisé dans le nom du projet ou dans le chemin
du fichier dans lequel le projet est enregistré. Il est également recommandé de conserver des
noms de fichiers et des chemins de fichier relativement courts afin de ne pas atteindre
accidentellement les limites de caractères (256 caractères maximum pour un système
d'exploitation Windows). Cliquez sur Suivant.
4) Choisissez créer un projet RTL (Register Transfer Level) et maintenez la case décochée pour
que nous puissions spécifier les sources pour notre projet. Cliquez sur Suivant.
5) Cliquez sur Créer un fichier pour ajouter notre module Verilog.
6) Dans la fenêtre qui apparaît, conservez le type de fichier comme Verilog et nommez votre
module Verilog. Un nom couramment utilisé pour les modules, en particulier ceux qui appellent
et utilisent d'autres modules, est «top». Nous conserverons le fichier enregistré dans notre fichier
de projet (tel que déterminé par Vivado). Cliquez sur OK.
7) Après avoir cliquer sur Suivant dans les cœurs IP, car nous n'en avons aucun à ajouter, cliquez
sur Ajouter des fichiers sur la page Ajouter des contraintes. Les cartes Digilent disposent d’un
fichier maître XDC (Xilinx Design Constraints) disponible en annexe. Comme j'utilise l'Arty, j'ai
utilisé le Master XDC disponible sur son centre de ressources du côté droit sous «Ressources de
conception» et j'ai sauvé le mien vers un emplacement pratique sur mon ordinateur.
8) Vous aurez la possibilité de parcourir votre fichier XDC, que j'ai enregistré dans un dossier
nommé VivadoXDCfiles. Cliquez sur OK.
9) Assurez-vous que le bouton Copier les fichiers de contraintes dans le projet est coché. Cela
vous garantit de modifier ultérieurement une copie du fichier xdc principal, plutôt que le fichier
d'origine. Puis cliquez sur Suivant.
10) Ici, vous voudrez sélectionner le FPGA que vous utilisez pour vous assurer que Vivado
conçoit et programme correctement le matériel. Vous pouvez effectuer une recherche par
numéro de pièce FPGA à partir de l'onglet Pièces ou sélectionner votre tableau à partir de
l'onglet Tableaux si vous disposez d'un fichier de carte. Digilent dispose de fichiers de carte pour
chacune de leurs cartes sur GitHub; Vous pouvez suivre un tutoriel sur la façon de les installer
sur votre ordinateur ici. Une fois que vous avez choisi la pièce (ou la carte) FPGA appropriée,
cliquez sur Suivant.
11) Confirmez que votre projet a ce que vous voulez avoir (au moins au début) et cliquez sur
«Terminer».
12) Après un bref chargement, nous vous présentons un assistant de module supérieur (puisque
nous avons dit que nous créions notre propre fichier source appelé «top»). Pour ce projet, nous
voulons avoir une entrée appelée «sw» et une sortie appelée «led». Les deux étant des entrées et
des sorties simples, laissez la case de bus non cochée pour les deux. Cliquez sur OK lorsque vous
avez terminé.

13) Nous sommes enfin à l'interface graphique principale de Vivado, où nous pouvons éditer nos
fichiers sources et contraintes et éventuellement programmer le FPGA. Double-cliquez sur notre
module Verilog appelé (dans mon cas) “top.v”; par défaut, il se trouve dans la fenêtre des sources
en haut au milieu de l'interface graphique Vivado.
14) Notre module Verilog apparaîtra dans la fenêtre supérieure gauche appelée espace de travail.
Il est pré-rempli avec du code Verilog incluant l’échelle de temps requise, une section de
commentaires à des fins de documentation, notre module nommé avec les entrées et les sorties
que nous avons créées dans l’assistant, et l’instruction endmodule.
15) Maintenant, nous avons juste besoin d'ajouter la fonctionnalité de la façon dont notre module
de circuit que nous créons sur le FPGA qui a une seule entrée et une seule sortie va fonctionner.
Cela se fait en déclarant nos entrées et sorties entre le}; dans le module et le mot-clé endmodule.
Pour ce projet, nous voulons juste que l’état de la sortie (la LED) soit identique à l’état de l’entrée
(le switch), nous utiliserons donc une instruction d’affectation pour assigner l’état de la LED à
l'état du commutateur via la ligne de code suivante:
assign led = sw;
Appuyez sur Cntl + S pour enregistrer vos modifications.
16) Nous allons maintenant éditer notre fichier de contraintes. Nous pouvons trouver notre
copie du XDC dans la fenêtre des sources dans le dossier Constraints → constrs_1. Double-
cliquez dessus pour l'ouvrir dans la fenêtre de l'espace de travail.
17) Notre XDC sera visible dans la fenêtre de l’espace de travail (comme mentionné dans l’étape
ci-dessus). Comme il s’agit d’un fichier maître XDC (du moins pour moi), il ya beaucoup de
lignes de texte, nous ne voulons donc que décommenter les broches que nous utilisons et
changer le nom de la pin pour correspondre aux noms de nos entrées et sorties. module.
18) Les deux lignes que je décomment dans ce projet seront la ligne correspondant au premier
commutateur (étiqueté SW0 sur l’écran de soie de l’Arty) et la ligne correspondant à la première
LED monochrome (étiquetée LD4 sur l’écran de soie de l’Arty). l'Arty). J'ai renommé le
commutateur (broche A8 sur le FPGA) en sw et renommé la LED (broche H5 sur le FPGA) en
led. Appuyez sur Cntr + S pour enregistrer vos modifications.
19) Cliquez sur le bouton Run Synthesis (Exécuter la synthèse) situé sur le côté gauche de
l'interface graphique Vivado.
20) Un assistant apparaîtra qui vous permettra de choisir vos options de synthèse. Vous voudrez
lancer votre projet dans le répertoire local et l'exécuter sur l'hôte local (par opposition à la
génération de scripts uniquement).
En passant, toute la combinaison de la synthèse, de l'implémentation et de la génération du
bitstream pour programmer le FPGA peut prendre un peu de temps (plus de 10 minutes dans
certains cas) puisque Vivado traite une tonne de choses cachées à l'utilisateur. et fonctionne avec
tout le FPGA et pas seulement ce que nous utilisons, donc vous voudrez probablement
maximiser le nombre de travaux (les cœurs d'ordinateurs Vivado sont autorisés à utiliser) à moins
que vous envisagiez de faire beaucoup d'autres choses en même temps.
Lorsque vous êtes satisfait de vos sélections, cliquez sur OK.
21) Après avoir cliqué sur OK, vous devez attendre que la synthèse soit terminée, ce qui peut
prendre une minute ou deux, en fonction de la vitesse d'exécution de votre ordinateur.
21) Cliquez sur Exécuter l'implémentation sur le prochain assistant qui apparaît, puis cliquez sur
OK. Vous pouvez encore choisir le nombre de tâches (les cœurs que votre ordinateur utilise) si
vous n'avez pas cliqué sur la case «Ne pas afficher cette boîte de dialogue» la dernière fois.
22) Après avoir cliqué sur ok, vous devez attendre que l'implémentation se termine, ce qui peut
prendre une minute ou deux selon la vitesse d'exécution de votre ordinateur.

23) Un autre assistant apparaîtra où vous voudrez cliquer sur Generate Bitstream.
En guise de remarque, vous ne voudrez pas forcément cliquer sur la case Ne plus afficher cette
boîte de dialogue car si vous concevez un circuit que votre FPGA doit exécuter, vous voudrez
peut-être simplement vérifier si Vivado a réussi à le faire. capable de le faire par la synthèse et la
mise en œuvre. S'il y a un avertissement ou une erreur, vous ne voudriez pas générer un flux
binaire défectueux.
Après cet écran, vous pourrez choisir des options de génération de bitstream, un peu comme
pour la synthèse et l'implémentation. Lorsque vous êtes satisfait de vos sélections, cliquez sur
OK.
24) Après avoir cliqué sur ok, vous devez attendre que la génération de bitstream se termine, ce
qui peut prendre une minute ou deux selon la vitesse de votre ordinateur.
25) Cliquez sur Ouvrir le gestionnaire de matériel (Hardware Manager), puis cliquez sur OK.
26) Si votre FPGA n’est pas déjà connecté à votre ordinateur via un câble micro-USB, vous
verrez qu’aucune cible matérielle n’est ouverte en haut de l’écran. Allez-y et cliquez sur le texte
Ouvrir la cible à côté du message.
27) Assurez-vous que votre FPGA est connecté à votre ordinateur (et que les voyants
d'alimentation du FPGA s'allument lorsqu'il est connecté à votre ordinateur), puis choisissez
Connexion automatique dans le menu qui apparaît lorsque vous cliquez sur Ouvrir la cible.
28) On vous demandera ensuite de choisir le fichier bitstream que nous allons programmer avec
le FPGA; nous n'avons pas de noyau de débogage dans notre code, nous n'aurons donc rien à y
mettre.
29) Le fichier bitstream lui-même est un peu peu intuitif à trouver. Vous pouvez le trouver en
ouvrant le dossier dans lequel vous avez demandé à Vivado de sauvegarder votre projet, accédez
à <projectName> .runs, puis impliquez_1, puis choisissez le fichier .bit que vous voyez. J'ai
nommé mon module Verilog top.v, donc le fichier bit est top.bit. Puis cliquez sur OK.
30) Enfin, nous pouvons cliquer sur Program; le processus de programmation prend moins de 10
secondes pour tout ordinateur, donc il n’est pas trop difficile d’attendre

Maintenant c'est fini! La façon dont ce projet a été configuré, le premier commutateur (nommé
SW0 sur l'Arty) contrôle l'état de la première LED (appelée LD4 sur l'Arty).

VIVADO,ARTIX-7
Lab 8: Hello World avec Verilog & Vivado
Partie 1:
Pour ce lab, il vous faut:
 Digilent Arty Board

 Câble micro USB pour programmer et alimenter la carte Arty
 Xilinx Vivado installé (y compris les fichiers de la carte Digilent)
Hello World avec Verilog & Vivado

Nous allons commencer avec le monde traditionnel des cartes de développement: utiliser une
logique simple pour contrôler les LED vertes sur notre carte. Dans la deuxième partie, nous
passerons aux horloges, au comptage, à la modulation de largeur d'impulsion et aux LED RVB.
Terminologie
Avant de nous lancer dans la pratique de la création de notre premier projet, je devrais expliquer
quelques termes du titre:
Verilog est un langage de description de matériel (HDL) qui vous permet d'exprimer votre
conception à un niveau supérieur au lieu de décrire directement des portes logiques. Ceci est à
peu près analogue à la manière dont C vous permet d'exprimer votre conception de logiciel à un
niveau supérieur à celui du langage d'assemblage. Les autres HDL incluent VHDL et Chisel.
Vivado est la suite de développement FPGA de Xilinx. Il comprend tout ce dont vous avez
besoin pour écrire Verilog et programmer un FPGA Xilinx. Il n'y a pas à contourner le fait que
c'est un monstre: nécessitant environ 20 Gio d'espace disque. Heureusement, il a une version
gratuite et n'est pas trop contre-intuitif une fois que vous avez joué avec pendant un petit
moment. Vivado est disponible pour Windows et Linux mais pas pour macOS.
Arty Board

Dans cette partie, nous sommes intéressés par les quatre Leds verts (LD4-7), quatre
commutateurs (SW0-3) et quatre boutons (BTN0-3). Vous pouvez les voir vers le bas du tableau
dans la photo ci-dessus. Le FPGA lui-même est la puce carrée au milieu du tableau étiquetée
"Artix-7".
Créer un projet
1. Démarrer Vivado.
2. Sélectionnez "Créer un projet" sous "Démarrage rapide"(Quick Start).
3. Nom du projet: SE01 et assurez-vous que "Créer un sous-répertoire du projet" est
sélectionné.
4. Type de projet: "Projet RTL" et assurez-vous que "Ne pas spécifier les sources pour le
moment" est sélectionné.
5. Partie par défaut: Sélectionnez "Boards" puis choisissez "Arty" (Partie: xc7a35ticsg324-
1L). Si ce n'est pas dans la liste, vous devez quitter Vivado et installer le fichier de la carte
Arty.
6. Passez en revue le "Résumé du nouveau projet" (New Project Summary)et cliquez sur
"Terminer" (Finish).
Hello verilog
1. En haut à gauche de la fenêtre Vivado, sélectionnez "Ajouter des sources" (Add Sources
)sous "Gestionnaire de projets" (Project Manager).
2. Choisissez "Ajouter ou créer des sources de conception" et cliquez sur "Suivant".
3. Sélectionnez "Créer un fichier" au milieu de la boîte de dialogue.
4. Assurez-vous que le type de fichier est défini sur "Verilog" et nommez le fichier top.v,
puis cliquez sur "Terminer".
5. Dans la boîte de dialogue "Définir le module", cliquez sur "OK", puis sur "Oui" lorsque
vous y êtes invité.
Remplacez le contenu du module supérieur de top.v par:

La première partie du module définit les entrées et les sorties que nous utilisons:
 CLK - l'horloge à 100 MHz

 led [3: 0] - les quatre LED vertes (étiquetées LD4-7 sur la carte Arty elle-même)
 sw [3: 0] - les quatre commutateurs
reg est l'abréviation de register: vous pouvez le considérer comme définissant une variable. Cela
crée une logique pour stocker l'état de quelque chose; dans ce cas, si une LED est allumée ou
éteinte.
La deuxième partie du module est l'endroit où nous écrivons notre logique. A chaque fois que
l'horloge se déclenche, nous vérifions l'état de l'interrupteur sw [0]: s'il est éteint, nous désactivons
le led [0]; sinon nous allumons la LED. 1'b0 est un littéral d'un bit avec la valeur 0. Vous verrez
plus d'exemples de littéraux plus loin dans ce tutoriel.
Enregistrez votre fichier en appuyant sur Ctrl-S ou en utilisant le bouton Enregistrer en haut à
gauche de la fenêtre de l'éditeur (oui, cela ressemble toujours à une disquette).
Vous pouvez utiliser Ctrl + / pour (dé) commenter la ligne en cours dans la fenêtre de l'éditeur
Vivado.
Fichier de contraintes
Un FPGA est très flexible. Vous pouvez connecter différents types d'entrées et de sorties aux
centaines de broches. Avant de synthétiser notre code, nous devons dire à Vivado comment
notre carte Arty est connectée. Vivado utilise des contraintes pour cartographier une référence,
telle que la led [0], à la norme de pin et d'E / S appropriée. Les contraintes fournissent également
des détails sur la source d'horloge, CLK, qui est fondamentale pour nos conceptions.
1. En haut à gauche de la fenêtre Vivado, sélectionnez "Ajouter des sources" sous

"Gestionnaire de projets".
2. Choisissez "Ajouter ou créer des contraintes" et cliquez sur "Suivant".
3. Sélectionnez "Créer un fichier" au milieu de la boîte de dialogue.
4. Assurez-vous que le type de fichier est défini sur "XDC" et nommez le fichier arty.xdc,
puis cliquez sur "Terminer".

Sélectionnez arty.xdc dans la fenêtre de l'éditeur, ajoutez le contenu suivant, puis enregistrez le
fichier.
Nous devons suivre quatre étapes:
1. Synthesis - convertit le Verilog en portes logiques

2. Implementation - optimise et définit la conception logique du FPGA cible
3. Generate Bitstream - génère le fichier bit FPGA à partir de l'implémentation
4. Program Device - charge le fichier de bit sur le FPGA
Même sur un PC rapide, tout ce processus prend quelques minutes, alors soyez patient.
1. Cliquez sur le bouton de lecture vert en haut de l'écran Vivado.

2. Sélectionnez "Run Synthesis".
 Si une boîte de dialogue "Lancer les exécutions" apparaît, sélectionnez "Ne plus
afficher cette boîte de dialogue" et cliquez sur "OK".
 En haut à droite de votre fenêtre Vivado, vous verrez un message "Running
synth_design".
3. Une boîte de dialogue apparaîtra vous invitant à "Exécuter l'implémentation".
 Cliquez sur "OK" pour lancer l'implémentation.
4. Une boîte de dialogue apparaîtra pour indiquer "Mise en œuvre réussie".
 Sélectionnez "Générer Bitstream" et cliquez sur "OK".
5. Une boîte de dialogue apparaîtra pour indiquer que "la génération de flux binaire est
terminée avec succès".
 Sélectionnez "Ouvrir le gestionnaire de matériel" et cliquez sur "OK".
Si vous fermez accidentellement une étape, vous pouvez trouver des commandes pour exécuter
les différentes étapes sur le côté gauche de la fenêtre Vivado.
Gestionnaire de matériel (Hardware Manager)

1. Connectez votre carte Arty à votre PC en utilisant un câble micro USB.
2. En bas à gauche de Vivado, sélectionnez "Open Target" sous "Open Hardware
Manager".
3. Choisissez "Connexion automatique" dans le menu.
4. Sélectionnez "Program Device" sous "Open Hardware Manager".
5. Il devrait y avoir une option "xc7a35t_0"; Ceci est votre conseil Arty.
6. Accédez à votre fichier bitstream SE01 / SE01.runs / impl_1 / top.bit.
7. Cliquez sur "Program".
Hello LED
Faites glisser le commutateur SW0 sur votre carte pour contrôler la LED verte LD4.
Partie 2:
Cette fonctionnalité n'est pas quelque chose que vous ne pourriez pas réaliser avec un
microcontrôleur. Cependant, cela vaut la peine de réfléchir à ce que vous avez fait ici. Vous avez
utilisé une logique programmable pour créer un circuit imprimé dans le FPGA lui-même: il n'y a
pas de CPU exécutant votre code. C'est comme si vous aviez câblé le circuit avec des composants
matériels discrets.
Pour voir une représentation visuelle de votre conception, vous pouvez visualiser le design
élaboré. Vous pouvez trouver ceci sous "Analyse RTL" sur le côté gauche de la fenêtre Vivado.
Vous pouvez voir les entrées d'horloge et de commutateur aller aux LED via quatre registres, qui
contiennent la valeur pour chaque LED.
Plus de commutateurs, plus de LED

Maintenant, vous avez ce travail sur un commutateur, et une LED vous pouvez facilement
appliquer la même approche aux autres. Ce qui suit utilise deux commutateurs, chacun contrôlant
deux DEL.
NB Si vous êtes toujours dans Hardware Manager, vous pouvez revenir à votre code source
Verilog en sélectionnant "Gestionnaire de projets" en haut à gauche de la fenêtre Vivado.

Remplacez le module supérieur existant dans top.v par le suivant:
Réexécutez la synthèse, l'implémentation, la génération bitstream et programmez la carte comme

auparavant. Vous devriez pouvoir contrôler deux Leds avec chacun des deux premiers
commutateurs.
2'b définit une valeur binaire de 2 bits: nous avons deux LED qui attendent chacune un bit, donc
une valeur de deux bits est appropriée ici. Vous pouvez également voir la notation pour
sélectionner une plage des sorties LED: led [1: 0] comprend led[0] et led[1].
Nous avons également quatre boutons-poussoirs sur le tableau; nous pouvons facilement les
ajouter à notre conception.
Pour inclure les boutons de commande, vous devez les ajouter à notre fichier de contraintes.
Ouvrez arty.xdc et ajoutez les lignes suivantes au bas:
Ensuite, remplacez votre module supérieur par le suivant. Notez l'ajout des entrées de bouton
btn [3: 0], qui correspondent aux nouvelles entrées du fichier de contraintes:

Réexécutez la synthèse, l'implémentation, la génération bitstream et programmez la carte comme
auparavant.
SW0 contrôle tous les voyants, tandis que BTN0 sélectionne deux modèles de voyants différents.
Essayez vos propres combinaisons de commutateurs, boutons et voyants. Assurez-vous que vos
valeurs ont la même largeur que vos entrées et sorties, par exemple trois bits pour trois DEL: led
[3: 1] <= 3'b101;

VIVADO,ARTIX-7
Lab 9: Implémentation d'un Compteur avec Artix-7
Partie 1:
Dans ce TP nous allons realiser la simulation d’un compteur, l’énoncé qui suit va pas à pas vous
indiquer les diff érentes étapes à suivre pour réaliser cette simulation.
Figure 1. Code Compteur

Figure 2. Testbench Compteur
1. Lancer le logiciel Vivado
2. Créez le projet compteur.xpr en cliquant sur Create Project

3. Choisissez le device Artix-7 xca35tcsg324-1
4. Ajouter le nom code compteur et tapez le code de la Figure 1
5. Ajouter le nom code Testcompteur et tapez le code de testbench de la Figure 2

 Avant de configurer un FPGA avec un systeme numérique préalablement décrit en
´VHDL, il est necessaire d’en faire une simulation afin de détecter les erreurs. C’est ce
que nous allons faire ici.
 Dans le dossier Simulation Sources double-cliquez sur le fichier TestCompteur.vhd Ce

fichier contient un code VHDL permettant de tester le compteur decrit dans le ´ fichier
compteur.vhd. Vous allez analyser le contenu de ce fichier :
(a) Q2: Identifiez les lignes ou le compteur a tester est instancié.
(b) Pour genérer des stimuli envoyés au compteur, nous utilisons la construction process.
Un process permet de decrire un processus séquentiel.
i. Q3: Combien de process sont utilises ? Quel est le role de chaque process ?
ii. Q4: Quelle est la clause VHDL utilisee pour mettre des points d’arrétˆ dans les process ?
6. Ajouter le fichier de contrainte compteur.xdc avant Generate Bitstream

7. Cliquez deux fois sur Generate Bitstream
7. Branchez le Artix-7 avec ton PC Cliquez deux fois sur Program Device

8. Ajoutez le fichier compteur.bit

9. Vérifiez le bon fonctionnement de Artix -7 avec la logique de code
Partie 2:
Il est parfois utile de pouvoir observer les signaux internes du FPGA en temps réel comme si on
utilisait un analyseur logique. Chez Xilinx, il existe un outil d’analyse qui utilise la liaison JTAG à
cet effet, c’est Vivado Analyzer. Il existe plusieurs méthodes pour l’utiliser : certaines nécessitent
la modification du code VHDL, d’autres sont totalement transparentes. Nous allons utiliser la
plus simple (sans modification du code VHDL).
C’est une méthode utile pour la mise au point mais elle consomme des ressources du FPGA
(notamment de la mémoire) et peut perturber le placement routage et donc le respect des
contraintes de timing. Dans le design final, il faut retirer ces outils d’analyse. Le but de ce TP est
de vous montrer l’utilisation de l’analyseur logique utilisable dans le FPGA (ILA : Integrated
Logic Analyzer) et configurable depuis Vivado. Cet analyseur vous permettra de réaliser la mise
au point de votre design directement dans le FPGA. Cela vous permettra de trouver des erreurs
impossibles à voir en simulation. En utilisant l’analyseur intégré ILA, vous pourrez voir
l’évolution des signaux internes de votre design dans le FPGA, donc en temps réel, sans modifier
votre code VHDL. Pour cela, Vivado doit insérer un composant (core) ILA après synthèse.
Fermez le Hardware Manager. Après synthèse, de nombreuses options sont apparues dans le
navigateur. Cliquez sur « Open Synthesized Design » :
La fenêtre Synthesized Design (design après synthèse) apparaît. Par défaut, elle montre
généralement l’intérieur du FPGA ce qui ne nous intéresse pas. Pour obtenir un schéma du
design synthétisé, sélectionnez le menu :

Puis cliquez sur Debug :
Le schéma du design apparaît à droite et les signaux internes à gauche (dans Nets) :
Pour zoomer sur le schéma, il suffit de cliquer en haut et à gauche de la zone à sélectionner, de
tirer vers le bas et à droite, puis de relacher le bouton de la souris :
ATTENTION : les signaux que vous voyez ici sont les signaux après synthèse et pas ceux déclarés dans votre
design. Le synthétiseur a optimisé le design et supprimé (ou fusionné) les signaux qu’il a estimé inutiles. Par

exemple, tous les signaux non utilisés (y compris ceux non connectés à l’extérieur du design) seront supprimés par
défaut. Normalement, les signaux utiles placés en sorties d’une bascule D persistent après synthèse. C’est pour cela
que nous avons resynchronisé le reset sur l’horloge clk100 et mis des reset synchrones dans tous les composants.
De ce fait, la sélection des signaux à debugger n’est pas toujours évidente car leur nom peut
changer. Nous allons utiliser le schéma pour nous aider. Par exemple, à la sortie du composant
reset_sync, vous pouvez sélectionner le signal sreset qui apparaît alors surligné dans la fenêtre
Netlist puis faire un clic droit et cliquer sur « Mark Debug » :

VIVADO,ARTIX-7
Lab 10: Implémentation Arty Pmod VGA
Description
Ce simple projet de démonstration VGA démontre l'utilisation d'un VGA Pmod connecté aux
ports Pmod de l'Arty. Le comportement est le suivant:
 Une boîte rebondissante et des barres de couleurs noir, blanc et multiples sont affichées
sur un moniteur VGA connecté.
 Le VGA Pmod est contrôlé par l'Arty via les ports Pmod JB et JC.
 La résolution de l'écran est configurable via le code HDL.
Conditions préalables
Matériel
 Arty FPGA board
 Pmod VGA
 Câble micro-USB

 Moniteur VGA et câble
Logiciel
 Vivado Design Suite
Des versions plus récentes peuvent être utilisées, mais la procédure peut varier légèrement
Téléchargez et lancez la démo Arty Pmod VGA

https://github.com/Digilent/Arty-Pmod-VGA/releases/download/v2016.4-2/Arty-Pmod-VGA-2016.4-2.zip
1) Suivez le didacticiel Utiliser les projets de démonstration Github de Digilent. Il s’agit d’un
projet de conception HDL et, en tant que tel, ne prend pas en charge le SDK Vivado,
sélectionnez les options de didacticiel appropriées pour une conception uniquement
Vivado. Revenez à ce guide lorsque vous êtes invité à vérifier la configuration matérielle
et la configuration requises.
2) Une fois que vous avez généré votre fichier bit, assurez-vous que votre VGA Pmod est
branché sur les ports Pmod de votre Arty, JB et JC. Utilisez un câble VGA pour
connecter le Pmod VGA au port VGA de votre moniteur. Retournez au didacticiel
Github Projects pour terminer la programmation de votre tableau.

ANNEXES
ANNEXE 1: Master UCF Listing KC705 Board UCF Listing
NET SFP_TX_DISABLE LOC = Y20 | IOSTANDARD=LVCMOS25; # Bank 12 VCCO - VADJ_FPGA - IO_0_12

NET USER_SMA_GPIO_P LOC = Y23 | IOSTANDARD=LVCMOS25; # Bank 12 VCCO - VADJ_FPGA - IO_L1P_T0_12
NET USER_SMA_GPIO_N LOC = Y24 | IOSTANDARD=LVCMOS25; # Bank 12 VCCO - VADJ_FPGA - IO_L1N_T0_12
NET SDIO_SDWP LOC = Y21 | IOSTANDARD=LVCMOS25; # Bank 12 VCCO - VADJ_FPGA - IO_L2P_T0_12
NET SDIO_SDDET LOC = AA21 | IOSTANDARD=LVCMOS25; # Bank 12 VCCO - VADJ_FPGA - IO_L2N_T0_12
NET SDIO_CMD_LS LOC = AB22 | IOSTANDARD=LVCMOS25; # Bank 12 VCCO - VADJ_FPGA - IO_L3P_T0_DQS_12
NET SDIO_CLK_LS LOC = AB23 | IOSTANDARD=LVCMOS25; # Bank 12 VCCO - VADJ_FPGA - IO_L3N_T0_DQS_12
NET SDIO_DAT2_LS LOC = AA22 | IOSTANDARD=LVCMOS25; # Bank 12 VCCO - VADJ_FPGA - IO_L4P_T0_12
NET SDIO_DAT1_LS LOC = AA23 | IOSTANDARD=LVCMOS25; # Bank 12 VCCO - VADJ_FPGA - IO_L4N_T0_12
NET SDIO_DAT0_LS LOC = AC20 | IOSTANDARD=LVCMOS25; # Bank 12 VCCO - VADJ_FPGA - IO_L5P_T0_12
NET SDIO_CD_DAT3_LS LOC = AC21 | IOSTANDARD=LVCMOS25; # Bank 12 VCCO - VADJ_FPGA - IO_L5N_T0_12
NET FMC_LPC_LA12_P LOC = AA20 | IOSTANDARD=LVCMOS25; # Bank 12 VCCO - VADJ_FPGA - IO_L6P_T0_12
NET FMC_LPC_LA12_N LOC = AB20 | IOSTANDARD=LVCMOS25; # Bank 12 VCCO - VADJ_FPGA - IO_L6N_T0_VREF_12
NET FMC_LPC_LA13_P LOC = AB24 | IOSTANDARD=LVCMOS25; # Bank 12 VCCO - VADJ_FPGA - IO_L7P_T1_12
NET FMC_LPC_LA13_N LOC = AC25 | IOSTANDARD=LVCMOS25; # Bank 12 VCCO - VADJ_FPGA - IO_L7N_T1_12
NET FMC_LPC_LA16_P LOC = AC22 | IOSTANDARD=LVCMOS25; # Bank 12 VCCO - VADJ_FPGA - IO_L8P_T1_12
NET FMC_LPC_LA16_N LOC = AD22 | IOSTANDARD=LVCMOS25; # Bank 12 VCCO - VADJ_FPGA - IO_L8N_T1_12
NET FMC_LPC_LA15_P LOC = AC24 | IOSTANDARD=LVCMOS25; # Bank 12 VCCO - VADJ_FPGA - IO_L9P_T1_DQS_12
NET FMC_LPC_LA15_N LOC = AD24 | IOSTANDARD=LVCMOS25; # Bank 12 VCCO - VADJ_FPGA - IO_L9N_T1_DQS_12
NET FMC_LPC_LA14_P LOC = AD21 | IOSTANDARD=LVCMOS25; # Bank 12 VCCO - VADJ_FPGA - IO_L10P_T1_12
NET FMC_LPC_LA14_N LOC = AE21 | IOSTANDARD=LVCMOS25; # Bank 12 VCCO - VADJ_FPGA - IO_L10N_T1_12
NET FMC_LPC_LA01_CC_P LOC = AE23 | IOSTANDARD=LVCMOS25; # Bank 12 VCCO - VADJ_FPGA - IO_L11P_T1_SRCC_12
NET FMC_LPC_LA01_CC_N LOC = AF23 | IOSTANDARD=LVCMOS25; # Bank 12 VCCO - VADJ_FPGA - IO_L11N_T1_SRCC_12
NET FMC_LPC_LA00_CC_P LOC = AD23 | IOSTANDARD=LVCMOS25; # Bank 12 VCCO - VADJ_FPGA - IO_L12P_T1_MRCC_12
NET FMC_LPC_LA00_CC_N LOC = AE24 | IOSTANDARD=LVCMOS25; # Bank 12 VCCO - VADJ_FPGA - IO_L12N_T1_MRCC_12
NET FMC_LPC_CLK0_M2C_P LOC = AF22 | IOSTANDARD=LVCMOS25; # Bank 12 VCCO - VADJ_FPGA - IO_L13P_T2_MRCC_12
NET FMC_LPC_CLK0_M2C_N LOC = AG23 | IOSTANDARD=LVCMOS25; # Bank 12 VCCO - VADJ_FPGA - IO_L13N_T2_MRCC_12
NET SI5326_INT_ALM_LS LOC = AG24 | IOSTANDARD=LVCMOS25; # Bank 12 VCCO - VADJ_FPGA - IO_L14P_T2_SRCC_12
NET HDMI_INT LOC = AH24 | IOSTANDARD=LVCMOS25; # Bank 12 VCCO - VADJ_FPGA - IO_L14N_T2_SRCC_12
NET FMC_LPC_LA10_P LOC = AJ24 | IOSTANDARD=LVCMOS25; # Bank 12 VCCO - VADJ_FPGA - IO_L15P_T2_DQS_12
NET FMC_LPC_LA10_N LOC = AK25 | IOSTANDARD=LVCMOS25; # Bank 12 VCCO - VADJ_FPGA - IO_L15N_T2_DQS_12
NET FMC_LPC_LA11_P LOC = AE25 | IOSTANDARD=LVCMOS25; # Bank 12 VCCO - VADJ_FPGA - IO_L16P_T2_12
NET FMC_LPC_LA11_N LOC = AF25 | IOSTANDARD=LVCMOS25; # Bank 12 VCCO - VADJ_FPGA - IO_L16N_T2_12
NET FMC_LPC_LA09_P LOC = AK23 | IOSTANDARD=LVCMOS25; # Bank 12 VCCO - VADJ_FPGA - IO_L17P_T2_12
NET FMC_LPC_LA09_N LOC = AK24 | IOSTANDARD=LVCMOS25; # Bank 12 VCCO - VADJ_FPGA - IO_L17N_T2_12
NET FMC_LPC_LA07_P LOC = AG25 | IOSTANDARD=LVCMOS25; # Bank 12 VCCO - VADJ_FPGA - IO_L18P_T2_12
NET FMC_LPC_LA07_N LOC = AH25 | IOSTANDARD=LVCMOS25; # Bank 12 VCCO - VADJ_FPGA - IO_L18N_T2_12
NET FMC_LPC_LA02_P LOC = AF20 | IOSTANDARD=LVCMOS25; # Bank 12 VCCO - VADJ_FPGA - IO_L19P_T3_12
NET FMC_LPC_LA02_N LOC = AF21 | IOSTANDARD=LVCMOS25; # Bank 12 VCCO - VADJ_FPGA - IO_L19N_T3_VREF_12
NET FMC_LPC_LA08_P LOC = AJ22 | IOSTANDARD=LVCMOS25; # Bank 12 VCCO - VADJ_FPGA - IO_L21P_T3_DQS_12
NET FMC_LPC_LA08_N LOC = AJ23 | IOSTANDARD=LVCMOS25; # Bank 12 VCCO - VADJ_FPGA - IO_L21N_T3_DQS_12
NET FMC_LPC_LA04_P LOC = AH21 | IOSTANDARD=LVCMOS25; # Bank 12 VCCO - VADJ_FPGA - IO_L23P_T3_12
NET FMC_LPC_LA04_N LOC = AJ21 | IOSTANDARD=LVCMOS25; # Bank 12 VCCO - VADJ_FPGA - IO_L23N_T3_12
NET FMC_LPC_LA06_P LOC = AK20 | IOSTANDARD=LVCMOS25; # Bank 12 VCCO - VADJ_FPGA - IO_L24P_T3_12
NET SI5326_RST_LS LOC = AE20 | IOSTANDARD=LVCMOS25; # Bank 12 VCCO - VADJ_FPGA - IO_25_12
NET ROTARY_INCB LOC = Y25 | IOSTANDARD=LVCMOS25; # Bank 13 VCCO - VADJ_FPGA - IO_0_13
NET ROTARY_INCA LOC = Y26 | IOSTANDARD=LVCMOS25; # Bank 13 VCCO - VADJ_FPGA - IO_L1P_T0_13
NET ROTARY_PUSH LOC = AA26 | IOSTANDARD=LVCMOS25; # Bank 13 VCCO - VADJ_FPGA - IO_L1N_T0_13
NET REC_CLOCK_C_P LOC = W27 | IOSTANDARD=LVDS_25; # Bank 13 VCCO - VADJ_FPGA - IO_L2P_T0_13
NET REC_CLOCK_C_N LOC = W28 | IOSTANDARD=LVDS_25; # Bank 13 VCCO - VADJ_FPGA - IO_L2N_T0_13
NET GPIO_DIP_SW3 LOC = Y28 | IOSTANDARD=LVCMOS25; # Bank 13 VCCO - VADJ_FPGA - IO_L3P_T0_DQS_13
NET GPIO_DIP_SW2 LOC = AA28 | IOSTANDARD=LVCMOS25; # Bank 13 VCCO - VADJ_FPGA - IO_L3N_T0_DQS_13
NET GPIO_DIP_SW1 LOC = W29 | IOSTANDARD=LVCMOS25; # Bank 13 VCCO - VADJ_FPGA - IO_L4P_T0_13
NET GPIO_DIP_SW0 LOC = Y29 | IOSTANDARD=LVCMOS25; # Bank 13 VCCO - VADJ_FPGA - IO_L4N_T0_13
NET XADC_GPIO_3 LOC = AA27 | IOSTANDARD=LVCMOS25; # Bank 13 VCCO - VADJ_FPGA - IO_L5P_T0_13
NET XADC_GPIO_2 LOC = AB28 | IOSTANDARD=LVCMOS25; # Bank 13 VCCO - VADJ_FPGA - IO_L5N_T0_13
NET XADC_GPIO_1 LOC = AA25 | IOSTANDARD=LVCMOS25; # Bank 13 VCCO - VADJ_FPGA - IO_L6P_T0_13
NET XADC_GPIO_0 LOC = AB25 | IOSTANDARD=LVCMOS25; # Bank 13 VCCO - VADJ_FPGA - IO_L6N_T0_VREF_13
NET FMC_LPC_LA33_N LOC = AC30 | IOSTANDARD=LVCMOS25; # Bank 13 VCCO - VADJ_FPGA - IO_L7N_T1_13
NET FMC_LPC_LA32_P LOC = Y30 | IOSTANDARD=LVCMOS25; # Bank 13 VCCO - VADJ_FPGA - IO_L8P_T1_13
NET FMC_LPC_LA32_N LOC = AA30 | IOSTANDARD=LVCMOS25; # Bank 13 VCCO - VADJ_FPGA - IO_L8N_T1_13
NET FMC_LPC_LA31_P LOC = AD29 | IOSTANDARD=LVCMOS25; # Bank 13 VCCO - VADJ_FPGA - IO_L9P_T1_DQS_13
NET FMC_LPC_LA31_N LOC = AE29 | IOSTANDARD=LVCMOS25; # Bank 13 VCCO - VADJ_FPGA - IO_L9N_T1_DQS_13
NET FMC_LPC_LA30_P LOC = AB29 | IOSTANDARD=LVCMOS25; # Bank 13 VCCO - VADJ_FPGA - IO_L10P_T1_13
NET FMC_LPC_LA30_N LOC = AB30 | IOSTANDARD=LVCMOS25; # Bank 13 VCCO - VADJ_FPGA - IO_L10N_T1_13
NET FMC_LPC_LA18_CC_P LOC = AD27 | IOSTANDARD=LVCMOS25; # Bank 13 VCCO - VADJ_FPGA - IO_L11P_T1_SRCC_13
NET FMC_LPC_LA18_CC_N LOC = AD28 | IOSTANDARD=LVCMOS25; # Bank 13 VCCO - VADJ_FPGA - IO_L11N_T1_SRCC_13
NET FMC_LPC_LA17_CC_P LOC = AB27 | IOSTANDARD=LVCMOS25; # Bank 13 VCCO - VADJ_FPGA - IO_L12P_T1_MRCC_13
NET FMC_LPC_LA17_CC_N LOC = AC27 | IOSTANDARD=LVCMOS25; # Bank 13 VCCO - VADJ_FPGA - IO_L12N_T1_MRCC_13
NET FMC_LPC_CLK1_M2C_P LOC = AG29 | IOSTANDARD=LVCMOS25; # Bank 13 VCCO - VADJ_FPGA - IO_L13P_T2_MRCC_13
NET FMC_LPC_CLK1_M2C_N LOC = AH29 | IOSTANDARD=LVCMOS25; # Bank 13 VCCO - VADJ_FPGA - IO_L13N_T2_MRCC_13
NET FMC_LPC_LA29_P LOC = AE28 | IOSTANDARD=LVCMOS25; # Bank 13 VCCO - VADJ_FPGA - IO_L14P_T2_SRCC_13
NET FMC_LPC_LA29_N LOC = AF28 | IOSTANDARD=LVCMOS25; # Bank 13 VCCO - VADJ_FPGA - IO_L14N_T2_SRCC_13
NET FMC_LPC_LA26_P LOC = AK29 | IOSTANDARD=LVCMOS25; # Bank 13 VCCO - VADJ_FPGA - IO_L15P_T2_DQS_13
NET FMC_LPC_LA26_N LOC = AK30 | IOSTANDARD=LVCMOS25; # Bank 13 VCCO - VADJ_FPGA - IO_L15N_T2_DQS_13
NET FMC_LPC_LA28_P LOC = AE30 | IOSTANDARD=LVCMOS25; # Bank 13 VCCO - VADJ_FPGA - IO_L16P_T2_13
NET FMC_LPC_LA27_P LOC = AJ28 | IOSTANDARD=LVCMOS25; # Bank 13 VCCO - VADJ_FPGA - IO_L17P_T2_13
NET FMC_LPC_LA27_N LOC = AJ29 | IOSTANDARD=LVCMOS25; # Bank 13 VCCO - VADJ_FPGA - IO_L17N_T2_13
NET FMC_LPC_LA25_N LOC = AD26 | IOSTANDARD=LVCMOS25; # Bank 13 VCCO - VADJ_FPGA - IO_L19N_T3_VREF_13
NET FMC_LPC_LA21_P LOC = AG27 | IOSTANDARD=LVCMOS25; # Bank 13 VCCO - VADJ_FPGA - IO_L21P_T3_DQS_13
NET FMC_LPC_LA21_N LOC = AG28 | IOSTANDARD=LVCMOS25; # Bank 13 VCCO - VADJ_FPGA - IO_L21N_T3_DQS_13
NET FMC_LPC_LA23_P LOC = AH26 | IOSTANDARD=LVCMOS25; # Bank 13 VCCO - VADJ_FPGA - IO_L22P_T3_13
NET FMC_LPC_LA20_P LOC = AF26 | IOSTANDARD=LVCMOS25; # Bank 13 VCCO - VADJ_FPGA - IO_L23P_T3_13
NET GPIO_LED_4_LS LOC = AE26 | IOSTANDARD=LVCMOS25; # Bank 13 VCCO - VADJ_FPGA - IO_25_13
NET PHY_RXD4 LOC = R19 | IOSTANDARD=LVCMOS25; # Bank 14 VCCO - VCC2V5_FPGA - IO_0_14
NET FLASH_D0 LOC = P24 | IOSTANDARD=LVCMOS25; # Bank 14 VCCO - VCC2V5_FPGA - IO_L1P_T0_D00_MOSI_14
NET FLASH_D1 LOC = R25 | IOSTANDARD=LVCMOS25; # Bank 14 VCCO - VCC2V5_FPGA - IO_L1N_T0_D01_DIN_14
NET FLASH_D2 LOC = R20 | IOSTANDARD=LVCMOS25; # Bank 14 VCCO - VCC2V5_FPGA - IO_L2P_T0_D02_14
NET FLASH_D3 LOC = R21 | IOSTANDARD=LVCMOS25; # Bank 14 VCCO - VCC2V5_FPGA - IO_L2N_T0_D03_14
NET PHY_MDC LOC = R23 | IOSTANDARD=LVCMOS25; # Bank 14 VCCO - VCC2V5_FPGA - IO_L3P_T0_DQS_PUDC_B_14
NET FPGA_EMCCLK LOC = R24 | IOSTANDARD=LVCMOS25; # Bank 14 VCCO - VCC2V5_FPGA - IO_L3N_T0_DQS_EMCCLK_14
NET FLASH_D4 LOC = T20 | IOSTANDARD=LVCMOS25; # Bank 14 VCCO - VCC2V5_FPGA - IO_L4P_T0_D04_14

NET FLASH_D5 LOC = T21 | IOSTANDARD=LVCMOS25; # Bank 14 VCCO - VCC2V5_FPGA - IO_L4N_T0_D05_14
NET FLASH_D6 LOC = T22 | IOSTANDARD=LVCMOS25; # Bank 14 VCCO - VCC2V5_FPGA - IO_L5P_T0_D06_14
NET FLASH_D7 LOC = T23 | IOSTANDARD=LVCMOS25; # Bank 14 VCCO - VCC2V5_FPGA - IO_L5N_T0_D07_14
NET FPGA_FCS LOC = U19 | IOSTANDARD=LVCMOS25; # Bank 14 VCCO - VCC2V5_FPGA - IO_L6P_T0_FCS_B_14
NET FLASH_D8 LOC = U20 | IOSTANDARD=LVCMOS25; # Bank 14 VCCO - VCC2V5_FPGA - IO_L6N_T0_D08_VREF_14
NET FLASH_D9 LOC = P29 | IOSTANDARD=LVCMOS25; # Bank 14 VCCO - VCC2V5_FPGA - IO_L7P_T1_D09_14
NET FLASH_D12 LOC = P28 | IOSTANDARD=LVCMOS25; # Bank 14 VCCO - VCC2V5_FPGA - IO_L8N_T1_D12_14
NET PHY_CRS LOC = R30 | IOSTANDARD=LVCMOS25; # Bank 14 VCCO - VCC2V5_FPGA - IO_L9P_T1_DQS_14
NET FLASH_D13 LOC = T30 | IOSTANDARD=LVCMOS25; # Bank 14 VCCO - VCC2V5_FPGA - IO_L9N_T1_DQS_D13_14
NET PHY_RXCTL_RXDV LOC = R28 | IOSTANDARD=LVCMOS25; # Bank 14 VCCO - VCC2V5_FPGA - IO_L11P_T1_SRCC_14
NET PHY_RXD7 LOC = T28 | IOSTANDARD=LVCMOS25; # Bank 14 VCCO - VCC2V5_FPGA - IO_L11N_T1_SRCC_14
NET PHY_RXD6 LOC = T26 | IOSTANDARD=LVCMOS25; # Bank 14 VCCO - VCC2V5_FPGA - IO_L12P_T1_MRCC_14
NET PHY_RXD5 LOC = T27 | IOSTANDARD=LVCMOS25; # Bank 14 VCCO - VCC2V5_FPGA - IO_L12N_T1_MRCC_14
NET PHY_RXCLK LOC = U27 | IOSTANDARD=LVCMOS25; # Bank 14 VCCO - VCC2V5_FPGA - IO_L13P_T2_MRCC_14
NET PHY_RXD3 LOC = U28 | IOSTANDARD=LVCMOS25; # Bank 14 VCCO - VCC2V5_FPGA - IO_L13N_T2_MRCC_14
NET PHY_RXD2 LOC = T25 | IOSTANDARD=LVCMOS25; # Bank 14 VCCO - VCC2V5_FPGA - IO_L14P_T2_SRCC_14
NET PHY_RXD1 LOC = U25 | IOSTANDARD=LVCMOS25; # Bank 14 VCCO - VCC2V5_FPGA - IO_L14N_T2_SRCC_14
NET FLASH_WAIT LOC = U29 | IOSTANDARD=LVCMOS25; # Bank 14 VCCO - VCC2V5_FPGA - IO_L15P_T2_DQS_RDWR_B_14
NET PHY_RXD0 LOC = U30 | IOSTANDARD=LVCMOS25; # Bank 14 VCCO - VCC2V5_FPGA - IO_L15N_T2_DQS_DOUT_CSO_B_14
NET PHY_RXER LOC = V26 | IOSTANDARD=LVCMOS25; # Bank 14 VCCO - VCC2V5_FPGA - IO_L16P_T2_CSI_B_14
NET FLASH_A15 LOC = V27 | IOSTANDARD=LVCMOS25; # Bank 14 VCCO - VCC2V5_FPGA - IO_L16N_T2_A15_D31_14
NET FLASH_A14 LOC = V29 | IOSTANDARD=LVCMOS25; # Bank 14 VCCO - VCC2V5_FPGA - IO_L17P_T2_A14_D30_14
NET FLASH_A11 LOC = W26 | IOSTANDARD=LVCMOS25; # Bank 14 VCCO - VCC2V5_FPGA - IO_L18N_T2_A11_D27_14
NET FLASH_A9 LOC = V20 | IOSTANDARD=LVCMOS25; # Bank 14 VCCO - VCC2V5_FPGA - IO_L19N_T3_A09_D25_VREF_14
NET FLASH_A8 LOC = W23 | IOSTANDARD=LVCMOS25; # Bank 14 VCCO - VCC2V5_FPGA - IO_L20P_T3_A08_D24_14
NET SM_FAN_TACH LOC = U22 | IOSTANDARD=LVCMOS25; # Bank 14 VCCO - VCC2V5_FPGA - IO_L21P_T3_DQS_14
NET FLASH_A6 LOC = U23 | IOSTANDARD=LVCMOS25; # Bank 14 VCCO - VCC2V5_FPGA - IO_L21N_T3_DQS_A06_D22_14
NET FLASH_A3 LOC = U24 | IOSTANDARD=LVCMOS25; # Bank 14 VCCO - VCC2V5_FPGA - IO_L23P_T3_A03_D19_14
NET FLASH_A1 LOC = W21 | IOSTANDARD=LVCMOS25; # Bank 14 VCCO - VCC2V5_FPGA - IO_L24P_T3_A01_D17_14
NET PHY_COL LOC = W19 | IOSTANDARD=LVCMOS25; # Bank 14 VCCO - VCC2V5_FPGA - IO_25_14
NET USB_TX LOC = M19 | IOSTANDARD=LVCMOS25; # Bank 15 VCCO - VCC2V5_FPGA - IO_0_15
NET XADC_VAUX0P_R LOC = J23 | IOSTANDARD=LVCMOS25; # Bank 15 VCCO - VCC2V5_FPGA - IO_L1P_T0_AD0P_15
NET XADC_VAUX0N_R LOC = J24 | IOSTANDARD=LVCMOS25; # Bank 15 VCCO - VCC2V5_FPGA - IO_L1N_T0_AD0N_15
NET XADC_VAUX8P_R LOC = L22 | IOSTANDARD=LVCMOS25; # Bank 15 VCCO - VCC2V5_FPGA - IO_L2P_T0_AD8P_15
NET XADC_VAUX8N_R LOC = L23 | IOSTANDARD=LVCMOS25; # Bank 15 VCCO - VCC2V5_FPGA - IO_L2N_T0_AD8N_15
NET USB_RTS LOC = K23 | IOSTANDARD=LVCMOS25; # Bank 15 VCCO - VCC2V5_FPGA - IO_L3P_T0_DQS_AD1P_15
NET USB_RX LOC = K24 | IOSTANDARD=LVCMOS25; # Bank 15 VCCO - VCC2V5_FPGA - IO_L3N_T0_DQS_AD1N_15
NET IIC_SDA_MAIN LOC = L21 | IOSTANDARD=LVCMOS25; # Bank 15 VCCO - VCC2V5_FPGA - IO_L4P_T0_AD9P_15
NET IIC_SCL_MAIN LOC = K21 | IOSTANDARD=LVCMOS25; # Bank 15 VCCO - VCC2V5_FPGA - IO_L4N_T0_AD9N_15
NET PHY_MDIO LOC = J21 | IOSTANDARD=LVCMOS25; # Bank 15 VCCO - VCC2V5_FPGA - IO_L5P_T0_AD2P_15
NET FMC_LPC_PRSNT_M2C_B_LS LOC = J22 | IOSTANDARD=LVCMOS25; # Bank 15 VCCO - VCC2V5_FPGA - IO_L5N_T0_AD2N_15
NET FMC_HPC_PRSNT_M2C_B_LS LOC = M20 | IOSTANDARD=LVCMOS25; # Bank 15 VCCO - VCC2V5_FPGA - IO_L6P_T0_15
NET PHY_RESET LOC = L20 | IOSTANDARD=LVCMOS25; # Bank 15 VCCO - VCC2V5_FPGA - IO_L6N_T0_VREF_15
NET FMC_HPC_PG_M2C_LS LOC = J29 | IOSTANDARD=LVCMOS25; # Bank 15 VCCO - VCC2V5_FPGA - IO_L7P_T1_AD10P_15
NET FMC_C2M_PG_LS LOC = H29 | IOSTANDARD=LVCMOS25; # Bank 15 VCCO - VCC2V5_FPGA - IO_L7N_T1_AD10N_15
NET FMC_VADJ_ON_B_LS LOC = J27 | IOSTANDARD=LVCMOS25; # Bank 15 VCCO - VCC2V5_FPGA - IO_L8P_T1_AD3P_15
NET PHY_TXD7 LOC = J28 | IOSTANDARD=LVCMOS25; # Bank 15 VCCO - VCC2V5_FPGA - IO_L8N_T1_AD3N_15
NET PHY_TXD6 LOC = L30 | IOSTANDARD=LVCMOS25; # Bank 15 VCCO - VCC2V5_FPGA - IO_L9P_T1_DQS_AD11P_15
NET PHY_TXC_GTXCLK LOC = K30 | IOSTANDARD=LVCMOS25; # Bank 15 VCCO - VCC2V5_FPGA - IO_L9N_T1_DQS_AD11N_15
NET PHY_TXD5 LOC = K26 | IOSTANDARD=LVCMOS25; # Bank 15 VCCO - VCC2V5_FPGA - IO_L10P_T1_AD4P_15
NET PHY_TXD4 LOC = J26 | IOSTANDARD=LVCMOS25; # Bank 15 VCCO - VCC2V5_FPGA - IO_L10N_T1_AD4N_15
NET SM_FAN_PWM LOC = L26 | IOSTANDARD=LVCMOS25; # Bank 15 VCCO - VCC2V5_FPGA - IO_L11P_T1_SRCC_AD12P_15
NET USB_CTS LOC = L27 | IOSTANDARD=LVCMOS25; # Bank 15 VCCO - VCC2V5_FPGA - IO_L11N_T1_SRCC_AD12N_15
NET USER_SMA_CLOCK_P LOC = L25 | IOSTANDARD=LVDS_25; # Bank 15 VCCO - VCC2V5_FPGA - IO_L12P_T1_MRCC_AD5P_15
NET USER_SMA_CLOCK_N LOC = K25 | IOSTANDARD=LVDS_25; # Bank 15 VCCO - VCC2V5_FPGA - IO_L12N_T1_MRCC_AD5N_15
NET USER_CLOCK_P LOC = K28 | IOSTANDARD=LVDS_25; # Bank 15 VCCO - VCC2V5_FPGA - IO_L13P_T2_MRCC_15
NET USER_CLOCK_N LOC = K29 | IOSTANDARD=LVDS_25; # Bank 15 VCCO - VCC2V5_FPGA - IO_L13N_T2_MRCC_15
NET PHY_TXCLK LOC = M28 | IOSTANDARD=LVCMOS25; # Bank 15 VCCO - VCC2V5_FPGA - IO_L14P_T2_SRCC_15
NET PHY_TXD3 LOC = L28 | IOSTANDARD=LVCMOS25; # Bank 15 VCCO - VCC2V5_FPGA - IO_L14N_T2_SRCC_15
NET PHY_TXD2 LOC = M29 | IOSTANDARD=LVCMOS25; # Bank 15 VCCO - VCC2V5_FPGA - IO_L15P_T2_DQS_15
NET FLASH_ADV_B LOC = M30 | IOSTANDARD=LVCMOS25; # Bank 15 VCCO - VCC2V5_FPGA - IO_L15N_T2_DQS_ADV_B_15
NET PHY_TXD0 LOC = N27 | IOSTANDARD=LVCMOS25; # Bank 15 VCCO - VCC2V5_FPGA - IO_L16P_T2_A28_15
NET PHY_TXCTL_TXEN LOC = M27 | IOSTANDARD=LVCMOS25; # Bank 15 VCCO - VCC2V5_FPGA - IO_L16N_T2_A27_15
NET PHY_TXER LOC = N29 | IOSTANDARD=LVCMOS25; # Bank 15 VCCO - VCC2V5_FPGA - IO_L17P_T2_A26_15
NET PHY_INT LOC = N30 | IOSTANDARD=LVCMOS25; # Bank 15 VCCO - VCC2V5_FPGA - IO_L17N_T2_A25_15
NET PHY_TXD1 LOC = N25 | IOSTANDARD=LVCMOS25; # Bank 15 VCCO - VCC2V5_FPGA - IO_L18P_T2_A24_15
NET FLASH_A23 LOC = N26 | IOSTANDARD=LVCMOS25; # Bank 15 VCCO - VCC2V5_FPGA - IO_L18N_T2_A23_15
NET FLASH_A22 LOC = N19 | IOSTANDARD=LVCMOS25; # Bank 15 VCCO - VCC2V5_FPGA - IO_L19P_T3_A22_15
NET FLASH_A21 LOC = N20 | IOSTANDARD=LVCMOS25; # Bank 15 VCCO - VCC2V5_FPGA - IO_L19N_T3_A21_VREF_15
NET FLASH_A20 LOC = N21 | IOSTANDARD=LVCMOS25; # Bank 15 VCCO - VCC2V5_FPGA - IO_L20P_T3_A20_15
NET FLASH_A19 LOC = N22 | IOSTANDARD=LVCMOS25; # Bank 15 VCCO - VCC2V5_FPGA - IO_L20N_T3_A19_15
NET IIC_MUX_RESET_B LOC = P23 | IOSTANDARD=LVCMOS25; # Bank 15 VCCO - VCC2V5_FPGA - IO_L21P_T3_DQS_15
NET FLASH_A18 LOC = N24 | IOSTANDARD=LVCMOS25; # Bank 15 VCCO - VCC2V5_FPGA - IO_L21N_T3_DQS_A18_15
NET FLASH_A17 LOC = P21 | IOSTANDARD=LVCMOS25; # Bank 15 VCCO - VCC2V5_FPGA - IO_L22P_T3_A17_15
NET FLASH_A16 LOC = P22 | IOSTANDARD=LVCMOS25; # Bank 15 VCCO - VCC2V5_FPGA - IO_L22N_T3_A16_15
NET FLASH_OE_B LOC = M24 | IOSTANDARD=LVCMOS25; # Bank 15 VCCO - VCC2V5_FPGA - IO_L23P_T3_FOE_B_15
NET FLASH_FWE_B LOC = M25 | IOSTANDARD=LVCMOS25; # Bank 15 VCCO - VCC2V5_FPGA - IO_L23N_T3_FWE_B_15
NET FLASH_A25 LOC = M22 | IOSTANDARD=LVCMOS25; # Bank 15 VCCO - VCC2V5_FPGA - IO_L24P_T3_RS1_15
NET FLASH_A24 LOC = M23 | IOSTANDARD=LVCMOS25; # Bank 15 VCCO - VCC2V5_FPGA - IO_L24N_T3_RS0_15
NET SFP_LOS_LS LOC = P19 | IOSTANDARD=LVCMOS25; # Bank 15 VCCO - VCC2V5_FPGA - IO_25_15
NET PCIE_WAKE_B_LS LOC = F23 | IOSTANDARD=LVCMOS25; # Bank 16 VCCO - VADJ_FPGA - IO_0_16
NET HDMI_R_D0 LOC = B23 | IOSTANDARD=LVCMOS25; # Bank 16 VCCO - VADJ_FPGA - IO_L1P_T0_16
NET HDMI_R_D1 LOC = A23 | IOSTANDARD=LVCMOS25; # Bank 16 VCCO - VADJ_FPGA - IO_L1N_T0_16
NET HDMI_R_D2 LOC = E23 | IOSTANDARD=LVCMOS25; # Bank 16 VCCO - VADJ_FPGA - IO_L2P_T0_16
NET HDMI_R_D3 LOC = D23 | IOSTANDARD=LVCMOS25; # Bank 16 VCCO - VADJ_FPGA - IO_L2N_T0_16
NET HDMI_R_D4 LOC = F25 | IOSTANDARD=LVCMOS25; # Bank 16 VCCO - VADJ_FPGA - IO_L3P_T0_DQS_16
NET HDMI_R_D5 LOC = E25 | IOSTANDARD=LVCMOS25; # Bank 16 VCCO - VADJ_FPGA - IO_L3N_T0_DQS_16
NET HDMI_R_D6 LOC = E24 | IOSTANDARD=LVCMOS25; # Bank 16 VCCO - VADJ_FPGA - IO_L4P_T0_16
NET HDMI_R_D7 LOC = D24 | IOSTANDARD=LVCMOS25; # Bank 16 VCCO - VADJ_FPGA - IO_L4N_T0_16
NET HDMI_R_D8 LOC = F26 | IOSTANDARD=LVCMOS25; # Bank 16 VCCO - VADJ_FPGA - IO_L5P_T0_16
NET HDMI_R_D9 LOC = E26 | IOSTANDARD=LVCMOS25; # Bank 16 VCCO - VADJ_FPGA - IO_L5N_T0_16
NET HDMI_R_D10 LOC = G23 | IOSTANDARD=LVCMOS25; # Bank 16 VCCO - VADJ_FPGA - IO_L6P_T0_16
NET HDMI_R_D11 LOC = G24 | IOSTANDARD=LVCMOS25; # Bank 16 VCCO - VADJ_FPGA - IO_L6N_T0_VREF_16
NET FMC_HPC_LA16_P LOC = B27 | IOSTANDARD=LVCMOS25; # Bank 16 VCCO - VADJ_FPGA - IO_L7P_T1_16
NET FMC_HPC_LA16_N LOC = A27 | IOSTANDARD=LVCMOS25; # Bank 16 VCCO - VADJ_FPGA - IO_L7N_T1_16
NET FMC_HPC_LA15_P LOC = C24 | IOSTANDARD=LVCMOS25; # Bank 16 VCCO - VADJ_FPGA - IO_L8P_T1_16
NET FMC_HPC_LA15_N LOC = B24 | IOSTANDARD=LVCMOS25; # Bank 16 VCCO - VADJ_FPGA - IO_L8N_T1_16
NET FMC_HPC_LA14_P LOC = B28 | IOSTANDARD=LVCMOS25; # Bank 16 VCCO - VADJ_FPGA - IO_L9P_T1_DQS_16
NET FMC_HPC_LA14_N LOC = A28 | IOSTANDARD=LVCMOS25; # Bank 16 VCCO - VADJ_FPGA - IO_L9N_T1_DQS_16
NET FMC_HPC_LA13_P LOC = A25 | IOSTANDARD=LVCMOS25; # Bank 16 VCCO - VADJ_FPGA - IO_L10P_T1_16
NET FMC_HPC_LA01_CC_P LOC = D26 | IOSTANDARD=LVCMOS25; # Bank 16 VCCO - VADJ_FPGA - IO_L11P_T1_SRCC_16
NET FMC_HPC_LA01_CC_N LOC = C26 | IOSTANDARD=LVCMOS25; # Bank 16 VCCO - VADJ_FPGA - IO_L11N_T1_SRCC_16
NET FMC_HPC_LA00_CC_P LOC = C25 | IOSTANDARD=LVCMOS25; # Bank 16 VCCO - VADJ_FPGA - IO_L12P_T1_MRCC_16
NET FMC_HPC_LA00_CC_N LOC = B25 | IOSTANDARD=LVCMOS25; # Bank 16 VCCO - VADJ_FPGA - IO_L12N_T1_MRCC_16
NET FMC_HPC_CLK0_M2C_P LOC = D27 | IOSTANDARD=LVCMOS25; # Bank 16 VCCO - VADJ_FPGA - IO_L13P_T2_MRCC_16
NET FMC_HPC_CLK0_M2C_N LOC = C27 | IOSTANDARD=LVCMOS25; # Bank 16 VCCO - VADJ_FPGA - IO_L13N_T2_MRCC_16
NET FMC_HPC_LA07_P LOC = E28 | IOSTANDARD=LVCMOS25; # Bank 16 VCCO - VADJ_FPGA - IO_L14P_T2_SRCC_16
NET FMC_HPC_LA07_N LOC = D28 | IOSTANDARD=LVCMOS25; # Bank 16 VCCO - VADJ_FPGA - IO_L14N_T2_SRCC_16
NET FMC_HPC_LA12_P LOC = C29 | IOSTANDARD=LVCMOS25; # Bank 16 VCCO - VADJ_FPGA - IO_L15P_T2_DQS_16
NET FMC_HPC_LA12_N LOC = B29 | IOSTANDARD=LVCMOS25; # Bank 16 VCCO - VADJ_FPGA - IO_L15N_T2_DQS_16
NET FMC_HPC_LA10_P LOC = D29 | IOSTANDARD=LVCMOS25; # Bank 16 VCCO - VADJ_FPGA - IO_L16P_T2_16

NET FMC_HPC_LA10_N LOC = C30 | IOSTANDARD=LVCMOS25; # Bank 16 VCCO - VADJ_FPGA - IO_L16N_T2_16
NET FMC_HPC_LA08_P LOC = E29 | IOSTANDARD=LVCMOS25; # Bank 16 VCCO - VADJ_FPGA - IO_L18P_T2_16
NET FMC_HPC_LA08_N LOC = E30 | IOSTANDARD=LVCMOS25; # Bank 16 VCCO - VADJ_FPGA - IO_L18N_T2_16
NET FMC_HPC_LA02_P LOC = H24 | IOSTANDARD=LVCMOS25; # Bank 16 VCCO - VADJ_FPGA - IO_L19P_T3_16
NET FMC_HPC_LA02_N LOC = H25 | IOSTANDARD=LVCMOS25; # Bank 16 VCCO - VADJ_FPGA - IO_L19N_T3_VREF_16
NET FMC_HPC_LA04_P LOC = G28 | IOSTANDARD=LVCMOS25; # Bank 16 VCCO - VADJ_FPGA - IO_L20P_T3_16
NET FMC_HPC_LA04_N LOC = F28 | IOSTANDARD=LVCMOS25; # Bank 16 VCCO - VADJ_FPGA - IO_L20N_T3_16
NET FMC_HPC_LA11_P LOC = G27 | IOSTANDARD=LVCMOS25; # Bank 16 VCCO - VADJ_FPGA - IO_L21P_T3_DQS_16
NET FMC_HPC_LA11_N LOC = F27 | IOSTANDARD=LVCMOS25; # Bank 16 VCCO - VADJ_FPGA - IO_L21N_T3_DQS_16
NET FMC_HPC_LA03_N LOC = H27 | IOSTANDARD=LVCMOS25; # Bank 16 VCCO - VADJ_FPGA - IO_L23N_T3_16
NET FMC_HPC_LA06_N LOC = G30 | IOSTANDARD=LVCMOS25; # Bank 16 VCCO - VADJ_FPGA - IO_L24N_T3_16
NET PCIE_PERST_LS LOC = G25 | IOSTANDARD=LVCMOS25; # Bank 16 VCCO - VADJ_FPGA - IO_25_16
NET GPIO_LED_5_LS LOC = G19 | IOSTANDARD=LVCMOS25; # Bank 17 VCCO - VADJ_FPGA - IO_0_17
NET HDMI_R_CLK LOC = K18 | IOSTANDARD=LVCMOS25; # Bank 17 VCCO - VADJ_FPGA - IO_L1P_T0_17
NET HDMI_R_HSYNC LOC = J18 | IOSTANDARD=LVCMOS25; # Bank 17 VCCO - VADJ_FPGA - IO_L1N_T0_17
NET HDMI_R_VSYNC LOC = H20 | IOSTANDARD=LVCMOS25; # Bank 17 VCCO - VADJ_FPGA - IO_L2P_T0_17
NET HDMI_SPDIF_OUT_LS LOC = G20 | IOSTANDARD=LVCMOS25; # Bank 17 VCCO - VADJ_FPGA - IO_L2N_T0_17
NET HDMI_R_SPDIF LOC = J17 | IOSTANDARD=LVCMOS25; # Bank 17 VCCO - VADJ_FPGA - IO_L3P_T0_DQS_17
NET HDMI_R_DE LOC = H17 | IOSTANDARD=LVCMOS25; # Bank 17 VCCO - VADJ_FPGA - IO_L3N_T0_DQS_17
NET HDMI_R_D12 LOC = J19 | IOSTANDARD=LVCMOS25; # Bank 17 VCCO - VADJ_FPGA - IO_L4P_T0_17
NET HDMI_R_D13 LOC = H19 | IOSTANDARD=LVCMOS25; # Bank 17 VCCO - VADJ_FPGA - IO_L4N_T0_17
NET HDMI_R_D14 LOC = L17 | IOSTANDARD=LVCMOS25; # Bank 17 VCCO - VADJ_FPGA - IO_L5P_T0_17
NET HDMI_R_D15 LOC = L18 | IOSTANDARD=LVCMOS25; # Bank 17 VCCO - VADJ_FPGA - IO_L5N_T0_17
NET HDMI_R_D16 LOC = K19 | IOSTANDARD=LVCMOS25; # Bank 17 VCCO - VADJ_FPGA - IO_L6P_T0_17
NET HDMI_R_D17 LOC = K20 | IOSTANDARD=LVCMOS25; # Bank 17 VCCO - VADJ_FPGA - IO_L6N_T0_VREF_17
NET FMC_HPC_LA33_N LOC = H22 | IOSTANDARD=LVCMOS25; # Bank 17 VCCO - VADJ_FPGA - IO_L7N_T1_17
NET FMC_HPC_LA31_P LOC = G22 | IOSTANDARD=LVCMOS25; # Bank 17 VCCO - VADJ_FPGA - IO_L9P_T1_DQS_17
NET FMC_HPC_LA31_N LOC = F22 | IOSTANDARD=LVCMOS25; # Bank 17 VCCO - VADJ_FPGA - IO_L9N_T1_DQS_17
NET FMC_HPC_LA18_CC_P LOC = F21 | IOSTANDARD=LVCMOS25; # Bank 17 VCCO - VADJ_FPGA - IO_L11P_T1_SRCC_17
NET FMC_HPC_LA18_CC_N LOC = E21 | IOSTANDARD=LVCMOS25; # Bank 17 VCCO - VADJ_FPGA - IO_L11N_T1_SRCC_17
NET FMC_HPC_LA17_CC_P LOC = F20 | IOSTANDARD=LVCMOS25; # Bank 17 VCCO - VADJ_FPGA - IO_L12P_T1_MRCC_17
NET FMC_HPC_LA17_CC_N LOC = E20 | IOSTANDARD=LVCMOS25; # Bank 17 VCCO - VADJ_FPGA - IO_L12N_T1_MRCC_17
NET FMC_HPC_CLK1_M2C_P LOC = D17 | IOSTANDARD=LVCMOS25; # Bank 17 VCCO - VADJ_FPGA - IO_L13P_T2_MRCC_17
NET FMC_HPC_CLK1_M2C_N LOC = D18 | IOSTANDARD=LVCMOS25; # Bank 17 VCCO - VADJ_FPGA - IO_L13N_T2_MRCC_17
NET FMC_HPC_LA20_P LOC = E19 | IOSTANDARD=LVCMOS25; # Bank 17 VCCO - VADJ_FPGA - IO_L14P_T2_SRCC_17
NET FMC_HPC_LA20_N LOC = D19 | IOSTANDARD=LVCMOS25; # Bank 17 VCCO - VADJ_FPGA - IO_L14N_T2_SRCC_17
NET FMC_HPC_LA28_P LOC = D16 | IOSTANDARD=LVCMOS25; # Bank 17 VCCO - VADJ_FPGA - IO_L15P_T2_DQS_17
NET FMC_HPC_LA28_N LOC = C16 | IOSTANDARD=LVCMOS25; # Bank 17 VCCO - VADJ_FPGA - IO_L15N_T2_DQS_17
NET FMC_HPC_LA22_N LOC = B20 | IOSTANDARD=LVCMOS25; # Bank 17 VCCO - VADJ_FPGA - IO_L19N_T3_VREF_17
NET FMC_HPC_LA24_P LOC = A16 | IOSTANDARD=LVCMOS25; # Bank 17 VCCO - VADJ_FPGA - IO_L20P_T3_17
NET FMC_HPC_LA21_P LOC = A20 | IOSTANDARD=LVCMOS25; # Bank 17 VCCO - VADJ_FPGA - IO_L21P_T3_DQS_17
NET FMC_HPC_LA21_N LOC = A21 | IOSTANDARD=LVCMOS25; # Bank 17 VCCO - VADJ_FPGA - IO_L21N_T3_DQS_17
NET GPIO_LED_6_LS LOC = E18 | IOSTANDARD=LVCMOS25; # Bank 17 VCCO - VADJ_FPGA - IO_25_17
NET GPIO_SW_C LOC = G12 | IOSTANDARD=LVCMOS25; # Bank 18 VCCO - VADJ_FPGA - IO_0_18
NET FMC_HPC_HA13_P LOC = L16 | IOSTANDARD=LVCMOS25; # Bank 18 VCCO - VADJ_FPGA - IO_L1P_T0_18
NET FMC_HPC_HA13_N LOC = K16 | IOSTANDARD=LVCMOS25; # Bank 18 VCCO - VADJ_FPGA - IO_L1N_T0_18
NET FMC_HPC_HA16_N LOC = K15 | IOSTANDARD=LVCMOS25; # Bank 18 VCCO - VADJ_FPGA - IO_L2N_T0_18
NET FMC_HPC_HA23_P LOC = L12 | IOSTANDARD=LVCMOS25; # Bank 18 VCCO - VADJ_FPGA - IO_L3P_T0_DQS_18
NET FMC_HPC_HA23_N LOC = L13 | IOSTANDARD=LVCMOS25; # Bank 18 VCCO - VADJ_FPGA - IO_L3N_T0_DQS_18
NET FMC_HPC_HA20_P LOC = K13 | IOSTANDARD=LVCMOS25; # Bank 18 VCCO - VADJ_FPGA - IO_L4P_T0_18
NET FMC_HPC_HA20_N LOC = J13 | IOSTANDARD=LVCMOS25; # Bank 18 VCCO - VADJ_FPGA - IO_L4N_T0_18
NET FMC_HPC_HA18_P LOC = K14 | IOSTANDARD=LVCMOS25; # Bank 18 VCCO - VADJ_FPGA - IO_L5P_T0_18
NET FMC_HPC_HA22_N LOC = K11 | IOSTANDARD=LVCMOS25; # Bank 18 VCCO - VADJ_FPGA - IO_L6N_T0_VREF_18
NET FMC_HPC_HA15_P LOC = H15 | IOSTANDARD=LVCMOS25; # Bank 18 VCCO - VADJ_FPGA - IO_L7P_T1_18
NET FMC_HPC_HA15_N LOC = G15 | IOSTANDARD=LVCMOS25; # Bank 18 VCCO - VADJ_FPGA - IO_L7N_T1_18
NET FMC_HPC_HA21_P LOC = J11 | IOSTANDARD=LVCMOS25; # Bank 18 VCCO - VADJ_FPGA - IO_L8P_T1_18
NET FMC_HPC_HA14_P LOC = J16 | IOSTANDARD=LVCMOS25; # Bank 18 VCCO - VADJ_FPGA - IO_L9P_T1_DQS_18
NET FMC_HPC_HA14_N LOC = H16 | IOSTANDARD=LVCMOS25; # Bank 18 VCCO - VADJ_FPGA - IO_L9N_T1_DQS_18
NET FMC_HPC_HA19_P LOC = H11 | IOSTANDARD=LVCMOS25; # Bank 18 VCCO - VADJ_FPGA - IO_L10P_T1_18
NET FMC_HPC_HA19_N LOC = H12 | IOSTANDARD=LVCMOS25; # Bank 18 VCCO - VADJ_FPGA - IO_L10N_T1_18
NET FMC_HPC_HA01_CC_P LOC = H14 | IOSTANDARD=LVCMOS25; # Bank 18 VCCO - VADJ_FPGA - IO_L11P_T1_SRCC_18
NET FMC_HPC_HA01_CC_N LOC = G14 | IOSTANDARD=LVCMOS25; # Bank 18 VCCO - VADJ_FPGA - IO_L11N_T1_SRCC_18
NET FMC_HPC_HA17_CC_P LOC = G13 | IOSTANDARD=LVCMOS25; # Bank 18 VCCO - VADJ_FPGA - IO_L12P_T1_MRCC_18
NET FMC_HPC_HA17_CC_N LOC = F13 | IOSTANDARD=LVCMOS25; # Bank 18 VCCO - VADJ_FPGA - IO_L12N_T1_MRCC_18
NET FMC_HPC_HA00_CC_P LOC = D12 | IOSTANDARD=LVCMOS25; # Bank 18 VCCO - VADJ_FPGA - IO_L13P_T2_MRCC_18
NET FMC_HPC_HA00_CC_N LOC = D13 | IOSTANDARD=LVCMOS25; # Bank 18 VCCO - VADJ_FPGA - IO_L13N_T2_MRCC_18
NET FMC_HPC_HA09_P LOC = F12 | IOSTANDARD=LVCMOS25; # Bank 18 VCCO - VADJ_FPGA - IO_L14P_T2_SRCC_18
NET FMC_HPC_HA09_N LOC = E13 | IOSTANDARD=LVCMOS25; # Bank 18 VCCO - VADJ_FPGA - IO_L14N_T2_SRCC_18
NET FMC_HPC_HA03_P LOC = C12 | IOSTANDARD=LVCMOS25; # Bank 18 VCCO - VADJ_FPGA - IO_L15P_T2_DQS_18
NET FMC_HPC_HA03_N LOC = B12 | IOSTANDARD=LVCMOS25; # Bank 18 VCCO - VADJ_FPGA - IO_L15N_T2_DQS_18
NET FMC_HPC_HA04_P LOC = F11 | IOSTANDARD=LVCMOS25; # Bank 18 VCCO - VADJ_FPGA - IO_L16P_T2_18
NET FMC_HPC_HA04_N LOC = E11 | IOSTANDARD=LVCMOS25; # Bank 18 VCCO - VADJ_FPGA - IO_L16N_T2_18
NET FMC_HPC_HA10_P LOC = A11 | IOSTANDARD=LVCMOS25; # Bank 18 VCCO - VADJ_FPGA - IO_L17P_T2_18
NET FMC_HPC_HA10_N LOC = A12 | IOSTANDARD=LVCMOS25; # Bank 18 VCCO - VADJ_FPGA - IO_L17N_T2_18
NET FMC_HPC_HA02_P LOC = D11 | IOSTANDARD=LVCMOS25; # Bank 18 VCCO - VADJ_FPGA - IO_L18P_T2_18
NET FMC_HPC_HA02_N LOC = C11 | IOSTANDARD=LVCMOS25; # Bank 18 VCCO - VADJ_FPGA - IO_L18N_T2_18
NET FMC_HPC_HA05_P LOC = F15 | IOSTANDARD=LVCMOS25; # Bank 18 VCCO - VADJ_FPGA - IO_L19P_T3_18
NET FMC_HPC_HA05_N LOC = E16 | IOSTANDARD=LVCMOS25; # Bank 18 VCCO - VADJ_FPGA - IO_L19N_T3_VREF_18
NET FMC_HPC_HA08_P LOC = E14 | IOSTANDARD=LVCMOS25; # Bank 18 VCCO - VADJ_FPGA - IO_L20P_T3_18
NET FMC_HPC_HA08_N LOC = E15 | IOSTANDARD=LVCMOS25; # Bank 18 VCCO - VADJ_FPGA - IO_L20N_T3_18
NET FMC_HPC_HA06_P LOC = D14 | IOSTANDARD=LVCMOS25; # Bank 18 VCCO - VADJ_FPGA - IO_L21P_T3_DQS_18
NET FMC_HPC_HA06_N LOC = C14 | IOSTANDARD=LVCMOS25; # Bank 18 VCCO - VADJ_FPGA - IO_L21N_T3_DQS_18
NET FMC_HPC_HA11_P LOC = B13 | IOSTANDARD=LVCMOS25; # Bank 18 VCCO - VADJ_FPGA - IO_L22P_T3_18
NET FMC_HPC_HA12_P LOC = C15 | IOSTANDARD=LVCMOS25; # Bank 18 VCCO - VADJ_FPGA - IO_L23P_T3_18
NET FMC_HPC_HA12_N LOC = B15 | IOSTANDARD=LVCMOS25; # Bank 18 VCCO - VADJ_FPGA - IO_L23N_T3_18
NET FMC_HPC_HA07_P LOC = B14 | IOSTANDARD=LVCMOS25; # Bank 18 VCCO - VADJ_FPGA - IO_L24P_T3_18
NET GPIO_LED_7_LS LOC = F16 | IOSTANDARD=LVCMOS25; # Bank 18 VCCO - VADJ_FPGA - IO_25_18
NET PMBUS_DATA_LS LOC = Y14 | IOSTANDARD=LVCMOS15; # Bank 32 VCCO - VCC1V5_FPGA - IO_0_VRN_32
NET DDR3_D24 LOC = AK16 | IOSTANDARD=SSTL15; # Bank 32 VCCO - VCC1V5_FPGA - IO_L1P_T0_32
NET DDR3_D31 LOC = AK15 | IOSTANDARD=SSTL15; # Bank 32 VCCO - VCC1V5_FPGA - IO_L1N_T0_32
NET DDR3_D26 LOC = AG15 | IOSTANDARD=SSTL15; # Bank 32 VCCO - VCC1V5_FPGA - IO_L2P_T0_32
NET DDR3_D30 LOC = AH15 | IOSTANDARD=SSTL15; # Bank 32 VCCO - VCC1V5_FPGA - IO_L2N_T0_32
NET DDR3_DQS3_P LOC = AH16 | IOSTANDARD=SSTL15; # Bank 32 VCCO - VCC1V5_FPGA - IO_L3P_T0_DQS_32

NET DDR3_DQS3_N LOC = AJ16 | IOSTANDARD=SSTL15; # Bank 32 VCCO - VCC1V5_FPGA - IO_L3N_T0_DQS_32
NET DDR3_D27 LOC = AF15 | IOSTANDARD=SSTL15; # Bank 32 VCCO - VCC1V5_FPGA - IO_L4P_T0_32
NET DDR3_D29 LOC = AG14 | IOSTANDARD=SSTL15; # Bank 32 VCCO - VCC1V5_FPGA - IO_L4N_T0_32
NET DDR3_D28 LOC = AH17 | IOSTANDARD=SSTL15; # Bank 32 VCCO - VCC1V5_FPGA - IO_L5P_T0_32
NET DDR3_D25 LOC = AJ17 | IOSTANDARD=SSTL15; # Bank 32 VCCO - VCC1V5_FPGA - IO_L5N_T0_32
NET DDR3_DM3 LOC = AE16 | IOSTANDARD=SSTL15; # Bank 32 VCCO - VCC1V5_FPGA - IO_L6P_T0_32
NET DDR3_D21 LOC = AJ19 | IOSTANDARD=SSTL15; # Bank 32 VCCO - VCC1V5_FPGA - IO_L7P_T1_32
NET DDR3_D16 LOC = AG19 | IOSTANDARD=SSTL15; # Bank 32 VCCO - VCC1V5_FPGA - IO_L8P_T1_32
NET DDR3_D20 LOC = AH19 | IOSTANDARD=SSTL15; # Bank 32 VCCO - VCC1V5_FPGA - IO_L8N_T1_32
NET DDR3_DQS2_P LOC = AJ18 | IOSTANDARD=SSTL15; # Bank 32 VCCO - VCC1V5_FPGA - IO_L9P_T1_DQS_32
NET DDR3_DQS2_N LOC = AK18 | IOSTANDARD=SSTL15; # Bank 32 VCCO - VCC1V5_FPGA - IO_L9N_T1_DQS_32
NET DDR3_D23 LOC = AD19 | IOSTANDARD=SSTL15; # Bank 32 VCCO - VCC1V5_FPGA - IO_L10P_T1_32
NET DDR3_D22 LOC = AE19 | IOSTANDARD=SSTL15; # Bank 32 VCCO - VCC1V5_FPGA - IO_L10N_T1_32
NET DDR3_D19 LOC = AF18 | IOSTANDARD=SSTL15; # Bank 32 VCCO - VCC1V5_FPGA - IO_L11P_T1_SRCC_32
NET DDR3_D18 LOC = AG18 | IOSTANDARD=SSTL15; # Bank 32 VCCO - VCC1V5_FPGA - IO_L11N_T1_SRCC_32
NET DDR3_DM2 LOC = AF17 | IOSTANDARD=SSTL15; # Bank 32 VCCO - VCC1V5_FPGA - IO_L12P_T1_MRCC_32
NET PMBUS_CLK_LS LOC = AG17 | IOSTANDARD=LVCMOS15; # Bank 32 VCCO - VCC1V5_FPGA - IO_L12N_T1_MRCC_32
NET DDR3_D15 LOC = AD18 | IOSTANDARD=SSTL15; # Bank 32 VCCO - VCC1V5_FPGA - IO_L13P_T2_MRCC_32
NET DDR3_D14 LOC = AE18 | IOSTANDARD=SSTL15; # Bank 32 VCCO - VCC1V5_FPGA - IO_L13N_T2_MRCC_32
NET DDR3_D11 LOC = AD17 | IOSTANDARD=SSTL15; # Bank 32 VCCO - VCC1V5_FPGA - IO_L14P_T2_SRCC_32
NET DDR3_D9 LOC = AD16 | IOSTANDARD=SSTL15; # Bank 32 VCCO - VCC1V5_FPGA - IO_L14N_T2_SRCC_32
NET DDR3_DQS1_P LOC = Y19 | IOSTANDARD=DIFF_SSTL15; # Bank 32 VCCO - VCC1V5_FPGA - IO_L15P_T2_DQS_32
NET DDR3_DQS1_N LOC = Y18 | IOSTANDARD=DIFF_SSTL15; # Bank 32 VCCO - VCC1V5_FPGA - IO_L15N_T2_DQS_32
NET DDR3_D12 LOC = AA18 | IOSTANDARD=SSTL15; # Bank 32 VCCO - VCC1V5_FPGA - IO_L16P_T2_32
NET DDR3_D13 LOC = AB18 | IOSTANDARD=SSTL15; # Bank 32 VCCO - VCC1V5_FPGA - IO_L16N_T2_32
NET DDR3_D8 LOC = AB19 | IOSTANDARD=SSTL15; # Bank 32 VCCO - VCC1V5_FPGA - IO_L17P_T2_32
NET DDR3_D10 LOC = AC19 | IOSTANDARD=SSTL15; # Bank 32 VCCO - VCC1V5_FPGA - IO_L17N_T2_32
NET DDR3_DM1 LOC = AB17 | IOSTANDARD=SSTL15; # Bank 32 VCCO - VCC1V5_FPGA - IO_L18P_T2_32
NET DDR3_D6 LOC = AE15 | IOSTANDARD=SSTL15; # Bank 32 VCCO - VCC1V5_FPGA - IO_L19P_T3_32
NET DDR3_D5 LOC = AB15 | IOSTANDARD=SSTL15; # Bank 32 VCCO - VCC1V5_FPGA - IO_L20N_T3_32
NET DDR3_DQS0_P LOC = AC16 | IOSTANDARD=DIFF_SSTL15; # Bank 32 VCCO - VCC1V5_FPGA - IO_L21P_T3_DQS_32
NET DDR3_DQS0_N LOC = AC15 | IOSTANDARD=DIFF_SSTL15; # Bank 32 VCCO - VCC1V5_FPGA - IO_L21N_T3_DQS_32
NET DDR3_D2 LOC = AC14 | IOSTANDARD=SSTL15; # Bank 32 VCCO - VCC1V5_FPGA - IO_L22P_T3_32
NET DDR3_D3 LOC = AD14 | IOSTANDARD=SSTL15; # Bank 32 VCCO - VCC1V5_FPGA - IO_L22N_T3_32
NET DDR3_D1 LOC = AA16 | IOSTANDARD=SSTL15; # Bank 32 VCCO - VCC1V5_FPGA - IO_L23N_T3_32
NET DDR3_DM0 LOC = Y16 | IOSTANDARD=SSTL15; # Bank 32 VCCO - VCC1V5_FPGA - IO_L24P_T3_32
NET DDR3_D7 LOC = Y15 | IOSTANDARD=SSTL15; # Bank 32 VCCO - VCC1V5_FPGA - IO_L24N_T3_32
NET PMBUS_ALERT_LS LOC = AB14 | IOSTANDARD=LVCMOS15; # Bank 32 VCCO - VCC1V5_FPGA - IO_25_VRP_32
NET VRN_33 LOC = Y13 | IOSTANDARD=SSTL15; # Bank 33 VCCO - VCC1V5_FPGA - IO_0_VRN_33
NET GPIO_SW_N LOC = AA12 | IOSTANDARD=LVCMOS15; # Bank 33 VCCO - VCC1V5_FPGA - IO_L1P_T0_33
NET GPIO_SW_S LOC = AB12 | IOSTANDARD=LVCMOS15; # Bank 33 VCCO - VCC1V5_FPGA - IO_L1N_T0_33
NET GPIO_LED_1_LS LOC = AA8 | IOSTANDARD=LVCMOS15; # Bank 33 VCCO - VCC1V5_FPGA - IO_L2P_T0_33
NET GPIO_LED_0_LS LOC = AB8 | IOSTANDARD=LVCMOS15; # Bank 33 VCCO - VCC1V5_FPGA - IO_L2N_T0_33
NET GPIO_LED_3_LS LOC = AB9 | IOSTANDARD=LVCMOS15; # Bank 33 VCCO - VCC1V5_FPGA - IO_L3P_T0_DQS_33
NET GPIO_LED_2_LS LOC = AC9 | IOSTANDARD=LVCMOS15; # Bank 33 VCCO - VCC1V5_FPGA - IO_L3N_T0_DQS_33
NET LCD_RS_LS LOC = Y11 | IOSTANDARD=LVCMOS15; # Bank 33 VCCO - VCC1V5_FPGA - IO_L4P_T0_33
NET LCD_DB7_LS LOC = Y10 | IOSTANDARD=LVCMOS15; # Bank 33 VCCO - VCC1V5_FPGA - IO_L4N_T0_33
NET LCD_DB6_LS LOC = AA11 | IOSTANDARD=LVCMOS15; # Bank 33 VCCO - VCC1V5_FPGA - IO_L5P_T0_33
NET LCD_DB5_LS LOC = AA10 | IOSTANDARD=LVCMOS15; # Bank 33 VCCO - VCC1V5_FPGA - IO_L5N_T0_33
NET LCD_DB4_LS LOC = AA13 | IOSTANDARD=LVCMOS15; # Bank 33 VCCO - VCC1V5_FPGA - IO_L6P_T0_33
NET LCD_RW_LS LOC = AB13 | IOSTANDARD=LVCMOS15; # Bank 33 VCCO - VCC1V5_FPGA - IO_L6N_T0_VREF_33
NET LCD_E_LS LOC = AB10 | IOSTANDARD=LVCMOS15; # Bank 33 VCCO - VCC1V5_FPGA - IO_L7P_T1_33
NET DDR3_ODT1 LOC = AC10 | IOSTANDARD=SSTL15; # Bank 33 VCCO - VCC1V5_FPGA - IO_L7N_T1_33
NET DDR3_ODT0 LOC = AD8 | IOSTANDARD=SSTL15; # Bank 33 VCCO - VCC1V5_FPGA - IO_L8P_T1_33
NET DDR3_S1_B LOC = AE8 | IOSTANDARD=SSTL15; # Bank 33 VCCO - VCC1V5_FPGA - IO_L8N_T1_33
NET DDR3_S0_B LOC = AC12 | IOSTANDARD=SSTL15; # Bank 33 VCCO - VCC1V5_FPGA - IO_L9P_T1_DQS_33
NET DDR3_CAS_B LOC = AC11 | IOSTANDARD=SSTL15; # Bank 33 VCCO - VCC1V5_FPGA - IO_L9N_T1_DQS_33
NET DDR3_RAS_B LOC = AD9 | IOSTANDARD=SSTL15; # Bank 33 VCCO - VCC1V5_FPGA - IO_L10P_T1_33
NET DDR3_WE_B LOC = AE9 | IOSTANDARD=SSTL15; # Bank 33 VCCO - VCC1V5_FPGA - IO_L10N_T1_33
NET DDR3_CLK1_P LOC = AE11 | IOSTANDARD=DIFF_SSTL15; # Bank 33 VCCO - VCC1V5_FPGA - IO_L11P_T1_SRCC_33
NET DDR3_CLK1_N LOC = AF11 | IOSTANDARD=DIFF_SSTL15; # Bank 33 VCCO - VCC1V5_FPGA - IO_L11N_T1_SRCC_33
NET SYSCLK_P LOC = AD12 | IOSTANDARD=LVDS; # Bank 33 VCCO - VCC1V5_FPGA - IO_L12P_T1_MRCC_33
NET SYSCLK_N LOC = AD11 | IOSTANDARD=LVDS; # Bank 33 VCCO - VCC1V5_FPGA - IO_L12N_T1_MRCC_33
NET DDR3_CLK0_P LOC = AG10 | IOSTANDARD=DIFF_SSTL15; # Bank 33 VCCO - VCC1V5_FPGA - IO_L13P_T2_MRCC_33
NET DDR3_CLK0_N LOC = AH10 | IOSTANDARD=DIFF_SSTL15; # Bank 33 VCCO - VCC1V5_FPGA - IO_L13N_T2_MRCC_33
NET DDR3_CKE1 LOC = AE10 | IOSTANDARD=SSTL15; # Bank 33 VCCO - VCC1V5_FPGA - IO_L14P_T2_SRCC_33
NET DDR3_CKE0 LOC = AF10 | IOSTANDARD=SSTL15; # Bank 33 VCCO - VCC1V5_FPGA - IO_L14N_T2_SRCC_33
NET DDR3_TEMP_EVENT LOC = AJ9 | IOSTANDARD=SSTL15; # Bank 33 VCCO - VCC1V5_FPGA - IO_L15P_T2_DQS_33
NET DDR3_BA2 LOC = AK9 | IOSTANDARD=SSTL15; # Bank 33 VCCO - VCC1V5_FPGA - IO_L15N_T2_DQS_33
NET DDR3_BA1 LOC = AG9 | IOSTANDARD=SSTL15; # Bank 33 VCCO - VCC1V5_FPGA - IO_L16P_T2_33
NET DDR3_BA0 LOC = AH9 | IOSTANDARD=SSTL15; # Bank 33 VCCO - VCC1V5_FPGA - IO_L16N_T2_33
NET DDR3_A15 LOC = AK11 | IOSTANDARD=SSTL15; # Bank 33 VCCO - VCC1V5_FPGA - IO_L17P_T2_33
NET DDR3_A14 LOC = AK10 | IOSTANDARD=SSTL15; # Bank 33 VCCO - VCC1V5_FPGA - IO_L17N_T2_33
NET DDR3_A13 LOC = AH11 | IOSTANDARD=SSTL15; # Bank 33 VCCO - VCC1V5_FPGA - IO_L18P_T2_33
NET DDR3_A12 LOC = AJ11 | IOSTANDARD=SSTL15; # Bank 33 VCCO - VCC1V5_FPGA - IO_L18N_T2_33
NET DDR3_A11 LOC = AE13 | IOSTANDARD=SSTL15; # Bank 33 VCCO - VCC1V5_FPGA - IO_L19P_T3_33
NET DDR3_A10 LOC = AF13 | IOSTANDARD=SSTL15; # Bank 33 VCCO - VCC1V5_FPGA - IO_L19N_T3_VREF_33
NET DDR3_A9 LOC = AK14 | IOSTANDARD=SSTL15; # Bank 33 VCCO - VCC1V5_FPGA - IO_L20P_T3_33
NET DDR3_A8 LOC = AK13 | IOSTANDARD=SSTL15; # Bank 33 VCCO - VCC1V5_FPGA - IO_L20N_T3_33
NET DDR3_A7 LOC = AH14 | IOSTANDARD=SSTL15; # Bank 33 VCCO - VCC1V5_FPGA - IO_L21P_T3_DQS_33
NET DDR3_A6 LOC = AJ14 | IOSTANDARD=SSTL15; # Bank 33 VCCO - VCC1V5_FPGA - IO_L21N_T3_DQS_33
NET DDR3_A5 LOC = AJ13 | IOSTANDARD=SSTL15; # Bank 33 VCCO - VCC1V5_FPGA - IO_L22P_T3_33
NET DDR3_A4 LOC = AJ12 | IOSTANDARD=SSTL15; # Bank 33 VCCO - VCC1V5_FPGA - IO_L22N_T3_33
NET DDR3_A3 LOC = AF12 | IOSTANDARD=SSTL15; # Bank 33 VCCO - VCC1V5_FPGA - IO_L23P_T3_33
NET DDR3_A2 LOC = AG12 | IOSTANDARD=SSTL15; # Bank 33 VCCO - VCC1V5_FPGA - IO_L23N_T3_33
NET DDR3_A1 LOC = AG13 | IOSTANDARD=SSTL15; # Bank 33 VCCO - VCC1V5_FPGA - IO_L24P_T3_33
NET DDR3_A0 LOC = AH12 | IOSTANDARD=SSTL15; # Bank 33 VCCO - VCC1V5_FPGA - IO_L24N_T3_33
NET VRP_33 LOC = AD13 | ; # Bank 33 VCCO - VCC1V5_FPGA - IO_25_VRP_33
NET GPIO_SW_W LOC = AC6 | IOSTANDARD=LVCMOS15; # Bank 34 VCCO - VCC1V5_FPGA - IO_0_VRN_34
NET DDR3_D57 LOC = AD3 | IOSTANDARD=SSTL15; # Bank 34 VCCO - VCC1V5_FPGA - IO_L1N_T0_34
NET DDR3_DQS7_P LOC = AD2 | IOSTANDARD=DIFF_SSTL15; # Bank 34 VCCO - VCC1V5_FPGA - IO_L3P_T0_DQS_34
NET DDR3_DQS7_N LOC = AD1 | IOSTANDARD=DIFF_SSTL15; # Bank 34 VCCO - VCC1V5_FPGA - IO_L3N_T0_DQS_34
NET DDR3_DM7 LOC = AC7 | IOSTANDARD=SSTL15; # Bank 34 VCCO - VCC1V5_FPGA - IO_L6P_T0_34
NET VTTVREF LOC = AD7 | ; # Bank 34 VCCO - VCC1V5_FPGA - IO_L6N_T0_VREF_34
NET DDR3_D49 LOC = AF2 | IOSTANDARD=SSTL15; # Bank 34 VCCO - VCC1V5_FPGA - IO_L7N_T1_34
NET DDR3_D48 LOC = AF1 | IOSTANDARD=SSTL15; # Bank 34 VCCO - VCC1V5_FPGA - IO_L8N_T1_34
NET DDR3_DQS6_P LOC = AG4 | IOSTANDARD=DIFF_SSTL15; # Bank 34 VCCO - VCC1V5_FPGA - IO_L9P_T1_DQS_34
NET DDR3_DQS6_N LOC = AG3 | IOSTANDARD=DIFF_SSTL15; # Bank 34 VCCO - VCC1V5_FPGA - IO_L9N_T1_DQS_34
NET DDR3_D55 LOC = AE5 | IOSTANDARD=SSTL15; # Bank 34 VCCO - VCC1V5_FPGA - IO_L11P_T1_SRCC_34
NET DDR3_D53 LOC = AF5 | IOSTANDARD=SSTL15; # Bank 34 VCCO - VCC1V5_FPGA - IO_L11N_T1_SRCC_34
NET DDR3_DM6 LOC = AF6 | IOSTANDARD=SSTL15; # Bank 34 VCCO - VCC1V5_FPGA - IO_L12P_T1_MRCC_34
NET GPIO_SW_E LOC = AG5 | IOSTANDARD=LVCMOS15; # Bank 34 VCCO - VCC1V5_FPGA - IO_L12N_T1_MRCC_34
NET DDR3_D44 LOC = AH4 | IOSTANDARD=SSTL15; # Bank 34 VCCO - VCC1V5_FPGA - IO_L13P_T2_MRCC_34
NET DDR3_D45 LOC = AJ4 | IOSTANDARD=SSTL15; # Bank 34 VCCO - VCC1V5_FPGA - IO_L13N_T2_MRCC_34
NET DDR3_D41 LOC = AH6 | IOSTANDARD=SSTL15; # Bank 34 VCCO - VCC1V5_FPGA - IO_L14P_T2_SRCC_34
NET DDR3_D40 LOC = AH5 | IOSTANDARD=SSTL15; # Bank 34 VCCO - VCC1V5_FPGA - IO_L14N_T2_SRCC_34
NET DDR3_DQS5_P LOC = AG2 | IOSTANDARD=DIFF_SSTL15; # Bank 34 VCCO - VCC1V5_FPGA - IO_L15P_T2_DQS_34
NET DDR3_DQS5_N LOC = AH1 | IOSTANDARD=DIFF_SSTL15; # Bank 34 VCCO - VCC1V5_FPGA - IO_L15N_T2_DQS_34
NET DDR3_D43 LOC = AH2 | IOSTANDARD=SSTL15; # Bank 34 VCCO - VCC1V5_FPGA - IO_L16P_T2_34
NET DDR3_D42 LOC = AJ2 | IOSTANDARD=SSTL15; # Bank 34 VCCO - VCC1V5_FPGA - IO_L16N_T2_34

NET DDR3_DM5 LOC = AJ3 | IOSTANDARD=SSTL15; # Bank 34 VCCO - VCC1V5_FPGA - IO_L18P_T2_34
NET DDR3_RESET_B LOC = AK3 | IOSTANDARD=LVCMOS15; # Bank 34 VCCO - VCC1V5_FPGA - IO_L18N_T2_34
NET VTTVREF LOC = AG8 | ; # Bank 34 VCCO - VCC1V5_FPGA - IO_L19N_T3_VREF_34
NET DDR3_D34 LOC = AG7 | IOSTANDARD=SSTL15; # Bank 34 VCCO - VCC1V5_FPGA - IO_L20N_T3_34
NET DDR3_DQS4_P LOC = AH7 | IOSTANDARD=DIFF_SSTL15; # Bank 34 VCCO - VCC1V5_FPGA - IO_L21P_T3_DQS_34
NET DDR3_DQS4_N LOC = AJ7 | IOSTANDARD=DIFF_SSTL15; # Bank 34 VCCO - VCC1V5_FPGA - IO_L21N_T3_DQS_34
NET DDR3_DM4 LOC = AK5 | IOSTANDARD=SSTL15; # Bank 34 VCCO - VCC1V5_FPGA - IO_L24P_T3_34
NET CPU_RESET LOC = AB7 | IOSTANDARD=LVCMOS15; # Bank 34 VCCO - VCC1V5_FPGA - IO_25_VRP_34
NET PCIE_TX4_P LOC = T2 ; # Bank 115 - MGTXTXP3_115
NET PCIE_RX4_P LOC = V6 ; # Bank 115 - MGTXRXP3_115
NET PCIE_TX4_N LOC = T1 ; # Bank 115 - MGTXTXN3_115
NET PCIE_RX4_N LOC = V5 ; # Bank 115 - MGTXRXN3_115
NET PCIE_TX5_P LOC = U4 ; # Bank 115 - MGTXTXP2_115
NET PCIE_RX5_P LOC = W4 ; # Bank 115 - MGTXRXP2_115
NET PCIE_TX5_N LOC = U3 ; # Bank 115 - MGTXTXN2_115
NET PCIE_RX5_N LOC = W3 ; # Bank 115 - MGTXRXN2_115
NET PCIE_CLK_QO_N LOC = U7 ; # Bank 115 - MGTREFCLK1N_115
NET PCIE_CLK_QO_P LOC = U8 ; # Bank 115 - MGTREFCLK1P_115
NET PCIE_TX6_P LOC = V2 ; # Bank 115 - MGTXTXP1_115
NET PCIE_RX6_P LOC = Y6 ; # Bank 115 - MGTXRXP1_115
NET PCIE_TX6_N LOC = V1 ; # Bank 115 - MGTXTXN1_115
NET PCIE_RX6_N LOC = Y5 ; # Bank 115 - MGTXRXN1_115
NET PCIE_TX7_P LOC = Y2 ; # Bank 115 - MGTXTXP0_115
NET PCIE_RX7_P LOC = AA4 ; # Bank 115 - MGTXRXP0_115
NET PCIE_TX7_N LOC = Y1 ; # Bank 115 - MGTXTXN0_115
NET PCIE_RX7_N LOC = AA3 ; # Bank 115 - MGTXRXN0_115
NET PCIE_TX0_P LOC = L4 ; # Bank 116 - MGTXTXP3_116
NET PCIE_RX0_P LOC = M6 ; # Bank 116 - MGTXRXP3_116
NET PCIE_TX0_N LOC = L3 ; # Bank 116 - MGTXTXN3_116
NET PCIE_RX0_N LOC = M5 ; # Bank 116 - MGTXRXN3_116
NET PCIE_TX1_P LOC = M2 ; # Bank 116 - MGTXTXP2_116
NET PCIE_RX1_P LOC = P6 ; # Bank 116 - MGTXRXP2_116
NET PCIE_TX1_N LOC = M1 ; # Bank 116 - MGTXTXN2_116
NET SI5326_OUT_C_P LOC = L8 ; # Bank 116 - MGTREFCLK0P_116
NET PCIE_RX1_N LOC = P5 ; # Bank 116 - MGTXRXN2_116
NET SI5326_OUT_C_N LOC = L7 ; # Bank 116 - MGTREFCLK0N_116
NET FMC_LPC_GBTCLK0_M2C_C_N LOC = N7 ; # Bank 116 - MGTREFCLK1N_116
NET FMC_LPC_GBTCLK0_M2C_C_P LOC = N8 ; # Bank 116 - MGTREFCLK1P_116
NET PCIE_TX2_P LOC = N4 ; # Bank 116 - MGTXTXP1_116
NET PCIE_RX2_P LOC = R4 ; # Bank 116 - MGTXRXP1_116
NET PCIE_TX2_N LOC = N3 ; # Bank 116 - MGTXTXN1_116
NET PCIE_RX2_N LOC = R3 ; # Bank 116 - MGTXRXN1_116
NET PCIE_TX3_P LOC = P2 ; # Bank 116 - MGTXTXP0_116
NET PCIE_RX3_P LOC = T6 ; # Bank 116 - MGTXRXP0_116
NET PCIE_TX3_N LOC = P1 ; # Bank 116 - MGTXTXN0_116
NET PCIE_RX3_N LOC = T5 ; # Bank 116 - MGTXRXN0_116
NET FMC_LPC_DP0_C2M_P LOC = F2 ; # Bank 117 - MGTXTXP3_117
NET FMC_LPC_DP0_M2C_P LOC = F6 ; # Bank 117 - MGTXRXP3_117
NET FMC_LPC_DP0_C2M_N LOC = F1 ; # Bank 117 - MGTXTXN3_117
NET FMC_LPC_DP0_M2C_N LOC = F5 ; # Bank 117 - MGTXRXN3_117
NET SFP_TX_P LOC = H2 ; # Bank 117 - MGTXTXP2_117
NET SFP_RX_N LOC = G4 ; # Bank 117 - MGTXRXP2_117
NET SFP_TX_N LOC = H1 ; # Bank 117 - MGTXTXN2_117
NET SGMIICLK_Q0_P LOC = G8 ; # Bank 117 - MGTREFCLK0P_117
NET SFP_RX_P LOC = G3 ; # Bank 117 - MGTXRXN2_117
NET SGMIICLK_Q0_N LOC = G7 ; # Bank 117 - MGTREFCLK0N_117
NET SMA_MGT_REFCLK_N LOC = J7 ; # Bank 117 - MGTREFCLK1N_117
NET SMA_MGT_REFCLK_P LOC = J8 ; # Bank 117 - MGTREFCLK1P_117
NET SGMII_TX_P LOC = J4 ; # Bank 117 - MGTXTXP1_117
NET SGMII_RX_P LOC = H6 ; # Bank 117 - MGTXRXP1_117
NET SGMII_TX_N LOC = J3 ; # Bank 117 - MGTXTXN1_117
NET SGMII_RX_N LOC = H5 ; # Bank 117 - MGTXRXN1_117
NET SMA_MGT_TX_P LOC = K2 ; # Bank 117 - MGTXTXP0_117
NET SMA_MGT_RX_P LOC = K6 ; # Bank 117 - MGTXRXP0_117
NET SMA_MGT_TX_N LOC = K1 ; # Bank 117 - MGTXTXN0_117
NET SMA_MGT_RX_N LOC = K5 ; # Bank 117 - MGTXRXN0_117
NET FMC_HPC_DP3_C2M_P LOC = A4 ; # Bank 118 - MGTXTXP3_118
NET FMC_HPC_DP3_M2C_P LOC = A8 ; # Bank 118 - MGTXRXP3_118
NET FMC_HPC_DP3_C2M_N LOC = A3 ; # Bank 118 - MGTXTXN3_118
NET FMC_HPC_DP3_M2C_N LOC = A7 ; # Bank 118 - MGTXRXN3_118
NET FMC_HPC_DP2_C2M_P LOC = B2 ; # Bank 118 - MGTXTXP2_118
NET FMC_HPC_DP2_M2C_P LOC = B6 ; # Bank 118 - MGTXRXP2_118
NET FMC_HPC_DP2_C2M_N LOC = B1 ; # Bank 118 - MGTXTXN2_118
NET FMC_HPC_GBTCLK0_M2C_C_P LOC = C8 ; # Bank 118 - MGTREFCLK0P_118
NET FMC_HPC_DP2_M2C_N LOC = B5 ; # Bank 118 - MGTXRXN2_118
NET FMC_HPC_GBTCLK0_M2C_C_N LOC = C7 ; # Bank 118 - MGTREFCLK0N_118
NET FMC_HPC_GBTCLK1_M2C_C_N LOC = E7 ; # Bank 118 - MGTREFCLK1N_118
NET FMC_HPC_GBTCLK1_M2C_C_P LOC = E8 ; # Bank 118 - MGTREFCLK1P_118
NET FMC_HPC_DP1_C2M_P LOC = C4 ; # Bank 118 - MGTXTXP1_118
NET FMC_HPC_DP1_M2C_P LOC = D6 ; # Bank 118 - MGTXRXP1_118
NET FMC_HPC_DP1_C2M_N LOC = C3 ; # Bank 118 - MGTXTXN1_118
NET FMC_HPC_DP1_M2C_N LOC = D5 ; # Bank 118 - MGTXRXN1_118
NET FMC_HPC_DP0_C2M_P LOC = D2 ; # Bank 118 - MGTXTXP0_118
NET FMC_HPC_DP0_M2C_P LOC = E4 ; # Bank 118 - MGTXRXP0_118
NET FMC_HPC_DP0_C2M_N LOC = D1 ; # Bank 118 - MGTXTXN0_118
NET FMC_HPC_DP0_M2C_N LOC = E3 ; # Bank 118 - MGTXRXN0_118

ANNEXE 2: XDC file Artix-7
## This file is a general .xdc for the ARTY Rev. B
## 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 E3 IOSTANDARD LVCMOS33 } [get_ports { CLK100MHZ }]; #IO_L12P_T1_MRCC_35

Sch=gclk[100]
#create_clock -add -name sys_clk_pin -period 10.00 -waveform {0 5} [get_ports { CLK100MHZ }];
##Switches
set_property -dict { PACKAGE_PIN A8 IOSTANDARD LVCMOS33 } [get_ports { sw }]; #IO_L12N_T1_MRCC_16 Sch=sw[0]

#set_property -dict { PACKAGE_PIN C11 IOSTANDARD LVCMOS33 } [get_ports { sw[1] }]; #IO_L13P_T2_MRCC_16 Sch=sw[1]
#set_property -dict { PACKAGE_PIN C10 IOSTANDARD LVCMOS33 } [get_ports { sw[2] }]; #IO_L13N_T2_MRCC_16 Sch=sw[2]
#set_property -dict { PACKAGE_PIN A10 IOSTANDARD LVCMOS33 } [get_ports { sw[3] }]; #IO_L14P_T2_SRCC_16 Sch=sw[3]
##RGB LEDs
#set_property -dict { PACKAGE_PIN E1 IOSTANDARD LVCMOS33 } [get_ports { led0_b }]; #IO_L18N_T2_35 Sch=led0_b
#set_property -dict { PACKAGE_PIN F6 IOSTANDARD LVCMOS33 } [get_ports { led0_g }]; #IO_L19N_T3_VREF_35 Sch=led0_g
#set_property -dict { PACKAGE_PIN G6 IOSTANDARD LVCMOS33 } [get_ports { led0_r }]; #IO_L19P_T3_35 Sch=led0_r
#set_property -dict { PACKAGE_PIN G4 IOSTANDARD LVCMOS33 } [get_ports { led1_b }]; #IO_L20P_T3_35 Sch=led1_b
#set_property -dict { PACKAGE_PIN J4 IOSTANDARD LVCMOS33 } [get_ports { led1_g }]; #IO_L21P_T3_DQS_35 Sch=led1_g
#set_property -dict { PACKAGE_PIN G3 IOSTANDARD LVCMOS33 } [get_ports { led1_r }]; #IO_L20N_T3_35 Sch=led1_r
#set_property -dict { PACKAGE_PIN H4 IOSTANDARD LVCMOS33 } [get_ports { led2_b }]; #IO_L21N_T3_DQS_35 Sch=led2_b
#set_property -dict { PACKAGE_PIN J2 IOSTANDARD LVCMOS33 } [get_ports { led2_g }]; #IO_L22N_T3_35 Sch=led2_g
#set_property -dict { PACKAGE_PIN J3 IOSTANDARD LVCMOS33 } [get_ports { led2_r }]; #IO_L22P_T3_35 Sch=led2_r
#set_property -dict { PACKAGE_PIN K2 IOSTANDARD LVCMOS33 } [get_ports { led3_b }]; #IO_L23P_T3_35 Sch=led3_b
#set_property -dict { PACKAGE_PIN H6 IOSTANDARD LVCMOS33 } [get_ports { led3_g }]; #IO_L24P_T3_35 Sch=led3_g
#set_property -dict { PACKAGE_PIN K1 IOSTANDARD LVCMOS33 } [get_ports { led3_r }]; #IO_L23N_T3_35 Sch=led3_r
##LEDs
set_property -dict { PACKAGE_PIN H5 IOSTANDARD LVCMOS33 } [get_ports { led }]; #IO_L24N_T3_35 Sch=led[4]
#set_property -dict { PACKAGE_PIN J5 IOSTANDARD LVCMOS33 } [get_ports { led[1] }]; #IO_25_35 Sch=led[5]
#set_property -dict { PACKAGE_PIN T9 IOSTANDARD LVCMOS33 } [get_ports { led[2] }]; #IO_L24P_T3_A01_D17_14 Sch=led[6]
#set_property -dict { PACKAGE_PIN T10 IOSTANDARD LVCMOS33 } [get_ports { led[3] }]; #IO_L24N_T3_A00_D16_14 Sch=led[7]
##Buttons
#set_property -dict { PACKAGE_PIN D9 IOSTANDARD LVCMOS33 } [get_ports { btn[0] }]; #IO_L6N_T0_VREF_16 Sch=btn[0]
#set_property -dict { PACKAGE_PIN C9 IOSTANDARD LVCMOS33 } [get_ports { btn[1] }]; #IO_L11P_T1_SRCC_16 Sch=btn[1]
#set_property -dict { PACKAGE_PIN B9 IOSTANDARD LVCMOS33 } [get_ports { btn[2] }]; #IO_L11N_T1_SRCC_16 Sch=btn[2]
#set_property -dict { PACKAGE_PIN B8 IOSTANDARD LVCMOS33 } [get_ports { btn[3] }]; #IO_L12P_T1_MRCC_16 Sch=btn[3]
##Pmod Header JA
#set_property -dict { PACKAGE_PIN G13 IOSTANDARD LVCMOS33 } [get_ports { ja[0] }]; #IO_0_15 Sch=ja[1]
#set_property -dict { PACKAGE_PIN B11 IOSTANDARD LVCMOS33 } [get_ports { ja[1] }]; #IO_L4P_T0_15 Sch=ja[2]
#set_property -dict { PACKAGE_PIN A11 IOSTANDARD LVCMOS33 } [get_ports { ja[2] }]; #IO_L4N_T0_15 Sch=ja[3]
#set_property -dict { PACKAGE_PIN D12 IOSTANDARD LVCMOS33 } [get_ports { ja[3] }]; #IO_L6P_T0_15 Sch=ja[4]
#set_property -dict { PACKAGE_PIN D13 IOSTANDARD LVCMOS33 } [get_ports { ja[4] }]; #IO_L6N_T0_VREF_15 Sch=ja[7]
#set_property -dict { PACKAGE_PIN B18 IOSTANDARD LVCMOS33 } [get_ports { ja[5] }]; #IO_L10P_T1_AD11P_15 Sch=ja[8]
#set_property -dict { PACKAGE_PIN A18 IOSTANDARD LVCMOS33 } [get_ports { ja[6] }]; #IO_L10N_T1_AD11N_15 Sch=ja[9]
#set_property -dict { PACKAGE_PIN K16 IOSTANDARD LVCMOS33 } [get_ports { ja[7] }]; #IO_25_15 Sch=ja[10]
##Pmod Header JB
#set_property -dict { PACKAGE_PIN E15 IOSTANDARD LVCMOS33 } [get_ports { jb[0] }]; #IO_L11P_T1_SRCC_15 Sch=jb_p[1]
#set_property -dict { PACKAGE_PIN E16 IOSTANDARD LVCMOS33 } [get_ports { jb[1] }]; #IO_L11N_T1_SRCC_15 Sch=jb_n[1]
#set_property -dict { PACKAGE_PIN D15 IOSTANDARD LVCMOS33 } [get_ports { jb[2] }]; #IO_L12P_T1_MRCC_15 Sch=jb_p[2]
#set_property -dict { PACKAGE_PIN C15 IOSTANDARD LVCMOS33 } [get_ports { jb[3] }]; #IO_L12N_T1_MRCC_15 Sch=jb_n[2]
#set_property -dict { PACKAGE_PIN J17 IOSTANDARD LVCMOS33 } [get_ports { jb[4] }]; #IO_L23P_T3_FOE_B_15 Sch=jb_p[3]
#set_property -dict { PACKAGE_PIN J18 IOSTANDARD LVCMOS33 } [get_ports { jb[5] }]; #IO_L23N_T3_FWE_B_15 Sch=jb_n[3]
#set_property -dict { PACKAGE_PIN K15 IOSTANDARD LVCMOS33 } [get_ports { jb[6] }]; #IO_L24P_T3_RS1_15 Sch=jb_p[4]
#set_property -dict { PACKAGE_PIN J15 IOSTANDARD LVCMOS33 } [get_ports { jb[7] }]; #IO_L24N_T3_RS0_15 Sch=jb_n[4]
##Pmod Header JC
#set_property -dict { PACKAGE_PIN U12 IOSTANDARD LVCMOS33 } [get_ports { jc[0] }]; #IO_L20P_T3_A08_D24_14 Sch=jc_p[1]
#set_property -dict { PACKAGE_PIN V12 IOSTANDARD LVCMOS33 } [get_ports { jc[1] }]; #IO_L20N_T3_A07_D23_14 Sch=jc_n[1]
#set_property -dict { PACKAGE_PIN V10 IOSTANDARD LVCMOS33 } [get_ports { jc[2] }]; #IO_L21P_T3_DQS_14 Sch=jc_p[2]
#set_property -dict { PACKAGE_PIN V11 IOSTANDARD LVCMOS33 } [get_ports { jc[3] }]; #IO_L21N_T3_DQS_A06_D22_14

Sch=jc_n[2]
#set_property -dict { PACKAGE_PIN U14 IOSTANDARD LVCMOS33 } [get_ports { jc[4] }]; #IO_L22P_T3_A05_D21_14 Sch=jc_p[3]
#set_property -dict { PACKAGE_PIN V14 IOSTANDARD LVCMOS33 } [get_ports { jc[5] }]; #IO_L22N_T3_A04_D20_14 Sch=jc_n[3]
#set_property -dict { PACKAGE_PIN T13 IOSTANDARD LVCMOS33 } [get_ports { jc[6] }]; #IO_L23P_T3_A03_D19_14 Sch=jc_p[4]
#set_property -dict { PACKAGE_PIN U13 IOSTANDARD LVCMOS33 } [get_ports { jc[7] }]; #IO_L23N_T3_A02_D18_14 Sch=jc_n[4]
##Pmod Header JD
#set_property -dict { PACKAGE_PIN D4 IOSTANDARD LVCMOS33 } [get_ports { jd[0] }]; #IO_L11N_T1_SRCC_35 Sch=jd[1]
#set_property -dict { PACKAGE_PIN D3 IOSTANDARD LVCMOS33 } [get_ports { jd[1] }]; #IO_L12N_T1_MRCC_35 Sch=jd[2]
#set_property -dict { PACKAGE_PIN F4 IOSTANDARD LVCMOS33 } [get_ports { jd[2] }]; #IO_L13P_T2_MRCC_35 Sch=jd[3]
#set_property -dict { PACKAGE_PIN F3 IOSTANDARD LVCMOS33 } [get_ports { jd[3] }]; #IO_L13N_T2_MRCC_35 Sch=jd[4]
#set_property -dict { PACKAGE_PIN E2 IOSTANDARD LVCMOS33 } [get_ports { jd[4] }]; #IO_L14P_T2_SRCC_35 Sch=jd[7]
#set_property -dict { PACKAGE_PIN D2 IOSTANDARD LVCMOS33 } [get_ports { jd[5] }]; #IO_L14N_T2_SRCC_35 Sch=jd[8]
#set_property -dict { PACKAGE_PIN H2 IOSTANDARD LVCMOS33 } [get_ports { jd[6] }]; #IO_L15P_T2_DQS_35 Sch=jd[9]
#set_property -dict { PACKAGE_PIN G2 IOSTANDARD LVCMOS33 } [get_ports { jd[7] }]; #IO_L15N_T2_DQS_35 Sch=jd[10]
##USB-UART Interface
#set_property -dict { PACKAGE_PIN D10 IOSTANDARD LVCMOS33 } [get_ports { uart_rxd_out }]; #IO_L19N_T3_VREF_16
Sch=uart_rxd_out
#set_property -dict { PACKAGE_PIN A9 IOSTANDARD LVCMOS33 } [get_ports { uart_txd_in }]; #IO_L14N_T2_SRCC_16
Sch=uart_txd_in
##ChipKit Single Ended Analog Inputs

##NOTE: The ck_an_p pins can be used as single ended analog inputs with voltages from 0-3.3V (Chipkit Analog pins A0-A5).
## These signals should only be connected to the XADC core. When using these pins as digital I/O, use pins ck_io[14-19].
#set_property -dict { PACKAGE_PIN C5 IOSTANDARD LVCMOS33 } [get_ports { ck_an_n[0] }]; #IO_L1N_T0_AD4N_35

Sch=ck_an_n[0]
#set_property -dict { PACKAGE_PIN C6 IOSTANDARD LVCMOS33 } [get_ports { ck_an_p[0] }]; #IO_L1P_T0_AD4P_35
Sch=ck_an_p[0]
#set_property -dict { PACKAGE_PIN A5 IOSTANDARD LVCMOS33 } [get_ports { ck_an_n[1] }]; #IO_L3N_T0_DQS_AD5N_35
Sch=ck_an_n[1]
#set_property -dict { PACKAGE_PIN A6 IOSTANDARD LVCMOS33 } [get_ports { ck_an_p[1] }]; #IO_L3P_T0_DQS_AD5P_35
Sch=ck_an_p[1]
#set_property -dict { PACKAGE_PIN B4 IOSTANDARD LVCMOS33 } [get_ports { ck_an_n[2] }]; #IO_L7N_T1_AD6N_35
Sch=ck_an_n[2]
#set_property -dict { PACKAGE_PIN C4 IOSTANDARD LVCMOS33 } [get_ports { ck_an_p[2] }]; #IO_L7P_T1_AD6P_35
Sch=ck_an_p[2]
#set_property -dict { PACKAGE_PIN A1 IOSTANDARD LVCMOS33 } [get_ports { ck_an_n[3] }]; #IO_L9N_T1_DQS_AD7N_35
Sch=ck_an_n[3]
#set_property -dict { PACKAGE_PIN B1 IOSTANDARD LVCMOS33 } [get_ports { ck_an_p[3] }]; #IO_L9P_T1_DQS_AD7P_35
Sch=ck_an_p[3]
#set_property -dict { PACKAGE_PIN B2 IOSTANDARD LVCMOS33 } [get_ports { ck_an_n[4] }]; #IO_L10N_T1_AD15N_35
Sch=ck_an_n[4]
#set_property -dict { PACKAGE_PIN B3 IOSTANDARD LVCMOS33 } [get_ports { ck_an_p[4] }]; #IO_L10P_T1_AD15P_35
Sch=ck_an_p[4]
#set_property -dict { PACKAGE_PIN C14 IOSTANDARD LVCMOS33 } [get_ports { ck_an_n[5] }]; #IO_L1N_T0_AD0N_15
Sch=ck_an_n[5]
#set_property -dict { PACKAGE_PIN D14 IOSTANDARD LVCMOS33 } [get_ports { ck_an_p[5] }]; #IO_L1P_T0_AD0P_15
Sch=ck_an_p[5]
##ChipKit Digital I/O Low
#set_property -dict { PACKAGE_PIN V15 IOSTANDARD LVCMOS33 } [get_ports { ck_io[0] }]; #IO_L16P_T2_CSI_B_14 Sch=ck_io[0]
#set_property -dict { PACKAGE_PIN U16 IOSTANDARD LVCMOS33 } [get_ports { ck_io[1] }]; #IO_L18P_T2_A12_D28_14
Sch=ck_io[1]
#set_property -dict { PACKAGE_PIN P14 IOSTANDARD LVCMOS33 } [get_ports { ck_io[2] }]; #IO_L8N_T1_D12_14 Sch=ck_io[2]
#set_property -dict { PACKAGE_PIN T11 IOSTANDARD LVCMOS33 } [get_ports { ck_io[3] }]; #IO_L19P_T3_A10_D26_14
Sch=ck_io[3]
#set_property -dict { PACKAGE_PIN R12 IOSTANDARD LVCMOS33 } [get_ports { ck_io[4] }]; #IO_L5P_T0_D06_14 Sch=ck_io[4]
#set_property -dict { PACKAGE_PIN T14 IOSTANDARD LVCMOS33 } [get_ports { ck_io[5] }]; #IO_L14P_T2_SRCC_14 Sch=ck_io[5]
#set_property -dict { PACKAGE_PIN T15 IOSTANDARD LVCMOS33 } [get_ports { ck_io[6] }]; #IO_L14N_T2_SRCC_14 Sch=ck_io[6]
#set_property -dict { PACKAGE_PIN T16 IOSTANDARD LVCMOS33 } [get_ports { ck_io[7] }];
#IO_L15N_T2_DQS_DOUT_CSO_B_14 Sch=ck_io[7]
#set_property -dict { PACKAGE_PIN N15 IOSTANDARD LVCMOS33 } [get_ports { ck_io[8] }]; #IO_L11P_T1_SRCC_14 Sch=ck_io[8]
#set_property -dict { PACKAGE_PIN M16 IOSTANDARD LVCMOS33 } [get_ports { ck_io[9] }]; #IO_L10P_T1_D14_14 Sch=ck_io[9]
#set_property -dict { PACKAGE_PIN V17 IOSTANDARD LVCMOS33 } [get_ports { ck_io[10] }]; #IO_L18N_T2_A11_D27_14
Sch=ck_io[10]
#set_property -dict { PACKAGE_PIN U18 IOSTANDARD LVCMOS33 } [get_ports { ck_io[11] }]; #IO_L17N_T2_A13_D29_14
Sch=ck_io[11]
#set_property -dict { PACKAGE_PIN R17 IOSTANDARD LVCMOS33 } [get_ports { ck_io[12] }]; #IO_L12N_T1_MRCC_14
Sch=ck_io[12]
#set_property -dict { PACKAGE_PIN P17 IOSTANDARD LVCMOS33 } [get_ports { ck_io[13] }]; #IO_L12P_T1_MRCC_14
Sch=ck_io[13]

##ChipKit Digital I/O On Outer Analog Header
##NOTE: These pins should be used when using the analog header signals A0-A5 as digital I/O (Chipkit digital pins 14-19)
#set_property -dict { PACKAGE_PIN F5 IOSTANDARD LVCMOS33 } [get_ports { ck_io[14] }]; #IO_0_35 Sch=ck_a[0]
#set_property -dict { PACKAGE_PIN D8 IOSTANDARD LVCMOS33 } [get_ports { ck_io[15] }]; #IO_L4P_T0_35 Sch=ck_a[1]
#set_property -dict { PACKAGE_PIN C7 IOSTANDARD LVCMOS33 } [get_ports { ck_io[16] }]; #IO_L4N_T0_35 Sch=ck_a[2]
#set_property -dict { PACKAGE_PIN E7 IOSTANDARD LVCMOS33 } [get_ports { ck_io[17] }]; #IO_L6P_T0_35 Sch=ck_a[3]
#set_property -dict { PACKAGE_PIN D7 IOSTANDARD LVCMOS33 } [get_ports { ck_io[18] }]; #IO_L6N_T0_VREF_35 Sch=ck_a[4]
#set_property -dict { PACKAGE_PIN D5 IOSTANDARD LVCMOS33 } [get_ports { ck_io[19] }]; #IO_L11P_T1_SRCC_35 Sch=ck_a[5]
##ChipKit Digital I/O On Inner Analog Header

##NOTE: These pins will need to be connected to the XADC core when used as differential analog inputs (Chipkit analog pins A6-A11)
#set_property -dict { PACKAGE_PIN B7 IOSTANDARD LVCMOS33 } [get_ports { ck_io[20] }]; #IO_L2P_T0_AD12P_35

Sch=ad_p[12]
#set_property -dict { PACKAGE_PIN B6 IOSTANDARD LVCMOS33 } [get_ports { ck_io[21] }]; #IO_L2N_T0_AD12N_35
Sch=ad_n[12]
#set_property -dict { PACKAGE_PIN E6 IOSTANDARD LVCMOS33 } [get_ports { ck_io[22] }]; #IO_L5P_T0_AD13P_35
Sch=ad_p[13]
#set_property -dict { PACKAGE_PIN E5 IOSTANDARD LVCMOS33 } [get_ports { ck_io[23] }]; #IO_L5N_T0_AD13N_35
Sch=ad_n[13]
#set_property -dict { PACKAGE_PIN A4 IOSTANDARD LVCMOS33 } [get_ports { ck_io[24] }]; #IO_L8P_T1_AD14P_35
Sch=ad_p[14]
#set_property -dict { PACKAGE_PIN A3 IOSTANDARD LVCMOS33 } [get_ports { ck_io[25] }]; #IO_L8N_T1_AD14N_35
Sch=ad_n[14]
##ChipKit Digital I/O High
#set_property -dict { PACKAGE_PIN U11 IOSTANDARD LVCMOS33 } [get_ports { ck_io[26] }]; #IO_L19N_T3_A09_D25_VREF_14
Sch=ck_io[26]
#set_property -dict { PACKAGE_PIN V16 IOSTANDARD LVCMOS33 } [get_ports { ck_io[27] }]; #IO_L16N_T2_A15_D31_14
Sch=ck_io[27]
#set_property -dict { PACKAGE_PIN M13 IOSTANDARD LVCMOS33 } [get_ports { ck_io[28] }]; #IO_L6N_T0_D08_VREF_14
Sch=ck_io[28]
#set_property -dict { PACKAGE_PIN R10 IOSTANDARD LVCMOS33 } [get_ports { ck_io[29] }]; #IO_25_14 Sch=ck_io[29]
#set_property -dict { PACKAGE_PIN R11 IOSTANDARD LVCMOS33 } [get_ports { ck_io[30] }]; #IO_0_14 Sch=ck_io[30]
#set_property -dict { PACKAGE_PIN R13 IOSTANDARD LVCMOS33 } [get_ports { ck_io[31] }]; #IO_L5N_T0_D07_14 Sch=ck_io[31]
#set_property -dict { PACKAGE_PIN R15 IOSTANDARD LVCMOS33 } [get_ports { ck_io[32] }]; #IO_L13N_T2_MRCC_14
Sch=ck_io[32]
#set_property -dict { PACKAGE_PIN P15 IOSTANDARD LVCMOS33 } [get_ports { ck_io[33] }]; #IO_L13P_T2_MRCC_14
Sch=ck_io[33]
#set_property -dict { PACKAGE_PIN R16 IOSTANDARD LVCMOS33 } [get_ports { ck_io[34] }]; #IO_L15P_T2_DQS_RDWR_B_14
Sch=ck_io[34]
#set_property -dict { PACKAGE_PIN N16 IOSTANDARD LVCMOS33 } [get_ports { ck_io[35] }]; #IO_L11N_T1_SRCC_14
Sch=ck_io[35]
#set_property -dict { PACKAGE_PIN N14 IOSTANDARD LVCMOS33 } [get_ports { ck_io[36] }]; #IO_L8P_T1_D11_14 Sch=ck_io[36]
#set_property -dict { PACKAGE_PIN U17 IOSTANDARD LVCMOS33 } [get_ports { ck_io[37] }]; #IO_L17P_T2_A14_D30_14
Sch=ck_io[37]
#set_property -dict { PACKAGE_PIN T18 IOSTANDARD LVCMOS33 } [get_ports { ck_io[38] }]; #IO_L7N_T1_D10_14 Sch=ck_io[38]
#set_property -dict { PACKAGE_PIN R18 IOSTANDARD LVCMOS33 } [get_ports { ck_io[39] }]; #IO_L7P_T1_D09_14 Sch=ck_io[39]
#set_property -dict { PACKAGE_PIN P18 IOSTANDARD LVCMOS33 } [get_ports { ck_io[40] }]; #IO_L9N_T1_DQS_D13_14
Sch=ck_io[40]
#set_property -dict { PACKAGE_PIN N17 IOSTANDARD LVCMOS33 } [get_ports { ck_io[41] }]; #IO_L9P_T1_DQS_14 Sch=ck_io[41]
## ChipKit SPI
#set_property -dict { PACKAGE_PIN G1 IOSTANDARD LVCMOS33 } [get_ports { ck_miso }]; #IO_L17N_T2_35 Sch=ck_miso
#set_property -dict { PACKAGE_PIN H1 IOSTANDARD LVCMOS33 } [get_ports { ck_mosi }]; #IO_L17P_T2_35 Sch=ck_mosi
#set_property -dict { PACKAGE_PIN F1 IOSTANDARD LVCMOS33 } [get_ports { ck_sck }]; #IO_L18P_T2_35 Sch=ck_sck
#set_property -dict { PACKAGE_PIN C1 IOSTANDARD LVCMOS33 } [get_ports { ck_ss }]; #IO_L16N_T2_35 Sch=ck_ss
## ChipKit I2C
#set_property -dict { PACKAGE_PIN L18 IOSTANDARD LVCMOS33 } [get_ports { ck_scl }]; #IO_L4P_T0_D04_14 Sch=ck_scl
#set_property -dict { PACKAGE_PIN M18 IOSTANDARD LVCMOS33 } [get_ports { ck_sda }]; #IO_L4N_T0_D05_14 Sch=ck_sda
#set_property -dict { PACKAGE_PIN A14 IOSTANDARD LVCMOS33 } [get_ports { scl_pup }]; #IO_L9N_T1_DQS_AD3N_15
Sch=scl_pup
#set_property -dict { PACKAGE_PIN A13 IOSTANDARD LVCMOS33 } [get_ports { sda_pup }]; #IO_L9P_T1_DQS_AD3P_15
Sch=sda_pup
##Misc. ChipKit signals
#set_property -dict { PACKAGE_PIN M17 IOSTANDARD LVCMOS33 } [get_ports { ck_ioa }]; #IO_L10N_T1_D15_14 Sch=ck_ioa
#set_property -dict { PACKAGE_PIN C2 IOSTANDARD LVCMOS33 } [get_ports { ck_rst }]; #IO_L16P_T2_35 Sch=ck_rst
##SMSC Ethernet PHY
#set_property -dict { PACKAGE_PIN D17 IOSTANDARD LVCMOS33 } [get_ports { eth_col }]; #IO_L16N_T2_A27_15 Sch=eth_col
#set_property -dict { PACKAGE_PIN G14 IOSTANDARD LVCMOS33 } [get_ports { eth_crs }]; #IO_L15N_T2_DQS_ADV_B_15

Sch=eth_crs
#set_property -dict { PACKAGE_PIN F16 IOSTANDARD LVCMOS33 } [get_ports { eth_mdc }]; #IO_L14N_T2_SRCC_15
Sch=eth_mdc
#set_property -dict { PACKAGE_PIN K13 IOSTANDARD LVCMOS33 } [get_ports { eth_mdio }]; #IO_L17P_T2_A26_15
Sch=eth_mdio
#set_property -dict { PACKAGE_PIN G18 IOSTANDARD LVCMOS33 } [get_ports { eth_ref_clk }]; #IO_L22P_T3_A17_15
Sch=eth_ref_clk
#set_property -dict { PACKAGE_PIN C16 IOSTANDARD LVCMOS33 } [get_ports { eth_rstn }]; #IO_L20P_T3_A20_15 Sch=eth_rstn
#set_property -dict { PACKAGE_PIN F15 IOSTANDARD LVCMOS33 } [get_ports { eth_rx_clk }]; #IO_L14P_T2_SRCC_15
Sch=eth_rx_clk
#set_property -dict { PACKAGE_PIN G16 IOSTANDARD LVCMOS33 } [get_ports { eth_rx_dv }]; #IO_L13N_T2_MRCC_15
Sch=eth_rx_dv
#set_property -dict { PACKAGE_PIN D18 IOSTANDARD LVCMOS33 } [get_ports { eth_rxd[0] }]; #IO_L21N_T3_DQS_A18_15
Sch=eth_rxd[0]
#set_property -dict { PACKAGE_PIN E17 IOSTANDARD LVCMOS33 } [get_ports { eth_rxd[1] }]; #IO_L16P_T2_A28_15
Sch=eth_rxd[1]
#set_property -dict { PACKAGE_PIN E18 IOSTANDARD LVCMOS33 } [get_ports { eth_rxd[2] }]; #IO_L21P_T3_DQS_15
Sch=eth_rxd[2]
#set_property -dict { PACKAGE_PIN G17 IOSTANDARD LVCMOS33 } [get_ports { eth_rxd[3] }]; #IO_L18N_T2_A23_15
Sch=eth_rxd[3]
#set_property -dict { PACKAGE_PIN C17 IOSTANDARD LVCMOS33 } [get_ports { eth_rxerr }]; #IO_L20N_T3_A19_15
Sch=eth_rxerr
#set_property -dict { PACKAGE_PIN H16 IOSTANDARD LVCMOS33 } [get_ports { eth_tx_clk }]; #IO_L13P_T2_MRCC_15
Sch=eth_tx_clk
#set_property -dict { PACKAGE_PIN H15 IOSTANDARD LVCMOS33 } [get_ports { eth_tx_en }]; #IO_L19N_T3_A21_VREF_15
Sch=eth_tx_en
#set_property -dict { PACKAGE_PIN H14 IOSTANDARD LVCMOS33 } [get_ports { eth_txd[0] }]; #IO_L15P_T2_DQS_15
Sch=eth_txd[0]
#set_property -dict { PACKAGE_PIN J14 IOSTANDARD LVCMOS33 } [get_ports { eth_txd[1] }]; #IO_L19P_T3_A22_15
Sch=eth_txd[1]
#set_property -dict { PACKAGE_PIN J13 IOSTANDARD LVCMOS33 } [get_ports { eth_txd[2] }]; #IO_L17N_T2_A25_15
Sch=eth_txd[2]
#set_property -dict { PACKAGE_PIN H17 IOSTANDARD LVCMOS33 } [get_ports { eth_txd[3] }]; #IO_L18P_T2_A24_15
Sch=eth_txd[3]
##Quad SPI Flash
#set_property -dict { PACKAGE_PIN L13 IOSTANDARD LVCMOS33 } [get_ports { qspi_cs }]; #IO_L6P_T0_FCS_B_14 Sch=qspi_cs
#set_property -dict { PACKAGE_PIN K17 IOSTANDARD LVCMOS33 } [get_ports { qspi_dq[0] }]; #IO_L1P_T0_D00_MOSI_14
Sch=qspi_dq[0]
#set_property -dict { PACKAGE_PIN K18 IOSTANDARD LVCMOS33 } [get_ports { qspi_dq[1] }]; #IO_L1N_T0_D01_DIN_14
Sch=qspi_dq[1]
#set_property -dict { PACKAGE_PIN L14 IOSTANDARD LVCMOS33 } [get_ports { qspi_dq[2] }]; #IO_L2P_T0_D02_14
Sch=qspi_dq[2]
#set_property -dict { PACKAGE_PIN M14 IOSTANDARD LVCMOS33 } [get_ports { qspi_dq[3] }]; #IO_L2N_T0_D03_14
Sch=qspi_dq[3]
##Power Measurements
#set_property -dict { PACKAGE_PIN B17 IOSTANDARD LVCMOS33 } [get_ports { vsnsvu_n }]; #IO_L7N_T1_AD2N_15
Sch=ad_n[2]
#set_property -dict { PACKAGE_PIN B16 IOSTANDARD LVCMOS33 } [get_ports { vsnsvu_p }]; #IO_L7P_T1_AD2P_15
Sch=ad_p[2]
#set_property -dict { PACKAGE_PIN B12 IOSTANDARD LVCMOS33 } [get_ports { vsns5v0_n }]; #IO_L3N_T0_DQS_AD1N_15
Sch=ad_n[1]
#set_property -dict { PACKAGE_PIN C12 IOSTANDARD LVCMOS33 } [get_ports { vsns5v0_p }]; #IO_L3P_T0_DQS_AD1P_15
Sch=ad_p[1]
#set_property -dict { PACKAGE_PIN F14 IOSTANDARD LVCMOS33 } [get_ports { isns5v0_n }]; #IO_L5N_T0_AD9N_15
Sch=ad_n[9]
#set_property -dict { PACKAGE_PIN F13 IOSTANDARD LVCMOS33 } [get_ports { isns5v0_p }]; #IO_L5P_T0_AD9P_15
Sch=ad_p[9]
#set_property -dict { PACKAGE_PIN A16 IOSTANDARD LVCMOS33 } [get_ports { isns0v95_n }]; #IO_L8N_T1_AD10N_15
Sch=ad_n[10]
#set_property -dict { PACKAGE_PIN A15 IOSTANDARD LVCMOS33 } [get_ports { isns0v95_p }]; #IO_L8P_T1_AD10P_15
Sch=ad_p[10]

Les Références Bibliographiques
1. M.Aumiaux, "initiation au langage VHDL", 2ieme édition, Dunod, Paris 1999

2. P. Aubertin," Principe des Circuits Intégrés à Très Grande Échelle", ELE4304, Automne 2008
3. S. Yalamanchili, “VHDL Starter’s Guide,” Prentice Hall, Upper Saddle River, 1998.
4. J. Bhasker, “VHDL Primer,” 3rd Edition, Prentice Hall, Upper Saddle River, 1998.
5. P. J. Ashenden, “The Student’s Guide to VHDL,” Morgan Kaufmann Publishers, Inc, San Francisco, 1998.
6. A. Dewey, “Analysis and Design of Digital Systems,” PWS Publishing Company, New York, 1997.
7. C. H. Roth, “Digital System Design using VHDL”, PWS Publishing Company, New York, 1998.
8. D. Pellerin and D. Taylor, “VHDL Made Easy!”, ,” Prentice Hall, Upper Saddle River, 1997.
9. VHDL Reference Guide, Xilinx, Inc., (available on line: http://toolbox.xilinx.com/docsan/ (select
Foundation Series)
10. VHDL du langage à la modélisation, R.AIRIAU, J.M.BERGE, V.OLIVE, R.ROUILLARD, Presses
Polytechniques et Universitaires Romandes
11. VHDL Modeling for Digital Design Synthesis, YU.CHIN HSU, KEVIN.F.TSAI, JESSIE.T.LIU,
ERIC.S.LIN, Kluwer Academic Publishers
12. A guide to VHDL, STANLEY MAZOR, PATRICIA LANGSTRAAT, Kluwer Academic Publishers
13. VHDL : méthodologie de design et techniques avancées, T. SCHNEIDER, Dunod
14. VHDL Introduction à la synthèse logique, P. LARCHER, Eyrolles
15. VHDL Du langage au circuit, du circuit au langage, J. WEBER, M. MEAUDRE, Masson
16. IEEE Standard VHDL Language Reference Manual (VHDL-1993),
17. IEEE 1076-1993
18. IEEE Standard Multivalue Logic System for VHDL Model Interoperability,
19. IEEE Std 1164-1993
20. IEEE Standard VHDL Synthesis Packages,
21. IEEE-1076.3, 1997
22. Définit en autre le paquetage Numeric_Std, avec les types Unsigned et Signed.
23. IEEE Standard for VHDL Register Transfer Level Synthesis, IEEE 1076.6-1999
24. Cours Expert VHDL, design & verification, Doulos présenté par Bertrand Cuzeau, septembre 2001, 2002
25. Le Langage VHDL pour la Conception et le Test des Circuits Logiques Programmables, A.L.S.E., Paris,
Bertrand Cuzeau, juin 1999.
26. Cours : VHDL tout simplement …., Multi Video Designs, M. E. Garcia, mars 2000
27. Conception numérique : méthode et langage VHDL, Etienne Messerli, HEIG-VD, édition 2000 à 2005
28. Cours VHDL avancé, Etienne Messerli, HEIG-VD, 2004 à 2007
29. Cours VHDL avancé INSA, Rennes, France, Etienne Messerli, 2007 à 2009
30. https://fr.wikipedia.org/wiki/Architecture_MIPS
31. http://hdl.telecom-paristech.fr/verilog_syntaxe.html#convlex
32. http://www.fpga4student.com/2017/01/vhdl-code-for-fifo-memory.html
33. https://moodle.polymtl.ca/pluginfile.php/230711/mod_page/content/49/ELE3311-Guide_LAB-
v1.6.pdf
34. https://reference.digilentinc.com/vivado/getting_started/start
35. https://reference.digilentinc.com/learn/programmable-logic/tutorials/arty-pmod-vga-demo/start
36. http://bertrand.granado.free.fr/LE201/LE201/Travaux_Pratiques.html
37. http://bertrand.granado.free.fr/LE201/LE201/Travaux_Pratiques_files/projet2017.pdf
38. https://moodle.polymtl.ca/pluginfile.php/230711/mod_page/content/67/ELE3311-Guide_LAB-
v1.6.pdf
39. http://easytp.cnam.fr/alexandre/index_fichiers/support/zynq_cours_tp_vivado_basys3.pdf

View publication stats

VHDL

Hochgeladen von

Dokumentinformationen

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

VHDL

Hochgeladen von

Copyright:

Verfügbare Formate

See discussions, stats, and author profiles for this publication at: https://www.researchgate.

Synthèse VHDL d’architectures

Book · November 2018

MICROWAVE IMAGING TECHNIQUE FOR BREAST CANCER DETECTION View project

PROJECT I : SMART ANTENNA TECHNOLOGY View project

The user has requested enhancement of the downloaded file.

Institut Supérieur d'Informatique

Synthèse VHDL d’architectures

Ce cours de langage VHDL s'adresse particulièrement aux étudiants en Licences professionnelles et

Ridha Ghayoula, Ph.d, Eng

Page | 1 © ISI 2013 Ridha Ghayoula

Chapitre 1 INTRODUCTION A LA SYNTHESE LOGIQUE - VHDL 4

Chapitre 2 STRUCTURE D’UNE DESCRIPTION VHDL 24

Chapitre 3 MACHINE A ETATS FINIS 42

Chapitre 5 VERILOG POUR MÉMOIRE FIFO 84

Chapitre 6 COMMANDE PWM DES MOTEURS PAR FPGA 92

Chapitre 7 SYNTHESE D'UN PROCESSEUR MIPS SUR FPGA 99

INITIATION À L’ENVIRONNEMENT DE CONCEPTION FPGA ISE14.6, Vivado,Isim,

Page | 3 © ISI 2013 Ridha Ghayoula

1.2. Structure d'un programme en VHDL

Page | 4 © ISI 2013 Ridha Ghayoula

1.2.1. Déclaration des bibliothèques

Cela se fait de la manière suivante :

1.2.2. Déclaration de l’entité et des entrées / sorties (I/O)

Exemple N°1 : Une bascule D

Page | 5 © ISI 2013 Ridha Ghayoula

CONSTANT const_name {, const_name} : type := value;

Exemple N°2 : constant BUS_WIDTH : integer := 8;

Generic: La section GENERIC_DECLARATIONS dans l'entête ENTITY permet de définir

Cette méthode d'écriture permet une maintenance plus aisée.

Page | 6 © ISI 2013 Ridha Ghayoula

ARCHITECTURE behavior OF nor2 IS

1.2.2.2. Le SENS du signal.

Exemple N°1 : Faire un bus de 5 bits

Page | 7 © ISI 2013 Ridha Ghayoula

a) Les types prédéfinis par tous les compilateurs

Page | 8 © ISI 2013 Ridha Ghayoula

1.2.3. Les déclarations d'architecture

Architecture nom_de_l'architecture of nom_de_l'entite is

Exemple N°1 : Réaliser le programme VHDL d'une porte NAND

On donne : - l'affectation : <=

Page | 9 © ISI 2013 Ridha Ghayoula

Architecture desc_NAND of NAND is

1.2.4. Les opérateurs.

Exemple avec des portes logiques : S1 <= E2 and E1 ;

1.2.4.2. Opérateur de concaténation : &

Exemple N°1 : A <= "001";

1.2.4.3. Opérateurs logiques

Page | 10 © ISI 2013 Ridha Ghayoula

Exemple N°2 : A <= "1010011"

B <= "01" & A SLL 2 B <= 011001100

1.2.4.4.Opérateurs d’assignation et d’association

signal a : std_logic_vector (0 to 7);

Page | 11 © ISI 2013 Ridha Ghayoula

On aurais pu écrire aussi :

Page | 12 © ISI 2013 Ridha Ghayoula

Architecture desc_multiplex of multiplex is

Remarque : Les valeurs ne sont affectées qu'après la fin du process

Exemple N°2 : Déclaration d’une bascule D.

Exemple N°3 : La bascule D avec un reset asynchrone

Page | 14 © ISI 2013 Ridha Ghayoula

ARCHITECTURE archdff OF Bascule_D IS

B.1) Le fonctionnement du "If"

Page | 15 © ISI 2013 Ridha Ghayoula