VHDL Prot

,QWURGXFWLRQ
DX
9+'/
rvq (('
8Br
Introduction au VHDL
eivd
22 juin 1998
,1752'8&7,21
Cette introduction VHDL n'a pas la prtention de couvrir tous les aspects de ce langage.
En fait, elle suppose une connaissance pralable du langage ADA. Nous nous attarderons
d'avantage sur une mthode de travail avec le VHDL que sur la grammaire de ce langage.
Il existe pour cette dernire une quantit de livres dont certains sont cits dans la
bibliographie en fin de manuel. De plus, pour une rfrence sre, il est galement possible
de commander la norme VHDL 1993 (IEEE 1164).
Ce cours d'introduction se compose de trois modules :
1) une prsentation gnrale du langage qui permet dcrire trs rapidement des applications
simples.
2) une partie plus pousse sur le langage oriente vers lcriture de programmes plus
complexes.
3) une srie dexemples utilisables, de procdures utiles et de trucs et astuces.

%S@ACDTUPSDRV@
Le VHDL - WHSIC (Very High Speed Integrated Circuit) Cardware 9escription Ganguage
, linstar de lADA, a t demand par le DOD (Dpartement de la dfense amricain)
pour dcrire les circuits complexes, de manire tablir un langage commun avec ses
fournisseurs. Cest un langage, standard IEEE 1076 depuis 1987, qui aurait du assurer la
portabilit du code pour diffrents outils de travail (simulation, synthse pour tous les
circuits et tous les fabricants). Malheureusement, ce nest pour linstant pas le cas, bien que
plusieurs vendeurs aient tendance se rapprocher du VHDL utilis par Synopsis.
Une mise jour du langage VHDL sest faite en 1993 (IEEE 1164) et en 1996, la norme
1076.3 a permis de standardiser la synthse VHDL.

8UDGDUe9V9+'/
Le VHDL est un langage de spcification, de simulation et galement de conception.
cgx
v.1
1.1 (2)
eivd
22 juin 1998
Contrairement dautres langages (CUPL, ABEL) qui se trouvaient tre en premier lieu des
langages de conception, VHDL est dabord un langage de spcification. La normalisation
a dabord eu lieu pour la spcification et la simulation (1987) et ensuite pour la synthse
(1993). Cette notion est relativement importante pour comprendre le fonctionnement du
langage et son volution. Grce la normalisation, on peut tre certain quun systme dcrit
en VHDL standard est lisible quel que soit le fabricant de circuits. Par contre, cela demande
un effort important aux fabricants de circuits pour crer des compilateurs VHDL adapts
et autant que possible optimiss pour leurs propres circuits.
!
Tppvsvphv
Etabli en premier lieu pour de la spcification, cest dans ce domaine que la norme est
actuellement la mieux tablie. Il est tout--fait possible de dcrire un circuit en un VHDL
standard pour quil soit lisible de tous. Certains fabricants (de circuits ou de CAO) adaptent
ce langage pour donner lutilisateur quelques facilits supplmentaires, au dtriment de la
portabilit du code. Heureusement, il y a une nette tendance de la part des fabricants revoir
leurs positions et uniformiser le VHDL. Le rapprochement se fait, comme prcit, autour
du VHDL de Synopsis. Il est donc probable que lon sapproche dun vrai standard VHDL
et non plus dun standard thorique. Il y aura toujours des ajouts de la part des fabricants,
mais il ne sagira plus dune modification du langage (aussi lgre soit elle), mais de macros
offertes lutilisateur pour optimiser le code VHDL en fonction du circuit cible (en vue de
la synthse).
Cette possibilit de dcrire des circuits dans un langage universel est aussi trs pratique pour
viter les problmes de langue. De longues explications dans une langue peuvent ainsi tre
compltes par du code VHDL pour en faciliter la comprhension.
!!
Tvyhv
Le VHDL est galement un langage de simulation. Pour ce faire, la notion de temps, sous
diffrentes formes, y a t introduite. Des modules, destins uniquement la simulation,
peuvent ainsi tre crs et utiliss pour valider un fonctionnement logique ou temporel du
code VHDL.
La possibilit de simuler avec des programmes VHDL devrait considrablement faciliter
lcriture de tests avant la programmation du circuit et viter ainsi de nombreux essais sur
un prototype qui sont beaucoup plus coteux et dont les erreurs sont plus difficiles
trouver.
cgx
v.1
1.2 (3)
eivd
22 juin 1998
Bien que la simulation offre de grandes facilits de test, il est toujours ncessaire de
concevoir les circuits en vue des tests de fabrication, cest--dire en permettant laccs
certains signaux internes.
!"
8prv
Le VHDL permet la conception de circuits avec une grande quantit de portes. Les circuits
actuels comprennent, pour les FPGA par exemple, entre 500 et 100'000 portes et ce nombre
augmente trs rapidement. Lavantage dun langage tel que celui-ci par rapport aux langages
prcdents de conception matrielle est comparable lavantage dun langage informatique
de haut niveau (Pascal, ADA, C) vis--vis de lassembleur. Ce qui veut aussi dire que malgr
lvolution fulgurante de la taille des circuits, la longueur du code VHDL na pas suivi la
mme courbe. Cependant, ce langage tant conu en premier lieu pour de la spcification,
certaines variantes du langage ne sont pour l'instant pas utilisables pour la conception.
Il faut noter que lorsquil sagit de concevoir quelque chose en VHDL, il ne faut pas le faire
tte baisse. Le VHDL, bien que facilement accessible dans ses bases, peut devenir
extrmement compliqu sil sagit doptimiser le code pour une architecture de circuit. Cest
pour cette raison que de plus en plus de fabricants offrent des macros, gratuites pour les
fonctions sans grandes difficults et payantes pour les autres. Donc avant de concevoir une
ALU, un processeur RISC, une interface PCI ou dautres lments de cette complexit, il
peut tre judicieux de choisir un circuit cible en fonction des besoins et dacheter la macro
offerte par le constructeur. Il est bien vident quil faudra valuer les besoins (performance
du code ncessaire, quantit de pices produire) et le cot dune telle macro.
cgx
v.1
1.3 (4)
eivd
22 juin 1998
&203$5$,621 $9(& $'$

La structure du VHDL a t tire du langage ADA, ce qui implique que de nombreuses
notions acquises avec lADA seront utilises ici. Pour viter de faire double emploi avec des
cours sur lADA, seules les diffrences entre VHDL et ADA seront traites ci-dessous. Cela
permettra dcrire trs rapidement des programmes simples en VHDL.
6rhiyvr)
ADA est un langage pour crire des logiciels, VHDL est destin dcrire, simuler et
synthtiser des circuits. Il faut toujours faire attention ce que lon veut faire lorsque lon
programme en VHDL, sinon de mauvaises surprises peuvent apparatre.

6USV8UVS@9@TQSPBS6HH@T
La structure est celle de l'ADA. Par contre, VHDL a des particularits spcifiques la
modlisation de circuits. De nouveaux types sont dfinis, ainsi que de nouveaux mots
rservs. Ceux-ci sont directement lis laspect physique de la conception de circuits. De
plus, la notion de temps intervient dans le VHDL de la mme manire que dans la ralit.

/@TTDBI6VY
Un nouveau mot rserv fait son apparition avec VHDL, il sagit du mot vthy. Il permet
de dsigner les signaux qui seront utiliss dans le circuit intgr. Certains types particuliers,
souvent des types numrs, sont utiliss pour un signal. Par exemple le type BIT (0,1),
qui est pr-dfini en VHDL, ou des types plus complets comme le BIT_ETENDU
(0,1,X,Z). [BIT_ETENDU nest pas un type prdfini en VHDL]
cgx
v.1
2.1 (5)

eivd
22 juin 1998
7`Q@TQC`TDRV@T
De nouveaux types, les types physiques (distance, capacit, rsistance, ...), permettent de
dfinir des valeurs concrtes et de calculer partir de celles-ci. Certains de ces types seront
donns dans les annexes, ainsi que des exemples de calculs. Pour illustrer cela, un exemple
est donn ci-dessous pour reprsenter les temps. Ce type est prdfini en VHDL.
U`Q@ time DTS6IB@ -9_223_372_036_854_775_808 UP
9_223_372_036_854_775_807
VIDUT fs;
ps=1000 fs;
ns=1000 ps;
us=1000 ns;
ms=1000 us;
sec=1000 ms;
min=60 sec;
hr=60 min;
---------
-- 64 bits pour le codage
femtoseconde, unite de base

picoseconde
nanoseconde
microseconde
milliseconde
seconde
minute
heure
@I9VIDUT;
Ce type est pr-dfini cause de la notion de temps qui a t ajoute au VHDL. Lunit de
base est la femtoseconde et toutes les autres units sont dfinies partir de celle-ci. De
mme les autres types physiques se dfinissent partir dune unit et on peut rfrencer
toutes les autres la premire. Il sera donc possible de reprsenter, par exemple, la dure
de la charge dun condensateur qui se trouverait lentre du circuit intgr, ce qui rendra
les simulations de plus en plus ralistes.

1PUDPI9@U@HQT
Un ajout important du VHDL par rapport lADA est la notion de temps. Si celle-ci
apparat quand mme dans lADA, mais de manire lie lhorloge, elle sexprime en units
de temps sous VHDL qui pourraient tout aussi bien tre convertis en pas de simulation.
Cette notion permet de tenir compte des temps de retard des portes logiques ou de crer des
programmes pour la simulation des circuits.
Il faut galement savoir qu chaque assignation de signal, cette notion de temps est utilise.
Pour mieux comprendre cela, quelques exemples sont donns ci-dessous avec leurs
particularits.
r h;25i0
cgx
v.1
2.2 (6)
eivd
22 juin 1998
r h;25i$)7(50
Les deux assignements ci-dessus ont exactement la mme signification. On appelle temps
delta le temps nul, quil soit reprsent ou non par le code after 0ns. En effet, il est
impossible pour un systme dvaluer immdiatement une sortie, par consquent on place
sur la droite de lquation (A$B) la valeur future quaura la partie gauche de lquation
(Somme), avec le temps de retard impos par la logique ncessaire. Il est tout--fait
possible, pour une simulation, que lon ne dsire pas tenir compte des temps de transfert des
portes, on crira alors les quations sous lune des deux formes ci-dessus, mais nous aurons
alors une simulation purement fonctionnelle. La figure 2 reprsente le temps de rponse de
la sortie et ce qui sera affich lors dune simulation si lon choisi un temps de 0ns.
Dhtr!
r h;25i$)7(5 0
Cette quation indique que la valeur future de Somme vaut A$B, cette modification
interviendra 10ns aprs un changement sur lune des deux variables.
!#
9rrqrqpyhv)vrvryrh
Ci-dessus, nous avons vu la possibilit davoir un dlai entre laction sur lentre et laction
sur la sortie et cela sans nous occuper de quelle manire ce dlai tait utilis. Il existe deux
types de dlais en VHDL, lun agit soit comme un retard, soit comme un filtre (le dlai
inertiel) et lautre comme un retard pur (le dlai transport).
cgx
v.1
2.3 (7)
!#
eivd
22 juin 1998
Grqpyhvvrvry
Le dlai inertiel est le dlai dfini par dfaut dans VHDL. Il peut scrire de deux manires:
somme
somme
12 DI@SUD6G a YPS b 6AU@S 10ns;

12 a YPS b 6AU@S 10ns;
Il agit comme un filtre, cest--dire que toutes les impulsions de dure infrieure celle
indique sont supprimes. Celles qui sont gales ou suprieures sont retardes de cette
valeur. Les deux exemples ci-dessous reprsentent mieux cela.
Exemple 1 :
somme
12 DI@SUD6G a YPS b 6AU@S 10ns;
Dhtr"
Il est possible de voir dans cet exemple que limpulsion qui se trouve 35ns et qui ne dure
que 7.5ns est limine car elle est infrieure aux 10ns spcifies. Le reste du signal est
report de 10ns.
Exemple 2:
retard
cgx
12 DI@SUD6G signal 6AU@S 10ns;
v.1
2.4 (8)
eivd
22 juin 1998
Dhtr#
A nouveau, cet exemple montre que limpulsion 35ns et ne durant que 5ns nest pas prise
en compte et laisse le signal de sortie la valeur 1 avec toujours le mme retard de 10ns. Il
est impratif de lire ces diagrammes temporels de gauche droite, sinon on commettra
l'erreur de vouloir supprimer limpulsion 1 qui se trouve 40ns et qui dure 2.5ns.
!# !
Grqpyhvh
somme
12 US6ITQPSU a YPS b 6AU@S 10ns;
Avec ce type de dlai, toutes les impulsions sont transmises, mais avec le retard indiqu. Il
faut toujours prendre garde placer le mot-cl h si lon veut un retard pur sans
soccuper de filtrer des impulsions de dure infrieure celle indique.
figure 4
cgx
v.1
2.5 (9)
eivd
22 juin 1998
La mme impulsion 35ns durant 7.5ns qui avait t supprime en dlai inertiel est
conserve ci-dessus. Seul le retard de 10ns subsiste.
!#!
Vvyvhvqrrvrrhq
Une dernire question subsiste : pourquoi avoir dfini cette notion de temps ?
Deux raisons principales cela :
Premirement tout circuit rel a des temps de retard et il faut bien les exprimer dune
manire ou dune autre.
Deuximement, la notion de temps est ncessaire pour la simulation.
Il semble vident quun circuit logique gnre un retard entre son entre et sa sortie,
cependant, jusqu prsent aucun compilateur ne tenait compte de ce facteur. Etant donn
que VHDL a aussi t conu pour la simulation, il est dsormais possible den tenir compte
la conception dj. Le temps indiqu pour un retard sera alors utilis par la simulation pour
rendre celle-ci plus raliste. Il est bien entendu que ces temps ne sont utiliss que pour la
simulation. La synthse n'en tiendra pas compte. Il n'est, par consquent, pas possible de
gnrer un signal dhorloge enVHDL.
Figure 6
Sur la figure 6, qui reprsente un additionneur 1 bit, il y a deux portes logiques. Pour dcrire
un tel systme, il est possible dvaluer le retard de chacune des portes pour lintroduire
dans le code VHDL de la manire suivante :
somme 12 a YPS b 6AU@S 5ns;
report 12 a 6I9 b 6AU@S 4ns;
Ce code indiquera au simulateur les temps de propagation lis aux diffrentes fonctions du
cgx
v.1
2.6 (10)
eivd
22 juin 1998
circuit. Par contre, il ne sera pas tenu compte de ces temps pour crer le fichier qui sera
utilis pour la programmation du circuit. Le circuit aura les retards rels gnrs par ses
portes internes.
!#"
Vvyvhvqrqyrqrvyhv
VHDL permet de crer des modules qui ne servent qu simuler un systme. Dans ces
modules apparatront une suite de modifications des signaux dentre du systme qui
viteront au concepteur de les entrer manuellement. Un exemple trs simple est donn ciaprs, mais ce point sera trait plus tard dans ce cours. Cet exemple gnre un fichier
dentre pour le schma de la figure 6.
a 12 0 6AU@S 0ns,1 6AU@S 100ns,0
300ns;
b 12 0 6AU@S 0ns,1 6AU@S 200ns;

6AU@S 200ns,1 6AU@S
(WeI@H@IUT@UUS6IT68UDPIT
Dans un programme concurrent, cest la modification dun signal qui dclenche
lexcution du code. Deux types de modifications existent et sont dfinis sous les noms de
hhpv et pprr. Une dfinition de ces deux termes suffira au lecteur pour
reconnatre ce qui se cache sous chacun d'eux.
Evnement :
un vnement se passe lorsquil y a un changement de la valeur dun signal.
Transaction : une transaction a lieu lorsquune valeur est assigne un signal aprs un
temps donn. Si la valeur du signal est diffrente de celle qu'il avait
prcdemment (l'instant d'avant), alors elle gnre un vnement.
cgx
v.1
2.7 (11)

eivd
22 juin 1998
1PUDPI9
@Ye8VUDPI8PI8VSS@IU@@UTeRV@IUD@GG@
Dans un langage informatique, toutes les instructions se droulent de manire squentielle.
Par contre sur un circuit intgr, toutes les portes fonctionnent simultanment et tous les
signaux sont transmis de manire concurrente. Cest une erreur trs frquente dans un
langage de modlisation de circuits comme le VHDL quil y ait des confusions entre les
deux notions.
Pour viter celles-ci par la suite, une dfinition de quelques termes est donne ici.
Programme concurrent :
programme dans lequel les instructions s'excutent de

manire simultane. Il ny a aucun ordre dexcution de ces
vnements. VHDL est un programme excution
concurrente.
Programme squentiel :
programme se droulant de manire squentielle. Toutes les

oprations ont lieu les unes aprs les autres de manire
ordre (comme dans un programme informatique par
exemple, ADA, C, C++, Pascal, ...).
Systme combinatoire :
systme numrique dans lequel les valeurs des sorties sont

dtermines par les valeurs actuelles (aux temps de
propagation prs) des entres. Lorsquun vnement a lieu
une entre, il est immdiatement (aux temps de
propagation prs) rpercut sur la sortie.
Systme squentiel :
systme numrique dans lequel les valeurs des sorties sont

dtermines par des informations prcdemment mmorises
dans des bascules, et par les valeurs actuelles (aux temps
de propagation prs) des entres. Les informations
mmoriser sont enregistres dans des bascules en
synchronisme avec un signal dhorloge. Un vnement une
entre ne se rpercute pas forcment de faon immdiate
(aux temps de propagation prs) sur les sorties. Il
ninfluencera les informations mmorises que lors du
prochain coup dhorloge.
Pour linstant, il ne sera pas parl de la manire de coder en VHDL des systmes
combinatoires et squentiels. Ceci sera trait par la suite dans ce cours. Par contre quelques
notions seront donnes pour mieux discerner la manire dcrire du code pour des lments
concurrents par rapport un programme informatique, qui se veut squentiel. Prenons des
exemples, lun concurrent et lautre squentiel.
cgx
v.1
2.8 (12)
!%
eivd
22 juin 1998
Qthrjrppvpprr)
1234567-
6S8CDU@8UVS@ concurrent PA exemple DT

7@BDI
sortie_a 12 entree_a 6I9 entree_b;
sortie_b 12 sortie_c PS entree_a;
sortie_c 12 sortie_d 6I9 entree_b;
sortie_d 12 entree_a PS entree_c;
@I9 concurrent;
Dhtr&
Sur cette figure n 7, le rsultat des oprations est donn de manire brute sans voir de
quelle manire elles ont eu lieu. Une autre figure ci-dessous reprsente les mmes
oprations, mais cette fois-ci en indiquant tous les changements qui ont lieu, ce qui
permettra de voir que lordre des oprations dans un programme concurrent na aucune
importance, ce qui en complique gnralement la comprhension.
cgx
v.1
2.9 (13)
eivd
22 juin 1998
Dhtr'
Les temps t1, t2, t3, t4 et t5 sont des temps infiniment courts. En portant une tude
sur chacun de ces temps, il est possible de voir dans quel ordre les oprations se sont
droules.
t1 :
t2 :
t3 :
t4 :
t5 :
- changement de lentre c
- changement de la sortie d ligne 6 du code VHDL
- changement de la sortie c ligne 5 du code VHDL
- changement de la sortie b ligne 4 du code VHDL
- changement de lentre b
- changement de la sortie b ligne 4 du code VHDL
- changement de lentre a
- changement des sorties b & d lignes 4 & 6 du code VHDL
- changement des sorties b & d lignes 4 & 6 du code VHDL
- changement des sorties a, b & d lignes 3, 4 & 6 du code VHDL
L
L
L
L
L
L
L
En ralit, il y a aussi un temps delta entre deux changements simultans de signaux, mais
il najoute rien la comprhension de lordre de lexcution dun code concurrent.
Il est donc possible de voir ci-dessus que lordre des instructions dans le programme na
aucune importance, cest les modifications de la valeur des signaux qui dicteront lordre
dexcution des instructions.
cgx
v.1
2.10 (14)
!%!
eivd
22 juin 1998
Qthrjrppvprvryyr
Pour viter lutilisation de tel ou tel langage, du pseudo-code sera utilis pour lexemple.
1- Constante max_compteur = 10;
2- Dbut du programme
3- compteur = 0;
compteur
Initialise
le
4- Boucle permettant dafficher toutes les valeurs du compteur

5- boucle tant que compteur < max_compteur
6dbut de la boucle
7compteur = compteur + 1;
8afficher compteur;
Procedure daffichage
externe
9fin de la boucle;
10- fin du programme;
Le droulement squentiel dun programme est trs ais comprendre puisque le lecteur sait
exactement quelle est linstruction excute par le programme. Les instructions se droulent
dans un ordre trs prcis et il ny a aucun calcul faire pour rechercher linstruction
excute. Cest de cette manire que se droule lexcution des divers programmes
utilisation informatique. Cependant il est trs probable quapparaissent des programmes de
type informatique qui auront une excution dite concurrente. En effet les prochaines
technologies permettront probablement de reprogrammer les processeurs (VISC - Variable
Instruction Set Computer) partir dun logiciel. Cela permettra doptimiser ceux-ci, par
contre le code devra grer une quantit dinformations actuellement inexistantes [voir
Electronique n65- Dcembre 1996].
Certaines parties du code VHDL scrivent et sexcutent de manire squentielle, comme
par exemple ce qui se trouve dans le corps dun processus. Les signaux ragiront
diffremment selon quil sagisse de signaux inertiels ou transports.
Soit deux transactions, appelons-les premire et seconde selon leur ordre dapparition
dans le listing dun processus.
TRANSPORT
INERTIAL
La seconde transaction a lieu

hh la premire
Ecrit par-dessus la
premire transaction
Ecrit par-dessus la premire

transaction
La seconde transaction a lieu

hq la premire
Ajoute la seconde
transaction au signal
Ecrit par-dessus la premire

transaction si les valeurs sont
diffrentes, sinon les deux
sont maintenues
VHDL Analysis and Modeling of Digital Systems - Zainalabedin Navabi
cgx
v.1
2.11 (15)
eivd
22 juin 1998
4 graphiques reprsenteront les effets du codage en VHDL.

1a) Inertiel avec la seconde transaction qui a lieu avant la premire (fig.9)
7@BDI
QSP8@TT
7@BDI
sortie
sortie
121 6AU@S 10ns;

120 6AU@S 5ns;
X6DU0
@I9QSP8@TT0
@I90
-- premiere transaction
-- seconde transaction
1b) Transport avec la seconde transaction qui a lieu avant la premire (fig.9)
7@BDI
QSP8@TT
7@BDI
sortie
sortie
12 US6ITQPSU 1 6AU@S 10ns; -- premiere transaction

12 US6ITQPSU 0 6AU@S 5ns; -- seconde transaction
X6DU0
@I9QSP8@TT0
@I90
Dhtr(
2) Inertiel avec la seconde transaction qui a lieu aprs la premire, valeurs semblables (fig.
10)
7@BDI
QSP8@TT
7@BDI
sortie
sortie
120 6AU@S 10ns;

120 6AU@S 15ns;
X6DU0
@I9QSP8@TT0
@I90
cgx
v.1
2.12 (16)
eivd
22 juin 1998
Dhtr
3) Inertiel avec la seconde transaction qui a lieu aprs la premire, valeurs diffrentes (fig.
11)
7@BDI
QSP8@TT
7@BDI
sortie <=1
sortie <=0
X6DU0
@I9QSP8@TT0
@I90
6AU@S 10ns;
6AU@S 15ns;
Dhtr
Ltat '1' qui aurait d exister entre t=10ns et t=15ns a t filtr (supprim).
4) Transport avec la seconde transaction qui a lieu aprs la premire (fig. 12)
7@BDI
QSP8@TT
7@BDI
sortie
transaction
sortie
12US6ITQPSU 1 6AU@S 10ns;
12US6ITQPSU 0 6AU@S 15ns;

X6DU0
@I9QSP8@TT0
@I90
cgx
v.1
- -
p r e m i e r e
2.13 (17)
eivd
22 juin 1998
Dhtr !

'DAAeS@I8@@IUS@GVUDGDT6UDPI9VI@W6SD67G@@U9VITDBI6G
Maintenant, il reste savoir quel moment utiliser un signal, plutt quune variable. Pour
exprimer cette diffrence, nous allons reprendre une remarque de Navabi [1 - p.40].
- Les vth ont une reprsentation matrielle. De plus, une composante de temps leur est
associe. Les signaux peuvent autant tre utiliss dans des corps squentiels ou concurrents,
par contre leur dclaration ne se fait que dans une partie concurrente du code VHDL.
Lassignement se fait par les deux symboles 12 (< et =).
Exemples:
1) et_prov 12 a0 6I9 a1 6AU@S 10ns, 1 6AU@S 60ns;
Par cette instruction (utilise pour un programme de simulation), nous indiquons que le
signal ET_PROV vaut A0&A1 aprs 10ns et que 50ns plus tard (cd 60ns aprs le dbut),
il vaut 1.
2) sortie_et 12 a 6I9 b 6AU@S 40ns;
Cette instruction (utilise pour un programme de conception de circuit) nous indique que
SORTIE_ET vaut le ET logique de A et B et quil ne change quaprs 40ns. Ces 40ns ne
seront pas utilises par un synthtiseur. Par contre, cela permet dvaluer par simulation des
temps de retard sur un circuit que lon conoit.
- Les hvhiyr nont au contraire pas de notion de temps qui leur soit associe. Elles sont
souvent utilises pour dfinir des valeurs intermdiaires dans un code de type
comportemental. Ds le moment o lon veut rcuprer la valeur dune de ces variables pour
la reprsenter physiquement, il faut la convertir en signal. Elles ne peuvent tre dclares et
utilises que dans les parties squentielles dun code VHDL (processus, fonctions,
cgx
v.1
2.14 (18)
eivd
22 juin 1998
procdures).
Lassignement se fait par les deux symboles )2 (: et =).
Exemple:
increment

)2 increment 3;
'DAAeS@I8@@IUS@G@7DU@UG@7PPG@6I
Le type iv est un type associ un signal. Ce type est donc directement li au circuit luimme.
Le type iyrh, au contraire, na pas de reprsentation physique. Il est utilis pour les
oprations logiques du programme VHDL.
Pourquoi expliquer la diffrence entre ces deux types ? A cause de lutilisation qui en est
faite. Certaines personnes font la confusion entre ces deux types au dbut de leur
apprentissage du VHDL. En effet, ces deux types peuvent travailler avec les mmes
oprateurs et leur rsultats semblent quivalents. Pourtant quelques nuances existent, et
pour les cerner il faut observer les rsultats obtenus avec les diffrents oprateurs.
Les oprateurs logiques hqhqr donnent un rsultat du mme type que les
oprandes. Il existe des portes logiques de ce nom avec lesquelles on utilisera le type bit
pour reprsenter les entres et les sorties et il s'agit aussi d'oprateurs boolens comme dans
d'autres langages informatique. Ce sont donc bien deux types distincts ne s'utilisant pas pour
les mmes choses qui peuvent travailler avec ces oprateurs.
Les oprateurs relationnels 22313212 gnrent automatiquement un rsultat
boolen. Ce qui est tout--fait normal, puisquil est impossible de dfinir une valeur pour
une comparaison. Il nest possible que de dire si le rsultat de la comparaison est vrai ou
faux, ce qui correspond au type boolen. Si on veut faire une comparaison entre deux bits,
il faudra selon le rsultat assigner la valeur 0 ou 1 la sortie dsire.
Loprateur de concatnation & sutilisera avec un type bit. Cela permet de regrouper
plusieurs bits en un vecteur de bits. Cest trs pratique pour dfinir des bus.
cgx
v.1
2.15 (19)
eivd
'e%876 (1 9+'/

0eUCP9@9@US6W6DG
22 juin 1998
Lorsque l'on commence un dveloppement, il est utile de se demander de quelle manire

celui-ci sera ralis. Faut-il attaquer les problmes les uns aprs les autres ou en parallle ?
Quel type de description faut-il utiliser pour telle ou telle partie du circuit concevoir ? Et
il y en a dautres encore. Ce chapitre tente dy rpondre par une mthode de travail. Celle-ci
minimisera les erreurs de dveloppement en VHDL et facilitera la comprhension du code
VHDL crit par quelqu'un d'autre (pour autant que ce quelqu'un ait suivi cette mthode).
Lorganigramme (fig. 13) de la page 21 donne trois informations :
1) Quelles sont les diverses tapes dun projet.
2) Dans quel ordre va-t-on les traiter.
3) Quel type de structure VHDL faut-il employer pour les diffrentes parties du
dveloppement.
Pour faciliter la comprhension de lorganigramme, tout ce qui scrit en VHDL se trouve

dans des cases ombres.
Un dveloppement se dcompose donc de la manire suivante :
C
C
C
C
cgx
une premire tape consiste prparer la documentation. Celle-ci, crite en VHDL,

permet aussi de valider les spcifications avant de poursuivre le dveloppement.
ltape suivante consiste dvelopper conjointement deux parties du systme. Il
sagit de la description des bus et registres (gnralement par une description du
type syqrqpr) et de la description du pseudo-code ou des machines dtat (en
gnral laide dune description prrhyr). La simulation valide ces
descriptions.
un assemblage du tout est alors ralis par une description pryyr et lensemble
est aussi simul.
Les dernires tapes sont pour le placement-routage. La simulation de celui-ci et la
fabrication du produit.
v.1
3.1 (20)
eivd
22 juin 1998
I d e d u c ir c u it
D e s c r ip tio n
c o m p o r te m e n ta le
S im u l a ti o n d e l a
d e s c r ip ti o n
( a v e c te m p s n u ls )
D o c u m e n t a t i o n , P r p a r a t i o n d u d e s i g n , V a l id a t io n d e s s p c i f i c a t i o n s
D e s c r i p t io n
c o m p o rte m e n ta le
m o d if i e p o u r l a
s y n th s e
D e s c r ip tio n p a r flo t
de donnes
S y n th s e d e la
d e s c r ip tio n p a r f lo t
de donnes
S y n th s e d e la
d e s c r ip tio n
S im u l a ti o n d e l a
d e s c r ip tio n p a r f lo t
de donnes
S i m u la ti o n d e c e tte
d e s c r ip ti o n
( a v e c te m p s m o y e n s )
O p t im is a t io n e n v u e
d u c ir c u i t c i b l e
S i m u la ti o n d e c e tte
o p t im is a t io n
P s e u d o - c o d e , m a c h i n e s d ' t a t s
S t ru c tu re s d e b u s e t d e re g is tre s
D e s c r i p t io n
s t r u c t u r e l le ( o u d e s s in
du schm a)
S im u la tio n c o m p l t e
(a v e c te m p s m o ye n s )
I n t e r c o n n e c t io n s e n t r e l e s m o d u l e s , N e t l is t
P la c e m e n t, ro u ta g e
D e s c r i p t i o n p h y s iq u e
( a v e c te m p s c a lc u l s )
F a b r ic a t io n
T e s t fin a l
S im u l a t i o n
L a y o u t , li s t e d e s l m e n t s
P ro to ty p e
U t il i s a t i o n d u p r o d u i t
Dhtr "
cgx
v.1
3.2 (21)

eivd
22 juin 1998
6Qe8DAD86UDPI@UT`IUCT@
Deux tapes particulires apparaissent dans la figure 13, celle de la spcification et de la
synthse. En VHDL, il convient de bien distinguer ces deux tapes, car le code crit pour
lune ou lautre nest pour linstant pas compltement identique. Avant de commencer
lapprentissage du VHDL, il est donc ncessaire de les dfinir.
La spcification est la partie dun dveloppement qui consiste valider par la simulation ce
qui a t demand par le mandataire. Elle permet de corriger un cahier des charges incorrect
ou de complter celui-ci. La spcification en VHDL permet de crer une sorte de maquette
qui a, vu de l'extrieur, le comportement du systme dsir.
La synthse permet de gnrer automatiquement partir du code VHDL un schma de
cblage permettant la programmation du circuit cible. La description du code pour une
synthse est, en thorie, indpendante de larchitecture du circuit. En pratique, le style utilis
aura une influence sur le rsultat de la synthse, influence lie au type de circuit et au
synthtiseur utilis. Le code devra tre optimis pour un type circuit. Si le besoin
doptimisation nest pas trs important, cette partie peut se drouler trs rapidement, alors
quau contraire, si le besoin doptimisation est grand, les subtilits pour coder de manire
adquate en VHDL obligeront le concepteur y consacrer beaucoup de temps. Dailleurs,
ce nest souvent plus en VHDL que lon optimisera, car ce langage se rvle, pour linstant
en tout cas, peu adapt cet usage. Il faudra travailler un niveau plus proche du circuit ou
acheter des macros pr-existantes.

/DIU@SA68@9+'/
Avant dcrire un programme en VHDL, il faut dfinir linterface entre lintrieur du circuit
et le monde extrieur (reprsentation graphique sur la figure 14, 28). Il ne suffit pas davoir
un programme qui dcrit un certain comportement. Ce comportement ragit selon des
entres et agit sur des sorties (ou des entres-sorties) et tous ces ports seront connects
une carte externe au circuit. Toutes ces connexions correspondent cette interface.
cgx
v.1
3.3 (22)
eivd
22 juin 1998
Dhtr #
La figure 14, 28 reprsente les besoins dun concepteur. Il a un certain nombre dentres,
de sorties et dentres-sorties, de plus quelques valeurs par dfaut lui sont connues (comme
par exemple le dlai typique dune porte logique simple). A ce moment de la conception, il
ne connat pas encore ce quil va programmer. Il possde juste ces informations et le nom
du module quil doit crer (fqrfyfrvr). La manire de coder cette figure en VHDL
est la suivante :
-- --------------------------------------------------------------- declaration et utilisation des bibliotheques necessaires
-- --------------------------------------------------------------
VT@ work.bibliotheques_necessaires.6GG;
-- --------------------------------------------------------------- declaration de lentite et de ses ports dentree-sortie
-- --------------------------------------------------------------
@IUDU` nom_de_l_entite DT
B@I@SD8 (parametres_generiques: type := Valeur_par_defaut);
QPSU (ports_d_entree : DI type_ports_d_entree;
ports_de_sortie : PVU type_ports_de_sortie;
ports_d_entree_sortie : DIPVU type_ports_entree_sortie);
@I9 nom_de_l_entite;
-- --------------------------------------------------------------- architecture du programme, structure interne
-- --------------------------------------------------------------
6S8CDU@8UVS@ type_de_description PA nom_de_l_entite DT

7@BDI
cgx
v.1
3.4 (23)
eivd
22 juin 1998
-- programme interne, encore inconnu pour le concepteur
@I9 type_de_description;
On dclare en premier lieu les diffrentes bibliothques qui seront utilises. Le code se
dcompose en deux parties principales, lentit et larchitecture.
Entit :
Lentit est la vue externe de llment cr. On y dclare les ports dentre
et de sortie et on y donne un nom llment (fqrfyfrvr pour
lexemple ci-dessus). Il est aussi possible de dfinir des paramtres
gnriques, cest--dire des paramtres qui ont une valeur utilise par dfaut
si lutilisateur de cette entit nen donne pas une autre. Par exemple, si une
architecture appelle lentit ci-dessus sans spcifier de temps de dlai, alors
la valeur Whyrfhfqrsh sera utilise.
Architecture : Larchitecture est lvaluation du contenu de llment cr. Il est tout--fait

possible davoir plusieurs architectures diffrentes pour une mme entit.
Lors de la dfinition de larchitecture, on y indique le type de description
utilise (rfqrfqrpvv) et lentit utilise (fqrfyrvr). Aucun
de ces deux mots nest rserv.
Un commentaire commence laide des deux caractres -- et se termine par la fin de ligne.

/@9+'/QPVSG@8PH7DI6UPDS@
Ltude du VHDL pour des circuits concrets ne se fera pas selon lapproche classique qui
consiste donner une liste des instructions pour les utiliser ensuite, mais elle sappuiera sur
les besoins, les outils tant alors fournis. Cela double parfois les informations, mais permet
de ne pas avoir besoin de comprendre tout le VHDL avant de dmarrer un petit projet.
Une premire tape traitera du dveloppement de programmes VHDL pour de la logique
combinatoire et une deuxime soccupera de la logique squentielle.
Regardons dabord quelques modules classiques en combinatoire. La description de chacun
de ces modules sera faite sous la forme la plus approprie.
Tqr
cgx
Urqrqrpvv
Qhtr
compos seulement de portes logiques
flot de donnes / structurelle
25
compos dlments en bibliothque
structurelle
30
table de vrit
flot de donnes
28
v.1
3.5 (24)
eivd
22 juin 1998
Tqr
"#
Urqrqrpvv
Qhtr
bascule asynchrone (RS par exemple)
flot de donnes
26
multiplexeur
flot de donnes
27
lments en cascade
structurelle
30
comparateur
comportementale
31
9rpvvhsyqrqpr
Pour dcrire des lments simples, des tables de vrit ou autres multiplexeurs, il est trs
pratique dutiliser la description dite hsyqrqpr. Ce type de description se droule
de manire concurrente. Tous les signaux sont assigns en mme temps. Il suffit de placer
la droite dune quation ce que lon veut assigner au signal qui se trouve la gauche de
lquation.
"#
Ghqqvvr
Un exemple, un demi-additionneur 1 bit, aidera la comprhension de ce type de

description.
Dhtr $
cgx
v.1
3.6 (25)
eivd
22 juin 1998
Code VHDL :
@IUDU` demi_add_1bit DT
QPSU (entree_a : DI bit;
entree_b : DI bit;
sortie
: PVU bit;
report
: PVU bit);
@I9 demi_add_1bit;
6S8CDU@8UVS@ flot_de_donnees PA demi_add_1bit DT
7@BDI
Report 12 entree_a 6I9 entree_b;
Sortie 12 entree_a YPS entree_b;
@I9 flot_de_donnees;
Lentit et larchitecture se dclarent de manire habituelle. Pour lassignation des signaux,

deux oprateurs ont t utiliss AND et XOR (la liste exhaustive se trouve en annexe).
"# !
GhihpyrSThpur
La bascule RS asynchrone est aussi un exemple trs simple pour une description
combinatoire par flot de donnes. Il compltera lexemple de ladditionneur.
@IUDU` bascule_RS DT
B@I@SD8 (delai: UDH@ := 5 ns); -- delai par defaut, modifiable
QPSU (set, reset :DI
bit;
sortie
:DIPVU bit);
@I9 bascule_RS;
6S8CDU@8UVS@ flot_de_donnees PA bascule_RS DT
7@BDI
sortie 12 set PS (sortie 6I9IPU reset) 6AU@S delai;
Certains compilateurs demanderont cette architecture :

6S8CDU@8UVS@ flot_de_donnees PA bascule_RS DT
TDBI6G sortie_int : bit;
7@BDI
sortie_int 12 sortie 6I9IPU reset;
sortie 12 set PS sortie_int 6AU@S delai;
cgx
v.1
3.7 (26)
"# "
eivd
22 juin 1998
Gryvyrr
Les deux exemples prcdents placent toujours la mme quation sur la sortie, mais si le
concepteur veut raliser un multiplexeur, il devra assigner, suivant le code de slection, la
valeur des entres la sortie. Il existe en VHDL une commande qui permet cela, le mot
rserv ur. Elle permet de donner une condition lors dun assignement.
Prenons le cas dun multiplexeur 8 entres et 3 bits de slection. Le symbole est reprsent
sur la figure 16.
Dhtr %
Code VHDL :
@IUDU` mux8 DT
QPSU (e7, e6, e5, e4, e3, e2, e1, e0: DI bit;
G2, G1, G0: DI bit;
sortie: PVU bit);
@I9 mux8;
6S8CDU@8UVS@ flux_de_donnees PA mux8 DT
TDBI6G adresse : bit_vector(2 9PXIUP 0);
7@BDI
adresse 12 G2G1G0;
XDUC adresse T@G@8U

sortie 12 e0 6AU@S
e1 6AU@S
e2 6AU@S
e3 6AU@S
e4 6AU@S
e5 6AU@S
cgx
-- concatenation en un seul vecteur
delai
delai
delai
delai
delai
delai
XC@I
XC@I
XC@I
XC@I
XC@I
XC@I
v.1
000,
001,
010,
011,
100,
101,
3.8 (27)
eivd
22 juin 1998
e6 6AU@S delai XC@I 110,

e7 6AU@S delai XC@I 111;
@I9 flux_de_donnees;
"# #
Ghhiyrqrpvp
De mme, il est aussi possible dutiliser avantageusement ce mot rserv when pour crer
une table de vrit. Lexemple utilis est trs simple comprendre puisquil sagit dafficher
sur un affichage 7 segments la valeur dun code BCD. Les cas non dsirs afficheront un X.
9"
9!
9
T&
T%
T$
T#
T"
T!
0011
L 1001111
@IUDU` sept_seg DT
QPSU (code_binaire: DI bit_vector(3 9PXIUP 0); -- code dentree
S7, S6, S5, S4, S3, S2, S1: PVU bit); -- affichage 7 seg.
cgx
v.1
3.9 (28)
eivd
22 juin 1998
@I9 sept_seg;
6S8CDU@8UVS@ TDV_flot_de_donnees PA sept_seg DT
TDBI6G code_sept_seg : bit_vector(6 9PXIUP 0);
7@BDI
XDUC code_binaire T@G@8U
code_sept_seg 12 "0111111" 6AU@S delai XC@I "0000",
"0000110" 6AU@S delai XC@I "0001",
"1011011" 6AU@S delai XC@I "0010",
"1001111" 6AU@S delai XC@I "0011",
"1100110" 6AU@S delai XC@I "0100",
"1101101" 6AU@S delai XC@I "0101",
"1111101" 6AU@S delai XC@I "0110",
"0000111" 6AU@S delai XC@I "0111",
"1111111" 6AU@S delai XC@I "1000",
"1101111" 6AU@S delai XC@I "1001",
"1110110" XC@IPUC@ST; -- X
S7
S6
S5
S4
S3
S2
S1
12
12
12
12
12
12
12
-----------
0
1
2
3
4
5
6
7
8
9
code_sept_seg(6);
code_sept_seg(5);
code_sept_seg(4);
code_sept_seg(3);
code_sept_seg(2);
code_sept_seg(1);
code_sept_seg(0);
@I9 TDV_flot_de_donnees;
"# $
Spp
QPSU (ports_d_entree
: DI
type_ports_d_entree;
type_ports_de_sortie;
ports_de_sortie
: PVU
7@BDI
signal_sortie_1 12action_1;
signal_sortie_2 12 action_2 XC@I condition_1,
action_3 XC@I condition_2,
action_4 XC@IPUC@ST;
...
cgx
v.1
3.10 (29)
"#!
eivd
22 juin 1998
9rpvvpryyr
Cette description correspond un assemblage de modules. Chacun des modules est dcrit
de manire comportementale ou par flot de donnes et fait partie ensuite dune bibliothque
de modules. Ils sont alors utiliss de la mme manire que la structure dun schma. Un
additionneur 4 bits donnera un bon exemple de ce type de description. Pour ce faire, le
module dun additionneur 1 bit sera utilis.
Elment se trouvant en bibliothque : (additionneur 1 bit)
@IUDU` addit_1_bit DT
QPSU (entree_a: DI bit;
entree_b: DI bit;
report_prec: DI bit;
somme: PVU bit;
report_suiv: PVU bit);
@I9 addit_1_bit;
6S8CDU@8UVS@ flot_de_donnees PA addit_1_bit DT
7@BDI
report_suiv 12 (entree_a 6I9 entree_b) PS (entree_a 6I9 report_prec)
PS (entree_b 6I9 report_prec);
somme 12 entree_a YPS entree_b YPS report_prec;
Additionneur 4 bits :
@IUDU` addit_4_bits DT
QPSU (nombre1, nombre2 : DI bit_vector (3 9PXIUP 0);
report_in
: DI bit;
total
: PVU bit_vector (3 9PXIUP 0);
report_out
: PVU bit);
@I9 addit_4_bits;
6S8CDU@8UVS@ structurelle PA addit_4_bits DT
8PHQPI@IU bloc1 QPSU (entree_a, entree_b, report_prec : DI bit;
somme, report_suiv : PVU bit);
@I98PHQPI@IU;
APS6GG: bloc1 VT@@IUDU`XPSF.addit_1_bit (flot_de_donnees);
TDBI6G report0, report1, report2 : bit;
7@BDI
g0 : bloc1 QPSUH6Q
(nombre1(0), nombre2(0), report_in, total(0), report0);
g1 : bloc1 QPSUH6Q
(nombre1(1), nombre2(1), report0, total(1), report1);
cgx
v.1
3.11 (30)
eivd
22 juin 1998
g2 : bloc1 QPSUH6Q
(nombre1(2), nombre2(2), report1, total(2), report2);
g3 : bloc1 QPSUH6Q
(nombre1(3), nombre2(3), report2, total(3), report_out);
@I9 structurelle;
"#!
Spp
: DI
ports_de_sortie
: PVU
8PHQPI@IU nom_du_composant_local QPSU (
type_des_entrees;
entrees_du_comp
: DI
type_des_sorties;
sorties_du_comp
: PVU
entrees_sorties_comp : DIPVU type_entrees_sorties);
@I98PHQPI@IU;
APS6GG : nom_du_composant_local
VT@@IUDU`XPSFnom_entite_comp (nom_arch_composant);
7@BDI
nom_de_l_element )nom_du_composant_local QPSUH6Q

(entrees_du_comp, sorties_du_comp,
entrees_sorties_comp);
"#"
9rpvvprrhyr
La description comportementale se fait laide dun processus. Les instructions lintrieur

de celui-ci sexcutent de manire squentielle.
Un comparateur est un lment combinatoire avantageusement dcrit de faon
comportementale.
cgx
v.1
3.12 (31)
eivd
22 juin 1998
Dhtr '
@IUDU` comparateur DT
QPSU (vecteur1, vecteur2 : DI bit_vector (3 9PXIUP 0);
pg, egal, pp : DI bit;
v1pgv2, v1egalv2, v1ppv2 : PVU bit);
@I9 comparateur;
6S8CDU@8UVS@comportementale PA comparateur DT
7@BDI
QSP8@TT (vecteur1, vecteur2, pg, egal, pp)
7@BDI
v1pgv2 12 0;
v1egalv2 12 0;
v1ppv2 12 0;
-----
initialisation obligatoire,
sinon des bascules sont
rajoutees pour synchroniser les
signaux
DA vecteur1 3 vecteur2 UC@I

v1pgv2 12 1 6AU@S delai;
v1egalv2 12 0 6AU@S delai;
v1ppv2 12 0 6AU@S delai;
@GTDA vecteur1 2 vecteur2 UC@I
v1pgv2 12 pg 6AU@S delai;
v1egalv2 12 egal PSIPU(pg PS pp) 6AU@S delai;
v1ppv2 12 pp 6AU@S delai;
@GTDA vecteur1 1 vecteur2 UC@I
v1pgv2 12 0 6AU@S delai;
v1egalv2 12 0 6AU@S delai;
v1ppv2 12 1 6AU@S delai;
@I9DA;
@I9QSP8@TT;
@I9 comportementale;
Le fonctionnement de ce petit programme demande quelques explications. Cest un

processus dans lequel il y a trois branches o lon compare les deux nombres. Dans chacun
cgx
v.1
3.13 (32)
eivd
22 juin 1998
des cas, des valeurs de sorties appropries sont donnes aprs un dlai. Chaque fois quune
des valeurs se trouvant entre parenthses aprs le mot-cl pr est modifie,le processus
est activ et toutes les instructions sont excutes squentiellement.
"#"
Spp
Pour dcrire un programme sous forme comportementale dun systme combinatoire, la

structure est la suivante :
: DI
ports_de_sortie
: PVU
7@BDI
QSP8@TT (valeurs_permettant_d_entrer_dans_le_processus)
7@BDI
description du code;
@I9QSP8@TT;

/@9+'/QPVSVIT`TUH@TeRV@IUD@G
La plupart des systmes logiques sont squentiels et peuvent tre crits en VHDL. A
nouveau, la prsentation de cette partie se fera selon les besoins et non les outils.
Tqr
Urqrqrpvv
bascule simple (D par exemple)

cgx
comportementale, flot de donnes

v.1
Qhtr
36, 41
3.14 (33)
eivd
22 juin 1998
Tqr
Urqrqrpvv
Qhtr
bascule D avec set synchrone, reset

asynchrone et un enable
comportementale
18
machine dtats
machine dtats
47
compteurs
structurelle (flot de donnes)
52
compos dlments en bibliothque
structurelle
52
lments en cascade (compteur)
structurelle
52
Les systmes squentiels se dcomposent en trois parties : le dcodeur dtat futur

(combinatoire), le registre (squentiel) et le dcodeur de sortie (combinatoire) selon la figure
19. Pour faciliter lcriture et surtout la lecture du code VHDL, cette structure sera, dans
la mesure du possible, respecte. Elle offre galement lavantage de navoir que peu ou pas
de modifications apporter au processus dcrivant le registre pour passer dun
dveloppement lautre. Cette partie du code tant en effet la plus difficile reprsenter,
il vaut mieux la simplifier au maximum et minimiser ainsi le risque derreurs.
Cependant, il arrive parfois que les dcodeurs d'tat futur et de sortie peuvent trs
facilement s'crire si cette description se fait dans un seul et mme processus ; c'est le cas
pour une description partir d'un graphe d'tats. Dans ces cas, il sera avantageux de
regrouper les deux processus combinatoires.
Selon le type d'architecture utilise (flip-flops D-CE par exemple), il sera ncessaire de
regrouper diffrement les processus, mais cela n'entre pas dans le cadre d'une introduction
au VHDL et nous laisserons de ct ces particularits lies aux synthtiseurs.
Dhtr (
Voici quelques avantages de cette mthode :

- La structure du code VHDL est toujours la mme pour un systme squentiel, ce qui
facilite la cration dun fichier chablon.
cgx
v.1
3.15 (34)
eivd
22 juin 1998
- On spare laction de lhorloge des actions que lon veut sur les signaux.
- Il nest pas utile de vrifier chaque fois la structure du code. Une fois correcte, elle le reste.
Cette structure est la suivante :
: DI
ports_de_sortie
: PVU
TDBI6G present, futur : type_des_signaux;
7@BDI
--------------------------------------------------------------------- ce premier processus est celui qui decode letat futur de la
-- bascule, on lappellera processus dentree
--------------------------------------------------------------------
QSP8@TT (liste_de_sensibilite_du_processus)
7@BDI
Comportement_du_decodeur_d_etat_futur;
@I9QSP8@TT;
--------------------------------------------------------------------- ce processus est celui qui soccupe de la gestion des bascules

-- on lappellera processus de memorisation
--------------------------------------------------------------------
QSP8@TT
7@BDI
X6DUVIUDG clock@W@IU and clock = 1;
sortie_bascule <= valeur_d_entree 6AU@S delai;
@I9QSP8@TT0
--------------------------------------------------------------------- le processus suivant est celui du decodeur de sortie
-- on lappellera processus de sortie
--------------------------------------------------------------------
QSP8@TT (liste_de_sensibilite_du_processus)
7@BDI
Comportement_du_decodeur_de_sortie;
@I9QSP8@TT0
Chaque partie est reprsente par un processus. Il est bien sr possible de dcouper les
dcodeurs dtat futur et de sortie en plusieurs processus pour permettre le dveloppement
de petites entits rutilisables pour dautres dveloppements. Le processus de mmorisation
cgx
v.1
3.16 (35)
eivd
22 juin 1998
est en quelque sorte une de ces entits: conu une fois pour toutes, le processus nest plus
touch pour des dveloppements ultrieurs.
Lexcution des processus est la suivante :
- Tous les processus sexcutent de manire parallle entre eux.
- Lexcution lintrieur dun processus se fait de manire squentielle.
Un processus est activ ds quun des signaux de la liste de sensibilit change dtat. Cette
liste de sensibilit peut prendre deux formes : soit elle apparat entre parenthses juste aprs
le mot-cl pr (a), soit elle fait partie dune ligne hvvy lintrieur du processus
(b). La nouvelle norme prconise plutt la deuxime, mais elle nest pour linstant pas trs
bien accepte par les synthtiseurs.
a - QSP8@TT (liste de sensibilit)
....
@I9QSP8@TT0
b - QSP8@TT
....
X6DUVIUDG (liste de signaux)
....
@I9QSP8@TT0
Cette liste de sensibilit doit comprendre tous les signaux susceptibles de modifier le
comportement du systme.
"$
9rpvvprrhyr
Le premier exemple VHDL squentiel et le plus classique est celui dune bascule D. Son
code est le suivant :
----------------------------------------------------------------------- Nom du fichier : basculeD.vhd
-- Auteur
: C. Guex
-- Date
: avril 1997
-- Version
: 1.0
-- Modifications :
-- Auteur
:
Date :
----------------------------------------------------------------------- But
: exemple du cours VHDL dune bascule D
----------------------------------------------------------------------
@IUDU` bascule_d DT
B@I@SD8 (delai: time := 7 ns);
QPSU (entree_D, clock : DI bit;
cgx
v.1
3.17 (36)
eivd
22 juin 1998
sortie : PVU bit);
@I9 bascule_d;
6S8CDU@8UVS@ flot_de_donnees PA bascule_d DT

TDBI6G sortie_bascule : bit;
TDBI6G entree_bascule : bit;
-- signal intermediaire
-- signal intermediaire
7@BDI
----------------------------------------------------------------------- ce premier processus est celui qui decode letat futur de la
----------------------------------------------------------------------
QSP8@TT (entree_D)
7@BDI
entree_bascule 12 entree_D;
@I9QSP8@TT;
----------------------------------------------------------------------- ce processus est celui qui soccupe de la gestion des bascules

----------------------------------------------------------------------
QSP8@TT
7@BDI
sortie_bascule 12 entree_bascule 6AU@S delai;
@I9QSP8@TT;
----------------------------------------------------------------------- le processus suivant est celui du decodeur de sortie
----------------------------------------------------------------------
QSP8@TT (sortie_bascule)
7@BDI
sortie 12 sortie_bascule;
@I9QSP8@TT;
Dans ce cas particulier, les processus dentre et de sortie ne font rien. Il ny a donc aucun
dlai spcifier pour ces deux processus. Par contre, le processus de mmorisation a un
dlai correspondant au temps de transfert dune bascule. Ce dlai est choisir en fonction
du circuit pressenti pour le dveloppement, ce pour amliorer la qualit de la simulation. Il
ne faut pas oublier que ce dlai na une valeur que pour la simulation. Il nest pas possible
de dfinir une sorte dhorloge interne au circuit.
Etant donn que les processus d'entre et de sortie ne font rien, le code se simplifiera de la
manire suivante :
----------------------------------------------------------------------- Nom du fichier : basculeD.vhd
-- Auteur
: C. Guex
-- Date
: avril 1997
cgx
v.1
3.18 (37)
eivd
22 juin 1998
-- Version
: 1.0
-- Modifications :
-- Auteur
:
Date :
----------------------------------------------------------------------- But
: exemple du cours VHDL dune bascule D
----------------------------------------------------------------------
@IUDU` bascule_d DT
B@I@SD8 (delai: time := 7 ns);
QPSU (entree_D, clock : DI bit;
sortie : PVU bit);
@I9 bascule_d;
6S8CDU@8UVS@ flot_de_donnees PA bascule_d DT
7@BDI
-- processus du decodeur detat futur inexistant
----------------------------------------------------------------------
QSP8@TT
7@BDI
sortie 12 entree_D 6AU@S delai;
@I9QSP8@TT;
-- processus du decodeur de sortie inexistant
Une bascule un peu plus complte sera donne comme deuxime exemple. Il sagit dune
bascule D avec enable et deux entres supplmentaires que sont le set synchrone et le reset
asynchrone. Le schma, dcoup selon les trois processus est le suivant (figure 22):
Dhtr!
cgx
v.1
3.19 (38)
eivd
22 juin 1998
Dhtr!
Dhtr!!
Lenable na pas t plac directement sur la bascule, car il na pas de rapport direct avec
elle. Il sagit en fait dun multiplexeur qui slectionne soit la valeur dentre, soit lancienne
valeur de la bascule selon ltat du signal rhiyr. Le processus de mmorisation soccupe
lui de traiter lhorloge et les informations indpendantes de lentre, comme le set et le reset.
Pour terminer, le dcodeur de sortie est trivial et vaut sa propre entre. Ce qui donne le code
VHDL suivant :
----------------------------------------------------------------------- Nom du fichier : b_D_RSE.vhd
-- Auteur
: C. Guex
-- Date
: avril 1997
-- Version
: 1.0
-- Modifications :
-- Auteur
:
Date :
----------------------------------------------------------------------- But
: exemple du cours VHDL dune bascule D avec reset
-asynchrone, set synchrone et enable pour valider
-le transfert dune entree sur la sortie
----------------------------------------------------------------------
@IUDU` bascule_d_ar_ss_en DT
B@I@SD8 (delai: time := 7 ns); -- delai de transfert dune porte
cgx
v.1
3.20 (39)
eivd
QPSU (entree_D : DI
clock
: DI
a_reset
: DI
s_set
: DI
enable
: DI
sortie
: PVU
@I9 bascule_d_ar_ss_en;
bit;
bit;
bit;
bit;
bit;
bit);
22 juin 1998
-------
entree de la bascule D
horloge de la bascule D
reset asynchrone de la bascule D
set synchrone de la bascule D
validation de la bascule D
sortie de la bascule D
----------------------------------------------------------------------- Architecture comportementale dune bascule D avec reset asynchrone

-- et set synchrone. Un enable autorise ou non le transfert de
-- lentree D.
----------------------------------------------------------------------
6S8CDU@8UVS@ comportementale PA bascule_d_ar_ss_en DT

TDBI6G entree_bascule : bit; -- valeur de letat futur de la bascule
TDBI6G sortie_bascule : bit; -- valeur intermediaire que prendra
-- la sortie
7@BDI
----------------------------------------------------------------------- ce premier processus est celui qui decode letat futur de la
----------------------------------------------------------------------
QSP8@TT (entree_D, sortie_bascule, enable)

7@BDI
DA enable = 1 UC@I
entree_bascule 12 entree_D;
@GT@
entree_bascule 12 sortie_bascule;
@I9DA;
@I9QSP8@TT;
----------------------------------------------------------------------
QSP8@TT
7@BDI
X6DUVIUDG (a_reset = 1) PS (clock@W@IU 6I9 clock = 1);
DA a_reset = 1 UC@I
sortie_bascule 12 0 6AU@S delai;
-- reset asynchrone
-- prioritaire
@GT@
DA s_set = 1 UC@I
sortie_bascule 12 1 6AU@S delai; -- set synchrone en
-- deuxieme priorite
@GT@
sortie_bascule 12 entree_bascule 6AU@S delai;
@I9DA;
@I9DA;
@I9QSP8@TT;
cgx
v.1
3.21 (40)
eivd
22 juin 1998
----------------------------------------------------------------------- le processus suivant est celui du decodeur de sortie

----------------------------------------------------------------------
QSP8@TT
7@BDI
sortie 12 sortie_bascule;
@I9QSP8@TT;
Toutes les bascules peuvent tre construites selon le modle prcdent. Il est aussi possible
de conserver cette bascule en bibliothque sous forme dlment rutilisable. Quelques
autres exemples de modules squentiels vont encore tre donns pour illustrer ce langage.
Il existe galement une autre forme dcriture, moins pratique, que nous allons voir dans le
prochain paragraphe.
"$!
9rpvvhsyqrqpr
En effet, il est aussi possible de dcrire des modules squentiels par flot de donnes. Ces
descriptions peuvent prendre deux formes, selon les exemples donns ci-aprs. Cependant,
ce type de description nest pas des plus appropri pour un module squentiel et il nen sera
pas fait grand tat.
Cette description est trs semblable celle utilise dans la partie combinatoire. Il suffit
dajouter aux quations la synchronisation avec lhorloge de la manire suivante :
sortie 12 entree XC@I (horloge = 1 6I9IPU horlogeTU67G@) @GT@ sortie;
Le handicap dune telle mthode est quil faut crire pour chaque sortie cette condition. Il
existe un moyen dviter ceci en crant un bloc. Toutes les oprations se trouvant alors dans
ce bloc ne se drouleront que si la condition dentre est vraie. Ce qui veut dire que si nous
plaons lattente du flanc montant de lhorloge comme condition dentre, tous les signaux
internes au bloc seront synchroniss.
Lexemple dune bascule D est donn ci-aprs [selon les pages 180-181 de Navabi]. Deux
architectures sont crites pour montrer la diffrence entre une synchronisation de lhorloge
sur un seul signal ou sur tout un bloc.
@IUDU` d_flipflop DT
B@I@SD8 (delai1: time := 4 ns; delai2: time := 5 ns);
QPSU(d, c : DI bit;
q, qb : PVU bit);
cgx
v.1
3.22 (41)
eivd
22 juin 1998
@I9 d_flipflop;
-- exemple de signaux gardes (bloc)
6S8CDU@8UVS@ guarding PA d_flipflop DT

7@BDI
ff: 7GP8F(c=1 6I9IPU cTU67G@)
7@BDI
q 12 BV6S9@9
d 6AU@S delai1;
qb 12 BV6S9@9IPU d 6AU@S delai2;
@I97GP8F ff;
@I9 guarding;
-- exemple de signaux assignes
6S8CDU@8UVS@ assignement PA d_flipflop DT

TDBI6G etat_interne : bit;
7@BDI
etat_interne 12 d XC@I (c=1 6I9IPU cTU67G@) @GT@ etat_interne;

etat_interne 6AU@S delai1;
q 12
qb 12IPU etat_interne 6AU@S delai2;
@I9 assignement;
Lexemple dun bloc est celui correspondant la premire architecture. Le bloc commence
par un irtv et se termine par un rq. A lintrieur de celui-ci, tous les signaux qui ont le
mot cl thqrq sur leur affectation ne changent pas tant que la condition de bloc nest pas
remplie (en loccurrence, le flanc montant de lhorloge). Ce qui veut dire que les signaux q
et qb ne ragissent quau flanc de lhorloge. On dit de ces signaux quils sont gards.
Contrairement la premire architecture, la deuxime ne modifie que le signal etat_interne
au flanc de lhorloge, les deux signaux q et qb changent uniquement lors dune variation de
etat_interne.
Pour mieux comprendre le principe, un fichier de test et son rsultat graphique sont donns
ci-dessous :
@IUDU` flipflop_test DT
@I9 flipflop_test;
6S8CDU@8UVS@ input_output PA flipflop_test DT
8PHQPI@IU
flop QPSU (d, c : DI bit;
q, qb : PVU bit);
@I98PHQPI@IU;
APS c1: flop VT@@IUDU` XPSF.d_flipflop (assignement);
APS c2: flop VT@@IUDU` XPSF.d_flipflop (guarding);
TDBI6G dd, cc, q1, q2, qb1, qb2 : bit;
7@BDI
cgx
v.1
3.23 (42)
eivd
22 juin 1998
-- inversion de cc toutes les 400ns jusqua 2us

cc 12IPU cc 6AU@S 400 ns XC@IIPX < 2 us @GT@ cc;
-- inversion de dd toutes les 1000ns jusqua 2us
dd 12IPU dd 6AU@S 1000 ns XC@IIPX < 2 us @GT@ dd;
c1: flop QPSUH6Q (dd, cc, q1, qb1);
c2: flop QPSUH6Q (dd, cc, q2, qb2);
@I9 input_output;
Rsultat graphique :
Dhtr!"
Ce graphique rvle la diffrence entre qb1 et qb2 selon la description VHDL. le signal qb1
est bel est bien l'inverse du signal q1, contrairement qb2 par rapport q2.
Mais comme cela a dj t dit, cette mthode pour dcrire un systme squentiel nest pas
des plus lisible et nest que peu employe, on lvitera donc.
cgx
v.1
3.24 (43)
"$"
eivd
22 juin 1998
9rpvv qr hpuvr prvryyr j hv q thur qph q

thvthr
Un graphe d'tats ou un organigramme se traduit tout naturellement en VHDL, en utilisant

les structures 86T@ et DAUC@I@GT@. La figure 24 montre la forme gnrale de
l'architecture des dcodeurs d'tat futur et de sortie, la mmorisation de l'tat tant dcrite
dans un processus spar.
352&(66
&$6(
:+(1 etat_1
:+(1 etat_2
,)
(/6,)
condition_1
condition_2
,)
action 1
action 2
:+(1 etat_n
...
condition_3
(/6(
action 3
action 4
(/6(
,)
condition_4
(/6(
action 6
action 7
action 5
Dhtr!#
Sous forme VHDL, cela donne :

6S8CDU@8UVS@ machine_etats PA entite_machine_etats DT
U`Q@ etat DT (cas_1, ..., cas_n);
TDBI6G present : etat )2 cas_1;
TDBI6G futur : etat;
-- etat present, par defaut cas_1

-- etat futur
QSP8@TT (present, entrees)

7@BDI
86T@ present DT
XC@I cas_1 23
DA condition_d_entrees UC@I
cgx
v.1
-- selon les entrees

3.25 (44)
eivd
22 juin 1998
sorties 12 valeur_a_mettre_sur_les_sorties;
futur 12 etat_futur_dans_ce_cas;
@GTDA not condition_d_entrees UC@I
@GT@
valeur_avant_synchro 12 maintien_de_la_sortie;
futur 12 etat_de_trappe;
@I9DA0
.
.
.
XC@I cas_n 23
DA autre_condition_d_entrees then
@GTDA not autre_condition_d_entrees UC@I
@GT@
@I9DA0
@I986T@0
@I9QSP8@TT0
@I9 machine_etats;
"$"
Uhvvvpqvvryyr
Regardons de manire plus prcise les diffrentes transitions, conditionnelles ou non pour
les coder en VHDL.
Une transition inconditionnelle scrit de la manire suivante :
XC@I etat_1 23
Aucune condition vs nest dfinie pour passer ltat suivant. Par consquent, une fois
arriv dans ltat 1, le dcodeur dtat futur passera de toute manire un seul tat futur,
celui indiqu droite de lassignation.
cgx
v.1
3.26 (45)
"$"!
eivd
22 juin 1998
Uhvvpqvvryyr
Une transition conditionnelle se dfini par linstruction vsurryr. Il faut placer ltat
futur dans la branche correspondant sa condition.
XC@I etat_1 23
@GTDA autre_condition_d_entrees UC@I
@GT@
@I9DA0
"$""
Tvrvpqvvryyr
Quant aux sorties inconditionnelles, de la mme manire que pour une transition
inconditionnelle, on place directement droite de lassignation la valeur que la sortie doit
prendre.
XC@I etat_1 23
"$"#
Tvrpqvvryyr
Les sorties conditionnelles peuvent scrire sous deux formes. Lune o lon donne la
condition dsire en lieu et place dune valeur, lautre en insrant lassignation de la sortie
dans une branche correspondant la condition souhaite. Il est aussi possible de cumuler
ces deux mthodes pour placer une condition sur les sorties, alors quelles se trouvent dj
dans une branche de condition.
XC@I etat_1 23
sorties 12 condition_a_mettre_sur_les_sorties;
ou
cgx
v.1
3.27 (46)
eivd
22 juin 1998
XC@I etat_1 23
-- selon les entrees
sorties 12 valeur_ou_condition_a_mettre_sur_les_sorties;
@GTDA autre_condition_d_entrees UC@I
sorties 12autre_valeur_ou_condition_a_mettre_sur_les_sorties;
@GT@
@I9DA0
"$"$
Spp
Un rsum avec toutes les possibilits apparat ci-dessous :

XC@I etat_1 23
sortie 12 valeur_1;
sortie 12 condition_1;
-- sortie inconditionnelle
-- sortie conditionnelle
-- (condition 1)
DA condition_2 UC@I
sortie 12 valeur_2;
-- (condition 2)
futur 12 etat_futur_dans_ce_cas; -- transition conditionnelle
@GTDA condition_3 UC@I
sortie 12 condition_4;
-- (cond. 3 et 4)
futur 12 etat_futur_dans_ce_cas; -- transition conditionnelle
@GT@
@I9DA0
XC@I etat_2 23
futur 12 etat_futur_dans_ce_cas; -- transition inconditionnelle
"$"%
Tvrpuvpr
Pour post-synchroniser une sortie, il faut crer une sortie intermdiaire qui sera ensuite
place sur lentre dune bascule.
cgx
v.1
3.28 (47)
"$"&
eivd
22 juin 1998
@ryr)qprprqrr
Lexemple utilis pour reprsenter une machine tats en VHDL est lun des plus
classiques, puisquil sagit dun dtecteur de sens.
Son fonctionnement est le suivant :
Un disque peut tourner dans deux sens. Deux capteurs se trouvent dun ct du disque pour
lire la position de celui-ci. Il sagit alors de dterminer dans quel sens tourne le disque.
Dhtr!$
La sortie est active tant quil tourne dans le sens anti-horaire. (Sortie de Mealy postsynchronise active haute).
Il faut noter que le graphe d'tats prsent ci-dessous n'est pas le graphe le plus optimal,
mais il permet de prsenter diffrents aspects du codage VHDL en un seul exemple.
cgx
v.1
3.29 (48)
eivd
22 juin 1998
Dhtr!%
----------------------------------------------------------------------- Nom du fichier : m_etats.vhd

-- Auteur
: C. Guex
-- Date
: avril 1997
-- Version
: 1.0
-- Modifications :
-- Auteur
:
Date :
----------------------------------------------------------------------- But
: exemple du cours VHDL dune machine detats avec
-reset asynchrone et set synchrone
----------------------------------------------------------------------
@IUDU` detecteur_sens DT
B@I@SD8 (delai: time := 7 ns);-- delai de transfert dune porte
QPSU (entree_a: DI bit;
-- entree a du detecteur de sens
-- entree b du detecteur de sens
entree_b: DI bit;
-- horloge de la bascule D
clk
: DI bit;
-- reset asynch. de la bascule D
reset
: DI bit;
-- set synchrone de la bascule D
set
: DI bit;
sens_anti_horaire : PVU bit);-- sens de rotation
@I9 detecteur_sens;
----------------------------------------------------------------------- Architecture comportementale dune bascule D avec reset asynchrone
-- et set synchrone. Un enable autorise ou non le transfert de
-- lentree D.
----------------------------------------------------------------------
6S8CDU@8UVS@ comportementale PA detecteur_sens DT
cgx
v.1
3.30 (49)
eivd
22 juin 1998
U`Q@ etat DT (position_1, position_2, position_4, position_3);

-- attribut existant sur certains compilateurs pour le codage des
-- etats, mais ceci ne fait pas partie de la norme vhdl
--type etat is (position_1, position_2, position_3, position_4);
--attribute enum_encoding of etat: type is
-"00 " &
-- position_1
-"01 " &
-- position_2
-"11 " &
-- position_3
-"10 " ;
-- position_4
TDBI6G present : etat := position_1; -- etat present,

TDBI6G futur : etat;
TDBI6G sortie_bascule : bit;
TDBI6G valeur_avant_synchro : bit;
-------
depart: position_1
etat futur
valeur intermediaire que
prendra la sortie
valeur de letat futur de la
bascule
7@BDI
----------------------------------------------------------------------- processus des decodeurs detat futur et de sortie
----------------------------------------------------------------------
QSP8@TT (present, entree_a, entree_b)

7@BDI
86T@ present DT
XC@I position_1 23
DA entree_a = 1 6I9 entree_b = 0 UC@I
valeur_avant_synchro 12 0;
futur 12 position_2;
@GTDA entree_a = 0 6I9 entree_b = 1 UC@I
@GT@
valeur_avant_synchro 12 sortie_bascule;
@I9DA;
XC@I position_2 23
@GT@
@I9DA;
XC@I position_3 23
cgx
v.1
3.31 (50)
eivd
22 juin 1998
@GT@
@I9DA;
XC@I position_4 23
@GT@
@I9DA;
@I986T@;
@I9QSP8@TT;
----------------------------------------------------------------------- processus de memorisation de letat interne et de la post-synchro
-- de la sortie
----------------------------------------------------------------------
QSP8@TT
7@BDI
X6DUVIUDG (clk@W@IU 6I9 clk=1) PS (reset=1);
DA reset = 1 UC@I
sortie_bascule 12 0 6AU@S delai; -- reset asynchrone
present 12 position_1 6AU@S delai;
@GT@
DA set = 1 UC@I
-- prioritaire
-- retour a letat initial
sortie_bascule 1= 1 6AU@S delai;

present 12 position_1 6AU@S delai;
@GT@
-- set en 2eme priorite

-- retour a letat initial
sortie_bascule 12 valeur_avant_synchro 6AU@S delai;

-- transfert de letat
present 12 futur 6AU@S delai;
@I9DA;
@I9DA;
@I9QSP8@TT;
----------------------------------------------------------------------- En creant une variable intermediaire sortie_bascule, il est
-- possible de maintenir la valeur de la bascule tout en gardant
-- la variable sens_anti_horaire comme etant une sortie et non une
-- entree-sortie.
-- Il faut neanmoins assigner cette variable intermediaire a la sortie
----------------------------------------------------------------------
cgx
v.1
3.32 (51)
eivd
22 juin 1998
QSP8@TT (sortie_bascule)
7@BDI
sens_anti_horaire 12 sortie_bascule;
@I9QSP8@TT;
On peut remarquer dans cet exemple quil est possible et mme trs recommand de donner
un nom mnmonique (un nom rappelant le rle jou par cet tat dans le fonctionnement de
la MSS) chaque tat. Une fois ces noms choisis, il faut dclarer un type numr pour
dfinir ces diffrents tats. Pour le codage de ceux-ci, plusieurs compilateurs offrent une
fonction enum_encoding, malheureusement, elle nest pas standard et par consquent nest
pas utilisable partout. Si elle nexiste pas, il faut placer les tats dans lordre de leur code
dans la dclaration du type (A VERIFIER).
De mme, un etat dinitialisation peut tre choisi, ainsi quun etat de trappe. Les tats non
utiliss peuvent aussi avoir des noms prvus.
Sil faut dcrire plusieurs machines dtats en parallle, il vaut mieux crer des fichiers
VHDL pour chacune des machines et ensuite utiliser une description structurelle pour lier
le tout.
"$#
9rpvvpryyr
Il ny a aucune diffrence entre une description structurelle dun systme squentiel et celle
dun systme combinatoire. Un tel type de description na normalement un sens que pour
un systme modulaire. Lexemple sera celui dune cascade de compteurs 1 bit pour raliser
un compteur 4 bits.
Elment se trouvant en bibliothque : (compteur 1 bit)
@IUDU` compt_1_bit DT
QPSU (horloge
: DI
report_prec : DI
sortie
: PVU
report_suiv : PVU
@I9 compt_1_bit;
bit;
bit;
bit;
bit);
6S8CDU@8UVS@ flot_de_donnees PA compt_1_bit DT

TDBI6G int_sortie : bit;
TDBI6G int_report_suiv : bit;
7@BDI
cgx
v.1
3.33 (52)
eivd
22 juin 1998
int_report_suiv 12 int_sortie 6I9 report_prec;

int_sortie 12 int_sortie YPS report_prec XC@I
(horloge = 1 6I9IPU horlogeTU67G@) @GT@ int_sortie;
report_suiv 12 int_report_suiv;
sortie 12 int_sortie;
Compteur 4 bits :
@IUDU` compt_4_bits DT
QPSU (horloge
: DI
report_in
bit;
: DI bit;
-- enable du
compteur
valeur_compteur : PVU bit_vector (3 9PXIUP 0);
report_out
: PVU bit);
@I9 compt_4_bits;
6S8CDU@8UVS@ structurelle PA compt_4_bits DT

8PHQPI@IU bloc1 QPSU (horloge, report_prec : DI bit;
sortie, report_suiv : PVU bit);
@I98PHQPI@IU;
APS6GG : bloc1 VT@@IUDU` XPSF.compt_1_bit (compt_flux_de_donnees);
TDBI6G report0, report1, report2 : bit;
7@BDI
g0 : bloc1 QPSUH6Q
(horloge, report_in, valeur_compteur(0), report0);
g1 : bloc1 QPSUH6Q
(horloge, report0, valeur_compteur(1), report1);
g2 : bloc1 QPSUH6Q
(horloge, report1, valeur_compteur(2), report2);
g3 : bloc1 QPSUH6Q
(horloge, report2, valeur_compteur(3), report_out);
@I9 structurelle;
Voil les diffrents principes de base pour dcrire un circuit en VHDL. Mais ce nest pas
tout, car lun des intrts majeurs du langage est la possibilit de simuler par le mme
langage les diffrents modules. Sur les quelques pages suivantes, nous verrons donc les
bases pour crer un fichier de test pour la simulation.
cgx
v.1
3.34 (53)

eivd
22 juin 1998
/6TDHVG6UDPI
Pour tre efficace, une simulation doit tre la plus complte possible, sans tre redondante.
Une bonne simulation pure de tous les tests doubls permettra une bonne conomie tant
pour le temps consacr cette simulation que pour les tests sur circuit ensuite. De plus, le
fichier crit pour la simulation peut tre avantageusement utilis pour tous les tests ultrieurs
(sur le prototype, en fabrication, etc).
Comme prcit, un systme de test fournissant les stimulis et vrifiant les rponses peut
aussi tre crit en VHDL. Un module de simulation (test bench) sera cr et lintrieur de
celui-ci, nous intgrerons le module tester. En code VHDL, nous aurons ceci :
@IUDU` sim_nom_entite DT
@I9 sim_nom_entite;
----------------------------------------------------------------------- Architecture de la simulation
----------------------------------------------------------------------
6S8CDU@8UVS@ simulation PA sim_nom_entite DT

8PHQPI@IU nom_composant QPSU (entrees
type_entree_sortie;
: PVU type_sorties);
sorties
@I98PHQPI@IU0
APS
6GG
)nom_composant
(arch_mod_a_tester);
VT@
: DI type_entrees;
entrees_sorties : DIPVU
@IUDU`
XPSFent_mod_a_tester
7@BDI
a1: nom_composant QPSUH6Q (entrees, entrees_sorties, sorties);
QSP8@TT
-- simulation
@I9QSP8@TT0
@I9 simulation;
Pour tester plusieurs parties distinctes dun mme fichier VHDL, il est possible de crer
plusieurs processus de simulation. Par contre, il est prfrable pour une meilleure
comprhension davoir un droulement temporel pour tous les signaux ayant un rapport
entre eux. Expliquons-nous : en VHDL, il est possible de donner toutes les caractristiques
temporelles dun signal en une seule fois, ce qui permet de dcrire toutes les entres de
manire parallle comme lexemple ci-dessous :
cgx
v.1
3.35 (54)
eivd
22 juin 1998
6S8CDU@8UVS@ simulation_par_signal PA sim_nom_entite DT

TDBI6Gentree_1 : bit :=0;
7@BDI
entree_1 12 0, 1 6AU@S 23 ns, 1 6AU@S 35 ns, 1 6AU@S45 ns;
entree_2 12 1 6AU@S 17 ns, 0 6AU@S 35 ns, 1 6AU@S52 ns;
entree_3 12 0, 1 6AU@S 10 ns, 0 6AU@S 14 ns, 1 6AU@S25 ns;
@I9 simulation_par_signal;
Malheureusement, il est trs difficile de se retrouver avec une telle simulation, car il faut
vrifier tous les signaux pour voir s'il y a un changement ou non. La chronologie des
vnements nest absolument pas vidente et il faudrait reclasser les signaux pour en avoir
une ide (1re action sur les entres 1 et 3, puis deux fois sur la 3, ensuite une action sur
lentre 2 pour continuer par lentre 1, etc.). Il vaut donc mieux avoir une simulation
chronologique, parfois plus longue crire, mais nettement plus comprhensible et
rutilisable. Cette simulation peut se trouver sous deux formes, lune rfrence au temps
t0 et lautre au dernier vnement qui a eu lieu.
Code VHDL pour une simulation chronologique rfrence au temps t0 :
@I9 sim_nom_entite;
6S8CDU@8UVS@ simulation_chronologique_t0 PA sim_nom_entite DT
TDBI6G entree_1 : bit :=0;
7@BDI
QSP8@TT
7@BDI
entree_1
entree_3
entree_3
entree_3
entree_2
entree_1
entree_3
entree_1
entree_2
entree_1
entree_2
X6DU;
12
12
12
12
12
12
12
12
12
12
12
US6ITQPSU
US6ITQPSU
US6ITQPSU
US6ITQPSU
US6ITQPSU
US6ITQPSU
US6ITQPSU
US6ITQPSU
US6ITQPSU
US6ITQPSU
US6ITQPSU
0;
0;
1 6AU@S
0 6AU@S
1 6AU@S
1 6AU@S
1 6AU@S
0 6AU@S
0 6AU@S
1 6AU@S
1 6AU@S
10
14
17
23
25
35
35
45
52
ns;
ns;
ns;
ns;
ns;
ns;
ns;
ns;
ns;
@I9QSP8@TT;
@I9 simulation_chronologique_t0;
cgx
v.1
3.36 (55)
eivd
22 juin 1998
Code VHDL pour une simulation chronologique rfrence au dernier vnement :

@I9 sim_nom_entite;
6S8CDU@8UVS@ simulation_chronologique PA sim_nom_entite DT
TDBI6G entree_1 : bit )20;
7@BDI
QSP8@TT
7@BDI
entree_1 12 0;
entree_3 12 0;
X6DUAPS 10 ns;
entree_3 12 1;
X6DUAPS 4 ns;
entree_3 12 0;
X6DUAPS 3 ns;
entree_2 12 1;
X6DUAPS 6 ns;
entree_1 12 1;
X6DUAPS 2 ns;
entree_3 12 1;
X6DUAPS 10 ns;
entree_1 12 1;
entree_2 12 0;
X6DUAPS 10 ns;
entree_1 12 1;
X6DUAPS 7 ns;
entree_2 12 1;
@I9QSP8@TT0
@I9 simulation_chronologique;
Si la premire forme semble plus lisible, cest la deuxime qui est utilise pour crer des
procdures facilitant une simulation par cycles dhorloge. En effet, pour faciliter la
simulation, deux procdures et un processus peuvent tre crs. Une procdure pour dfinir
un cycle dhorloge, lautre pour dfinir le pas de simulation, et le processus pour dfinir la
squence dun cycle dhorloge. Les simulations pourront alors scrire sous la forme
suivante :
QSP8@TT
7@BDI
cycle;
-- cycle inactif obligatoire
entree_1 12 valeur_de_l_entree;
cgx
v.1
3.37 (56)
eivd
22 juin 1998
entree_2 12 valeur_de_l_entree;
sim(10);
-- pas de simulation de duree 10 * lunite minimale
controle_sortie_1 12 sortie_1 YPS 'valeur_desiree_de_la_sortie';

entree_1 12 'valeur_de_l_entree';
cycle;
-- termine le cycle dhorloge commence par le sim

cycle;
-- cycle dhorloge

cycle(5);
-- 5 cycles dhorloge

sim_end 12 true; -- fin de la simulation
@I9QSP8@TT0
Srhr)
le premier cycle est inactif et il faut le mettre. Il sert se positionner

correctement au dbut de la simulation.
Les signaux dclarer et les procdures sont les suivantes (attention, seul ce qui est en gras
peut tre modifi) :
8PITU6IUrvqr)vr)2 0rvqrquytr
8PITU6IUvrfv)vr)2 0vrqrrvvhyr
TDBI6Gvfrq)iyrh)2shyr0svqryhvyhv
TDBI6Guytr)iv0vthyquytr
TDBI6Gqrifppyr)iv0
vqvryrqriqppyrquytr

Qrrqrhqrvyhvhrpyvrqrrvvhyr

QSP8@9VS@virfqfvrfqrfr)Drtr)2 DT
7@BDI
cgx
v.1
3.38 (57)
eivd
22 juin 1998
X6DUAPSirfqfvrfqrfrvrfv0
@I9v0

Qprqrrrhqryhvrhryvrppyrquytr
Grrvrhryqryhprqrrvryrppyrrprqrv
pryvpvrhvhpyrhrryr)vhshvryr
hqrvyhvpuvrhhrrhpur
pivhvr

QSP8@9VS@ppyrirfqrfppyr)Drtr)2 DT
7@BDI
APSvDI UPirfqrfppyrGPPQ
X6DUVIUDGqrifppyr@W@IU6I9qrifppyr2 0
@I9GPPQ0
@I9ppyr0
7@BDI

prprtrrrruytryhvyhv

QSP8@TT
7@BDI
DAIPUvfrqUC@I
uytr12
6AU@Srvqr#
6AU@S!rvqr#
6AU@S"rvqr#0
qrifppyr12
6AU@Svrfv0
X6DUAPSrvqr0
@GT@X6DU0
@I9DA0
@I9QSP8@TT0
Pour illustrer ces fichiers de simulation, un fichier de test pour le dtecteur de sens vu
auparavant est donn ci-dessous :
----------------------------------------------------------------------- Nom du fichier : m_etats.vhd
-- Auteur
: C. Guex
-- Date
: avril 1997
-- Version
: 1.0
-- Modifications :
-- Auteur
:
Date :
----------------------------------------------------------------------- But
: exemple du cours VHDL dune simulation dune
-machine detats avec reset asynchrone et set
-synchrone
cgx
v.1
3.39 (58)
eivd
22 juin 1998
----------------------------------------------------------------------
@IUDU` sim_detecteur_sens DT
@I9 sim_detecteur_sens;
----------------------------------------------------------------------- Architecture du module de simulation du detecteur de sens
----------------------------------------------------------------------
6S8CDU@8UVS@ simul_det_sens PA sim_detecteur_sens DT

8PHQPI@IU detect_sens QPSU (entree_a, entree_b, clk, reset, set : DI
bit;
@I98PHQPI@IU;
sens : PVU bit);
APS6GG : detect_sens VT@@IUDU` XPSF.detecteur_sens (det_sens_etats);

8PITU6IU periode : time := 100 ns;
8PITU6IU unite_min : time := 1 ns;
TDBI6G
TDBI6G
TDBI6G
TDBI6G
TDBI6G
TDBI6G
TDBI6G
sim_end : boolean :=
entree_a, entree_b :
set, reset : bit;
horloge : bit;
debut_cycle : bit;
verif_sortie : bit;
erreur : bit;
false;
bit;
-- signal dhorloge
-- indique le debut dun cycle dhorloge
----------------------------------------------------------------------- Permet des pas de simulation avec lunite de temps minimale

----------------------------------------------------------------------
QSP8@9VS@ sim (nombre_d_unites_de_temps : Integer := 1) DT

7@BDI
X6DUAPS (nombre_d_unites_de_temps * unite_min);
@I9 sim;
----------------------------------------------------------------------- Procedure permettant plusieurs cycles dhorloge
-- Le premier appel de la procedure termine le cycle precedent si
-- celui-ci netait pas complet (par exemple : si on a fait quelques
-- pas de simulation non synchronises avant, reset asynchrone,
-- combinatoire, ...)
----------------------------------------------------------------------
QSP8@9VS@ cycle (nombre_de_cycles : Integer := 1) DT

7@BDI
APS i DI 1 UP nombre_de_cycles GPPQ
X6DUVIUDG debut_cycle@W@IU 6I9 debut_cycle = 1;
@I9GPPQ;
@I9 cycle;
7@BDI
cgx
v.1
3.40 (59)
eivd
22 juin 1998
----------------------------------------------------------------------- ce processus genere une horloge pour la simulation

----------------------------------------------------------------------
QSP8@TT
7@BDI
DAIPU sim_endUC@I
horloge 12 0,
1 6AU@S periode 4,
1 6AU@S 2 periode 4,
0 6AU@S 3 periode 4;
debut_cycle 12 1,
0 6AU@Sunite_min;
X6DUAPS periode;
@GT@X6DU;
@I9DA;
@I9QSP8@TT;
a1: detect_sens QPSUH6Q
(entree_a, entree_b, horloge, reset, set, verif_sortie);
QSP8@TT
7@BDI
-- Attention, le premier cycle doit etre double pour un fonctionnement
-- correct ou alors, le plus simple est de toujours commencer par un
-- cycle inactif
cycle;
-- cycle inactif
reset 12 1;
sim(10);
reset 12 0;
cycle;
set 12 0;
entree_a 12 0;
entree_b 12 0;
cycle;
entree_a 12 0;
entree_b 12 1;
cycle(4);
erreur 12 verif_sortie
entree_a 12 1;
entree_b 12 1;
cycle;
entree_a 12 1;
entree_b <= 0;
cycle;
entree_a 12 0;
entree_b 12 0;
cycle;
cgx
YPS 1;
YPS 1;
YPS 1;
YPS 1;
v.1
3.41 (60)
eivd
entree_a 12 1;
entree_b 12 0;
cycle;
entree_a 12 1;
entree_b 12 1;
cycle;
entree_a 12 0;
entree_b 12 1;
cycle;
entree_a 12 0;
entree_b 12 0;
cycle;
22 juin 1998
YPS 0;
YPS 0;
YPS 0;
YPS 0;
sim_end 12 true;
@I9QSP8@TT;
@I9 simul_det_sens;
Pour tester les sorties, la solution la plus simple est dutiliser une fonction ou exclusif et de
comparer la valeur relle de la sortie par rapport la valeur souhaite. La valeur du signal
rr devrait toujours valoir 0. Nous aurons donc :
erreur 12 sortie YPS valeur souhaitee;
Ir)

Un paquetage a t cr afin de faciliter la simulation. On le retrouve dans le

chapitre consacr aux fichiers de simulation.
3PG6SDUe9@T@IUSe@TTPSUD@T
La polarit des signaux en VHDL peut scrire de manire trs simple si lon se donne une
norme. Pour dcrire le fonctionnement dun systme, il est beaucoup plus ais dcrire en
polarit positive, plutt quen polarit mixte. Cest donc dans cette optique quune interface
peut tre cre entre le module dcrivant le fonctionnement du systme (crit en polarit
positive) et le monde extrieur.
La reprsentation graphique de cette interface est la suivante :
cgx
v.1
3.42 (61)
eivd
22 juin 1998
Dhtr!&
et le code VHDL est celui-ci :

----------------------------------------------------------------------- Nom du fichier : polarite.vhd
-- Auteur
: C. Guex
-- Date
: mai 1997
-- Version
: 1.0
-- Modifications :
-- Auteur
:
Date :
----------------------------------------------------------------------- But
: interface pour polariser les signaux
----------------------------------------------------------------------
@IUDU` module_exterieur DT
QPSU (d0_L : DI bit;
d1_H : DI bit;
d2_L : DI bit;
d3_H : DI bit;
q0_L : PVU bit;
q1_L : PVU bit;
q2_H : PVU bit);
@I9 module_exterieur;
--------
entree
entree
entree
entree
sortie
sortie
sortie
0
1
2
3
0
1
2
active
active
active
active
active
active
active
basse
haute
basse
haute
basse
basse
haute
----------------------------------------------------------------------- Architecture pour la polarite des signaux

----------------------------------------------------------------------
6S8CDU@8UVS@ polarite PA module_exterieur DT

8PHQPI@IU module_interieur
QPSU (d0, d1, d2, d3 : DIbit;
q0, q1, q2
: PVU bit);
@I98PHQPI@IU;
APS6GG : module_interieur
cgx
v.1
3.43 (62)
eivd
22 juin 1998
VT@@IUDU`XPSF.ent_module_interieur (arch_module_interieur);
TDBI6G d3, d2, d1, d0, q2, q1, q0 : bit;
7@BDI
pol1 : module_interieur QPSUH6Q (d0, d1, d2, d3, q0, q1, q2);
-d0
d1
d2
d3
entrees
12IPU d0_L;
12
d1_H;
12IPU d2_L;
12
d3_H;
-- sorties
q0_L 12IPU q0;
q1_L 12IPU q1;
q2;
q2_H 12
@I9 polarite;
Comme il est possible de le voir ci-dessus, cette norme est la suivante :

hpqrvthqqyrvpvrrrqvqvphvqrhyhvp
yrqyrvpvrqppvryhvpvvr
rvrshprrppprqpvtryhyhvpqvthy
yrqyrvpvrrrtyipqhyvrshpr
qryrpvryrvthyryhvpvqvprqhyrqvthyqr
yhhvqrvhr)
QRPBGXBVLJQDOfC
QRPBGXBVLJQDOfG
ryhvpvvr
ryhvppthvr
vyrqryhvpqvthyvyvprjyrpvrqqyrhypprh
!vthjyhvpvrrqhyvrshprhvvyvrhhyrvthq
qyrvpvrr)pyxfGrpyxfC
cgx
v.1
3.44 (63)
eivd
6758&785( '8 9+'/

6USV8UVS@BeIeS6G@9VIQSPBS6HH@9+'/
22 juin 1998
Un programme VHDL se structure de la manire suivante :

-- --------------------------------------------------------------- declaration et utilisation des bibliotheques necessaires
-- --------------------------------------------------------------
-- --------------------------------------------------------------- declaration de lentite et de ses ports dentree-sortie
-- --------------------------------------------------------------
QPSU (ports_d_entree : DI type_ports_d_entree;
ports_de_sortie : PVU type_ports_de_sortie;
-- --------------------------------------------------------------- architecture du programme, structure interne
-- --------------------------------------------------------------

7@BDI
-- programme interne
cgx
v.1
4.1 (64)

eivd
22 juin 1998
/@T7D7GDPUCRV@T
9psvvv)
Une iviyvuqr est le regroupement dun ensemble dlments

destins tre rutiliss dans un dveloppement ultrieur.
Dclaration :
#!
Rrrqhriviyvuqr4
Le but dune bibliothque est de regrouper de faon organise un ensemble dlments

(entits, paquetages) de manire pouvoir les utiliser dans nos programmes VHDL. Cest
en quelque sorte un magasin de pices.
Il existe deux types de bibliothques :
-
#!!
les bibliothques de lutilisateur (user library) : Il sy trouve tout ce quil a cr et

analys en VHDL. Lutilisateur cre lors de chaque projet sa (ou ses) bibliothque(s)
utilisateur.
Les bibliothques systme : Elles font partie du systme logiciel mis disposition de
lutilisateur, et sont exploitables dans tout projet.
8rqppyhrriviyvuqrqhsvpuvrWC9G4
Pour utiliser des lments dans un fichier VHDL, il faut dabord savoir si lon veut utiliser
un lment de notre espace de travail (fichier VHDL cr par lutilisateur) ou si lon veut
utiliser un lment qui se trouve dans une bibliothque externe.
#!!
Gpyprjvyvrshvhvrqrrrhprqrhhvywr
En VHDL, on assimile lespace de travail une bibliothque (bien quil nen soit pas une).
Pour y utiliser un lment, la plupart des compilateurs VHDL emploient le mot XPSF
comme nom de bibliothque. Ds lors, tous les lments crs par lutilisateur peuvent tre
rutiliss dans un autre fichier VHDL du mme projet : il suffit de dclarer les lments de
la bibliothque WORK que lon dsire utiliser.
cgx
v.1
4.2 (65)
eivd
22 juin 1998
Par exemple, si lutilisateur a cr un paquetage (fichier VHDL dans lequel on trouve une
srie de variables, constantes, signaux, fonctions et procdures), il peut lutiliser en dclarant
la ligne suivante au dbut de son nouveau fichier VHDL :
.nom_du_paquetage.6GG0
VT@XPSF
Lorsque cest un element que lon dsire utiliser, la dclaration est la suivante :
FOR ALL : nom_element USE ENTITY XPSF.entite_element(arch_element);
Note : Certains compilateurs placent le rsultat de lanalyse dans une bibliothque

pralablement cre par lutilisateur. Ds ce moment, sil compile un paquetage,
celui-ci se retrouvera dans lespace de travail, mais aussi dans la bibliothque cre
par lutilisateur. Pour utiliser un lment de son paquetage, il aura deux manires de
le dclarer :
.nom_du_paquetage.6GG;
VT@ XPSF
ou
VT@
nom_bibliotheque_utilisateur.nom_du_paquetage.6GG;
Exemple :
VT@XPSFhrhtrfrfytvr6GG0
ou
VT@rhrhtrfrfytvr6GG0
#!!!
Gpyprjvyvrshvhvrqrhriviyvuqr
Pour utiliser un lment dune bibliothque, il faut dabord dclarer celle-ci dans notre
fichier VHDL, puis il faut spcifier quels sont les parties de la bibliothque utiliser.
Ce qui donne le code suivant :
nom_de_bibliotheque;
VT@ nom_de_bibliotheque.nom_du_paquetage.6GG;
GD7S6S`
Exemple pour utiliser le paquetage de simulation (la description suit dans quelques pages):
einev;
VT@ einev.simulation_pkg.6GG;
GD7S6S`
cgx
v.1
4.3 (66)
eivd
),&+,(56 '( 6,08/$7,21 '(6 (;(03/(6

36RV@U6B@TDHVG6UDPI
22 juin 1998
Ce paquetage a t cr pour faciliter la simulation en VHDL et la rendre plus structure.

Plusieurs de ces fonctions et procdures sont utilises dans les exemples de simulation qui
se trouveront ensuite.
$
Qppqrrspvvyvhiyr
Nous trouverons ci-dessous toutes les procdures et fonctions utilisables dans ce paquetage:
Les lments entre crochets [ ] sont des lments optionnels. Il nest pas ncessaire de les
mettre.
v0
v
avance dun pas de simulation. La valeur par dfaut est de

100ns.
v(a);
v
excute un certain nombre de pas de simulation.
nombre de pas de simulation.
Exemple : v$0
v(b unite_temps);
cgx
v.1
5.1 (67)
eivd
excute un pas de simulation.
dure du pas de simulation.
unite_temps
unit de temps dun pas de simulation.
22 juin 1998
Exemple : v 0
v(a, b unite_temps);
v
excute un certain nombre de pas de simulation.
nombre de pas de simulation.
dure du pas de simulation.
unite_temps
unit de temps dun pas de simulation.
Exemple : v$ 0

ppyr0
ppyr
Excute un cycle dhorloge. La forme du cycle doit tre

spcifie dans le fichier de simulation. Dans le cas o lon se
trouvait au milieu dun cycle, cette commande terminera le
cycle en cours.
ppyr(n);
ppyr
Excute un certain nombre de cycles dhorloge. La forme du

cycle doit tre spcifie dans le fichier de simulation. Dans le
cas o lon se trouvait au milieu dun cycle, cette commande
terminera le cycle en cours.
nombre de cycles dhorloge effectus.
Exemple : ppyr$0
rpu(texte [, nom_de_fichier]);
cgx
v.1
5.2 (68)
eivd
22 juin 1998
rpu
Commande dcriture dans un fichier.
texte
Texte que lon dsire crire dans le fichier.
nom_de_fichier
Nom du fichier dans lequel on dsire crire le texte. Cet

lment est optionnel. Sil nest pas indiqu, le fichier par
dfaut est ryh.
Exemples :
rpu9riqryhvyhv0
rpuAvpr0
rpu(valeur [, nom_de_fichier]);
rpu
valeur
Valeur dun signal que lon dsire crire dans le fichier.
nom_de_fichier
Nom du fichier dans lequel on dsire crire la valeur du

signal. Cet lment est optionnel. Sil nest pas indiqu, le
fichier par dfaut est ryh.
Exemples :
rpurh0
rpu 0
rpurhpr0
rpu(texte, valeur [, nom_de_fichier]);

rpu
texte
Texte que lon dsire crire dans le fichier.

Valeur dun signal que lon dsire crire dans le fichier.
valeur
nom_de_fichier
Exemples :
cgx
Nom du fichier dans lequel on dsire crire. Cet lment est

optionnel. Sil nest pas indiqu, le fichier par dfaut est
ryh.
rpuivqrh2rh0
rpurrr2 0
rpuivqrh2rhpr0
v.1
5.3 (69)
eivd
22 juin 1998
rpuf(vecteur [, string(nom_de_fichier)]);
rpuf
vecteur
Vecteur que lon dsire crire dans le fichier.
nom_de_fichier

Exemples :
rpufrprfh0
rpuf 0
rpufrprfhpr0
rpuf vtpr0
rpuf(texte , vecteur [, nom_de_fichier]);

rpuf
vecteur
Vecteur que lon dsire crire dans le fichier.
nom_de_fichier

Exemples :
rpufyrrprhh)rprfh0
rpufyrrprh2rprfhpr0
Attention :
il ne faut pas mettre

mais
rpufyrrprh2 0
rpuyrrprh2 0
vecteur_a vecteur_b;
Oprateur logique YPS utilisable pour des vecteurs.

Lopration ou exclusif se fait bit bit. Les dimensions du
vecteur de sortie sont celles du premier vecteur. De ce fait,
il est possible dcrire vecteur_a <= vecteur_a xor
vecteur_b; mais pas vecteur_b <= vecteur_a xor
vecteur_b;
cgx
v.1
5.4 (70)
eivd
vecteur_a
Premier vecteur.
vecteur_b
Deuxime vecteur.
Exemples :
22 juin 1998
r12pr 0
r12 pr0
r12prfhprfi0
rprfh12rprfhrprfi0
purpx (vecteur_a, valeur_a_tester [, nom_de_fichier]);

purpx
Commande indiquant dans un fichier sil y a une diffrence

entre une valeur ou un vecteur calcul dans un fichier VHDL
et un rsultat suppos par lutilisateur. Attention, la valeur
calcule doit toujours se mettre en premier.
vecteur_a
Valeur ou vecteur de sortie dun fichier VHDL.
valeur_a_tester
Valeur que lon dsire comparer la valeur ou au vecteur

prcdent.
nom_de_fichier

ryh.
Exemples :
purpxpr 0
purpxpr prv0
vqvrfvfrr(vecteur [, nom_de_fichier]);
cgx
vqvrfvfrr
Ecrit dans un fichier en ordre si le vecteur tester vaut

zro et erreur sur le pas de simulation prcdant si le
vecteur tester est non nul. Sutilise aprs une vrification
des valeurs de sortie par un XOR.
vecteur
Vecteur tester.
nom_de_fichier

ryh.
v.1
5.5 (71)
Exemples :
eivd
22 juin 1998
vqvrfvfrrr0
vqvrfvfrrrpr0
pfrp(vecteur_a, vecteur_b [, ecrire [, nom_de_fichier]]);

pfrp
Compare deux vecteurs. Sils sont gaux, le rsultat de cette

fonction sera un signal de type bit et de valeur 0 et sil ne
sont pas gaux, la valeur restitue sera 1. De plus, si
lutilisateur le dsire, il crit dans un fichier si les vecteurs
sont gaux ou non.
vecteur_a
Premier vecteur comparer.
vecteur_b
Deuxime vecteur comparer.
ecrire
Indique si lon veut crire le rsultat dans un fichier ou non.

Pour crire dans un fichier, il faut spcifier v. Cette valeur
est optionnelle et ne sindique pas si lon ne dsire pas crire
le rsultat dans un fichier.
nom_de_fichier

ryh.
Exemples :
$ !
cgx
r12pfrprh 0
r12pfrprh v0
r12pfrprh vpr0
8hr
hfqrfvyhvfv
est la dure par dfaut dun pas de simulation. Elle a t

dfinie .
fsvpuvr
reprsente le nom du fichier par dfaut pour tous les

enregistrements. Ce nom par dfaut est ryh.
vrfqrfrfv
est lunit de temps minimale dans la simulation. Elle a t

dfinie .
v.1
5.6 (72)
$ "
est un type numr avec les deux valeurs suivantes : v,

.
Tvth
qrifppyr

22 juin 1998
Ur
hpprr
$ #
eivd
est un signal qui doit tre utilis pour des simulations

squentielles.
&P9@9VQ6RV@U6B@9@TDHVG6UDPI
---------------------------------------------------------------------------- Auteur
: Claude Guex
-- Date
: octobre 1997
-- But
: faciliter la simulation en VHDL
-- Remarques : 1) Plusieurs procedures et fonctions utilisent le paquetage
-standard textio pour les acces aux fichiers. Ce paquetage
-etant refuse par plusieurs compilateurs, il sera peut-etre necessaire de les modifier. Il sagit de :
-- toutes les procedures ECHO (3 procedures)
-- de la procedure INDIQUER_SI_ERREUR
-- de la fonction CMP_VECT
---------------------------------------------------------------------------- Modifications :
-- Auteur
:
Date :
-- But
:
---------------------------------------------------------------------------- Ajout de procedures et fonctions :
-- Auteur
:
Date :
-- But
:
---------------------------------------------------------------------------
86( std.textio.$//;
3$&.$*( simulation_pkg ,6
---------------------------------------------------------------------------- ZONE MODIFIABLE PAR LUTILISATEUR
--------------------------------------------------------------------------&2167$17 pas_de_simulation_min : time := 100 ns;
&2167$17 nom_fichier : string := "resultat.txt";
---------------------------------------------------------------------------- FIN DE LA ZONE MODIFIABLE PAR LUTILISATEUR
---------------------------------------------------------------------------
cgx
v.1
5.7 (73)
eivd
22 juin 1998
7<3( accepter ,6 (oui,non);

&2167$17 unite_de_temps_min : time := 1 ns;
6,*1$/ debut_cycle : bit; -- indique le debut dun cycle dhorloge
---------------------------------------------------------------------------- Procedure permettant des pas de simulation avec lunite minimale
---------------------------------------------------------------------------
352&('85( sim (nombre_d_unites_de_temps : integer := 1 ;

unite_min : time := pas_de_simulation_min);
---------------------------------------------------------------------------
352&('85( sim (unite_min : time;

nombre_d_unites_de_temps : integer := 1 );
---------------------------------------------------------------------------- Procedure permettant plusieurs cycles dhorloge
-- Le premier appel de la procedure termine le cycle precedent si celui-ci
-- netait pas complet (par exemple : si on a fait quelques pas de
-- simulation non synchronises avant, reset asynchrone, combinatoire, ...)
---------------------------------------------------------------------------
352&('85( cycle (nombre_de_cycles : integer := 1);

---------------------------------------------------------------------------- Procedure qui indique dans un fichier si un vecteur est nul ou non
---------------------------------------------------------------------------
352&('85( indiquer_si_erreur (somme : ,1 bit_vector;

nom_du_fichier: string := nom_fichier);
---------------------------------------------------------------------------- Procedure permettant decrire dans un fichier un texte.
---------------------------------------------------------------------------
352&('85( echo (texte_a_ecrire: string;

---------------------------------------------------------------------------- Procedure permettant decrire dans un fichier la valeur dun signal.
---------------------------------------------------------------------------
352&('85( echo (valeur_a_ecrire: bit;

---------------------------------------------------------------------------- Procedure permettant decrire dans un fichier un vecteur.
---------------------------------------------------------------------------
352&('85( echo_v (vecteur_a_ecrire: bit_vector;

---------------------------------------------------------------------------- Procedure permettant decrire dans un fichier un texte et la valeur
-- dun signal.
---------------------------------------------------------------------------

valeur_a_ecrire: bit;
--------------------------------------------------------------------------cgx
v.1
5.8 (74)
eivd
22 juin 1998
-- Procedure permettant decrire dans un fichier un texte et un vecteur.

---------------------------------------------------------------------------
352&('85( echo_v (texte_a_ecrire: string;

vecteur_a_ecrire: bit_vector;
---------------------------------------------------------------------------- Procedure qui compare ce que lutilisateur desire et le calcul resultant
-- de la description VHDL. Indique la valeur fausse sil y en a.
---------------------------------------------------------------------------
352&('85( check (valeur_1, valeur_2 : bit;

---------------------------------------------------------------------------
352&('85( check (vecteur_1, vecteur_2 : bit_vector;

---------------------------------------------------------------------------- Fonction qui verifie lidenticite de deux vecteurs.
-- Elle ne fait quindiquer si les deux vecteurs sont identiques (0) ou
-- non (1) a laide dun bit.
---------------------------------------------------------------------------
)81&7,21 cmp_vect (vecteur_1, vecteur_2 : bit_vector;

ecrire_fichier: accepter := non;
nom_du_fichier: string := nom_fichier)
5(7851 bit;
---------------------------------------------------------------------------- Fonction permettant de faire loperation "ou exclusif" sur des vecteurs
-- Le "ou exclusif" se fait bit a bit.
-- PAS AU POINT. A TERMINER
---------------------------------------------------------------------------
)81&7,21 "xor" (vecteur_1, vecteur_2 : bit_vector) 5(7851 bit_vector;

(1' simulation_pkg;
3$&.$*( %2'< simulation_pkg ,6

---------------------------------------------------------------------------
352&('85( sim (nombre_d_unites_de_temps : integer := 1 ;

unite_min : time := pas_de_simulation_min)
,6
%(*,1
:$,7 )25 (nombre_d_unites_de_temps * unite_min);
(1' sim;
---------------------------------------------------------------------------

cgx
v.1
5.9 (75)
eivd
22 juin 1998
nombre_d_unites_de_temps : integer := 1 )
,6
%(*,1
(1' sim;
---------------------------------------------------------------------------
352&('85( cycle (nombre_de_cycles : integer := 1) ,6

%(*,1
)25 i ,1 1 72 nombre_de_cycles /223
:$,7 817,/ debut_cycle(9(17 $1' debut_cycle = 1;
end loop;
(1' cycle;
---------------------------------------------------------------------------
352&('85( indiquer_si_erreur (somme : ,1 bit_vector;
nom_du_fichier: string := nom_fichier) ,6

&2167$17 texte : string := "en ordre";
&2167$17 texte2 : string := "erreur de fonctionnement sur le pas de simulation
precedent";
9$5,$%/( vecteur_int : bit_vector(somme+,*+ '2:172 somme/2:):=(27+(56 =>
0);
9$5,$%/( pointeur_pour_fichier : line;

),/( fichier_resultats : text ,6 287 nom_du_fichier;
%(*,1
,) somme = vecteur_int 7+(1
write (pointeur_pour_fichier,texte);
writeline(fichier_resultats,pointeur_pour_fichier);
(/6(
write (pointeur_pour_fichier,texte2);
(1' ,);
(1' indiquer_si_erreur;
---------------------------------------------------------------------------


,6
%(*,1
(1'
write (pointeur_pour_fichier,texte_a_ecrire);
echo;

---------------------------------------------------------------------------
352&('85( echo (valeur_a_ecrire: bit;

cgx
v.1
5.10 (76)
eivd

22 juin 1998
,6
%(*,1
(1'
write (pointeur_pour_fichier,valeur_a_ecrire);
echo;
---------------------------------------------------------------------------- Procedure permettant decrire dans un fichier un vecteur

---------------------------------------------------------------------------
352&('85( echo_v (vecteur_a_ecrire: bit_vector;
,6

%(*,1
(1'
write (pointeur_pour_fichier,vecteur_a_ecrire);
echo_v;

-- dun signal.
---------------------------------------------------------------------------

valeur_a_ecrire: bit;
,6
%(*,1
(1'
echo;
---------------------------------------------------------------------------- Procedure permettant decrire dans un fichier un texte et un vecteur.

---------------------------------------------------------------------------

vecteur_a_ecrire: bit_vector;
,6
%(*,1
(1'
echo_v;

---------------------------------------------------------------------------
352&('85( check (valeur_1, valeur_2 : bit;

&2167$17 enordre : string := "En ordre";

&2167$17 erreur1 : string := "Vous avez specifie ";
cgx
v.1
,6
5.11 (77)
eivd
22 juin 1998
&2167$17 erreur2 : string := " et votre fichier VHDL calcule ";

%(*,1
,) valeur_1 = valeur_2 7+(1
write (pointeur_pour_fichier,enordre);
(/6(
write (pointeur_pour_fichier,erreur1);
write (pointeur_pour_fichier,valeur_2);
(1' ,);
(1' check;
---------------------------------------------------------------------------
352&('85( check (vecteur_1, vecteur_2 : bit_vector;

%(*,1
$66(57 (vecteur_1/(1*7+ = vecteur_2/(1*7+)
5(3257 "Attention, les deux vecteurs sont de taille differente"
6(9(5,7< error;
,) vecteur_1 = vecteur_2 7+(1
(/6(
write (pointeur_pour_fichier,vecteur_2);
(1' ,);
(1' check;
-- non (1) a laide dun bit.
---------------------------------------------------------------------------
)81&7,21 cmp_vect (vecteur_1, vecteur_2 : bit_vector;

5(7851 bit ,6
&2167$17 egaux : string := "Les deux vecteurs sont egaux";

&2167$17 differents : string := "Les deux vecteurs sont differents";
%(*,1
cgx
v.1
5.12 (78)
eivd
22 juin 1998
,) ecrire_fichier = oui 7+(1

write(pointeur_pour_fichier,egaux);
(1' ,);
5(7851 0;
(/6(
write(pointeur_pour_fichier,differents);
(1' ,);
5(7851 1;
(1' ,);
(1' cmp_vect;
---------------------------------------------------------------------------- Fonction permettant de faire loperation "ou exclusif" sur des vecteurs
-- Le "ou exclusif" se fait bit a bit.
-- Il est obligatoire de redefinir les vecteurs dentree, En effet
-- lutilisateur de cette fonction peut entrer deux vecteurs de meme taille
-- mais avec des bornes differentes :
-vecteur_1(7 downto 0), vecteur_2(1 to 8)
-- Mais il peut encore entrer un vecteur directement par sa valeur, ce qui
-- implique quil naura pas de bornes (ex : "0011010").
-- Il est des lors impossible de parcourir les vecteurs dune borne a
-- lautre, car elles peuvent etre soit differentes, soit inexistantes !
-- Attention : on peut ecrire
vecteur_a <= vecteur_a xor vecteur_b;
-mais pas
vecteur_b <= vecteur_a xor vecteur_b;
---------------------------------------------------------------------------
)81&7,21 "xor" (vecteur_1, vecteur_2 : bit_vector) 5(7851 bit_vector ,6

$/,$6 v1: bit_vector((vecteur_1/(1*7+ - 1) '2:172 0) ,6 vecteur_1;
$/,$6 v2: bit_vector((vecteur_2/(1*7+ - 1) '2:172 0) ,6 vecteur_2;
9$5,$%/( vecteur_intermediaire : bit_vector(vecteur_15$1*();
9$5,$%/( compteur_interne : integer := vecteur_1/(1*7+ - 1;
%(*,1
$66(57 (vecteur_1/(1*7+ = vecteur_2/(1*7+)
6(9(5,7< error;
)25 i ,1 vecteur_15$1*( /223
,) v1(compteur_interne) = v2(compteur_interne) 7+(1
vecteur_intermediaire(i) := 0;
(/6(
vecteur_intermediaire(i) := 1;
(1' ,);
compteur_interne := compteur_interne - 1;
(1' /223;
5(7851 vecteur_intermediaire;
(1' "xor";
(1' simulation_pkg;

&P9@9VQ6RV@U6B@9@TDHVG6UDPIQPVSG@TU9BGPBD8B
---------------------------------------------------------------------------- Auteur
: Claude Guex
-- Date
: octobre 1997
-- But
: faciliter la simulation en VHDL
-- Remarques : 1) Plusieurs procedures et fonctions utilisent le paquetage
cgx
v.1
5.13 (79)
eivd
22 juin 1998
-standard textio pour les acces aux fichiers. Ce paquetage

-etant refuse par plusieurs compilateurs, il sera peut-etre necessaire de les modifier. Il sagit de :
-- toutes les procedures ECHO (3 procedures)
-- de la procedure INDIQUER_SI_ERREUR
-- de la fonction CMP_VECT
---------------------------------------------------------------------------- Modifications :
-- Auteur
:
Date :
-- But
:
---------------------------------------------------------------------------- Ajout de procedures et fonctions :
-- Auteur
:
Date :
-- But
:
---------------------------------------------------------------------------
86( std.textio.$//;
/,%5$5< ieee;
86( ieee.std_logic_1164.$//;
86( ieee.std_logic_textio.$//;
3$&.$*( simulation_std_logic_pkg ,6
---------------------------------------------------------------------------- ZONE MODIFIABLE PAR LUTILISATEUR
--------------------------------------------------------------------------&2167$17 pas_de_simulation_min : time := 100 ns;
&2167$17 nom_fichier : string := "resultat.txt";
---------------------------------------------------------------------------- FIN DE LA ZONE MODIFIABLE PAR LUTILISATEUR
---------------------------------------------------------------------------
7<3( accepter ,6 (oui,non);

&2167$17 unite_de_temps_min : time := 1 ns;
6,*1$/ debut_cycle : std_logic; -- indique le debut dun cycle dhorloge
---------------------------------------------------------------------------
352&('85( sim (nombre_d_unites_de_temps : Integer := 1 ;

unite_min : time := pas_de_simulation_min);
---------------------------------------------------------------------------

nombre_d_unites_de_temps : Integer := 1 );
---------------------------------------------------------------------------
352&('85( cycle (nombre_de_cycles : Integer := 1);

---------------------------------------------------------------------------
cgx
v.1
5.14 (80)
eivd
22 juin 1998
352&('85( indiquer_si_erreur (somme : ,1 std_logic_vector;

---------------------------------------------------------------------------

---------------------------------------------------------------------------
352&('85( echo (valeur_a_ecrire: std_logic;

---------------------------------------------------------------------------- Procedure permettant decrire dans un fichier un vecteur.
---------------------------------------------------------------------------
352&('85( echo_v (vecteur_a_ecrire: std_logic_vector;

-- dun signal.
---------------------------------------------------------------------------

valeur_a_ecrire: std_logic;
---------------------------------------------------------------------------- Procedure permettant decrire dans un fichier un texte et un vecteur.
---------------------------------------------------------------------------

vecteur_a_ecrire: std_logic_vector;
---------------------------------------------------------------------------
352&('85( check (valeur_1, valeur_2 : std_logic;

---------------------------------------------------------------------------
352&('85( check (vecteur_1, vecteur_2 : std_logic_vector;

-- non (1) a laide dun std_logic.
---------------------------------------------------------------------------
)81&7,21 cmp_vect (vecteur_1, vecteur_2 : std_logic_vector;

nom_du_fichier: string := nom_fichier) return std_logic;
cgx
v.1
5.15 (81)
eivd
22 juin 1998
(1' simulation_std_logic_pkg;
3$&.$*( %2'< simulation_std_logic_pkg ,6

---------------------------------------------------------------------------
352&('85( sim (nombre_d_unites_de_temps : Integer := 1 ;
,6
unite_min : time := pas_de_simulation_min)
%(*,1
(1' sim;
---------------------------------------------------------------------------

nombre_d_unites_de_temps : Integer := 1 )
,6
%(*,1
(1' sim;
---------------------------------------------------------------------------
352&('85( cycle (nombre_de_cycles : Integer := 1) ,6

%(*,1
)25 i ,1 1 72 nombre_de_cycles /223
:$,7 817,/ debut_cycleevent $1' debut_cycle = 1;
(1' /223;
(1' cycle;
---------------------------------------------------------------------------
352&('85( indiquer_si_erreur (somme : ,1 std_logic_vector;

&2167$17 texte : string := "en ordre";
&2167$17 texte2 : string := "erreur de fonctionnement sur le pas de simulation
precedent";
9$5,$%/( vecteur_int : std_logic_vector(somme+,*+ '2:172 somme/2:):=(27+(56
=> 0);
%(*,1
,) somme = vecteur_int 7+(1
write (pointeur_pour_fichier,texte);
(/6(
cgx
v.1
5.16 (82)
eivd
22 juin 1998
write (pointeur_pour_fichier,texte2);
(1' ,);
(1' indiquer_si_erreur;
---------------------------------------------------------------------------


,6
%(*,1
(1'
echo;

---------------------------------------------------------------------------
352&('85( echo (valeur_a_ecrire: std_logic;


,6
%(*,1
(1'
echo;
---------------------------------------------------------------------------- Procedure permettant decrire dans un fichier un vecteur

---------------------------------------------------------------------------
352&('85( echo_v (vecteur_a_ecrire: std_logic_vector;


,6
%(*,1
(1'
echo_v;

-- dun signal.
---------------------------------------------------------------------------

valeur_a_ecrire: std_logic;
,6
%(*,1
(1'
echo;
---------------------------------------------------------------------------
cgx
v.1
5.17 (83)
eivd
22 juin 1998
-- Procedure permettant decrire dans un fichier un texte et un vecteur.

---------------------------------------------------------------------------

vecteur_a_ecrire: std_logic_vector;
,6
%(*,1
(1'
echo_v;

---------------------------------------------------------------------------
352&('85( check (valeur_1, valeur_2 : std_logic;

%(*,1
,) valeur_1 = valeur_2 7+(1
(/6(
(1' ,);
(1' check;
---------------------------------------------------------------------------
352&('85( check (vecteur_1, vecteur_2 : std_logic_vector;

%(*,1
$66(57 (vecteur_1/(1*7+ = vecteur_2/(1*7+)
6(9(5,7< error;
(/6(
cgx
v.1
5.18 (84)
eivd
22 juin 1998
(1' ,);
(1' check;
-- non (1) a laide dun std_logic.
---------------------------------------------------------------------------
)81&7,21 cmp_vect (vecteur_1, vecteur_2 : std_logic_vector;

5(7851 std_logic ,6
&2167$17 egaux : string := "Les deux vecteurs sont egaux";

&2167$17 differents : string := "Les deux vecteurs sont differents";
%(*,1
write(pointeur_pour_fichier,egaux);
(1' ,);
5(7851 0;
(/6(
write(pointeur_pour_fichier,differents);
(1' ,);
5(7851 1;
(1' ,);
(1' cmp_vect;
(1' simulation_std_logic_pkg;

)D8CD@S9@TDHVG6UDPI9V9e8P9@VST@QUT@BH@IUT
-- Auteur : Claude Guex
-- Date
: octobre 1997
-- But
: Test un comparateur
/,%5$5< einev;
86( einev.simulation_pkg.$//;
(17,7< sim_sept_segments ,6
(1' sim_sept_segments;
$5&+,7(&785( simulation 2) sim_sept_segments ,6
&20321(17 sept_seg_a 3257 (code_binaire : ,1 bit_vector (3 '2:172 0);
S7, S6, S5, S4, S3, S2, S1 : 287 bit);
(1' &20321(17;
cgx
v.1
5.19 (85)
eivd
22 juin 1998
)25 $// : sept_seg_a 86( (17,7< :25..sept_seg(tdv_sept_seg);

6,*1$/
6,*1$/
6,*1$/
6,*1$/
6,*1$/
sim_end : boolean := false;

code_binaire : bit_vector (3 '2:172 0);
sept_segments : bit_vector (6 '2:172 0);
S7, S6, S5, S4, S3, S2, S1 : bit;
erreur : bit_vector (6 '2:172 0);
---------------------------------------------------------------------------- PROGRAMME DE SIMULATION

---------------------------------------------------------------------------
%(*,1
a1: sept_seg_a
3257 0$3 (code_binaire, S7, S6, S5, S4, S3, S2, S1 );
352&(66 (S7, S6, S5, S4, S3, S2, S1)

%(*,1
sept_segments(6) S7;
(1' 352&(66;
352&(66
%(*,1
echo("---- debut de la simulation");
echo("---- affiche un 0");
code_binaire "0000";
sim;
erreur sept_segments ;25 "0111111";
indiquer_si_erreur(erreur);
sim;
sim;
sim;
sim;
sim;
cgx
v.1
5.20 (86)
eivd
22 juin 1998

sim;
sim;
sim;
sim;
echo("---- affiche un X");
sim;
sim;
sim;
sim;
sim;
sim;
echo("---- fin de la simulation");
cgx
v.1
5.21 (87)
eivd
sim_end
22 juin 1998
true;
:$,7;
(1' 352&(66;
(1' simulation;

)D8CD@S9@TDHVG6UDPI9V8PHQ6S6U@VS
-- Auteur : Claude Guex
-- Date
: octobre 1997
-- But
: Test un comparateur
/,%5$5< einev;
(17,7< sim_comparateur ,6
(1' sim_comparateur;
$5&+,7(&785( simulation 2) sim_comparateur ,6
&20321(17 comparateur1 3257 (vecteur1,vecteur2 : ,1 bit_vector (3 '2:172 0);
pg, egal, pp : ,1 bit;
v1pgv2, v1egalv2, v1ppv2 : 287 bit);
(1' &20321(17;
)25 $// : comparateur1 86( (17,7< :25..comparateur(comportementale);
6,*1$/
6,*1$/
6,*1$/
6,*1$/
6,*1$/
6,*1$/
6,*1$/

vecteur_a, vecteur_b : bit_vector (3 '2:172 0);
pg, egal, pp : bit;
comparaison_precedente : bit_vector (2 '2:172 0);
vapgvb, vaegalvb, vappvb : bit;
resultat_comparaison : bit_vector (2 '2:172 0);
erreur : bit_vector (2 '2:172 0);
---------------------------------------------------------------------------- PROGRAMME PRINCIPAL

---------------------------------------------------------------------------
%(*,1
a1: comparateur1
vappvb );
3257 0$3 (vecteur_a, vecteur_b, pg, egal, pp, vapgvb, vaegalvb,
352&(66 (comparaison_precedente)
%(*,1
pg
comparaison_precedente(2);
egal comparaison_precedente(1);
pp
comparaison_precedente(0);
(1' 352&(66;
352&(66 (vapgvb, vaegalvb, vappvb)
%(*,1
resultat_comparaison(2) vapgvb;
cgx
v.1
5.22 (88)
eivd
resultat_comparaison(1)
resultat_comparaison(0)
(1' 352&(66;

22 juin 1998
vaegalvb;
vappvb;
352&(66
%(*,1
echo("---- debut de la simulation");
comparaison_precedente "000";
echo("---- vecteur_a = vecteur_b = 0, pas de report");
vecteur_a "0000";
vecteur_b "0000";
sim;
erreur resultat_comparaison ;25 "010"; --pour verifier graphiquement
check (resultat_comparaison, "010");
--verification par fichier
echo("---- vecteur_a = vecteur_b = 0, egal = 1");
vecteur_a "0000";
vecteur_b "0000";
sim;
erreur resultat_comparaison ;25 "010";
echo("---- vecteur_a = vecteur_b = 0, pp = 1");
vecteur_a "0000";
vecteur_b "0000";
sim;
echo("---- vecteur_a = vecteur_b = 0, pg = 1");
vecteur_a "0000";
vecteur_b "0000";
sim;
vecteur_a "0001";
vecteur_b "0001";
sim;
vecteur_a "0010";
vecteur_b "0010";
sim;
vecteur_a "0011";
vecteur_b "0011";
sim;
vecteur_a "0100";
cgx
v.1
5.23 (89)
eivd
22 juin 1998
vecteur_b "0100";
sim;
vecteur_a "0101";
vecteur_b "0101";
sim;
vecteur_a "0110";
vecteur_b "0110";
sim;
vecteur_a "0111";
vecteur_b "0111";
sim;
vecteur_a "1000";
vecteur_b "1000";
sim;
vecteur_a "1001";
vecteur_b "1001";
sim;
echo("---- vecteur_a = vecteur_b = a, egal = 1");
vecteur_a "1010";
vecteur_b "1010";
sim;
echo("---- vecteur_a = vecteur_b = b, egal = 1");
vecteur_a "1011";
vecteur_b "1011";
sim;
echo("---- vecteur_a = vecteur_b = c, egal = 1");
vecteur_a "1100";
vecteur_b "1100";
sim;
echo("---- vecteur_a = vecteur_b = d, egal = 1");
vecteur_a "1101";
vecteur_b "1101";
sim;
cgx
v.1
5.24 (90)
eivd
22 juin 1998

echo("---- vecteur_a = vecteur_b = e, egal = 1");
vecteur_a "1110";
vecteur_b "1110";
sim;
echo("---- vecteur_a = vecteur_b = f, egal = 1");
vecteur_a "1111";
vecteur_b "1111";
sim;
echo("---- vecteur_a < vecteur_b");
vecteur_a "0000";
vecteur_b "0001";
sim;
vecteur_a "0000";
vecteur_b "0110";
sim;
vecteur_a "0000";
vecteur_b "1011";
sim;
echo("---- vecteur_a > vecteur_b");
vecteur_a "0100";
vecteur_b "0000";
sim;
vecteur_a "0111";
vecteur_b "0001";
sim;
vecteur_a "1110";
vecteur_b "0110";
sim;
echo("---- test non complet pour les > et <, mais suffisant");
echo("---- fin de la simulation");
echo("---- il reste toute une serie de tests a terminer ",
string("a_faire.txt"));
cgx
v.1
5.25 (91)
eivd
sim_end
22 juin 1998
true;
:$,7;
(1' 352&(66;
(1' simulation;

)D8CD@S9@TDHVG6UDPI9V8PHQU@VS7DUT
----------------------------------------------------------------------- Nom du fichier : comptsim.vhd
-- Auteur
: C. Guex
-- Date
: mai 1997
-- Version
: 1.0
-- Modifications :
-- Auteur
:
Date :
----------------------------------------------------------------------- But
: exemple du cours VHDL : simulation dun compteur
----------------------------------------------------------------------
/,%5$5< einev;
(17,7< sim_compteur ,6
(1' sim_compteur;
----------------------------------------------------------------------- Architecture pour la simulation du compteur
----------------------------------------------------------------------
$5&+,7(&785( simul_compteur 2) sim_compteur ,6

&20321(17 compteur 3257 (horloge, report_in : ,1 bit;
valeur_compteur : 287 bit_vector (3 '2:172 0);
report_out : 287 bit);
(1' &20321(17;
)25 $// : compteur 86( (17,7< :25.compt_4_bits (structurelle);
&2167$17 periode : time := 100 ns;
6,*1$/ sim_end : boolean := false;
6,*1$/
6,*1$/
6,*1$/
6,*1$/
6,*1$/
valeur_compteur : bit_vector (3 '2:172 0);

enable : bit;
report_sortie : bit;
horloge : bit;
-- signal dhorloge
erreur : bit_vector (3 downto 0);
%(*,1
----------------------------------------------------------------------- ce processus genere une horloge pour la simulation
----------------------------------------------------------------------
cgx
v.1
5.26 (92)
eivd
352&(66
%(*,1
,) 127 sim_end 7+(1
horloge
0,
1 $)7(5
1 $)7(5
0 $)7(5
debut_cycle
1,
0 $)7(5
:$,7 )25 periode;
(/6( :$,7;
(1' ,);
(1' 352&(66;
a1: compteur
22 juin 1998
periode / 4,
2 * periode / 4,
3 * periode / 4;
unite_de_temps_min;
3257 0$3 (horloge, enable, valeur_compteur, report_sortie);
352&(66
%(*,1
-- Attention, le premier cycle doit etre double pour un fonctionnement correct
-- ou alors, le plus simple est de toujours commencer par un cycle inactif
cycle;
enable
cycle;
erreur
cycle;
erreur
cycle;
erreur
cycle;
erreur
cycle;
erreur
cycle;
erreur
cycle;
erreur
cycle;
erreur
enable
cycle;
erreur
cycle;
erreur
enable
cycle;
erreur
cycle;
erreur
cycle;
erreur
cycle;
erreur
cycle;
erreur
cycle;
erreur
cycle;
erreur
cycle;
erreur
cycle;
cgx
-- cycle inactif
1;
valeur_compteur
;25 "0001";
valeur_compteur
;25 "0010";
valeur_compteur
;25 "0011";
valeur_compteur
;25 "0100";
valeur_compteur
;25 "0101";
valeur_compteur
;25 "0110";
valeur_compteur
;25 "0111";

valeur_compteur
0;
valeur_compteur

valeur_compteur
1;
valeur_compteur
;25 "1001";
valeur_compteur
;25 "1010";
valeur_compteur
;25 "1011";
valeur_compteur
;25 "1100";
valeur_compteur
;25 "1101";
valeur_compteur
;25 "1110";
valeur_compteur
;25 "1111";
valeur_compteur
;25 "0000";
;25 "1000";
;25 "1000";
;25 "1000";
v.1
5.27 (93)
eivd
erreur
sim_end
valeur_compteur
22 juin 1998
;25 "0001";
true;
(1' 352&(66;
(1' simul_compteur;

)D8CD@S9@TDHVG6UDPI9V9eU@8U@VS9@T@IT
---------------------------------------------------------------------------- Nom du fichier : m_etats.vhd
-- Auteur
: C. Guex
-- Date
: avril 1997
-- Version
: 1.0
-- Modifications
:
-- Auteur
:
Date :
---------------------------------------------------------------------------- But
: exemple du cours VHDL dune simulation dune machine
-detats avec reset asynchrone et set synchrone
---------------------------------------------------------------------------
/,%5$5< einev;
(17,7< sim_detecteur_sens ,6
(1' sim_detecteur_sens;
---------------------------------------------------------------------------- Architecture pour la simulation du detecteur de sens
---------------------------------------------------------------------------
$5&+,7(&785( simul_det_sens 2) sim_detecteur_sens ,6

&20321(17 detect_sens 3257 (entree_a, entree_b, clk, reset, set : ,1 bit;
sens : 287 bit);
(1' &20321(17;
)25 $// : detect_sens 86( (17,7< :25..detecteur_sens (det_sens_etats);
&2167$17 periode : time := 100 ns;
6,*1$/
6,*1$/
6,*1$/
6,*1$/
6,*1$/
6,*1$/

entree_a, entree_b : bit;
set, reset : bit;
horloge : bit;
-- signal dhorloge
verif_sortie : bit;
erreur : bit;
%(*,1
cgx
v.1
5.28 (94)
eivd
22 juin 1998
---------------------------------------------------------------------------- ce processus genere une horloge pour la simulation

---------------------------------------------------------------------------
352&(66
%(*,1
,) 127 sim_end 7+(1
horloge
0,
1 $)7(5
1 $)7(5
0 $)7(5
debut_cycle
1,
0 $)7(5
:$,7 )25 periode;
(/6( :$,7;
(1' ,);
(1' 352&(66;
a1: detect_sens
verif_sortie);
3257
periode / 4,
2 * periode / 4,
3 * periode / 4;
unite_de_temps_min;
0$3
(entree_a,
entree_b,
horloge,
reset,
set,
352&(66
%(*,1
-- Attention, le premier cycle doit etre double pour un fonctionnement correct
-- ou alors, le plus simple est de toujours commencer par un cycle inactif
cycle;
-- cycle inactif
reset 1;
sim(10);
reset 0;
cycle;
set 0;
entree_a 0;
entree_b 0;
cycle;
entree_a 0;
entree_b 1;
cycle(4);
erreur verif_sortie
entree_a 1;
entree_b 1;
cycle;
erreur verif_sortie
entree_a 1;
entree_b 0;
cycle;
erreur verif_sortie
entree_a 0;
entree_b 0;
cycle;
erreur verif_sortie
entree_a 1;
entree_b 0;
cycle;
erreur verif_sortie
entree_a 1;
entree_b 1;
cycle;
erreur verif_sortie
entree_a 0;
entree_b 1;
cgx
;25 1;
;25 1;
;25 1;
;25 1;
;25 0;
;25 0;
v.1
5.29 (95)
eivd
cycle;
erreur
entree_a
entree_b
cycle;
erreur
sim_end

verif_sortie
0;
0;
verif_sortie
22 juin 1998
;25 0;
;25 0;
true;
(1' 352&(66;
(1' simul_det_sens;
cgx
v.1
5.30 (96)
eivd
$11(;(6

/@TPQeS6U@VST9+'/
22 juin 1998
Tous les oprateurs existants en VHDL se trouvent dans la liste ci-dessous dans lordre
dcroissant de leur priorit :
pqr
9+'/
pyhr
vvp
rryr
hi
valeur absolue
op. divers
abs A
non logique
op. divers
not A
puissance
op. divers
A**B
multiplication
op. de multiplication
A*B
division
A/B
modulo
A mod B
remainder
A rem B
plus
op. de signe
+A
moins
op. de signe
-A
addition
op. daddition
A+B
soustraction
op. daddition
A-B
concatnation
op. daddition
- D1&D0
- vh&dl
quivalent
op. relationnels
when A=B
2
diffrent de
op. relationnels
when A/=B
plus petit
op. relationnels
when A<B
plus petit ou gal
op. relationnels
when A<=B
plus grand
op. relationnels
when A>B

12
3
cgx
v.1
6.1 (97)
eivd
9+'/
pqr
vvp
rryr
op. relationnels
when A>=B
hq
et
op. logiques
A and B
ou
op. logiques
A or B
hq
et invers
op. logiques
A nand B
ou invers
op. logiques
A nor B
ou exclusif
op. logiques
A xor B
/@THPUTSeT@SWeT
abs
access
after
alias
all
and
architecture
array
assert
attribute
begin
block
body
buffer
bus
case
component
configuration
constant
cgx
pyhr
plus grand ou gal
32

22 juin 1998
disconnect
downto
else
elsif
end
entity
exit
file
for
function
generate
generic
guarded
if
in
inout
is
label
library
linkage
loop
package
port
procedure
process
map
mod
range
record
register
rem
report
return
units
until
use
variable
nand
new
next
nor
not
null
of
on
open
or
others
out
v.1
wait
when
while
with
xor
select
severity
signal
subtype
then
to
transport
type
6.2 (98)

eivd
22 juin 1998
36TT6B@9@$7@G@I9+'/
$EHO
9+'/
(QWUpHVVRUWLHV
(QWUpHVVRUWLHV
qyr route
rv route v
9rpyhhv
entree QDI;
A1, A0 QDI;
A = [A1, A0];
entree: v STD_LOGIC;
A: v STD_LOGIC_VECTOR(1 q 0);
sortie QDIvr reg ;

S1, S0 QDIvr reg;
S = [S1, S0];
sortie: STD_LOGIC;
S: STD_LOGIC_VECTOR(1 q 0);
entree_sortie QDIvr reg;
entree_sortie: v STD_LOGIC;);
rq;
Apvrr
Apvrr
9rpyhhv
hpuvrpr behavioral s route v
...
...
@hv
rq behavioral;
...
cgx
9ppyhhvqryuytr
9ppyhhvqryuytr
bascule.pyx2 horloge;
bascule )2 entree_bascule;
pr (horloge)
vs horloge'rr hq horloge 2 '1'
ur bascule 12 entree_bascule;
rqvs;
rqpr;
6vthv
6vthv
)2, 2
12
v.1
6.3 (99)
eivd
22 juin 1998
$EHO
9+'/
Gtvr
Gtvr
, , ,
hq, , ,
Hhpuvrjph
Hhpuvrjph
Thrfqvhth machine
phr machine v
Thr etat_1:
ur etat_1 23
sortie 2 1;
BU etat_futur;
sortie 12 1;
machine 12 etat_futur;
Thr etat_2:
ur etat_2 23
sortie 2 1;
DA condition UC@I
etat_futur
@GT@DA (condition) UC@I
etat_1;
sortie 12 1;
vs condition ur
machine 12 etat_futur;
ryvs condition ur
machine 12 etat_1;
ryr
machine 12 etat_initial;
rqvs0
urur23
machine 12 etat_trappe;
rqphr;
cgx
v.1
6.4 (100)
eivd

/@TQ6RV@U6B@TTU6I96S9T
%#
Thqhq
22 juin 1998
La norme du paquetage Standard peut tre commande ladresse suivante :

The Institute of Electrical and Electronics Engineers, Inc.
345 East 47th Street
New York
NY 10017-2394
USA
Rfrence :
IEEE Standard VHDL Language Reference Manual
ANSI/IEEE Std 1076-1993 (Revision of IEEE Std 1076-1987)
ISBN 1-55937-376-8
version 1994 (une nouvelle dition est publie tous les 5 ans environ)
%#!
Urv
La norme de Textio peut tre commande ladresse suivante :

New York
NY 10017-2394
USA
Rfrence :
IEEE Standard VHDL Language Reference Manual
ANSI/IEEE Std 1076-1993 (Revision of IEEE Std 1076-1987)
ISBN 1-55937-376-8
cgx
v.1
6.5 (101)
eivd
22 juin 1998
%#"
Tqfytvpf
%#
La norme du paquetage Std_logic_1164 peut tre commande ladresse suivante :

New York
NY 10017-2394
USA
Rfrence :
IEEE Standard Multivalue Logic System for VHDL Model Interoperability
(Std_logic_1164)
ANSI/IEEE Std 1164-1993
ISBN 1-55937-299-0
cgx
v.1
6.6 (102)
eivd
%,%/,2*5$3+,(

/@TDI9DTQ@IT67G@T

cgx
[1]
VHDL analysis and Modeling of Digital Systems, 1993

Zainalabedin Navabi
Ed. Mc Graw Hill
ISBN : 0-07-112732-1
[2]
VHDL for programmable logic

Kevin Skahill
Ed. Cypress Semiconductor
ISBN : 0-201-89573-0
22 juin 1998
/@T6VUS@T
[3]
A VHDL Primer, 1994

J. Bhasker
Ed. PTR PH
ISBN : 0-13-181447-8
[4]
VHDL du langage la modlisation, 1990

R. Airiau, J.-M. Berg, V. Olive, J. Rouillard
Presses Polytechniques et Universitaires Romandes
ISBN : 2-88074-191-2
[5]
Circuit Synthesis with VHDL, 1994

Roland Airiau, Jean-Michel Berg, Vincent Olive
Kluwer Academic Publishers
ISBN : 0-7923-9429-1
v.1
7.1 (103)
eivd
22 juin 1998
,1'(;
abrviations
DOD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
VHDL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
VHSIC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
VISC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
code VHDL
after . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
inertial . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
transport . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
when . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
combinatoire
description comportementale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
description par flot de donnes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
description structurelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
Commandes de simulation
cmp_vect . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70, 71
cycle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
echo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
indiquer_si_erreur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68, 69
sim . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
description
comportementale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31, 36
flot de donnes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25, 41
structurelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29, 51
DOD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
mots rservs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5, 96
norme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
paquetages
Standard . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
Std_logic_1164 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
Textio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
squentiel
description comportementale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
description par flot de donnes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
description structurelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
machines d'tat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
types physiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
temps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
VHDL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
VHSIC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
cgx
v.1
8.1 (104)
eivd
22 juin 1998
7$%/( '(6 0$7,5(6

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Bref historique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Utilit du VHDL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Spcification . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Simulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Conception . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.1 (2)
1.1 (2)
1.1 (2)
1.2 (3)
1.2 (3)
1.3 (4)
Comparaison avec ADA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.1 (5)

Structure des programmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.1 (5)
Les signaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.1 (5)
Types physiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.2 (6)
Notion de temps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.2 (6)
Deux types de dlai : inertiel et transport . . . . . . . . . . . . . . . . . . 2.3 (7)
Le dlai inertiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.4 (8)
Le dlai transport . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.5 (9)
Utilisation du temps pour exprimer un retard . . . . . . . . . . . . . . . 2.6 (10)
Utilisation du temps pour un module de simulation . . . . . . . . . . . 2.7 (11)
Evnements et transactions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.7 (11)
Notion d'excution concurrente et squentielle . . . . . . . . . . . . . . . . . . . . 2.8 (12)
Programme excution concurrente : . . . . . . . . . . . . . . . . . . . . . 2.9 (13)
Programme excution squentielle . . . . . . . . . . . . . . . . . . . . . 2.11 (15)
Diffrence entre lutilisation dune variable et dun signal . . . . . . . . . . . 2.14 (18)
Diffrence entre le bit et le boolean . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.15 (19)
Dbuts en VHDL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.1 (20)
Mthode de travail . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.1 (20)
Spcification et synthse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.3 (22)
Linterface VHDL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.3 (22)
Le VHDL pour le combinatoire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.5 (24)
Description par flot de donnes . . . . . . . . . . . . . . . . . . . . . . . . . . 3.6 (25)
Ladditionneur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.6 (25)
La bascule RS asynchrone . . . . . . . . . . . . . . . . . . . . . . . . 3.7 (26)
Le multiplexeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.8 (27)
La table de vrit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.9 (28)
Rsum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.10 (29)
Description structurelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.11 (30)
Rsum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.12 (31)
Description comportementale . . . . . . . . . . . . . . . . . . . . . . . . . . 3.12 (31)
Rsum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.14 (33)
Le VHDL pour un systme squentiel . . . . . . . . . . . . . . . . . . . . . . . . . 3.14 (33)
cgx
v.1
9.1 (105)
eivd
22 juin 1998
Description comportementale . . . . . . . . . . . . . . . . . . . . . . . . . . 3.17 (36)

Description par flot de donnes . . . . . . . . . . . . . . . . . . . . . . . . . 3.22 (41)
Description d'une machine squentielle partir d'un graphe d'tats ou d'un
organigramme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.24 (43)
Transitions inconditionnelles . . . . . . . . . . . . . . . . . . . . . 3.26 (45)
Transitions conditionnelles . . . . . . . . . . . . . . . . . . . . . . 3.26 (45)
Sorties inconditionnelles . . . . . . . . . . . . . . . . . . . . . . . . 3.27 (46)
Sorties conditionnelles . . . . . . . . . . . . . . . . . . . . . . . . . 3.27 (46)
Rsum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.28 (47)
Sorties post-synchronises . . . . . . . . . . . . . . . . . . . . . . 3.28 (47)
Exemple : dtecteur de sens . . . . . . . . . . . . . . . . . . . . . 3.28 (47)
Description structurelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.33 (52)
La simulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.34 (53)
Polarit des entres - sorties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.41 (60)
Structure du VHDL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.1 (63)
Structure gnrale dun programme VHDL . . . . . . . . . . . . . . . . . . . . . . 4.1 (63)
Les bibliothques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.2 (64)
Que trouve-t-on dans une bibliothque ? . . . . . . . . . . . . . 4.2 (64)
Comment dclare-t-on une bibliothque dans un fichier VHDL ?
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.2 (64)
Llment utiliser fait partie de notre espace de travail
(projet). . . . . . . . . . . . . . . . . . . . . . . . . . . 4.2 (64)
Llment utiliser fait partie dune autre bibliothque
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.3 (65)
Fichiers de simulation des exemples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.1 (66)
Paquetage simulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.1 (66)
Procdures et fonctions utilisables . . . . . . . . . . . . . . . . . . . . . . . 5.1 (66)
Constantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.6 (71)
Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.7 (72)
Signaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.7 (72)
Code du paquetage de simulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.7 (72)
Code du paquetage de simulation pour le std_logic_1164 . . . . . . . . . . . 5.13 (78)
Fichier de simulation du dcodeur sept segments . . . . . . . . . . . . . . . . . 5.19 (84)
Fichier de simulation du comparateur . . . . . . . . . . . . . . . . . . . . . . . . . . 5.22 (87)
Fichier de simulation du compteur 4 bits . . . . . . . . . . . . . . . . . . . . . . . . 5.25 (90)
Fichier de simulation du dtecteur de sens . . . . . . . . . . . . . . . . . . . . . . 5.28 (93)
Annexes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.1 (95)
Les oprateurs VHDL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.1 (95)
Les mots rservs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.2 (96)
Passage de Abel en VHDL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.3 (97)
Les paquetages standards . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.5 (99)
Standard . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.5 (99)
Textio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.5 (99)
cgx
v.1
9.2 (106)
eivd
22 juin 1998
Std_logic_1164 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.6 (100)

Bibliographie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.1 (101)
Les indispensables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.1 (101)
Les autres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.1 (101)
Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.1 (102)
Table des matires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.1 (103)
Auteur
E-mail
Ecole
Tlphone
Fax
Nom du fichier
Version
Date / heure
: Claude Guex
: guex@einev.ch
: eivd - Ecole d'ingnieurs du Canton de Vaud, rte de Cheseaux 1, 1400 Yverdon-les-Bains, Suisse
: +41 (0) 24 423.21.11
accs direct : +41 (0) 24 423.22.51
: +41 (0) 24 425.00.50
: VHDL_IMP.WPD
:1
: 22 juin 1998 / 11h01
Autres personnes contacter en cas dabsence :

M. Boada Serge
M. Gaumain Maurice
M. Messerli Etienne
M. Bornand Cdric
cgx
mail : boada@einev.ch
mail : gaumain@einev.ch
mail : messerli@einev.ch
mail : cedric.bornand@einev.ch
v.1
tlphone direct : +41 (0) 24 423.22.53

tlphone direct : +41 (0) 24 423.22.53
tlphone direct : +41 (0) 24 423.22.54
tlphone direct : +41 (0) 24 423.22.54
9.3 (107)

VHDL Prot

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

VHDL Prot

Загружено:

Авторское право:

Доступные форматы

,QWURGXFWLRQ

&203$5$,621 $9(& $'$

-- 64 bits pour le codage

femtoseconde, unite de base

12 DI@SUD6G a YPS b 6AU@S 10ns;

12 DI@SUD6G a YPS b 6AU@S 10ns;

12 DI@SUD6G signal 6AU@S 10ns;

12 US6ITQPSU a YPS b 6AU@S 10ns;

6AU@S 200ns,1 6AU@S

un vnement se passe lorsquil y a un changement de la valeur dun signal.

programme dans lequel les instructions s'excutent de

programme se droulant de manire squentielle. Toutes les

systme numrique dans lequel les valeurs des sorties sont

systme numrique dans lequel les valeurs des sorties sont

6S8CDU@8UVS@ concurrent PA exemple DT

4- Boucle permettant dafficher toutes les valeurs du compteur

La seconde transaction a lieu

Ecrit par-dessus la premire

La seconde transaction a lieu

Ecrit par-dessus la premire

VHDL Analysis and Modeling of Digital Systems - Zainalabedin Navabi

4 graphiques reprsenteront les effets du codage en VHDL.

121 6AU@S 10ns;

12 US6ITQPSU 1 6AU@S 10ns; -- premiere transaction

120 6AU@S 10ns;

12US6ITQPSU 1 6AU@S 10ns;

12US6ITQPSU 0 6AU@S 15ns;

Lorsque l'on commence un dveloppement, il est utile de se demander de quelle manire

Pour faciliter la comprhension de lorganigramme, tout ce qui scrit en VHDL se trouve

une premire tape consiste prparer la documentation. Celle-ci, crite en VHDL,

6S8CDU@8UVS@ type_de_description PA nom_de_l_entite DT

-- programme interne, encore inconnu pour le concepteur

Architecture : Larchitecture est lvaluation du contenu de llment cr. Il est tout--fait

compos seulement de portes logiques

flot de donnes / structurelle

compos dlments en bibliothque

bascule asynchrone (RS par exemple)

Un exemple, un demi-additionneur 1 bit, aidera la comprhension de ce type de

Lentit et larchitecture se dclarent de manire habituelle. Pour lassignation des signaux,

Certains compilateurs demanderont cette architecture :

XDUC adresse T@G@8U

-- concatenation en un seul vecteur

e6 6AU@S delai XC@I 110,

nom_de_l_element )nom_du_composant_local QPSUH6Q

La description comportementale se fait laide dun processus. Les instructions lintrieur

DA vecteur1 3 vecteur2 UC@I

Le fonctionnement de ce petit programme demande quelques explications. Cest un

Pour dcrire un programme sous forme comportementale dun systme combinatoire, la

bascule simple (D par exemple)

comportementale, flot de donnes

bascule D avec set synchrone, reset

structurelle (flot de donnes)

compos dlments en bibliothque

lments en cascade (compteur)

Les systmes squentiels se dcomposent en trois parties : le dcodeur dtat futur

Voici quelques avantages de cette mthode :

--------------------------------------------------------------------- ce processus est celui qui soccupe de la gestion des bascules

X6DUVIUDG (liste de signaux)

sortie : PVU bit);

6S8CDU@8UVS@ flot_de_donnees PA bascule_d DT

----------------------------------------------------------------------- ce processus est celui qui soccupe de la gestion des bascules

----------------------------------------------------------------------- Architecture comportementale dune bascule D avec reset asynchrone

6S8CDU@8UVS@ comportementale PA bascule_d_ar_ss_en DT

9rpvv qr hpuvr prvryyr j hv q thur qph q

Exemple : v$ 0