Beruflich Dokumente
Kultur Dokumente
Illustration de couverture:
Codex sur le vol des oiseaux
Lonard de Vinci - 1485-1490
crire & Comprendre VHDL & AMS J Rouillard 2008
1 CLS DE CE MANUEL
2 QUOI, O, ZONES DCLARATIVES, ZONES DINSTRUCTIONS
3 ENVIRONNEMENT, BIBLIOTHQUES
4 HIRARCHIE ET STRUCTURE
5 MODLISATION DE BIBLIOTHQUES - VITAL
6 SYSTME
7 COMPORTEMENTAL
8 SYNCHRONE
9 ASYNCHRONE
10 SWITCH
11 ANALOGIQUE
12 RFRENCES
13 INDEX
14 TABLE DES FIGURES
Table des Matires 15 BIBLIOGRAPHIE
1 CLS DE CE MANUEL............................................................................................................................. 7
1.1 OBJECTIF .............................................................................................................................................. 7
1.2 LORGANISATION DE CE MANUEL ......................................................................................................... 7
1.3 LES EXEMPLES DE CE MANUEL.............................................................................................................. 8
1.4 LES PAQUETAGES EN ANNEXE ............................................................................................................... 8
1.5 LES OUTILS ........................................................................................................................................... 8
1.6 MTHODOLOGIES USUELLES ................................................................................................................. 9
1.6.1 Conception descendante (Top-Down) ............................................................................................. 9
1.6.2 Conception montante (Bottom-Up) ................................................................................................. 9
1.6.3 Conception montante-descendante (Meet-In-The-Middle).............................................................. 9
1.7 LES VERSIONS DES LANGAGES ET DE LENVIRONNEMENT ................................................................... 10
1.7.1 Les versions des langages ............................................................................................................. 10
1.7.1.1 VHDL 7.2............................................................................................................................................ 10
1.7.1.2 VHDL 1076-1987................................................................................................................................ 10
1.7.1.3 VHDL 1076-1991 (Interprtations)..................................................................................................... 10
1.7.1.4 VHDL 1076-1993................................................................................................................................ 10
1.7.1.5 VHDL-AMS 1076.1-1999................................................................................................................... 11
1.7.1.6 VHDL 1076-2000................................................................................................................................ 11
1.7.1.7 VHDL 1076-2002................................................................................................................................ 11
1.7.1.8 VHDL-AMS 1076.1-2007................................................................................................................... 11
1.7.1.9 VHDL 1076-2008................................................................................................................................ 11
1.7.1.10 Portabilit entre versions ..................................................................................................................... 12
1.7.2 Les types logiques ......................................................................................................................... 13
1.7.2.1 Deux tats............................................................................................................................................ 13
1.7.2.2 Quatre tats.......................................................................................................................................... 13
1.7.2.3 Six tats ............................................................................................................................................... 13
1.7.2.4 Neuf tats ............................................................................................................................................ 13
1.7.2.5 Quarante six tats ................................................................................................................................ 13
1.7.2.6 Le paquetage STD_LOGIC_ 1164 ...................................................................................................... 14
1.7.2.7 Interoprabilit .................................................................................................................................... 14
1.7.3 La maintenance du langage et des paquetages ............................................................................. 14
2 QUOI, O, ZONES DCLARATIVES, ZONES DINSTRUCTIONS ............................................... 17
2.1 LES UNITS DE COMPILATION ............................................................................................................. 17
2.1.1 La dclaration dentit .................................................................................................................. 17
2.1.2 Le corps darchitecture ................................................................................................................. 18
2.1.3 La dclaration de paquetage......................................................................................................... 19
2.1.4 Le corps de paquetage................................................................................................................... 19
2.1.5 La dclaration de configuration.................................................................................................... 19
2.2 LES INSTRUCTIONS DCLARATIONS LOCALES .................................................................................. 20
2.2.1 Le bloc........................................................................................................................................... 20
2.2.2 Le processus .................................................................................................................................. 21
2.2.3 Le simultan procdural................................................................................................................ 22
2.2.4 Le type protg (moniteur) ............................................................................................................ 23
2.3 LES SOUS-PROGRAMMES ..................................................................................................................... 23
2.3.1 Les arguments ............................................................................................................................... 24
2.3.2 La procdure ................................................................................................................................. 24
2.3.3 La fonction .................................................................................................................................... 25
8.1 BASCULES........................................................................................................................................... 79
8.1.1 Bascule D ...................................................................................................................................... 79
8.1.2 Latch.............................................................................................................................................. 80
8.1.3 Bascule RS..................................................................................................................................... 80
8.1.4 Bascule JK..................................................................................................................................... 81
8.2 COMBINATOIRE SYNCHRONIS ........................................................................................................... 81
8.3 GNRATEUR DE SQUENCES PSEUDO-ALATOIRES ........................................................................... 83
8.4 BLOCS GARDS ................................................................................................................................... 85
9 ASYNCHRONE......................................................................................................................................... 87
9.1 ASYNCHRONE INONDANT, LE FLOT-DE-DONNES (DATA-FLOW) ........................................................ 87
9.1.1 Laffectation simple : un fil ou un registre.................................................................................... 87
9.1.2 L'affectation conditionnelle: un encodeur de priorit ................................................................... 87
9.1.3 L'affectation slecte: un multiplexeur.......................................................................................... 88
9.1.4 Lappel concurrent de procdure : un processus avec des arguments.......................................... 89
9.2 ASYNCHRONE PROTOCOLAIRE ............................................................................................................ 89
9.2.1 Handshake..................................................................................................................................... 89
9.2.2 Reconstitution dun signal cod NRZ et de son horloge ............................................................... 90
10 SWITCH..................................................................................................................................................... 95
10.1 UN MODLE DE SWITCH ...................................................................................................................... 95
10.2 UN OU EXCLUSIF EN SWITCH ......................................................................................................... 97
11 ANALOGIQUE ......................................................................................................................................... 99
11.1 OBJETS, INSTRUCTIONS, CONTRAINTES, DOMAINES ............................................................................ 99
11.1.1 Concepts et Objets : nature, quantit, terminal........................................................................ 99
11.1.2 Instructions............................................................................................................................. 101
11.1.3 Conditions dexcution et de solvabilit : .............................................................................. 101
11.1.4 Les domaines dexcution....................................................................................................... 102
11.2 LMENTS DE BASE .......................................................................................................................... 102
11.2.1 Rsistance............................................................................................................................... 102
11.2.2 Rsistance thermique.............................................................................................................. 103
11.2.3 Capacit ................................................................................................................................. 103
11.2.4 Self.......................................................................................................................................... 104
11.2.5 Source de tension.................................................................................................................... 105
11.2.6 Source de courant................................................................................................................... 105
11.2.7 Interrupteur ............................................................................................................................ 106
11.2.8 Diode ...................................................................................................................................... 106
11.2.9 Amplificateur oprationnel idal............................................................................................ 107
11.2.10 Un modle mcanique: Tac-Tac............................................................................................. 108
11.3 MODLISATION MIXTE ...................................................................................................................... 109
11.3.1 Convertisseur digital/analogique ........................................................................................... 109
11.3.1.1 Rseau R/2R, structurel ..................................................................................................................... 109
11.3.1.2 Convertisseur Digital-Analogique, comportemental ......................................................................... 111
11.3.2 Convertisseur Analogique-Digital.......................................................................................... 111
11.3.2.1 Comparateur ...................................................................................................................................... 112
11.3.2.2 Proposer des valeurs (modle purement digital)................................................................................ 112
11.3.2.3 Assemblage du convertisseur : modle structurel mixe analogique/digital ....................................... 114
12 RFRENCES ........................................................................................................................................ 117
12.1 STANDARD ET UTILES ....................................................................................................................... 117
12.1.1 STD.STANDARD .................................................................................................................... 117
12.1.2 STD.TEXTIO .......................................................................................................................... 119
12.1.3 STD_LOGIC_TEXTIO ........................................................................................................... 120
12.2 IEEE................................................................................................................................................. 121
12.2.1 IEEE.STD_LOGIC_1164 ....................................................................................................... 121
12.2.2 IEEE.STD_LOGIC_ARITH .................................................................................................... 123
12.2.3 IEEE.MATH_REAL ................................................................................................................ 126
12.3 IEEE-VITAL.................................................................................................................................... 127
12.3.1 BNF Vital................................................................................................................................ 127
12.3.2 VITAL_TIMING...................................................................................................................... 130
1
2 QUOI, O, ZONES DCLARATIVES, ZONES DINSTRUCTIONS
3 ENVIRONNEMENT, BIBLIOTHQUES
4 HIRARCHIE ET STRUCTURE
5 MODLISATION DE BIBLIOTHQUES - VITAL
1 Cls de ce manuel 6 SYSTME
7 COMPORTEMENTAL
8 SYNCHRONE
1.1 Objectif 9 ASYNCHRONE
10 SWITCH
Ce petit manuel ambitionne de prsenter 11 ANALOGIQUE
les diffrentes techniques de modlisation 12 RFRENCES
13 INDEX
en VHDL, avec des exemples 14 TABLE DES FIGURES
paradigmatiques, en prsentant les 15 BIBLIOGRAPHIE
concepts et techniques lis VHDL mais
en faisant dlibrment limpasse sur la prsentation en dtail du langage : le lecteur aura
donc besoin dune connaissance pralable ou dun autre manuel, par exemple le compagnon
de celui-ci Lire & Comprendre VHDL & AMS qui au contraire parle du langage et non des
modles, et qui est organis par traits du langage et non par style dapplication. Un aide
mmoire de 12 pages est la fin de ce manuel, que lon pourra dcouper et agrafer. Il est aussi
disponible en pdf. (Voir bibliographie [ROU1] et [ROU2], chapitre15 page 161)
Ce manuel n'est donc pas un recueil de modles, chose qu'on trouvera par ailleurs
facilement et en particulier sur Internet. Par ailleurs les exemples donns sont corrects la
connaissance de lauteur, mais aucune garantie ni engagement ne sont donns ce sujet.
Une mine dexemples et de modres rels seront particulirement trouvs sur le site :
http://tams-www.informatik.uni-hamburg.de/vhdl/ , voir [HAM] en bibliographie chapitre 15
page 161.
Cls de ce manuel
-8-
crire & Comprendre VHDL & AMS J Rouillard 2008
Cls de ce manuel
-9-
crire & Comprendre VHDL & AMS J Rouillard 2008
Houses). Ces lments, demands par les outils de synthse, sont conus comme des briques
mais sont eux-mmes des assemblages de briques, do le qualificatif.
Les spcifications sont reconfigurables, au mieux de ce quon sait faire. Le fondeur
matrise la technologie et peut donc violer en connaissance de cause les rgles quil impose
ses clients (paradigme: la cellule de Ram). Il utilisera massivement les paquetages VITAL
(chapitre 5, page 37).
La validation est interne ou soumise un sign-off (voir ci-dessus) avec proposition du produit
sur catalogue.
Les ingnieurs impliqus sont des ingnieurs de conception plutt analogique qui ignorent
le client final et peuvent ignorer les applications finales ; ils matrisent bien la technologie.
Cls de ce manuel
-10-
crire & Comprendre VHDL & AMS J Rouillard 2008
1
En effet, la variable partage casse une proprit essentielle de VHDL: elle permet de rendre l'excution
dpendante de l'ordre d'excution des processus. son actif, elle est indispensable pour modliser des
phnomnes stochastiques.
2
Un langage dassertion permet dexprimer des vrifications de proprits qui doivent tre toujours vraies. Par
exemple jamais tel signal et tel autre signal ne sont ensemble un sur le front montant de lhorloge .
Linstruction assert de VHDL, les processus retards (postponed) et la possibilit dcrire des processus
passifs (naffectant aucun signal) dans la dclaration dentit sont dj, en VHDL 1993, un embryon de langage
dassertions.
Cls de ce manuel
-11-
crire & Comprendre VHDL & AMS J Rouillard 2008
la possibilit de rendre un processus sensible sur tous les signaux qui sont dedans,
pour tre sr de ne pas en oublier et aller gaiement la synthse: process(all);
la possibilit de mettre des expressions dans les port map, (s'il s'agit d'expressions de
signaux);
force et release de signaux, permettant de coller un signal une valeur
indpendamment du reste de la description;
la possibilit d'utiliser des types comme arguments gnriques (ceci est bien
commode, par exemple dcrire un multiplexeur ne devrait pas exiger quon connaisse
le type des donnes qui circulent). Et la possibilit de faire des paquetages gnriques
(pour, par exemple, dvelopper des paquetages arithmtiques indpendants du nombre
de bits de l'instance). Pour illustration, cette limitation actuelle doit tre contourne
dans l'exemple dcrit en 7.1.4.2.2 page 62;
la possibilit d'avoir des tableaux et des enregistrements de types non-contraints. Les
versions antrieures ne permettent pas de dclarer un tableau "array (integer
range 1 to 5) of STRING": il est possible avant 2008 de dclarer un tableau non
contraint, mais pas ses lments qui doivent tre contraints;
diverses simplifications comme la gestion du dont care dans les instructions case?
(une variante du case). Ainsi une clause when "01---" couvre toutes les
combinaisons de 5 bits commenant par 01;
lutilisation de types comme STD_LOGIC en place de boolen (if S1 and S2 la
place de if S1='1' and S2='1');
les expressions conditionnelles (affectation conditionnelle comme S <= A when
condition else B; autorise en contexte squentiel);
les oprateurs de rduction (S <= and T; o T est un tableau de bits, devient
quivalent S <= T(0) and T(1) and etc.);
de nouveaux oprateurs, prfixs par un "?" permettant des comparaisons "logiques",
par exemple dans le type STD_LOGIC la comparaison entre un fort et un faible
"'1' ?= 'H'" rendra '1';
diffrents paquetages mathmatiques implmentant larithmtique sur des
reprsentations normalises de flottant virgule fixe ou prcision relative;
des primitives permettant d'avoir une vue textuelle de tous les types (fonctionnalit de
l'attribut IMAGE existant);
des paquetages mathmatiques et la faon de les utiliser;
et bien d'autres choses.
La liste des mots-rservs est de plus en plus importante, et le concepteur utilisant une
version antrieure devrait, dans la limite du raisonnable, viter d'employer des
identificateurs qui entreront fatalement en collision avec des mots-cls des futures
versions. Cette liste est augmente de: assume assume_guarantee context cover
fairness force parameter property release restrict restrict_guarantee
sequence strong vmode vprop vunit
Cls de ce manuel
-12-
crire & Comprendre VHDL & AMS J Rouillard 2008
Cls de ce manuel
-13-
crire & Comprendre VHDL & AMS J Rouillard 2008
possibles : (F) zro forc, (R) zro fort, (W) zro faible, (Z) zro haute impdance3, (D)
dconnection, et de mme un haute impdance, un faible, un fort, un forc. Ainsi ltat WD0,
valeur 0 cheval sur W et D, reprsentait la possibilit pour le signal davoir une valeur zro
faible ou zro haute impdance. L-dessus toute la logique pouvait tre dfinie, ainsi que les
fonctions de rsolution; ce systme tait particulirement adapt la modlisation en niveau
switch (voir chapitre 10 page 95 pour une vue de la question utilisant STD_LOGIC_1164).
1.7.2.7 Interoprabilit
Certainement dautres types logiques hantent encore des modles maintenir. La possibilit
dcrire ses propres types logiques et les questions dinteroprabilit avait t rgle dans le
standard initial par la possibilit dappeler des fonctions de conversion lors des port map ,
au vol. Ainsi il est possible dinstancier un composant utilisant 46 tats dans un modle qui
nen a que 9, pour autant quon dispose des fonctions de conversions dans les deux sens, en
crivant quelque chose comme:
port map (to_46_values(p46) => to_std_logic(pstd))
Ici to_46_values est une fonction qui prend un lment de type STD_LOGIC et propose une
valeur dans le type 46 valeurs. to_std_logic fait l'inverse. P46 et PSTD sont
respectivement des objets de type 46 ou 9 valeurs.
Ceci est videmment un pis-aller, puisque la conversion va forcment perdre de linformation.
De plus, l'appel de ces fonctions par le simulateur doit tre fait au gr des vnements et en
fonction des modes (in, out, inout), et cela devient rapidement une usine gaz. Depuis
l'arrive du paquetage STD_LOGIC_1164, cette fonctionnalit est rarement utilise. Hlas,
cest une aventure qui peut arriver au concepteur sil doit rcuprer un ancien modle. Ce
sujet est trait 4.2.5 page 34.
3
Cela signifie que la valeur est zro par conservation capacitive de la valeur prcdente.
Cls de ce manuel
-14-
crire & Comprendre VHDL & AMS J Rouillard 2008
en cas derreur non bloquante, la recommandation est mise en conserve pour inclusion
dans la prochaine rvision. Par exemple le fait que la fonction ENDLINE du
paquetage TEXTIO initial ait t illgale en VHDL (son argument tait de classe
variable) na t dcouvert quaprs la premire standardisation4. Cette fonction a t
supprime. On peut donc la retrouver dans danciens modles, les compilateurs de
lpoque ayant d faire une verrue pour cette fonction.
en cas de trait inesthtique ou mal bti, une discussion est engage pour la rsolution
qui est incluse dans la prochaine rvision. La notion de bit string a ainsi t
tendue des types non prdfinis afin de permettre lutilisation des notations octale
et hexadcimale pour les littraux de std_logic_vector. Ce ntait possible que pour
bit_vector en VHDL87.
en cas de demande de nouvelle fonctionnalit, tous les cinq ans peu prs- un appel
propositions est publi, une compilation en est faite, des propositions sont mises et
un vote a lieu qui doit enregistrer une super-majorit. Ceux qui votent non doivent dire
pourquoi, et dire ce qui les ferait voter oui ; le comit doit tenter de rpondre tous les
votes ngatifs et tenter de les faire changer davis. Ce systme a donc assez peu voir
avec un scrutin politique.
Le comit mre de tous les autres, le VASG (VHDL Analysis & Standardization Group) et
son organe technique ISAC (Issue Screening & Analysis Committee), qui soccupent de
VHDL en tant que langage et dont les travaux ont un effet sur tous les standards drivs
comme VHDL-AMS (lanalogique, voir chapitre 11 page 97) ; et mme les standards en
VHDL comme STD_LOGIC-1164 (12.2.1 page 119), WAVES5 ou VITAL (12.3 page
125), etc. Ces comits peuvent tre contact par nimporte qui et les sites, cette date, sont :
http://www.vhdl.org/vasg/ et http://www.vhdl.org/isac/. Les industriels et les clients peuvent
anticiper les modifications en consultant les documents de ces comits qui dcrivent ce qui
sera probablement soumis au vote de la prochaine rvision.
Cette activit tant le fait de volontaires (soit titre personnel, soit mandats par leur socit
mais nominalement, il ny a pas de sige appartenant une socit), il ne faut donc pas
sattendre une rponse immdiatement efficace. Par contre nimporte qui peut se porter
volontaire pour aller dans les runions et prendre sa part de travail.
Pour pouvoir voter sur le standard, il faut tre membre IEEE.
Le langage VHDL en tant que tel est vu en dtail dans le manuel compagnon de celui-ci
Lire & Comprendre VHDL & AMS (voir bibliographie [ROU1], chapitre15 page 161) o
lon tente de couvrir tous les traits du langage, car on est souvent amen lire et tenter de
comprendre ce quon ncrirait jamais.
4
Ce qui montre bien que, contrairement la plupart des langages o cest limplmentation du prototype qui
tient lieu de premire spcification, les premiers compilateurs VHDL sont sortis aprs la publication du manuel
de rfrence, cette erreur ayant t signale tout fait normalement par un des premiers compilateurs.
5
WAVES est un standard en VHDL qui permet de spcifier des vecteurs de test pour un modle, les rsultats
attendus et dautomatiser le test dune faon qui est compatible avec le testeur qui sera utilis pour tester le vrai
circuit. Il nest pas couvert par ce manuel. Voir Bibliographie [IE5] chapitre 15 page 163.
Cls de ce manuel
-15-
crire & Comprendre VHDL & AMS J Rouillard 2008
1 CLS DE CE MANUEL
2 Quoi, o, zones 2
3 ENVIRONNEMENT, BIBLIOTHQUES
dclaratives, zones 4 HIRARCHIE ET STRUCTURE
5 MODLISATION DE BIBLIOTHQUES - VITAL
dinstructions 6 SYSTME
7 COMPORTEMENTAL
8 SYNCHRONE
Dune faon gnrale, la plupart des 9 ASYNCHRONE
10 SWITCH
constructions comprennent une 11 ANALOGIQUE
partie dclarative et une partie 12 RFRENCES
13 INDEX
instructions. Il y a un jeu de 14 TABLE DES FIGURES
dclarations qui sont admissibles 15 BIBLIOGRAPHIE
dans toutes les parties dclaratives,
et dautres qui dpendent du domaine o lon se trouve (concurrent, squentiel).
Nous les appellerons ci-dessous dclarations gnrales pour viter davoir rpter ce
paquet.
entity ENT is
generic () ;
port () ;
begin
Dclarations gnrales plus
end entity ENT ;
sous-programmes (corps aussi)
natures, sous-natures
dconnexions
signaux, quantits, terminaux,
variables partages
limites (analogique)
assertions
processus passifs (qui naffectent pas de signaux)
appel concurrent de procdures passives
Mais lentit peut aussi contenir une quantit de dclarations qui seront vues par toutes ses
architectures : des instructions de visibilit (clause use) ou des dclarations de types, sous-
types, mme des objets comme des signaux, des quantits ou des variables partages.
Aprs le begin (optionnel donc), la dclaration dentit peut contenir des instructions, pour
autant que ces instructions ne crent pas dvnements et ne participent pas la simulation :
ce sont les assertions (plus utiles dans leur variante retarde - postponed) et les processus
passifs qui n'affectent as de signaux- dont le seul effet est de crer des traces la console ou
de remplir des fichiers.
Cest une des cinq units (une chose compilable en tant que telle) ; on peut la prfixer par des
appels de bibliothques (clause library) et des clauses use. Le corps darchitecture a lui aussi
une partie dclarative et une partie instructions, qui peuvent tre vides mais spares par le
mot-cl begin qui nest pas ici optionnel.
La partie dclarative peut contenir, en sus des dclarations gnrales, celles qui sont
spcifiques au domaine concurrent : ce qui a trait au composant (dclaration, configuration),
les objets concurrents : signaux, quantits, variables partages et ce qui a trait aux signaux
(dconnexion des signaux gards).
end package P ;
package body P is
end package P ;
Dclarations gnrales plus
sous-programmes (corps aussi)
variables partages
Figure 5 Contenu d'un corps de paquetage
Cest une des cinq units (une chose compilable en tant que telle) ; on peut la prfixer par des
appels de bibliothques (clause library) et des clauses use. Cest une construction qui permet
dassocier, de lextrieur, chaque composant dune architecture un couple entit/architecture
ou une autre configuration, et ceci transitivement. chaque tage, on ouvre la visibilit
dans le bloc ou larchitecture ouverte, rgle ventuellement par des clauses use ; et soit on
donne le nom (label) dune architecture ou dun bloc de niveau infrieur, et cest reparti pour
une configuration, soit on donne le nom (label) dun composant et la transitivit se termine
ici.
configuration de bloc
for label-architecture use
clauses use
configuration de larchitecture du bloc nomm label
ou configuration du composant nomm label
end for ;
Le bloc est une des instructions qui peut apparatre dans larchitecture ; il est un usage trs
restreint en VHDL, et il nest mentionn ici que pour la compltude : il ne sert qu crer une
zone dclarative quand on en a besoin dans une instruction generate, ou utiliser la
garde , trait de VHDL qui tombe en dsutude (voir 8.4 page 83). Le bloc lui tout seul
rcapitule les fonctionnalits de lentit et de larchitecture, il fait une dcoupe arbitraire dans
le code en nommant les fils de linterface.
Il a des arguments gnriques et des ports, que lon configure sur le champ avec des generic
map et port map. Lintrt de cette fonctionnalit surprenante est que la smantique de
linstanciation est entirement dcrite en blocs quivalents6, et que cela permet de dcrire de
multiples instances de la mme entit/architecture comme des duplications de code ; le
passage aux signaux rels tant fait au fil de leau par les port map.
On voit sur la figure que le bloc peut contenir dautres blocs. Larchitecture elle-mme nest
finalement quun bloc de premier niveau, les dclarations et instructions quon peut y mettre
sont les mmes.
6
Ce qui permet de simplifier le manuel de rfrence, qui explicite seulement la smantique du bloc; toutes les
fonctions d'instanciation se ramenant des constructions lexicalement quivalentes.
2.2.2 Le processus
Le processus (process) est une des instructions concurrentes. ce titre, sa position dans le
code vis--vis des autres instructions concurrentes na pas dimportance.
Le processus contient des instructions squentielles. Ces instructions l, lintrieur des zones
squentielles, sont excutes dans lordre qui a donc de limportance. Le processus peut tre
retard (postponed) ce qui permet dtre assur quil sera excut une fois et une seule par
temps o il est rveill, quand tous les signaux sont stables. videmment la condition de
validit est quil naffecte pas de signal avec un dlai nul.
La liste de sensibilit est une liste de signaux dont le changement de valeur va rveiller le
processus. Sa prsence empche de mettre des wait explicites dans le processus. Cette forme
est prfre des outils de synthse, bien que (ou car) plus contraignante.
optionnel, dit que le process est excut aprs tous les autres et ne
cre pas dvnement au temps courant
optionnelle, quivalent un wait sur la
mme liste de signaux la fin du process.
PROC : postponed process (sensibilit)
Instructions squentielles
simples :
o wait
o break
o assert et report
o next et exit (dans des boucles)
o affectation de variable et de signal
o appels de procdures
composites :
o if
o loop
o case
PROCD : procedural is
Dclarations gnrales plus
begin variables
sous-programmes (corps aussi)
end procedural PROCD ;
Instructions squentielles
simples :
o assert et report (mais sans garantie)
o next et exit (dans des boucles)
o affectation de quantits/variable
o appels de procdures
composites :
o if
o loop
o case
Les quantits y sont vues comme des variables, et affectes comme telles avec le signe := .
Les instructions y sont tout le jeu des instructions squentielles sauf celles qui interfrent avec
le temps et les vnements sur signaux : wait, break, affectation de signal.
Les instructions assert et report y sont lgales mais la norme ne dit pas si elles sont
excutes chaque excution du noyau, ou mises en conserve dune faon ou dune autre
pour un effet unique.
travaillent. Cette spcification peut tre isole, auquel cas il faudra la rpter plus bas en
ajoutant le corps du sous-programme. Elle peut se poursuivre par le corps du sous-
programme, auquel cas elle ne sera pas rpte. La sparation en deux morceaux permet
dune part de confiner limplmentation aux corps de paquetage en publiant la spcification,
dautre part de permettre lcriture dalgorithmes rcursivit croise (A appelle B qui
appelle A). Il y a deux catgories de sous-programmes, les procdures et les fonctions.
Les zones entre crochet sont optionnelles et ont une valeur par dfaut qui peut changer suivant
les contextes. Le genre concerne signal/variable/constant/file/quantity/terminal, le mode est
in/out/inout/buffer. Tous les genres et tous les modes ne sont pas autoriss partout.
Plusieurs arguments qui partagent exactement la mme dclaration peuvent tre factoriss et
spars par une virgule : la dclaration sera duplique pour chacun deux.
Nom1, Nom2 : INTEGER := 3 ;
Si la valeur par dfaut est un appel de fonction, cette fonction sera appele autant de fois quil
y a darguments initaliser.
2.3.2 La procdure
La procdure est une portion de code squentiel quon invoque en tant quinstruction : lappel
de procdure est une instruction squentielle et aussi une instruction concurrente. La
spcification donne son nom, et la liste des arguments esprs.
begin
Dclarations gnrales plus
end PROC ; variables
sous-programmes (corps aussi)
instructions squentielles
simples :
o wait
o assert et report
o next et exit (dans des boucles)
o affectation de variable et de signal
o appels de procdures
o return
composites :
o if
o loop
o case
2.3.3 La fonction
La fonction est une portion de code squentiel quon invoque en tant que valeur dans une
expression : lappel de la fonction nest pas une instruction. La spcification donne son nom,
et la liste des arguments esprs avec pour chacun son genre (signal, constante, fichier (file)
mais pas variable) son nom, son type, son mode (in forcment qui est par dfaut), et sa valeur
par dfaut ventuelle.
Elle donne aussi le type de la valeur retourne par la fonction.
end FUNC;
instructions squentielles
simples :
o assert et report
o next et exit (dans des boucles)
o affectation de variable
o appels de procdures
o return valeur
composites :
o if
o loop
o case
3 Environnement, 1
2
CLS DE CE MANUEL
QUOI, O, ZONES DCLARATIVES, ZONES DINSTRUCTIONS
Bibliothques 3
4 HIRARCHIE ET STRUCTURE
5 MODLISATION DE BIBLIOTHQUES - VITAL
6 SYSTME
7 COMPORTEMENTAL
Les bibliothques sont, pour le langage, 8 SYNCHRONE
9 ASYNCHRONE
de simples noms logiques : STD, IEEE, 10 SWITCH
etc. ; Cest linstallation de loutil qui 11 ANALOGIQUE
12 RFRENCES
redirige ces noms sur les emplacements 13 INDEX
physiques rels. Quelques unes de ces 14 TABLE DES FIGURES
15 BIBLIOGRAPHIE
bibliothques ont un statut spcial :
STD est la bibliothque mre
indispensable pour faire quoi que ce soit, elle contient le ncessaire paquetage
STANDARD. Il est inutile de la mentionner au dbut dune unit, par dfaut toutes
sont prfixes de library STD ; use STD.STANDARD.all ;
o STD.STANDARD cest l que sont dfinis les types BOOLEAN, BIT et
INTEGER. Or ces types sont utiliss dans le langage lui-mme, par exemple
BOOLEAN pour les instructions if, BIT pour lattribut TRANSACTION,
INTEGER pour llvation la puissance. Cest pourquoi lusage de STD est
par dfaut , la clause library STD ; est implicitement mise au dbut
de chaque unit, avec use STANDARD.all.
o STD.TEXTIO contient des primitives rustiques de lecture et criture sur fichier
et sur console. La base du systme dentres-sorties est quon lit ou on crit
ligne ligne des chanes de caractres. La conversion de ces chanes depuis ou
vers des types du langage est faire par ailleurs, quelques primitives sont
fournies dans le paquetage sur les types de STANDARD.
WORK est la bibliothque o lon travaille. Cest le seul endroit o lon a le droit de
compiler. La bibliothque WORK est vue, par ses clients, sous un autre nom
(MARTIN par exemple, depuis chez Dupont). Chaque concepteur a donc sa
bibliothque WORK, et accde celles des autres en donnant leur nom. Il est inutile
de la mentionner au dbut des units, comme pour STD par dfaut toutes les units
sont prfixes de library WORK ; (attention, pas de use par dfaut).
IEEE est une bibliothque qui contient les paquetages standardiss par les IEEE, ainsi
que de faon consensuelle des paquetages presque standards, mis dans le domaine
public par un vendeur par exemple.
o IEEE.STD_LOGIC_1164 contient le type 9 tats universellement utilis par
les concepteurs. : 'U' 'X' '0' '1' 'Z' 'W' 'L' 'H' ' -' U pour uninitialized, valeur par
dfaut dpose au dbut des simulations et permettant de reprer les signaux
qui nont pas t initialiss au bout dun temps raisonnable. Deux systmes
logiques (fort : 01X et faible :LHW low, high, weak conflict) permettent de
grer les forces : en cas de conflit entre un faible et un fort, cest le fort qui
gagne. On peut ainsi modliser des systmes drain ouvert par exemple. 0/L
et 1/H ont le sens logique usuel. X/W signifient conflit . Z est la haute
impdance, pour un bus que personne ne prend par exemple. Le '-' veut dire
dont care et ne sert quen synthse (en attendant VHDL 2008, voir
1.7.1.9 page 11) pour permettre de ne pas sur-spcifier et laisser le
synthtiseur optimiser (inversement, les valeurs UXW ne servent quau
simulateur, on ne va pas spcifier un conflit).
Environnement, Bibliothques
-27-
crire & Comprendre VHDL & AMS J Rouillard 2008
Les implmentations confondent parfois DISCIPLINES avec IEEE. Cest une des
corrections que lon peut tre amen faire quand on porte un modle.
Environnement, Bibliothques
-28-
crire & Comprendre VHDL & AMS J Rouillard 2008
1 CLS DE CE MANUEL
2 QUOI, O, ZONES DCLARATIVES, ZONES DINSTRUCTIONS
3 ENVIRONNEMENT, BIBLIOTHQUES
4
5 MODLISATION DE BIBLIOTHQUES - VITAL
6 SYSTME
4 Hirarchie et Structure 7 COMPORTEMENTAL
8 SYNCHRONE
9 ASYNCHRONE
architecture de l'entit 10 SWITCH
11 ANALOGIQUE
12 RFRENCES
13 INDEX
14 TABLE DES FIGURES
maps 15 BIBLIOGRAPHIE
dclaration Il y a deux niveaux de branchement dans une
d'entit
architecture: D'une part le composant, sorte de
support, est connect aux signaux et aux ports de
composant
l'architecture dans laquelle il est instanci. D'autre
maps part l'entit est connecte son composant, soit
par une spcification de configuration cela se
passe dans l'architecture elle-mme - soit par une
dclaration de configuration ce qui se fait depuis
architecture l'extrieur, dans une unit de conception
de l'entit en spcifique, la dclaration de configuration-.
construction chaque tage, on peut spcifier les gnriques, et
les branchements.
Figure 13 L'instance du composant et sa configuration avec une entit demandent deux port map et
deux generic map
4.1 La gnricit
Les entits et les composants peuvent tre gnriques ; la gnricit consiste dclarer une
constante dans une zone spciale, aprs le mot-cl generic, et ne donner sa valeur que plus
tard. Cela peut tre au moment dinstancier un composant, au moment de le configurer ou
carrment au moment de simuler ou de synthtiser.
entity SHIFTN is
generic (N : INTEGER ; delay: TIME);
port (inp: BIT_VECTOR(N-1 downto 0); outp: out BIT_VECTOR(N-1 downto 0))
end entity ADDN;
component COMP is
generic (X : INTEGER ; delay: TIME);
port (E: BIT_VECTOR(N-1 downto 0); S: out BIT_VECTOR(N-1 downto 0))
end component ADDN;
Hirarchie et Structure
-29-
crire & Comprendre VHDL & AMS J Rouillard 2008
On ne donne pas de valeur, on attache un argument lautre. Noter ici que si les arguments de
l'entit et du composant avaient le mme nom et le mme ordre, on pourrait compter sur les
liens par dfaut et ne pas crire les branches generic map et port map. On verra par ailleurs
qu'on n'est pas oblig de d'attacher les ports tels quels (voir 4.2 page 29).
CX: COMP generic map (X=>8, delay=> 2 ns) port map (E=>P1, S=>P2);
entity SHIFTN is
generic (N : INTEGER ; delay: TIME);
port (inp: BIT_VECTOR(N-1 downto 0); outp: out BIT_VECTOR(N-1 downto 0))
end entity ADDN;
component COMP is
port (E: BIT_VECTOR(7 downto 0); S: out BIT_VECTOR(7 downto 0))
end component ADDN;
On configure le composant avec cette entit l, mais il nous faut dire combien valent N et
delay pour que a marche:
Si lon instancie un autre composant de ce type, ce sera forcment le mme (8, 3 ns)
contrairement ce que lon a fait au paragraphe prcdent.
CY: COMP port map (E=>P3, S=>P4); -- CY est aussi sur 8 bits et 3 ns.
Hirarchie et Structure
-30-
crire & Comprendre VHDL & AMS J Rouillard 2008
Ceci nest pas le signe dune infriorit de cette mthode. Dune part on na pas souvent le
choix, les bibliothques tant importes ou achetes telles quelles ; dautre part si lon ne veut
se servir que de tel composant en multiples exemplaires identiques, il est inutile et pnible,
voire peu optimisable pour le simulateur, de repousser au dernier moment la donne de ses
paramtres.
entity SHIFTN is
generic (N : INTEGER ; delay: TIME);
port (inp: BIT_VECTOR(N-1 downto 0); outp: out BIT_VECTOR(N-1 downto 0))
end entity ADDN;
component COMP is
generic (delay: TIME);
port (E: BIT_VECTOR(7 downto 0); S: out BIT_VECTOR(7 downto 0))
end component ADDN;
On configure le composant avec cette entit l, mais il nous faut dire combien vaut N et passer
delay comme argument gnrique restant:
Dautres instances du mme composant pourront faire varier delay, mais pas N:
CY: COMP generic map (delay=> 4 ns) port map (E=>P3, S=>P4);
-- CY est sur 8 bits avec un dlai de 4 ns.
On utilisera cette fixation partielle de la gnricit lors de la configuration chaque fois que
lon voudra utiliser une entit trs gnrique venant dune bibliothque achete ou non
matrise, sur un composant dont la gnricit nous suffit .
Hirarchie et Structure
-31-
crire & Comprendre VHDL & AMS J Rouillard 2008
Attention : lutilisation dune de ces facilits nest pas exclusive des autres. En poussant
VHDL et ses facilits dassociations dans ses derniers retranchements, on peut arriver des
modles compltement illisibles et qui sont de vraies gageures excuter pour les outils de
CAO. utiliser avec autant de modration que les breuvages radicaux COOH, sinon le mal
de tte subsquent est de mme nature.
entity E is
port (A, B, C : BIT ; S : out BIT) ;
end entity E;
component C is
port (T: out BIT; X, Y, Z: BIT)
end component;
Nous allons utiliser lassociation par nom, qui permet de saffranchir des questions de
position:
for CX: C use entity LIB.E port map (A=>X, B=>Z, C=> Y, S => T);
CX : C port map (X=> P1, Y=> P2, Z=> P3, S => P4) ;
entity E is
port (A: BIT_VECTOR (1 to 10); ) ;
-- 10 lments
end entity E;
component C is
port (X :BIT_VECTOR (111 downto 102), ) ;
-- 10 lments aussi
end component;
Figure 14 Connexion en changeant la numrotation des ports
Ici, la bonne proprit de VHDL est que les associations sont faites lment par lment, de
gauche droite et sans regarder les directions:
Il est possible toutefois quon ait envie dassocier dans lautre sens ou dailleurs dans un ordre
quelconque : A(1) X(102), A(2) X(103), etc. Dans ce cas, on peut crire le dtail des
associations scalaires :
Hirarchie et Structure
-32-
crire & Comprendre VHDL & AMS J Rouillard 2008
L encore, la mme syntaxe de port map fonctionne pour linstance de composant, quand il
faut relier ses ports aux signaux/ports de larchitecture o il est instanci.
4.2.2 Forage
Les signaux de mode in peuvent tre associs une expression. On peut ainsi forcer une patte
la masse, par exemple.
component C is
port (ChipSelect : in BIT, .) ;
end component;
Ici, le signal in fine associ ChipSelect via la configuration aura une valeur permanente 0.
Ceci ne marche pas avec les outils fonctionnant sur une version de VHDL antrieure 93,
auquel cas il suffit de dclarer un signal nomm, quon met 0 et quon passe au port map.
Les signaux de mode out peuvent tre ignors du simulateur. Il suffit de leur associer le mot-
cl open. Ici par exemple, on a besoin d'une porte ou-exclusif (xor) mais on ne dispose que
d'un additionneur dans la bibliothque. On s'en sort en appelant l'additionneur et en ignorant
ses retenues: celle d'entre est colle 0, celle de sortie est ouverte. Le resteest un xor.
4.2.4 Dfaut
On peut donner une valeur par dfaut lors de la dclaration d'un port de mode in.
L'existence de cette valeur par dfaut permettra d'omettre ce port dans la liste d'association.
Nous nous retrouverons donc dans le cas du forage explicite vu au 4.2.2 ci-dessus.
Hirarchie et Structure
-33-
crire & Comprendre VHDL & AMS J Rouillard 2008
component C is
port (A, B: BIT :='0'; S: out BIT) ;
end component;
Cette situation est heureusement assez rare depuis l'arrive du standard STD_LOGIC_1164,
qui a unifi les types utiliss par les concepteurs VHDL, voir ce sujet 1.7.2.7 page 13.
Nanmoins on peut trouver des modles antrieurs et avoir les maintenir ou les utiliser.
On peut donc, dans une liste d'association, changer le type au vol des diffrents arguments
formels et rels. Pour cela on emballe le port en question par une fonction qui prend lautre en
argument et rend son type.
Supposons que FA soit une fonction prenant le type de B en argument et rendant le type de A,
et FB faisant linverse. Lexemple le plus simple de telles fonctions est la fonction
changement de type que lon a gratuitement en utilisant le nom du type quand les types
sont apparents, par exemples arithmtiques. Exemple :
Si I est entier et R rel, on peut crire I := INTEGER(R) et INTEGER est ici vu comme une
fonction de conversion. Nous avons donc dans le cas qui nous occupe:
entity E is
port (B1 : in TypeB; B2 : out TypeB; B3 : inout TypeB;..);
end entity;
Hirarchie et Structure
-34-
crire & Comprendre VHDL & AMS J Rouillard 2008
Voyons par exemple lutilisation dune boucle de gnration dans la construction dun
additionneur N bits partir dun demi additionneur un bit (deux entres, une sortie et une
retenue sortante) et dadditionneurs
complets un bit (deux entres, une retenue Etiquette : for I in 1 to 10 generate
entrante, une sortie et une retenue [begin] optionnel dans implementations
sortante). rcentes
end generate;
Voici lentit, noter que la taille des ports
dpend de la valeur de largument gnrique :
entity ADDN is
generic (N: INTEGER:=8);
port (A,B: BIT_VECTOR(N-1 downto 0); S: out BIT_VECTOR (N downto 0));
end entity ADDN;
Hirarchie et Structure
-35-
crire & Comprendre VHDL & AMS J Rouillard 2008
Pour illustrer ceci, voyons le cas dune ligne retard de N coups dhorloge sur un bit :
lentre (inp) est propage sur la sortie (outp) au bout de N fronts montants dhorloge (h).
La dclaration, trs classiquement, est gnrique sur N le nombre de coups dhorloge pour
le retard-, a une entre, une sortie et une horloge.
library ieee;
use ieee.std_logic_1164.all;
entity dcalage is
generic (N: positive:=16);
port (h, inp: in std_logic; outp:out std_logic);
end;
Larchitecture, elle, est plus originale: elle dclare sa propre entit en tant que composant.
Une instruction generate sert de condition darrt : si N=1, alors on crit une instruction flot
de donnes qui ralise le dcalage dune priode dhorloge, et une seule. Dans les autres cas
de figure, la question est ramene la mise bout--
bout dun dcalage de N/2 et dun dcalage de N-N/2 9
(il sagit de divisions entires), en passant par un
unique signal local, et le problme est repouss
ltage infrieur, ce qui fait que, in fine, tout le
modle sera compos de dcaleurs dune priode 4 5
dhorloge, instancis en poupes russes.
Sur lexemple ci-contre, on voit que lappel dun
dcaleur avec N=9 va instancier deux dcaleurs avec 2 2 2 3
N=4 et N=5, puis quatre avec N valant
respectivement 2, 2, 2 et 3, puis huit avec les valeurs
1, 1, 1, 1, 1, 1, 1, 2, et enfin neuf avec duplication du
dernier. 1 1 1 1 1 11 11 2
Chaque fois quon arrive N=1, la rcursivit est
termine, une unique instruction flot de donnes est
gnre. 1 1 1 1 1 11 11 1 1
Hirarchie et Structure
-36-
crire & Comprendre VHDL & AMS J Rouillard 2008
component dcalage
generic (N: positive);
port (h, inp: in std_logic; outp:out std_logic);
end component;
-- pas de configuration, le dfaut fonctionne bien car la
-- dclaration de composant est identique lentit
begin
end;
Hirarchie et Structure
-37-
crire & Comprendre VHDL & AMS J Rouillard 2008
1 CLS DE CE MANUEL
2 QUOI, O, ZONES DCLARATIVES, ZONES DINSTRUCTIONS
3 ENVIRONNEMENT, BIBLIOTHQUES
4 HIRARCHIE ET STRUCTURE
5 Modlisation de 5
6 SYSTME
bibliothques - VITAL 7 COMPORTEMENTAL
8 SYNCHRONE
9 ASYNCHRONE
10 SWITCH
11 ANALOGIQUE
12 RFRENCES
5.1 Pourquoi, comment ? 13 INDEX
14 TABLE DES FIGURES
Dans le cycle de conception classique, 15 BIBLIOGRAPHIE
o il est des modles qui nont pas vocation tre synthtiss (par exemple un modle de
RAM qui nest l que pour faire marcher le reste du modle) ; dans ce genre de
synthse tous les coups sont permis pourvu que a marche . Voir par exemple 7.1
page 55.
o il est des modles qui ont vocation tre synthtiss et alors on fait attention viter
la sur-spcification, pour permettre loutil de synthse de faire toutes les
optimisations quil jugera utiles. Voir par exemple 7.3 page 70.
o Enfin il est des modles qui sont limage exacte du circuit tel quil a t synthtis, et
quon simule afin de vrifier les proprits espres, notamment temporelles, ou quon
donne un client qui veut une image exacte de ce quil achte. Or la synthse consiste
faire linterconnexion dlments de bibliothque, lments qui sont fournis par le
fondeur. Dans ce cadre l, la spcification de ces lments et des ventuels dlais dus
leur interconnexion doit tre extrmement prcise. Les dlais en question peuvent tre
simples (la sortie bouge aprs un temps T si lentre bouge), plus complexe (on peut
spcifier des temps diffrents suivant les fronts) ou trs complexe (suivant les
diffrentes combinaisons, temps dalas, temps de propagation sur les fils.). Cest ce
style l qui nous intresse dans ce chapitre.
Cest un standard de bon usage de VHDL, permettant aux fondeurs de dvelopper des
modles de leurs bibliothques, et aux clients de construire leurs propres briques avec les
mmes outils, tout en garantissant aux clients un jeu de bonnes proprits dont voici les
essentielles :
o La rtro-annotation permet dinjecter dans un modle dj simul sans les temps
tous les dlais fournis par la synthse. On peut ainsi valider sparment la
fonctionnalit et la performance. Cette injection se fait sans ncessiter laccs au
source du modle, par la dfinition de gnriques et via un outil spcifique (utilisant le
standard SDF7) ou par des dclarations de configuration en VHDL cres
automatiquement.
o Linterface des modles utilise uniquement le type STD_LOGIC_1164 et mme
souvent un sous-ensemble de celui-ci.
o Les informations temporelles sont injectes grce des conventions de noms (la
syntaxe des identificateurs des ports et gnriques se trouve donc faire partie de ce
langage), et peut dfinir entre autres des informations sur les dlais ou des temps pin
to pin .
7
Standard IEEE 1497-2001 (SDF). Voir bibliographie [IE4] chapitre 15 page 163.
o Niveau 1: pour la performance. En sus dtre niveau 0, les conflits sont interdits sur
les signaux (deux processus ne peuvent pas crire sur le mme signal, il ny a donc
jamais dappel de fonctions de rsolution), les sous-programmes appels ne peuvent
pas tre crits par le concepteur (ils doivent venir des paquetages standards). Tous les
signaux et pas seulement les ports- doivent tre des types STD_LOGIC et
STD_LOGIC_VECTOR. Aucune dclaration, part des alias, nest autorise. Avec de
telles contraintes, chaque bloc du code peut tre optimis puisquils viennent tous de
paquetages prdfinis et que le travail du concepteur ne consiste qu' les assembler
entre eux.
o La syntaxe VITAL, dfinie comme une contrainte sur la syntaxe VHDL ; cest du
BNF.
o Les trois dclarations de paquetages ncessaires : timing, primitives, mmoire. Les
corps de ces paquetages sont dfinis en VHDL dans la norme titre de documentation,
mais ils sont probablement cods en dur dans les simulateurs commerciaux. Leur
longueur interdit de les mettre ici, le lecteur intress les trouvera facilement sur le
Web.
On en trouvera la dclaration 12.3.2 page 128, expurge de ses commentaires qui sont trop
volumineux pour tre mis ici. Ce paquetage est utilis par les autres et dfinit types et
primitives concernant les dlais du modle.
8
STD_ULOGIC est le type racine dont STD_LOGIC est le sous-type rsolu. Ils sont compatibles, lusage du
premier permet des optimisations dans les cas o lon est certain de ne pas avoir besoin de rsolution.
9
Il sagit dun type numr de genre caractre , c'est--dire que les symboles contenus scrivent
graphiquement comme des caractres mais nont rien voir, et sont incompatibles, avec les autres types du
mme genre comme BIT (pour les valeurs 0 et 1), CHARACTER (pour toutes les valeurs) ou STD_LOGIC
(pour 0, 1, X, -, Z), mme si le sens attribu est le mme que pour BIT et STD_LOGIC.
o / : 0 vers 1
o \ : 1 vers 0
o P : Union de / et ^ (tout front allant vers 1)
o N : Union de \ et v (tout front allant vers 0)
o r : 0 vers X
o f : 1 vers X
o p : Union de / et r (tout front venant de 0)
o n : Union de \ et f (tout front venant de 1)
o R : Union de f ^ et p (tout front montant)
o F : Union de v et n (tout front descendant)
o ^ : X vers 1
o v : X vers 0
o E : Union de v et ^ (tout front venant de X)
o A : Union de r et ^ (front montant de ou vers X)
o D : Union de f et v (front descendant de ou vers X)
o * : Union de R et F (tout front)
o X : Inconnu
o 0 : zro, niveau bas
o 1 : un, niveau haut
o - : dont care indiffrent.
o B : 0 ou 1
o Z : haute impdance
o S : tat stable
On y trouve aussi les types permettant de dfinir des composants par une table de vrit ou
une table dtats :
VitalTruthTables
et
VitalStateTables.
5.5.1.1 Fonctionnalit
Pour illustrer lintrt de VITAL, reprenons lternel xor :
library IEEE; use IEEE.std_logic_1164.all;
entity xorent is
port (a, b : in std_logic; s : out std_logic);
end xorent;
mais des valeurs proposes ce moment l. Le lecteur pourra vrifier sur le schma ci-contre
qui implmente le xor base de portes nand- en imaginant un dlai associ chaque porte,
que si on passe de la configuration 01 00, la premire porte ne change pas d'tat et donc
seules deux portes intervenant dans le dlai sont sur le chemin entre l'entre qui bouge et la
sortie. Par contre, le passage de 10 11 fait intervenir trois portes dans le chemin. Une bonne
modlisation nous conduirait crire une affectation complique dpendant des valeurs, ou,
plus lisible, un processus:
process (a,b)
Variable rsultat: bit;
begin
rsultat:=a xor b;
if (a = '0') or ( b='0' )
then s <= rsultat after 2 ns;
else s <= rsultat after 3 ns;
end if;
end process;
De mme que les dlais peuvent dpendre des valeurs proposes, ils peuvent aussi dpendre
du sens du front: dans une logique " drain ouvert", le passage zro se fait par un transistor
"fort" alors que le passage un se fait par une rsistance. La capacit attaque tant la mme
dans les deux cas, les dlais seront donc diffrents selon le sens de variation de la sortie
considre. Tout ceci complique srieusement la question de l'injection des dlais dans un
modle fonctionnel, on voit ici que mme sur un exemple simplissime comme le xor, la
spcification des dlais est bien plus complexe que la spcification de la fonctionnalit.
Se pose maintenant la question dautomatiser le passage de cette valeur gnrique. Il est clair
que le nom du gnrique ne peut plus tre quelconque, il faut un moyen dassocier ce nom au
Modlisation de Bibliothques - VITAL
-44-
crire & Comprendre VHDL & AMS J Rouillard 2008
dlai qui nous intresse, une convention qui puisse tre reconnue par des outils automatiques.
La solution VITAL consiste donner largument gnrique un nom calcul qui contient
toutes les informations utiles. Le nom du port peut ainsi tre prfix et postfix par des
indications pertinentes, et spares par des blancs-souligns.
5.5.2.1 Fonctionnalit
Pour larchitecture de notre xor, nous allons appeler une des primitives de VITAL_primitives:
le XOR2 qui a le bon got dexister. On peut lire dans le paquetage 12.3.3 page 133 que
cette procdure est ainsi dclare :
procedure VitalXOR2 (
signal q : out std_ulogic;
signal a, b : in std_ulogic;
constant tpd_a_q : in VitalDelayType01 := VitalDefDelay01;
constant tpd_b_q : I in N VitalDelayType01 := VitalDefDelay01;
constant ResultMap : in VitalResultMapType := VitalDefaultResultMap );
Ce type sera donc propag dans les arguments gnriques de notre entit :
library IEEE;
use IEEE.std_logic_1164.all;
use IEEE.VITAL_timing.all;
use IEEE.VITAL_primitives.all;
entity xorent is
generic (
tpd_a_s : VitalDelayType01 ;
tpd_b_s : VitalDelayType01 );
port (a, b : in std_logic; s : out std_logic);
attribute VITAL_LEVEL0 of xorent: entity is TRUE;
end xorent ;
VitalXOR2 (
q => s,
a => a,
b => b,
tpd_a_q => tpd_a_s,
tpd_b_q => tpd_b_s
);
end;
begin
begin
VitalPathDelay01 (
OutSignal => s,
OutSignalName => s,
OutTemp => s_zd,
Paths => (
0 => (InPutChangeTime => aLAST_EVENT,
PathDelay => tpd_a_s,
PathCondition => TRUE ),
1 => (InPutChangeTime => bLAST_EVENT,
PathDelay => tpd_a_s,
PathCondition => TRUE)
),
GlitchData => s_GlitchData );
end process ;
end;
Faisons un zoom sur le champ PATH: si nous voulions que des dlais diffrents soient
associs des conditions dynamiques diffrentes, il suffirait dtendre les champs
lmentaires; pour reprendre lexemple du dlai qui change si lune des entres est zro
(voir 5.5.1.3 ci-dessus la solution sans VITAL) :
Paths => (
0 => (InPutChangeTime => aLAST_EVENT,
PathDelay => un_dlai_appropri,
PathCondition => (b=0) ),
1 => (InPutChangeTime => bLAST_EVENT,
PathDelay => un_dlai_appropri,
PathCondition => (a=0)),
2 => (InPutChangeTime => aLAST_EVENT,
PathDelay => un_dlai_appropri,
PathCondition => TRUE ),
3 => (InPutChangeTime => bLAST_EVENT,
PathDelay => un_dlai_appropri,
PathCondition => TRUE)
),
Les items du PATH sont valus dans lordre et cest le premier qui gagne. Cest pourquoi
les dernires conditions peuvent tre attaches TRUE, si les autres conditions sont valides
elles seront excutes avant et le dlai correspondant mis en uvre.
5.5.2.4 Etc
Nous pourrions complexifier cet exemple ad nauseam, en permettant de grer les glitchs, en
introduisant les dlais dus aux pistes de connexion, etc. Ce que nous avons voulu montrer ici,
cest que grce ces conventions de noms, un outil peut automatiquement forcer les bonnes
valeurs gnriques sur un modle, valeurs quil a extraites du rsultat de la synthse ; ceci
sera fait en gnral par des outils travaillant avec SDF (un standard de description de dlais,
voir note 7 page 39). Nous avons aussi voulu montrer que les conventions VITAL permettent
toutes sortes de spcifications de dlais collant au plus prs avec la ralit des circuits
reprsents.
Pour forcer les valeurs des gnriques l'excution, la dclaration de configuration permet de
faire cela entirement en VHDL, en utilisant une proprit ad-hoc : on peut craser une
valeur gnrique donne par une configuration, en utilisant une autre configuration par-
dessus . Ainsi les rsultats de la synthse, exacts, peuvent remplacer les valeurs estimes
avant la synthse, sans avoir toucher au code source ni le recompiler.
1 CLS DE CE MANUEL
2 QUOI, O, ZONES DCLARATIVES, ZONES DINSTRUCTIONS
3 ENVIRONNEMENT, BIBLIOTHQUES
4 HIRARCHIE ET STRUCTURE
6 Systme 5 MODLISATION DE BIBLIOTHQUES - VITAL
6
7 COMPORTEMENTAL
La modlisation systme permet de 8 SYNCHRONE
9 ASYNCHRONE
valider des ides, des protocoles ou des 10 SWITCH
architectures sans entrer dans les 11 ANALOGIQUE
12 RFRENCES
dtails de limplmentation. Elle utilise 13 INDEX
des types abstraits, des variables 14 TABLE DES FIGURES
15 BIBLIOGRAPHIE
partages, des gnrateurs alatoires et
ses rsultats peuvent tre simplement statistiques. Elle peut amener crire des fonctions de
rsolution. Pour illustrer cela, nous allons prendre lexemple de la gestion de collision sur un
cble de genre Ethernet, dite CSMA (Carrier Sense Multiple Access : accs multiple avec test
de la porteuse)
6.1 Illustration
Le cble
En simplifiant beaucoup, nous allons considrer que le cble est un mdium commun N
transmetteurs. Chacun peut le prendre pour envoyer son message. Les messages, mme
s'ils portent une adresse de destination, peuvent tre lus par tout le monde, mais nous ne nous
intressons pas aux rcepteurs. Il est clair que, plus il y a de transmetteurs, moins il y a de
place pour les messages de chacun. Il est clair aussi que, chaque transmetteur ignorant les
autres, aucun protocole de diffusion ne peut viter les collisions. Voyons celui qui est le plus
couramment utilis :
1. Un transmetteur attend davoir un message transmettre
2. Il teste le cble pour savoir sil est libre.
Si non, il attend un temps convenu et recommence en 2
Si oui, il prend le cble, il va en 3 en envoyant son message
3. Si, pendant la transmission, le cble est en conflit
Il force un long conflit pour que tout le monde soit au courant indpendamment
des dlais de transmission
Il libre le cble
Il attend un temps alatoire avant de retourner en 2
4. Sinon, cest fini et retour en 1
Systme
-49-
crire & Comprendre VHDL & AMS J Rouillard 2008
en 3, pourquoi le cble peut-il tre en conflit alors que chaque transmetteur teste avant
de prendre la main? Simplement parce que deux, ou plus, transmetteurs peuvent en
mme temps ( un temps de transmission prs) dterminer que le cble est libre et en
mme temps le prendre. Et se retrouver en conflit.
Pourquoi forcer un conflit long, comme si on nen avait pas assez ? Parce que, vus les
dlais de transmission, un transmetteur peut rater le fait quil y a eu conflit et croire
son message correctement envoy alors quil a t en collision lautre bout. Il faut
forcer ltat de conflit plus longtemps que le plus long dlai de transmission.
Pourquoi attendre un temps alatoire aprs le conflit ? Parce que tous les transmetteurs
(en gnral 2) qui se retirent en mme temps doivent revenir des temps diffrents,
sinon un nouveau conflit est certain.
Quest-ce qui ne nous intresse pas ce niveau ? La nature du conflit, comment on le repre,
le contenu des trames des messages et leur codage. On veut rester aux notions de message,
collision, tat libre ou occup du cble.
Notre cble a trois tats logiques pertinents: libre, occup, en conflit. Nous allons faire un
type numr abstrait pour dtailler ces tats.
La fonction de rsolution a pour objet de dire quel est le vrai tat du cble quand
plusieurs valeurs sont proposes . Dans le jargon VHDL, les valeurs proposes sont dans
les pilotes (drivers), le vrai tat est la valeur relle (actual value). La fonction de rsolution
est capable de prendre un tableau de pilotes pour calculer la valeur relle.
Pour dfinir une fonction de rsolution, il nous faut un type capable de recevoir plusieurs
valeurs du mme type dont le nombre nest pas dit : ce sera un tableau non contraint.
type ad_hoc is array (integer range <>) of type_cble;
Enfin il faut dclarer le sous-type du cble qui est le type initial contraint par la fonction de
rsolution:
subtype pour_cble is resol type_cble;
Systme
-50-
crire & Comprendre VHDL & AMS J Rouillard 2008
Pour tester en vraie grandeur notre systme, il nous faudra des dizaines ou des centaines
dinstances du mme transmetteur. Mais pour que la simulation veuille dire quelque chose, il
faut videmment que chaque transmetteur ait sa vie propre, il nous faut un germe de hasard
dans la simulation ; cela naurait aucun sens de lancer un systme o tous les transmetteurs
voudraient toujours faire la mme chose au mme instant.
Il y a dans le paquetage IEEE.MATH_REAL une procdure UNIFORM qui rend un nombre
rel distribu dans [0.0 1.0[ ; comme tous les gnrateurs pseudo-alatoires, elle a besoin
dune mmoire statique quelle utilise pour calculer ses squences, laquelle doit tre
initialise une valeur quelconque au dbut, cest la ou les graine(s) (seed). La procdure en
question a besoin de deux seeds.
En VHDL, les signaux ont une proprit qui ne nous convient pas ici : leur valeur ne change
que quand tous les processus sont sur un wait. Utiliser un signal pour cette mmoire statique
nous donnerait le mme nombre alatoire chaque appel entre deux wait. Il nous faut des
variables. Hlas, les variables normales de contexte squentiel ne peuvent tre dclares
que dans les processus (a ne va pas ici, on aura plusieurs processus et utiliser les variables de
lun empcherait dappeler la fonction UNIFORM avec ses seeds dans un autre) et dans les
sous-programmes, o elles ne sont pas statiques.
Il nous faut donc utiliser une possibilit sulfureuse du langage, ne jamais utiliser hors des
simulations indterministes : les variables partages. Dans ce cadre simple nous nirons pas
jusqu utiliser les types protgs, trait du langage relativement rcent10 et qui permet de
garantir latomicit de laccs la mmoire partage en garantissant quau plus un processus
(process) a accs la mmoire en question par exemple dans le cas, rare, o le simulateur est
effectivement multi-processeurs- . En effet, mme dans le cas dcole o deux processus
appelleraient en mme temps la fonction UNIFORM qui utilise ces seeds, le seul effet serait
davoir une erreur dans le calcul de la squence alatoire, ce qui nous importe peu.
On dclare donc les variables partages en zone concurrente.
Ces variables seront utilises plus tard en inout par la procdure UNIFORM (de
IEEE.MATH_REAL) qui, chaque appel, met jour sa variable de sortie (mode out) laquelle
suivra cette fameuse squence alatoire.
procedure uniform(variable seed1, seed2 : inout positive ;x: out real);
package pkg_rseau is
end pkg_rseau;
10
L'utilisation des types protgs serait obligatoire avec les implmentations de VHDL 2000.
Systme
-51-
crire & Comprendre VHDL & AMS J Rouillard 2008
Le code de la fonction de rsolution doit tre dans le corps de paquetage. Rappelons quil
sagit de faire quelque chose de pertinent lorsque le cble est attaqu par 0, 1, 2, ou plus,
transmetteurs.
Lalgorithme est simple : on parcourt tous les lments du tableau, et on se souvient dans
MEM de ltat prcdemment calcul. Si le cble est (encore) libre et quon a une demande
doccupation, MEM passe occup. Si le cble est occup et quil y a une seconde demande
doccupation, MEM passe conflit et cest fini, on sort de la boucle devenue inutile. Si le
cble est dj en conflit, on ne change rien et on sort aussi. la fin on rend MEM.
package body pkg_rseau is
end pkg_rseau;
6.4 Protocole
Lentit du transmetteur va tre gnrique sur tous les paramtres que lon aura envie de faire
bouger pour valider notre systme: tous les temps dont nous avons parl plus haut; nous lui
passons aussi un numro qui permettra de lidentifier dans les messages console, chaque
transmetteur tant capable de faire un message sign.
use work.pkg_rseau.all;
entity transmetteur is
Systme
-52-
crire & Comprendre VHDL & AMS J Rouillard 2008
Nous voici maintenant dans le cur du problme. En fait il nous suffit de coder en VHDL les
tapes dtailles en 6.1 ci-dessus.
Cela ncessite une petite cuisine dont voici les secrets : Les conversions de types sont l pour
pouvoir utiliser un rel (le nombre alatoire) pour dfinir un temps. La multiplication par
1000 et la division par 1000 dans la mme expression parce que le passage par des entiers
tronque les rels, on garde donc lquivalent de 1000 positions discrtes possibles pour nos
temps alatoires. La multiplication par 2 (qui fait les 2000) parce que les temps spcifis sont
supposs tre des temps moyens, et que le nombre alatoire a, lui, une moyenne de 0.5.
Dans le code ci-aprs, des tiquettes sont mises en marge pour faire la correspondance avec
lalgorithme dcrit en 6.1 ci-dessus.
On se rappellera que lexpression wait until condition for temps a pour effet darrter
le processus jusqu ce que la condition soit vraie (il faut au moins un signal dedans sinon elle
nest jamais value) mais il y a un temps maximum au bout duquel le processus repartira,
condition vraie ou pas.
On voit aussi que, chaque fois quun nombre alatoire est invoqu, la procdure UNIFORM
est appele juste avant.
Systme
-53-
crire & Comprendre VHDL & AMS J Rouillard 2008
6.5 Tester
Pour tester tout a, nous allons faire classiquement une bote noire (entit sans ports ni
gnriques),
entity rseau is
end entity rseau;
dont larchitecture instanciera des transmetteurs ad libitum. En changeant les valeurs des
constantes, voire en en donnant de diffrentes chaque transmetteur ce qui nest pas fait ici,
on pourra observer quand le cble est satur par les collisions, mesure qui n'est pratiquement
accessible qu lexprience.
begin
G: for i in 1 to 100 generate -- 100 transmetteurs
T: entity work.transmetteur(arch)
generic map (i,
temps_moyen_entre_tentatives => 500 us,
temps_moyen_pour_ressai => 500 us,
temps_moyen_d_une_trame => 10 us,
temps_de_raction_pour_prendre_le_cble => 1us,
temps_d_attente_si_cble_occup => 50 us,
temps_de_forage => 30 us)
port map (cble);
end generate;
Les messages console seront de deux sortes : chaque transmetteur contient une instruction
report qui marque le conflit et dit son numro. Par surcrot, larchitecture de test contient une
assertion.
On peut maintenant simuler le modle, et rassembler dans des variables (partages) ou des
fichiers des informations statistiques en lanant la simulation pendant un temps qui peut tre
trs long. On saperoit que le dbut de la simulation contient normment de collisions entre
de nombreux transmetteurs, en effet dans ce modle simple les transmetteurs ne se
dsynchronisent quau bout dun certain temps. ce moment l, lessentiel des conflits
concernera 2 transmetteurs. Si lon exploite les traces, il faudra tenir compte de cette
simplification, ou alors changer un peu lalgorithme pour quil fonctionne correctement ds le
dbut.
Systme
-54-
crire & Comprendre VHDL & AMS J Rouillard 2008
revenir contribuer lembouteillage. Dans les vrais systmes, pour viter la coagulation
du systme, on sen tire en faisant patienter les utilisateurs finaux et en augmentant les dlais
de ressais de ltape 3 chaque fois quil y a chec. Ce qui ne fait que repousser lattente aux
clients du systme, mais il faut bien que quelquun attende sil y a trop de candidats.
Une fois le concept valid, le concepteur intrpide pourra attaquer le niveau logique, o les
messages sont des trames codes en NRZ (voir 9.2.2 page 88) avec des drapeaux HDLC et
une insertion de zros (7.2.2 page 67), o le conflit se repre au fait que la valeur moyenne
du signal nest pas 0.5 (comptage sur un temps donn) et o le forage de conflit est
simplement la mise 0 du cble pendant un temps suffisamment long, lequel fonctionne selon
le mode collecteur ouvert.
Systme
-55-
crire & Comprendre VHDL & AMS J Rouillard 2008
1 CLS DE CE MANUEL
2 QUOI, O, ZONES DCLARATIVES, ZONES DINSTRUCTIONS
3 ENVIRONNEMENT, BIBLIOTHQUES
4 HIRARCHIE ET STRUCTURE
5 MODLISATION DE BIBLIOTHQUES - VITAL
7 Comportemental 6 SYSTME
7
7.1 Comportemental non 8
9
SYNCHRONE
ASYNCHRONE
synthtisable 10 SWITCH
11 ANALOGIQUE
Il est frquent davoir crire des 12 RFRENCES
blocs quon veut simuler mais ne pas 13 INDEX
14 TABLE DES FIGURES
synthtiser. Cest le cas gnral pour 15 BIBLIOGRAPHIE
les structures rgulires, dont on veut
une instance dans le modle pour faire marcher le reste, mais qui, in fine, seront des blocs
prexistants fournis par le fondeur.
7.1.1 RAM
Nous voulons une RAM classique qui comporte un ordre de lecture/criture : rw pour
read/write, et un ordre de validation : cs pour chip select. Nous allons rendre cette RAM
gnrique sur le nombre de mots et le nombre de bits par mots.
library ieee;
use ieee.std_logic_1164.all;
entity RAM is
generic (nb_bits_adresse: positive:=16;
nb_bits_donnes: positive := 8);
port(
ADDRESS: in STD_LOGIC_VECTOR(nb_bits_adresse-1 downto 0);
DATA: inout STD_LOGIC_VECTOR(nb_bits_donnes-1 downto 0);
rw,cs: in STD_LOGIC
);
end entity RAM;
L'architecture est simple: sur le front montant de cs, on teste l'tat de rw (qui, juste test, ne
dclenche donc pas le processus) pour, selon le cas, mettre le contenu du bus d'entre dans la
mmoire, ou l'inverse. Quand cs retombe, le bus est mis "Z" ce qui signifie que la RAM le
"lche". On utilise les fonctions de conversion du paquetage std_logic_arith, que l'on trouvera
en 12.2.2 page 123.
library ieee; use ieee.std_logic_arith.all; -- pour conv_integer
architecture BEH of RAM is
begin
process (cs)
type RAM_MEM is array(0 to 2**nb_bits_adresse-1)
of STD_LOGIC_VECTOR (nb_bits_donnes-1 downto 0);
variable MEM: RAM_MEM:=(others=>(others=>'0'));
begin
if cs='1' then
if rw='1' then criture
MEM(conv_integer(unsigned((ADDRESS)))):=DATA;
else -- lecture
DATA<=MEM(conv_integer(unsigned((ADDRESS))));
end if;
else
DATA<=(others=>'Z');
end if;
end process;
end architecture BEH;
Comportemental
-57-
crire & Comprendre VHDL & AMS J Rouillard 2008
library ieee;
use ieee.std_logic_arith.all;
architecture IMMENSE of RAM is
begin
process (cs)
--------------- dclaration de type rcursif en VHDL
type cellule;
type pointeur is access cellule;
type cellule is record
adresse: integer;
donne: bit_vector(nb_bits_donnes-1 downto 0);
suivant: pointeur;
end record;
---------------
Comportemental
-58-
crire & Comprendre VHDL & AMS J Rouillard 2008
Ce traitement par liste peut videmment tre compliqu loisir si la performance est un
problme : on pourrait trier la liste (voir les algorithmes dinsertion dans une liste dj trie) ;
on pourrait aussi grer N listes qui seraient donc N fois plus courtes, N tant calcul partir
de ladresse dsigne et servant indexer un tableau de N pointeurs dbuts de listes. Ceci est
de lalgorithmique et sort du cadre de ce manuel.
7.1.4 ROM
premire vue, la ROM pourrait sembler tre plus simple que la RAM, une sorte de RAM
sans commande dcriture. En fait, cela est exact pour ce qui est de la partie fonctionnelle,
Comportemental
-59-
crire & Comprendre VHDL & AMS J Rouillard 2008
aprs le temps 0. Mais hlas la ROM pose la question de son initialisation. Il y a plusieurs
faons de procder, nous allons voir les deux extrmes : dans le code, hors du code.
Nanmoins, dans le cas dusage interne, on pourra trouver une utilit cette mthode. Voici
un exemple non gnrique (on aurait du mal crire un agrgat gnrique).
library ieee;
use ieee.std_logic_1164.all;
entity ROM is
port(
ADDRESS: in STD_LOGIC_VECTOR(15 downto 0);
DATA: inout STD_LOGIC_VECTOR(15 downto 0);
cs: in STD_LOGIC
);
end entity ROM;
library ieee;
use ieee.numeric_std.all; -- pour les fonctions to_integer
architecture BEH of ROM is
begin
process (cs)
type ROM_MEM is array(0 to 2**15)
of STD_LOGIC_VECTOR (15 downto 0);
variable MEM: ROM_MEM:=
(0 => "1110001110001111",11
1 => "0000000000000000",
2 | 3 => "1111000011110000", -- utilisation de la conjonction
4 to 10 => "1111111111111111", -- utilisation de l'tendue
others=> "0000000000000000"); -- utilisation de la clause others
begin
if cs='1' then
DATA<=MEM(to_integer(unsigned((ADDRESS))));
else
DATA<=(others=>'Z');
end if;
end process;
end architecture BEH;
11
On peut ben sr utiliser la notation hexadcimale: x"ABC0" ou octale: o"74523", on peut aussi arer les
constantes avec des blancs-souligns, dans toutes les bases.
Comportemental
-60-
crire & Comprendre VHDL & AMS J Rouillard 2008
wait de faon s'excuter au dbut de la simulation. Puis il y aura une boucle infinie,
contenant le wait on cs qui rglera le fonctionnement de la ROM au moment de simuler.
use std.textio.all;
library ieee;
use ieee.std_logic_textio.all;
use ieee.numeric_std.all;
architecture BEH of ROM is
begin
process
type ROM_MEM is array(2**nb_bits_adresse -1 downto 0)
of STD_LOGIC_VECTOR (nb_bits_donnes-1 downto 0);
file data_file:text open read_mode is init_file;
variable MEM: ROM_MEM;
variable L:line;
variable index:integer:=-1;
begin
end process;
end architecture BEH;
Comportemental
-61-
crire & Comprendre VHDL & AMS J Rouillard 2008
Le format du fichier texte est donc aussi simple que rustique : une ligne de 0 et de 1, en
quantit ncessaire et suffisante, par mot de la mmoire. On peut compliquer loisir le format
dentre pour, par exemple, le rendre compatible avec un standard (voir ci-dessous 7.1.4.2.2)
ou lui faire accepter des commentaires.
On utilise ici le paquetage STD_LOGIC_TEXTIO qui nest pas standard (il le sera avec les
implmentations VHDL 2008) mais trs largement diffus en code source (12.1.3 page 118).
Il nous permet ici de lire une chane de caractres sous la forme de std_logic_vector. Les
prfixes textio et std_logic_textio ont t laisss dans le code pour illustrer cela, bien quils
soient inutiles par la grce des clauses use qui sont en dbut de larchitecture.
Il s'agit ici d'un exercice consistant lire le format INTEL qui est largement utilis, et qui va
nous permettre de survoler quelques constructions algorithmiques ainsi que l'utilisation des
instructions assert:
:10000000C29FD29EE587D2E7F587758920758DFD61
:10001000758BFDD28E7530617531627532637533C3
:10002000007830E6600EA2D092E7F599083099FD8D
:06003000C29980EF80FE82
:00000001FF
Figure 19 Exemple de fichier au format INTEL
nous dit qu'il y a 16 octets ("10" hexa), qu'on va crire l'adresse 0 et suivantes ("0000"),
que c'est une ligne de donnes (le marqueur "00"), que les donnes sont C2 9F D2 9E E5 87
D2 E7 F5 87 75 89 20 75 8D FD, et qu'il manque 61 pour que la somme de tous les octets
fasse 256.
Nous ne nous intresserons donc pas dans ce petit exemple aux adresses tendues et autres
extensions qui n'ont rien de difficile mais surchargeraient ce manuel:
Comportemental
-62-
crire & Comprendre VHDL & AMS J Rouillard 2008
Afin d'isoler la question, faisons un paquetage ddi la lecture des formats INTEL et que
nous appellerons pour_INTEL. La procdure devra charger un tableau dcoup en mots de 8,
16, 32 ou plus bits alors que le format Intel spcifie des octets et des adresses doctets. Sil se
trouve que le tableau-mmoire que lon veut charger est constitu de mots de 8 bits, le code
peut tre lagu de bien des assertions (modulos) et de quelques calculs. Cela tant, ce code
est assez gnral pour pouvoir charger nimporte quel type de tableau ; il faut quand mme
que le mot-mmoire soit un multiple de 8 bits !
Comme VHDL ne connat pas les paquetages gnriques (ce qui changera avec l'arrive des
implmentations de VHDL 2008, voir 1.7.1.9 page 11), le paramtrage se fera par une
constante unique dclare dans la spcification. Le changement de cette constante implique
donc une recompilation.
library ieee;
use ieee.std_logic_1164.all;
package pour_INTEL is
constant largeur_mot : integer:=32;
-- cest ici que lon decide de la taille du mot,
-- tout le reste est calcul
type ROM_MEM is array(integer range <>)
of STD_LOGIC_VECTOR (largeur_mot-1 downto 0);
procedure lire_intel(ou: out ROM_MEM; fichier: in string) ;
end;
library ieee;
use ieee.std_logic_arith.all;
use std.textio.all;
package body pour_INTEL is
--================================================================
--Trois fonctions de service convertissant les caractres hexa
--en valeurs entires, dans les deux sens, et convertissant un entier
--en std_logic_vector de 8 bits
Comportemental
-63-
crire & Comprendre VHDL & AMS J Rouillard 2008
--===================================================================
procedure lire_intel(ou: out ROM_MEM; fichier: in string) is
-- lit fichier au format Intel dans OU .
begin
num_ligne:=0;
taille_mem:=OU'LENGTH;
-- la taille du tableau pass en argument.
nb_oct_par_mot:=OU(1)'LENGTH/8;
-- OU(1)'LENGTH est la taille du mot du tableau pass
-- en argument, gale largeur_mot . En divisant par 8
-- on a le nombre doctets mot.
Comportemental
-64-
crire & Comprendre VHDL & AMS J Rouillard 2008
readline(data_file,L); -- de textio
Comportemental
-65-
crire & Comprendre VHDL & AMS J Rouillard 2008
assert 16*to_int(L(2*nb_bytes+10))
+to_int(L(2*nb_bytes+11))
= sum
report "Checksum faux ligne "&integer'image(num_ligne) &
" trouv "&L(2*nb_bytes+10 to 2*nb_bytes+11) &
" attendu " & to_char(sum/16)& to_char(sum mod 16)
severity ERROR;
Comportemental
-66-
crire & Comprendre VHDL & AMS J Rouillard 2008
library ieee;
use ieee.std_logic_1164.all;
entity ROM is
generic (
init_file: STRING:="intel.txt"); -- le nom du fichier
port(
ADDRESS: in STD_LOGIC_VECTOR(15 downto 0);
DATA: inout STD_LOGIC_VECTOR(WORK.pour_INTEL.largeur_mot downto 0);
CS: in STD_LOGIC
);
end entity ROM;
--============================================
-- dbut de la boucle infinie qui contient le wait
loop
wait on cs;
if cs='1' then
DATA<=MEM(conv_integer(unsigned((ADDRESS))));
else
DATA<=(others=>'Z');
end if;
Comportemental
-67-
crire & Comprendre VHDL & AMS J Rouillard 2008
end loop;
end process;
end architecture BEH;
On veut un systme qui lon entre un mot de N bits en parallle (disons 8) et qui sorte, au
rythme dune horloge, ces bits un par un.
Lentit aura donc : une entre sur 8 bits et sa validation sur front, et une sortie sur un bit.
Une entre dhorloge et une de reset donc on a toujours besoin. Un signal occup indique ct
parallle que la conversion nest pas termine.
library ieee; use ieee.std_logic_1164.all;
entity srialisateur is
port (entre: std_logic_vector(7 downto 0);
reset: in std_logic;
validation: std_logic;
horloge: std_logic;
occup: out std_logic;
sortie: out std_logic);
end entity srialisateur;
La ralisation se fera en stockant lentre dans un registre interne (un signal) et en lexplorant
bit bit avec un indice de boucle (i) Cest un cas de figure synthtisable parce que les bornes
de la boucle sont des constantes statiques, ce serait plus dlicat sil sagissait de variables.
reset horloge
i sortie
8
validation
occup
Figure 20 Srialisateur
On notera que le signal occup compte sur la bonne discipline du ct gauche : si lon se
mle de recharger le registre avant que la conversion ne soit termine, laffaire recommence
zro. On pourrait rendre le bloc aveugle un nouveau rechargement pendant ce temps,
cest une affaire de choix.
Comportemental
-68-
crire & Comprendre VHDL & AMS J Rouillard 2008
00110110011111011110101011111111100100101111
Message initial
Message transmis
01111110 001101100111110011110101011111011110010010111101111110
00110110011111011110101011111111100100101111
Message reu aprs suppression des
zros et avec indicateurs de drapeaux
Figure 21 Insertion et destruction de zros
Comportemental
-69-
crire & Comprendre VHDL & AMS J Rouillard 2008
Pour insrer les zros, nous allons prendre une approche qui ne demande aucune mmoire
interne; cela va se payer par le fait que cest le bloc insertion qui va demander ses donnes
et qui, donc, ne demandera rien quand il insrera un zro. Autrement dit, les bits entreront
dune faon non rgulire, la demande. Lautre branche de lalternative serait de mettre une
mmoire tampon dans le bloc.
Pour dcoder, faisons lopration inverse. Lentit prend le signal cod, lhorloge, et produit
une sortie et un front indiquant quand la donne est valide.
library ieee; use ieee.std_logic_1164.all;
entity destruction_zros is
port(entre: in std_logic;
horloge: in std_logic;
sortie_valide: out std_logic;
sortie: out std_logic);
end entity destruction_zros;
Comportemental
-70-
crire & Comprendre VHDL & AMS J Rouillard 2008
Larchitecture est sensible aux fronts de lhorloge; sur le front descendant, lentre est copie
sur la sortie. Sur le front montant, le signal sortie_valide est mis un, sauf sil y a eu 5 uns
au coup dhorloge prcdent (do lutilisation dun boolen inhib pour en garder
mmoire.
Pour tester, il suffit dinstancier les deux entits dans une architecture de test:
entity testserie is end entity testserie;
En examinant les chronogrammes, il faudra bien tenir compte que la sortie nest pas
rgulire , il faut la considrer seulement quand elle est valide par un front de
sortie_valide.
Comportemental
-71-
crire & Comprendre VHDL & AMS J Rouillard 2008
Une machine tats finis est un systme qui a un ensemble fini dtats, un tat initial dans
lensemble susdit, des tats dits terminaux toujours dans cet ensemble, un ensemble fini
dentres, et une fonction permettant de passer dun tat un autre partir du couple
{tat_courant, entre}. On dit que lautomate reconnat les squences dentres qui
lamnent de son tat initial lun de ses tats terminaux.
Dans les exemples ci-dessous, et pour ne pas surcharger le code, nous allons prendre comme
exemple la machine dtat trs simple qui consiste ouvrir une porte automatique avec deux
boutons. Il y a deux tats : porte_ouverte, porte_ferme qui sont aussi des tats terminaux.
Ltat initial est porte_ferme. Il y a deux entres quon va supposer exclusives:
ouvrir_la_porte, fermer_la_porte. La sortie est un voyant libre/occup. On dira quessayer
douvrir une porte ouverte la laisse ouverte, et inversement.
En VHDL labstraction gagne ce quon dcrive ltat comme un lment dun type numr.
Nous aurons deux signaux de ce type, ltat courant et ltat venir calcul par la machine :
type type_tat_porte is (porte_ferme, porte_ouverte) ;
signal tat, tat_suivant : type_tat_porte := porte_ferme;
Les deux entres seront des signaux de type BIT, 1 si on appuie sur le bouton. Rappelons
quon les suppose exclusives, c'est--dire que, par exemple, quelque dispositif mcanique
empche physiquement quon ait la fois lune et lautre.
signal ouvrir_la_porte, fermer_la_porte : BIT ;
porte porte
ferme ouverte
Occup Libre
fermer_la_porte
Figure 22 Machine de Moore deux tats
Limplmentation lectronique est la suivante : un bloc combinatoire (c'est--dire qui peut se
ramener un jeu dquations logiques) attaque un registre command par un front dhorloge.
Comportemental
-72-
crire & Comprendre VHDL & AMS J Rouillard 2008
Une partie de la sortie de ce registre est la sortie du circuit, une autre partie est le codage de
ltat de la machine, qui revient sur lentre du bloc combinatoire.
horloge
Entre
combinatoire
combinatoire de sortie Sortie
calcul dtat registre
tat
La combinatoire dentre peut tre crite comme un processus ou comme du flot-de-donnes.
Comme le flot de donnes se ramne toujours un processus quivalent pour ce qui est de la
simulation, nous allons ici crire ce dernier :
Le registre sera dcrit galement par un processus sensible sur le front montant de lhorloge:
registre : process (horloge)
begin
if horloge='1' then -- on ne peut tre ici que sil y a vnement sur
-- lhorloge, donc ce test garantit un front montant.
tat <= tat_suivant ;
end if;
end process ;
Comportemental
-73-
crire & Comprendre VHDL & AMS J Rouillard 2008
Enfin la combinatoire de sortie sera ici trs simple dont voici la version processus , la
version flot-de-donnes tant trivialement dduite :
Au bilan, on voit sur cet exemple trs simple que l'tat de sortie se met jour une priode
d'horloge aprs l'action causale.
C'est un cas particulier de la machine de Moore o l'tat est aussi la sortie, par exemple un
compteur. La combinatoire de sortie est nulle, et le vecteur de sortie est identique au vecteur
d'tat, ce qui ramne la question deux processus.
ouvrir_la_porte Libre
porte porte
ferme ouverte
fermer_la_porte Occup
Comportemental
-74-
crire & Comprendre VHDL & AMS J Rouillard 2008
horloge
Entre combinatoire
de sortie Sortie
combinatoire
calcul dtat registre
tat
Figure 26 Machine de Mealy
Une cascade de telles machines risque de conduire un long chemin combinatoire aux dlais
imprvisibles. Pire, si de telles machines se parlent les unes aux autres avec des boucles
possibles, on peut trouver des boucles combinatoires et le circuit, cens tre logique, se met
osciller et se transforme en metteur ondes courtes avant de partir en chaleur et fumes.
Pour implmenter une machine de Mealy, nous n'avons donc qu' changer le bloc de sortie de
notre machine de Moore, les autres restent identiques :
Cette fois-ci, les sorties changent aussitt que la condition dentre change :
Comportemental
-75-
crire & Comprendre VHDL & AMS J Rouillard 2008
En envoyant des alas sur une entre (ici ouvrir_la_porte) on constate qu'ils se propagent
instantanment sur la sortie, chose qui n'arrive pas dans une machine de Moore et qui illustre
le souci d au fait qu'il y a un chemin combinatoire entre l'entre et la sortie.
Pour viter les questions de chemin combinatoire non matris, on peut synchroniser la sortie
de la machine de Mealy avec la mme horloge que celle qui sert au changement dtat. Les
deux blocs combinatoires peuvent alors tre runis.
horloge
Entre Sortie
combinatoires
de calcul dtat
et de sortie registre
tat
Figure 29 Machine de Mealy Synchronise
Comportemental
-76-
crire & Comprendre VHDL & AMS J Rouillard 2008
Nous aurons
Un processus dcrivant la fois la combinatoire du changement d'tats et de calcul de
la sortie
Un processus sensible sur l'horloge et activant le registre.
combinatoire : process (ouvrir_la_porte, fermer_la_porte, tat)
begin
case tat is
when porte_ouverte=>if fermer_la_porte = '1'
then tat_suivant <= porte_ferme ;
sortie_intermdiaire <= occup;
end if ;
when porte_ferme=> if ouvrir_la_porte = '1'
then tat_suivant <= porte_ouverte ;
sortie_intermdiaire <= libre;
end if ;
end case ;
end process ;
Dans ce montage, nous obtenons les chronogrammes de la machine de Mealy, mais sans les
alas si une entre se met bouger plus vite que l'horloge.
7.3.5 Codage
Les types numrs employs permettent une bonne abstraction, mais il vient un temps o il
faut coder ces valeurs sur un nombre de bits donns, et tous les codages ne sont pas
quivalents. On se souviendra d'une bonne proprit de VHDL, qui permet de faire des tests y
compris des case, sur des vecteurs de bits. Ainsi, tant donns le type et le signal:
type type_tats is (bleu, blanc, rouge);
signal tat: type_tats;
Il est possible de ne changer que trs lgrement le code VHDL au moment de donner des
codes nos valeurs:
subtype type_tat is bit_vector (1 downto 0);
signal tat: type_tat;
constant bleu: type_tat:= "00";
constant blanc: type_tat:= "01";
constant rouge: type_tat:= "10";
Ici nous prenons le choix d'avoir une combinaison par tat, ce qui demandera un dcodage
la synthse. Une solution plus rapide mais moins conomique est d'avoir un bit par tat: on
aurait besoin de 3 bits cods "001", "010", "100", avec la ncessit de grer toutes les
combinaisons interdites par un attrape-tout dans la logique. Autrement dit lintroduction dune
Comportemental
-77-
crire & Comprendre VHDL & AMS J Rouillard 2008
clause when others => dans les instructions case. Il arrive aussi que lon ait besoin
dutiliser le code de Gray, qui a la bonne ide de ne changer que dun bit entre deux tats
successifs : 000, 001, 011, 010, 110, 100, 101, 111, ce qui permet de se prmunir contre
larrive dtats baroques combinaisons interdites- cause de dlais imprvus.
Aprs cela, la beaut de VHDL fait que les instructions if et case ne demandent aucune
modification, c'est--dire que l'essentiel du modle ne change pas. Peut-tre faudra-t-il ajouter
une branche others dans les instructions case, si toutes les combinaisons ne sont pas
couvertes. Ce qui sera forcment le cas si lon utilise le type STD_LOGIC qui na pas que des
valeurs 0 et 1, lesquelles nont pas de sens pour la synthse mais ont un sens pour le
compilateur.
case tat is
when bleu =>
when blanc =>
when rouge =>
when others => report "erreur!";
-- ncessaire pour couvrir mme les cas qui n'arrivent pas
end case;
Comportemental
-78-
crire & Comprendre VHDL & AMS J Rouillard 2008
1 CLS DE CE MANUEL
2 QUOI, O, ZONES DCLARATIVES, ZONES DINSTRUCTIONS
3 ENVIRONNEMENT, BIBLIOTHQUES
4 HIRARCHIE ET STRUCTURE
8 Synchrone 5 MODLISATION DE BIBLIOTHQUES - VITAL
6 SYSTME
Le monde synchrone est un monde o 7 COMPORTEMENTAL
plusieurs choses se passent au mme 8
instant. Cet instant est dtermin en 9 ASYNCHRONE
10 SWITCH
gnral par une horloge. 11 ANALOGIQUE
12 RFRENCES
13 INDEX
8.1 Bascules 14 TABLE DES FIGURES
15 BIBLIOGRAPHIE
8.1.1 Bascule D
H
chaque front montant de H, lentre D est
recopie sur la sortie S. Cette valeur est
maintenue jusquau prochain front ontant de H.
library IEEE;
use IEEE.STD_LOGIC_1164.all;
entity basculeD is
port (H,D: in STD_LOGIC;
D S S: out STD_LOGIC);
end entity basculeD;
Figure 30 Bascule D
Synchrone
-79-
crire & Comprendre VHDL & AMS J Rouillard 2008
8.1.2 Latch
Figure 31 Latch
Ici nous n'avons aucun intrt passer par un processus sensible seulement sur H, puisque le
registre est transparent et doit rester sensible aux vnements sur D.
8.1.3 Bascule RS
La sortie Q prend la valeur 1 quand S vaut 1 et R vaut 0.
Elle prend la valeur 0 quand S vaut 0 et R vaut 1. Elle
Reset Q garde son ancienne valeur quand S = R = 0. . QB vaut
not Q sauf si S=R=1 qui est un tat interdit.
library IEEE;
use IEEE.STD_LOGIC_1164.all;
Set entity basculeRS is
Q port (R,S: in STD_LOGIC;
Q,QB: out STD_LOGIC);
end entity basculeRS;
Figure 32 Bascule RS
On peut construire cette fonctionnalit avec des nor ou des nand.
Synchrone
-80-
crire & Comprendre VHDL & AMS J Rouillard 2008
8.1.4 Bascule JK
horloge
Cest la bascule mre en ce sens quon peut
construire toutes les autres (sur front) partir de
J Q celle-ci. Elle est dfinie par lquation :
Au front dhorloge: Qn+1 = JQn + KQn
library IEEE;
use IEEE.STD_LOGIC_1164.all;
K entity basculeJK is
Q port (J,K,H: in STD_LOGIC;
Q,QB: out STD_LOGIC);
end entity basculeJK;
Figure 33 Bascule JK
Synchrone
-81-
crire & Comprendre VHDL & AMS J Rouillard 2008
clk
s
tmp
Figure 34 Chronogrammes d'un compteur asynchrone idal
Le rsultat est clairement un comptage sur 3 bits, la valeur de S parcourant le cycle 0,1,2..7,
0,1,2, etc. Le problme est que compteur est asynchrone, dfaut que nous mettons facilement
en vidence en forant des dlais observables la simulation dans chaque instruction :
ajoutons after 3 ns chaque affectation.
architecture a2 of e is
signal tmp:bit_vector(2 downto 0);
begin
tmp(0) <= not tmp(0) after 3 ns when horloge 'event and horloge ='1'
else unaffected ;
tmp(1) <= not tmp(1) after 3 ns when tmp(0)'event and tmp(0)='0'
else unaffected;
tmp(2) <= not tmp(2) after 3 ns when tmp(1)'event and tmp(1)='0'
else unaffected;
sortie <= tmp;
end architecture a2;
clk
s
tmp
Zoom
clk
s
tmp
Tous ces tats intermdiaires finissent par se stabiliser mais hlas aprs quantit de cheveux
qui font passer la sortie par quantit de valeurs incohrentes, ce quon voit sur le zoom ci-
dessus. Pire, le nombre de cheveux dpend de la donne qui passe, le temps de stabilisation
nest pas constant.
Synchronisation : la solution classique consiste dcrter que les tapes de calcul, sujettes
transitoires et tats instables, se font sur un front dhorloge, et que la lecture du rsultat se fait
sur lautre. Ainsi nous obtenons :
12
Tmp est recopi sur S. Il sert de signal interne quon peut lire et crire, au contraire de S quon ne peut pas lire
(mode out) et qui ne pourrait pas tre droite dune affectation.
Synchrone
-82-
crire & Comprendre VHDL & AMS J Rouillard 2008
architecture a3 of e is
signal Tmp:bit_vector(2 downto 0);
begin
tmp(0) <= not tmp(0) after 3 ns when horloge 'event and horloge ='0'
else unaffected ;
tmp(1) <= not tmp(1) after 3 ns when tmp(0)'event and tmp(0)='0'
else unaffected;
tmp(2) <= not tmp(2) after 3 ns when tmp(1)'event and tmp(1)='0'
else unaffected;
sortie <= tmp when horloge 'event and horloge ='1'
else unaffected;
end architecture a3;
Par quelques calculs simples, ceci nous permet aussi de calculer la valeur maximale de
lhorloge pour notre circuit : on calcule le cas pire de la stabilisation sur tmp, et le temps
obtenu doit tre infrieur la demi-priode de lhorloge.
Il sagit de produire une srie de valeurs binaires prsentant les caractristiques statistiques
dune srie alatoire. videmment, le circuit est dterministe et il prsente une priode ce qui
marque la limite de la mthode : cest le pseudo de pseudo-alatoire. La technique
consiste cascader des bascules et calculer lentre partir dun ou plusieurs ou-exclusif
prenant les sorties intermdiaires comme entres.
Pour illustrer avec un exemple simple, nous allons utiliser 16 bits et une seule boucle ou-
exclusif. Chaque tage sera simplement un bascule D telle que dcrite 8.1.1 page 77.
xor
+
reset
15 14 i 3 2 1 0
sortie
horloge
graine
Synchrone
-83-
crire & Comprendre VHDL & AMS J Rouillard 2008
Pour initialiser le gnrateur, nous avons besoin dune graine (la configuration initiale). Cela
ncessite davoir un port dentre de 16 bits et un signal de reset que nous mettons sur niveau.
Notons que la graine 0000 (hexa) ne convient pas, elle est absorbante pour cet algorithme.
library ieee; use ieee.std_logic_1164.all;
entity alea is
port (horloge: in STD_LOGIC;
reset: in STD_LOGIC;
graine: in STD_LOGIC_VECTOR(15 downto 0);
sortie: out STD_LOGIC);
end entity alea;
Pour larchitecture, nous allons instancier les 16 bascules D par une boucle generate.
Chacune sera relie deux signaux, en entre et en sortie, se faon pouvoir, pour lentre,
choisir entre la graine et la sortie de ltage prcdent.
Attention : Le composant est, pour les besoins de la cause, dfini avec un nom diffrent de
lentit basculeD, il faut donc faire une configuration : cette configuration ne peut pas se faire
dans la zone dclarative de larchitecture, elle ne serait pas vue par linstance qui est dans
le generate ; la solution consiste
o Dans les implmentations trs rcentes, utiliser la zone dclarative du generate
o Dans les implmentations plus anciennes la plupart-, dclarer un bloc ad hoc, ici
celui qui a le label BB, dans le seul but douvrir une zone dclarative lintrieur de la
boucle generate, qui sera visible de linstanciation.
Synchrone
-84-
crire & Comprendre VHDL & AMS J Rouillard 2008
end generate;
intermdiaire_entre(15) <=
graine(15) when reset=1
else intermdiaire_sortie(0) xor intermdiaire_sortie(1);
13
Dans les implmentations rcentes, on a le droit douvrir une zone dclarative dans une instruction generate,
le code serait exactement le mme mais en enlevant les deux lignes BB: block et end block BB;
Synchrone
-85-
crire & Comprendre VHDL & AMS J Rouillard 2008
architecture a of e is
begin
-- instructions concurrentes
-- instructions concurrentes
end architecture a;
La magie de cette condition cest quelle devient condition de toutes les instructions
daffectation de signaux qui comptent le mot-cl guarded.
Exemple de synchronisation :
Dans cet exemple, rien ne se passe que sur front montant de lhorloge (utilisation de
SSTABLE qui rend un signal, SEVENT ferait un systme marchant sur niveaux). Si nous
proposons deux valeurs ARG1 et ARG2, au prochain front montant SOMME est calcul, et
MOYENNE sera calcul au front montant suivant. Ceci permet de cascader proprement les
rsultats des oprations en laissant aux circuits le temps de se stabiliser. Voir ci-dessous les
timings de la situation o lon propose sur ARG1 et ARG2 dabord 10 et 16, puis 10 et 6. On
voit bien que SOMME y est disponible au front montant dhorloge suivant, et MOYENNE un
coup dhorloge aprs.
Le bloc gard a dautres usages dans le langage, si on le marie avec les signaux gards
(guarded signal). Leur intrt est toutefois mince et leur usage anecdotique.
Synchrone
-86-
crire & Comprendre VHDL & AMS J Rouillard 2008
1 CLS DE CE MANUEL
2 QUOI, O, ZONES DCLARATIVES, ZONES DINSTRUCTIONS
3 ENVIRONNEMENT, BIBLIOTHQUES
4 HIRARCHIE ET STRUCTURE
9 Asynchrone 5
6
MODLISATION DE BIBLIOTHQUES - VITAL
SYSTME
Dans le monde asynchrone, les 7 COMPORTEMENTAL
8 SYNCHRONE
vnements arrivent des temps
diffrents. Sil se trouve que tel 9
10 SWITCH
vnement arrive en mme temps 11 ANALOGIQUE
que tel autre, cest au hasard de la 12 RFRENCES
13 INDEX
course des vnements et cela na 14 TABLE DES FIGURES
pas dincidence sur le 15 BIBLIOGRAPHIE
s <= a or b;
Trs probablement, dans cet exemple, les conditions seront toutes de la forme (entreN = '1').
Dans ce cas particulier, on pourrait mme crire plus simplement si les entres sont
organises en tableau:
sortie <= Entres(TO_INTEGER(Slection));
O TO_INTEGER est une fonction qui convertit le tableau de bits de la slection en entier, de
telles fonctions avec toutes les variantes possibles existent en abondance dans les paquetages
IEEE.
Asynchrone
-88-
crire & Comprendre VHDL & AMS J Rouillard 2008
Cela permet dcrire du code comportemental et squentiel rutilisable, auquel on peut passer
des arguments de tous modes.
9.2.1 Handshake
Figure 41 Handshake
Un registre charg ou lu de
faon synchrone par un Donne disponible
systme horloge, est Demande de
donne
dcharg ou crit par un suivante
systme asynchrone, par lire_donne
Larchitecture sera un processus sensible sur tous les signaux de mode in ; ce processus sera
un if/elsif trois branches :
le reset sur niveau, qui est prioritaire,
Asynchrone
-89-
crire & Comprendre VHDL & AMS J Rouillard 2008
la lecture du registre interne depuis lextrieur asynchrone par un front montant sur
lire_donne , le front descendant indiquant que laffaire est faite.
lcriture du registre interne par lintrieur synchrone, sur un front montant de
chargement .
Les signaux de sortie indiquant que le bloc est libre ou occup dun ct ou de lautre
donne_disponible et demande_donne_suivante sont grs dans chaque branche.
Un bloc symtrique se chargeant de lire depuis le monde asynchrone et dcrire vers le monde
synchrone serait extrmement semblable.
architecture BEH of hds is
signal registre: std_logic_vector(7 downto 0);
begin
process(chargement,lire_donne, reset)
begin
if reset='1' then
donne_disponible<='0';
demande_donne_suivante<='0';
elsif lire_donne 'event then
if lire_donne ='1' then
donne_disponible <='0';
port_asynch<=registre ;
else
demande_donne_suivante <='1';
end if;
elsif chargementevent and (chargement ='1') then
registre <= port_synch;
donne_disponible <='1';
demande_donne_suivante <='0';
end if;
end process;
end architecture BEH ;
Horloge
Signal
Signal synchronis
sur front montant
Signal synchronis ou
exclusif lhorloge
Asynchrone
-90-
crire & Comprendre VHDL & AMS J Rouillard 2008
Le signal transmis a aussi la bonne proprit de porter sa propre horloge, puisquil suffit
dobserver le signal un certain temps et de dterminer la transition la plus courte : cest
forcment la demi-priode. De toute faon, les horloges tant dclenches par quartz et leur
frquence faisant partie du protocole, la question est plus celle de la synchronisation que celle
du calcul de la priode.
Reste dterminer la phase. Pour cela, il est facile de remarquer quil y a toujours une
transition sur le signal transmis quand il y a un front descendant de lhorloge, et
quinversement ce nest pas toujours le cas sur le front montant de lhorloge. Si l'on suppose
acquise la frquence, il y a deux horloges candidates, dphases dune demi-priode. Une
seule est telle que tous ses fronts descendants correspondent une transition du signal
transmis. Cest celle-l quil faut reconnatre et utiliser pour recombiner par ou exclusif avec
le signal.
Asynchrone
-91-
crire & Comprendre VHDL & AMS J Rouillard 2008
Signal transmis
Horloge 2: ce
n'est pas le cas
Signal transmis
Horloge peu
prs double et
pas synchrone
Horloge de la
bonne frquence
et pas synchrone
Signal initial
reconstitu avec
ses glitchs
Asynchrone
-92-
crire & Comprendre VHDL & AMS J Rouillard 2008
On ne peut pas utiliser ce dernier directement dans le modle, car on a besoin de lire lhorloge
et celle-ci est de mode out.
architecture beh of dcodeur is
signal horloge_locale, entre_synchronise: std_logic;
begin
reconstitution_horloge: process
begin
wait on entre;
wait until double_horloge ='1';
horloge_locale <= '1';
entre_synchronise <= entre;
wait until double_horloge ='1';
entre_synchronise <= entre;
horloge_locale <= '0';
end process reconstitution_horloge;
On testera facilement tout cela en assemblant dans une mme architecture le codeur, le
dcodeur, les constructions dhorloge et une forme donde de test sur lentre. On pourra
observer que, dans des limites dcentes, le systme est rsistant un dphasage de lhorloge
double et aussi une imprcision sur sa frquence. Mais attention : comme dit ci-dessus, on
verra aussi que, pour se caler sur la bonne phase, le systme a besoin dun certain temps, le
temps de voir apparatre la configuration qui permet de diffrencier les deux horloges
candidates. Cest pourquoi les systmes qui utilisent ce codage envoient des enttes porteurs
de configurations qui assurent, coup sr, la synchronisation.
Asynchrone
-93-
crire & Comprendre VHDL & AMS J Rouillard 2008
1 CLS DE CE MANUEL
2 QUOI, O, ZONES DCLARATIVES, ZONES DINSTRUCTIONS
3 ENVIRONNEMENT, BIBLIOTHQUES
4 HIRARCHIE ET STRUCTURE
5 MODLISATION DE BIBLIOTHQUES - VITAL
10 Switch 6
7
SYSTME
COMPORTEMENTAL
Le switch ou interrupteur est 8 SYNCHRONE
9 ASYNCHRONE
simplement un transistor MOS. Toute la
logique classique est videmment base 10
11 ANALOGIQUE
sur de tels interrupteurs, mais pour celle- 12 RFRENCES
13 INDEX
ci les tensions et courants de sortie ne 14 TABLE DES FIGURES
viennent pas des entres, dont 15 BIBLIOGRAPHIE
limpdance est grande ; et enfin les
deux rseaux de transistors sont duaux, on dit que ce
sont des portes complmentaires. Voici pour mmoire
une porte nor : on y voit que le courant de sortie nest
pas fourni par les entres. Les impdances d'entres
sont grandes, celle de sortie est faible. Rseau P
Nous allons voir ici quil est possible de construire de
la logique non complmentaire, o il ny a pas de
rseaux de portes duaux. Cela se payera par le fait
que, dans certains tats, les sorties seront connectes
directement sur une ou l'autre entre avec
contamination des impdances.
component switch
generic (genre: genre_mos);
port (source, drain: inout std_logic; grille: std_logic);
end component;
Voici lentit qui est gnrique sur le type de MOS et qui a deux ports de mode inout, plus la
commande de mode in.
library ieee;use ieee.std_logic_1164.all;
use work.switch_util.all;
entity switch is
generic (genre: genre_mos);
port (source, drain: inout std_logic; grille: std_logic);
end entity switch;
Switch
-95-
crire & Comprendre VHDL & AMS J Rouillard 2008
begin
source <='Z'; -- on libre source et drain "de l'intrieur"
drain <='Z'; -- pour connatre les contributions extrieures
if passant then
-- ici le switch est passant, il faut propager
lasttime:=now;
wait on source 'transaction, drain 'transaction, grille
until now/=lasttime or (passant and (source /= drain));
end process;
end;
La difficult de ce modle rside dans sa condition de rveil: il faut videmment tre sensible
sur la grille, mais aussi sur les simples transactions sur la source et le drain : en effet il est
possible que, le switch tant passant et forant 1 de lintrieur sur la source par exemple,
voit cette mme source ensuite force de lextrieur avec la mme valeur 1 : cela ne crera
pas dvnement, juste une transaction mais il faut la prendre en compte car ensuite, si le
drain venait tre lch de lextrieur il faudrait aussitt le forcer de lintrieur .
Or la sensibilit sur transaction apporte un risque de boucle infinie dlai nul dans un modle
VHDL : il faut limiter le rveil une transaction par temps simul (branche until) moins
que source et drain ne viennent tre diffrents alors que le transistor est passant. Cest
comme cela que se lit la condition until de linstruction wait.
la simulation, certains simulateurs vont tre perturbs par toutes ces valeurs diffrentes
apparaissant au mme temps de simulation mais des deltas diffrents, et cela peut se traduire
par des couleurscratives sur les transitions. Il suffit de les ignorer.
Switch
-96-
crire & Comprendre VHDL & AMS J Rouillard 2008
use work.switch_util.all;
architecture struct of switch_xor is
signal interne: std_logic:='Z';
signal copie_de_a, copie_de_b,source_de_s: std_logic;
-- signaux locaux qui seront passes en inout
-- alors que A,B,S sont en in et en out.
begin
copie_de_a<=A ; -- A est en inout,
copie_de_b<=B ; -- idem
S<=source_de_s; -- S est en out
C1: switch generic map (N) port map ('0', interne, copie_de_a);
C2: switch generic map (N) port map (interne, source_de_s, copie_de_b);
C3: switch generic map (P) port map (source_de_s, copie_de_a, copie_de_b);
C4: switch generic map (P) port map (source_de_s, copie_de_b, copie_de_a);
end architecture struct;
Switch
-97-
crire & Comprendre VHDL & AMS J Rouillard 2008
1 CLS DE CE MANUEL
2 QUOI, O, ZONES DCLARATIVES, ZONES DINSTRUCTIONS
3 ENVIRONNEMENT, BIBLIOTHQUES
4 HIRARCHIE ET STRUCTURE
11 Analogique 5
6
MODLISATION DE BIBLIOTHQUES - VITAL
SYSTME
7 COMPORTEMENTAL
8 SYNCHRONE
Le niveau de description analogique est 9 ASYNCHRONE
10 SWITCH
utilisable aux deux bouts de la chane de
dveloppement : soit au niveau systme 11
12 RFRENCES
(description de gabarits de filtres), soit au 13 INDEX
niveau lectrique, ce qui est le plus 14 TABLE DES FIGURES
15 BIBLIOGRAPHIE
frquent.
Une description analogique demande en
gnral lutilisation de paquetages spcifiques, dfinissant le domaine physique dans lequel
on se place lequel emporte ses propres lois de conservation. Dans la vaste majorit des cas qui
nous intressent, le paquetage appel sera disciplines.electrical_systems. Attention :
certaines implmentations confondent la bibliothque DISCIPLINES avec la bibliothque
IEEE, certaines ont deux bibliothques distinctes.
Tous les objets analogiques valus (porteurs de valeurs qui changent au cours de la
simulation) drivent de la notion de nature qui est au monde analogique ce que le type est au
monde informatique. La nature est attache une discipline , c'est--dire la partie du
monde physique qui lon veut reprsenter, et qui correspond en gnral un paquetage
spcifique contenant aussi les constantes et types utiles au domaine. Cette discipline peut tre
lectrique, mcanique, thermique, etc. Le concepteur lectronique utilisera principalement le
paquetage electrical_systems (12.4.2 page 152). On dclare des terminaux (terminal)
comme appartenant une nature. On dclare aussi des quantits (quantity) qui ont le statut
de variables dans le jeu dquations rsoudre et qui peuvent subir des quations
diffrentielles implicites selon la forme de leur dclaration. Quantits et terminaux peuvent
tre membres de structures, on peut faire des tableaux ou des structures incluant des natures.
La nature reprsente sous un nom unique la vue de la discipline qui obit des lois de
conservation comme celles de Kirchhoff en lectricit. Elle dclare un terminal
rfrence (voir ci-dessous la description des quantits et rfrences). Elle dfinit aussi
que les terminaux de cette nature auront deux quantits implicites : une des quantits
(ACROSS) est de la catgorie potentiel, lautre (THROUGH) est de la catgorie flux.
Les lois de conservation disent que le potentiel entre deux terminaux est unique, et que
la somme des flux est nulle. La nature dfinit aussi une rfrence qui sera la masse en
lectricit, point zro des mesures de potentiel. La nature lectrique est ainsi dfinie :
nature electrical is
voltage across
current through
electrical_ref reference ;
Quantits et terminaux peuvent apparatre en place de ports dans les interfaces des entits et
des composants.
Analogique
-100-
crire & Comprendre VHDL & AMS J Rouillard 2008
entity E is
port (signal S : out BIT ; quantity Q : in real ; terminal T : electrical)
end entity E ;
Contrairement aux autres objets du langage, les valeurs associes sont toujours de type rel ou
dun sous-type de genre rel, et sont initialises 0.0. Rappelons que dans le monde
squentiel, la valeur initiale est la plus petite du type, et donc pour le type rel est un rel
ngatif de trs grande valeur absolue :
signal S : real ;
-- initialis un nombre ngatif trs petit (de grande valeur absolue)
quantity Q : real ; -- initialise 0.0.
Attention: les valeurs initiales, explicites ou implicites, ne sont que les valeurs proposes au
simulateur pour commencer ses heuristiques de rsolution.
11.1.2 Instructions
Les quelques constructions spcifiques sont:
Lquation : qui a deux branches dordre indiffrent, et que le solveur cherche
rendre vraie :
o la version simple : A==B ;
o linstruction conditionnelle:
if condition use A==B ;
elsif condition use C==D ; elsifelseend use;
o linstruction slecte: case expression use
when X => A==B ;
when Y => C==D ;end case;
Les conditions sont boolennes et donc changent de valeur instantanment :
dans la plupart des cas, cela se traduira par une discontinuit dans le modle.
Cette discontinuit doit tre signale au simulateur par linstruction break, voir
ci-dessous 11.1.3.
Le procedural: sorte de processus permettant dcrire du code squentiel.
procedural is
dclarations
begin
instructions
end procedural ;
Cette instruction est dfinie par une quivalence de la forme quation simple,
comprenant dun ct lagrgat de toutes les quantits affectes dans le procedural, et
de lautre ct un appel de fonction reprenant le code du procdural, qui lon passe
en argument toutes les quantits et terminaux mentionns.
(Q1, Q2, Q3) == Appel_de_F(Q1, Q2, Q3 , Q4, T1,) ;
Le procedural est appel par le noyau un nombre indtermin de fois (contrairement
au processus). Ces appels visent rendre vraie lquation quivalente. Les variables
locales sont volatiles et rinitialises chaque appel (contrairement au processus).
Analogique
-101-
crire & Comprendre VHDL & AMS J Rouillard 2008
tre gale au nombre dquations dans chaque architecture. Cela est vrifi la
compilation ou au plus tard llaboration si lon utilise la gnration (generate).
Les discontinuits : chaque fois quil y a une discontinuit dans la reprsentation, le
solveur doit en tre averti au cours de la simulation, explicitement, par une instruction
break qui est lance depuis le monde logique, lui-mme ventuellement prvenu
depuis le monde analogique par lutilisation de lattribut ABOVE. Attention : rien ne
signale au concepteur quil a oubli de mettre cette instruction, mais un bon indice est
quil utilise des constructions conditionnelles dans le jeu dquations. Le cas chant,
en cas doubli les traces de simulation vont simplement gommer la discontinuit et
crer des situations impossibles (dans le cas de la balle qui rebondit, elle va passer
travers le mur avant de revenir, puisque le point de discontinuit na gure de chance
dtre exactement un point de calcul). Cette instruction signale au solveur quil doit
reprendre au temps spcifi qui devient donc un point de calcul obligatoire, avec de
nouvelles conditions pseudo-initiales quil doit donc chercher.
La convergence : aucune mthode automatique ne permet au compilateur de garantir
la convergence du jeu dquations. La mise au point des modles se fait donc
essentiellement sur cette question, avec la dtermination des bonnes valeurs
initiales.
La rsistance est simplement dfinie par sa valeur et ses bornes qui sont deux terminaux. La
valeur peut tre donne en gnrique (ce sera une constante) ou comme une quantit, auquel
cas elle pourra changer en cours de simulation.
Analogique
-102-
crire & Comprendre VHDL & AMS J Rouillard 2008
On voit ici que le modle de rsistance thermique dans un autre domaine conservatif est tout
fait semblable.
library ieee;
use ieee.thermal_systems.all;
entity resistance_th is
port (quantity k : IN THERMAL_RESISTANCE;
terminal th1, th2 : THERMAL);
end entity resistance_thermique;
11.2.3 Capacit
La capacit est simplement dfinie par sa valeur et ses bornes qui sont deux terminaux. La
valeur peut tre donne en gnrique (ce sera une constante) ou comme une quantit, auquel
cas elle pourra changer en cours de simulation.
On teste par la valeur du signal DOMAIN si le modle est en train de calculer son tat DC en
chargeant la capacit de faon que sa tension soit gale Vinit; ou sil est en train de simuler
dans le temps.
Analogique
-103-
crire & Comprendre VHDL & AMS J Rouillard 2008
11.2.4 Self
La self est simplement dfinie par sa valeur et ses bornes qui sont deux terminaux. La valeur
peut tre donne en gnrique (ce sera une constante) ou comme une quantit, auquel cas elle
pourra changer en cours de simulation.
On teste par la valeur du signal DOMAIN si le modle est en train de calculer son tat DC en
chargeant la self de faon que son courant soit gal Iinit; ou sil est en train de simuler
dans le temps.
Analogique
-104-
crire & Comprendre VHDL & AMS J Rouillard 2008
library ieee;
use disciplines.electrical_systems.all;
entity source_tension is
port (quantity consigne : in VOLTAGE;
quantity MAG : in VOLTAGE;
quantity PHASE : in REAL;
terminal p, m: ELECTRICAL);
end entity source_tension;
Larchitecture, dans les domaines quiescent et time , fait simplement en sorte que la
tension aux bornes des terminaux soit gale, au signe prs, la tension de rfrence. Dans le
domaine frequency , la tension porte un bruit dfini par son spectre (magnitude, phase).
library ieee;
use ieee.math_real.all;
architecture analog of source_tension is
quantity v across i through p to m;
quantity ac_spec : real spectrum MAG, MATH_2_PI * PHASE/360.0;
begin
if (domain = quiescent_domain) or (domain = time_domain) use
v == - consigne;
else
v == - ac_spec;
end use;
end architecture analog;
De mme que prcdemment, cette source de courant fonctionne dans les domaines de
simulation temporelle et frquentielle. Nous ne reprsenterons pas non plus toutes les
combinaisons possibles de permutations entre la gnricit et le passage de quantits.
library ieee;
use disciplines.electrical_systems.all;
entity source_courant is
port (quantity consigne : IN CURRENT;
quantity MAG : in CURRENT;
quantity PHASE : in REAL;
terminal p, m: ELECTRICAL);
end entity source_courant;
Analogique
-105-
crire & Comprendre VHDL & AMS J Rouillard 2008
library ieee;
use ieee.math_real.all;
architecture analog of source_courant is
quantity v across i through p to m;
quantity ac_spec : real spectrum MAG, MATH_2_PI * PHASE/360.0;
begin
if (domain = quiescent_domain) or (domain = time_domain) use
i == consigne;
else
i == ac_spec;
end use;
end architecture analog;
11.2.7 Interrupteur
Un interrupteur parfait a pour caractristique que, en position ferm, la tension ses bornes
est nulle, et quen position ouverte, le courant qui le traverse est nul. Lentit comporte donc
deux terminaux et une quantit de commande.
library ieee;
use disciplines.electrical_systems.all;
entity interrupteur is
port (quantity commande : in REAL;
terminal t1,t2 : ELECTRICAL);
end entity interrupteur;
Larchitecture va simplement dclarer les deux galits i=0 et v=0 selon la valeur de la
commande. noter lutilisation de linstruction break sur le signal cr par la commande,
puisquil y a une discontinuit quil faut signaler.
architecture analog of interrupteur is
quantity v across i through t1 to t2;
signal local : BOOLEAN;
begin
local <= commande (0.0);
break on local;
if (local and (commande > 0.0)) use
v == 0.0;
else
i == 0.0;
end use;
end architecture analog;
11.2.8 Diode
(Exemple repris de [TUT] page 161)
Analogique
-106-
crire & Comprendre VHDL & AMS J Rouillard 2008
Lamplificateur oprationnel idal a deux entres et une sortie, ses quations en mode linaire
sont simples: la diffrence de potentiel entre les entres est nulle, limpdance dentre est
infinie donc le courant dentre est nul.
Ce modle trs simple ne traite donc, ni des amplificateurs gain non infini, ni du mode
satur.
library DISCIPLINES;
use DISCIPLINES.electrical_systems.all;
entity ampli_op is
On notera que le modle demande deux quations, il faut que la somme des quantits libres,
through et de mode out soit gale 2. Nous voyons donc ici la ncessit de dclarer une
quantit qui nintervient pas dans les quations explicites : courant_sortie. Elle est
videmment rattache au systme par les quations implicites de Kirchhoff lies ses
terminaux de rfrence.
architecture ideal of ampli_op is
begin
ddp == 0.0;
courant_entre == 0.0;
end architecture ideal;
Analogique
-107-
crire & Comprendre VHDL & AMS J Rouillard 2008
Ce gadget trs simple est constitu de deux boules attaches un point fixe par une ficelle.
Hypothses : Nous allons supposer ici que
le choc est parfaitement lastique
seule la rsistance de lair a donc un effet ralentisseur (la force due
cette rsistance est de module K.S.v2 o S est la surface de la projection
de lobjet sur un plan perpendiculaire au mouvement, et K une constante
dpendant de la forme sexprimant en kg/m3 ; on prendra ici K.S = 0.3 kg/m)
les deux boules sont de masse gale et de diamte ngligeable (quasi-ponctuelles.)
Un peu de trigonomtrie nous apprend que la valeur absolue de la composante
horizontale de lacclration due laction de la pesanteur est = g x2/l2
Comme chacun sait, dans ce cas lors du choc les deux vitesses schangent , par exemple
si une boule tait immobile la boule en mouvement sarrte et la boule immobile part avec la
vitesse de la boule qui sarrte. Cest lobjet de la deuxime instruction break. Ceci se
dmontre facilement en posant la conservation de la quantit de mouvement (m1v1+m2v2) et
la conservation de lnergie (m1v12/2+m2v22/2).
Avec les hypothses prises, la masse nintervient pas dans les quations.
architecture a of tactac is
begin
-- les conditions initiales:
break v1 => 0.0, x1 => 0.1, v2 => 0.0, x2 => -0.0;
-- la discontinuit lors du choc
Analogique
-108-
crire & Comprendre VHDL & AMS J Rouillard 2008
end architecture a;
On vrifiera facilement quen donnant des conditions initiales symtriques (les deux boules
spares de leur position de repos avec la mme quantit), on obtient bien le rebond
caractristique de ce jeu.
Ce modle est facile compliquer pour, par exemple, simuler lexcitation que donne le joueur
au systme en remuant verticalement lensemble la bonne frquence. On peut aussi simuler
un choc plus ou moins mou en calculant la vitesse aprs le choc dune faon qui tienne
compte de la perte dnergie (dans le deuxime break).
Valeur analogique
2R R R
2R 2R 2R Etc
On voit ainsi que, si les entres numriques sont telles que 0 logique fait 0 volt et 1 logique
fait 5 volts, la sortie analogique aura une tension de 5* K * la_valeur_reprsente / 2n volts,
o K est un nombre infrieur 1 qui dpend de N (K=1/2 pour N=1, 3/4 pour N=2, 7/8 pour
Analogique
-109-
crire & Comprendre VHDL & AMS J Rouillard 2008
N=3, etc.) La dmonstration est triviale et relve de lapplication de la loi dOhm avec un
raisonnement par rcurrence.
Le plus souvent, les circuits de ce genre contiennent des amplificateurs oprationnels (pour ne
pas tre contraints par la tension dalimentation, ou saffranchir des impdances). Ils peuvent
aussi avoir des rseaux de rsistances plus simples mais ncessitant des rsistances de valeurs
R, 2R, 4R, 8R. Or il est infiniment plus facile de faire des rsistances identiques dont la valeur
exacte importe peu pour autant quelle soit commune, que des rsistances exactement
multiples les unes des autres dans des proportions qui peuvent aller de 1 232. Cest pourquoi
le rseau R/2R, servi le plus souvent par des amplificateurs oprationnels, est trs rpandu.
Larchitecture peut tre dcrite de faon structurelle, en instanciant les rsistances telles que
dfinies au 11.2.1 page 100 :
Analogique
-110-
crire & Comprendre VHDL & AMS J Rouillard 2008
Un convertisseur peut tre purement comportemental, c'est--dire dfini par des quations qui
ne prjugent en rien de limplmentation future.
library ieee;
use ieee.std_logic_arith.all;
architecture beh of CNA is
quantity V_Sortie across I_Sortie through sortie to ELECTRICAL_REF;
begin
V_Sortie ==
tension_reference *(2.0**N-1.0)
*real(conv_integer(unsigned(entree)))/2.0**(2*N);
break on entree;
end;
On voit quici, le modle recopie le comportement dun rseau R/2R et on calcule simplement
la tension de sortie en lui appliquant la formule vue 11.3.1.1 ci-dessus. La seule diffrence
est que limpdance de sortie de ce modle comportemental est nulle, ce modle reprsente
donc un systme actif amplificateur oprationnel, utilisant un rseau R/2R.
Analogique
-111-
crire & Comprendre VHDL & AMS J Rouillard 2008
Horloge
Validation
Logique proposant des
valeurs Sortie
Convertisseur Valide
Digital/analogique Registre de sortie
Entre analogique
Comparateur
Le convertisseur D/A est de la forme dcrite plus haut, par exemple un R/2R.
11.3.2.1 Comparateur
Le comparateur prend deux valeurs analogiques en entre et soumet 1 ou 0 sur son unique
sortie logique selon la comparaison des deux valeurs.
Lattribut ABOVE va faire tout le travail, comme il rend un boolen et que nous avons besoin
dun STD_LOGIC nous utilisons une affectation de signal conditionnelle.
library ieee;
use ieee.std_logic_1164.all;
use disciplines.electrical_systems.all ;
entity comp is
port (terminal A,B: electrical; resultat: out std_logic);
end;
Nous allons utiliser ici une solution rapide pour proposer des valeurs au comparateur, en
procdant par essais et dcisions sur chaque bit individuellement en commenant par le bit de
poids fort. Par exemple, supposons une valuation sur 4 bits et que la valeur analogique
dterminer soit entre la 10me position 1001 et la 11me position 1010 (sur 16, en
commenant 0)
On part de 0000
On propose 0000, le rsultat de la comparaison aprs CN/A est 0 (trop petit)
On change le premier bit
On propose 1000. Le rsultat de la comparaison est 0 (trop petit) ; on laisse.
Le premier bit est fix, passons au second :
1000 est trop petit, on propose 1100, le rsultat du comparateur est 1 (trop grand)
Analogique
-112-
crire & Comprendre VHDL & AMS J Rouillard 2008
On revient 1000.
Le second bit est fix, passons au troisime :
1000 est trop petit, on propose 1010, le rsultat est 1 (trop grand)
On revient 1000.
Le troisime bit est fix, passons au quatrime :
1000 est trop petit, on propose 1001.
Le rsultat de la comparaison est 0 (trop petit) ; on laisse.
Lentit aura en entre une horloge, dont nous utiliserons les deux fronts : lun pour proposer
la nouvelle valeur au convertisseur N /A, lautre pour lire le rsultat de la comparaison. Il y a
deux ports sortants de N bits, lun pour proposer la valeur dessai au convertisseur, lautre
pour fournir en sortie une valeur stable entre deux valuations. Une entre venant du
comparateur, et une sortie indiquant que la sortie est valide.
library ieee;
use ieee.std_logic_1164.all;
entity proposeur is
generic (N:integer:=16);
port ( horloge:in std_logic;
reset: in std_logic;
resultat_comparaison: in std_logic;
valide : out std_logic ;
proposition, sortie: out std_logic_vector(N-1 downto 0));
end entity proposeur;
Larchitecture est organise autour dun processus quon rend sensible sur lhorloge et sur le
reset.
library ieee;
use ieee.std_logic_1164.all;
architecture simple of proposeur is
begin
process(horloge, reset)
variable registre: std_logic_vector(N-1 downto 0);
variable I:integer:=N-1; -- pour indexer les bits
begin
if reset='1' then -- zone de reset
registre:=(others=>'0');
proposition<=registre;
sortie<=registre;
valide<='0';
I :=N-1 ;
elsif horloge'event then -- zone active par lhorloge
-- on suppose que la valeur propose ici est toujours trop petite
-- et que le bit courant vaut 0 (voir algorithme dtaill plus haut)
valide<='1'; -- la sortie est ici stable et valide
-- (cf ci-dessous)
if horloge='1' then -- front montant
registre(I):='1'; -- on passe 1 le bit courant
else -- front descendant
if resultat_comparaison='1' then
-- si la valeur est devenue trop grande,
-- on revient en arrire.
Analogique
-113-
crire & Comprendre VHDL & AMS J Rouillard 2008
registre(I):='0';
end if;
I := I-1;
end if;
proposition<=registre;
if I=0 then
sortie<=registre;
registre:=(others=>0);
valide<='0'; -- !!! la sortie sera stable et valide au passage 1
-- de ce signal (car attention au fait que les
-- signaux ne changent que sur un wait, sortie sera
-- propose au prochain wait et sa stabilit
-- demandera encore un demi-cycle dhorloge, cf supra)
I:=N-1;
end if;
end if; -- reset/horloge
end process;
end simple;
Pour assembler notre CAN, nous allons utiliser une architecture structurelle.
Larchitecture va appeler nos trois blocs que sont le proposeur, le comparateur et le CAN:
architecture struct of CAN is
component proposeur
generic (N:integer);
port ( horloge:in std_logic;
reset: in std_logic;
resultat_comparaison: in std_logic;
valide : out std_logic ;
proposition, sortie: out std_logic_vector(N-1 downto 0));
end component;
Analogique
-114-
crire & Comprendre VHDL & AMS J Rouillard 2008
component comp
port (terminal A,B: electrical; resultat: out std_logic);
end component;
component CNA
generic (N : positive;
tension_reference: voltage ) ;
port (signal entree : std_logic_vector( N-1 downto 0) ;
terminal sortie : electrical ) ;
end component;
begin
Analogique
-115-
crire & Comprendre VHDL & AMS J Rouillard 2008
1 CLS DE CE MANUEL
2 QUOI, O, ZONES DCLARATIVES, ZONES DINSTRUCTIONS
3 ENVIRONNEMENT, BIBLIOTHQUES
4 HIRARCHIE ET STRUCTURE
12 Rfrences 5 MODLISATION DE BIBLIOTHQUES - VITAL
6 SYSTME
7 COMPORTEMENTAL
12.1 Standard et utiles 8 SYNCHRONE
9 ASYNCHRONE
10 SWITCH
11 ANALOGIQUE
12
13 INDEX
14 TABLE DES FIGURES
15 BIBLIOGRAPHIE
12.1.1 STD.STANDARD
En italique les lignes spcifiques AMS.
package standard is
type boolean is (false,true);
type bit is ('0', '1');
type character is (
nul, soh, stx, etx, eot, enq, ack, bel, bs, ht, lf, vt, ff, cr, so, si,
dle, dc1, dc2, dc3, dc4, nak, syn, etb, can, em, sub, esc, fsp, gsp, rsp, usp,
' ', '!', '"', '#', '$', '%', '&', ''', '(', ')', '*', '+', ',', '-', '.', '/',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ':', ';', '<', '=', '>', '?',
'@', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '[', '\', ']', '^', '_',
'`', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '{', '|', '}', '~', del,
c128, c129, c143,
c144, c145, c159,
' ', '', '', '', '', '', '', '', '', '', '', '', '', '-', '', '',
'', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '',
'', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '',
'', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '',
'', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '',
'', '', '', '', '', '', '', '', '', '', '', '', '', '', '', ''
);
Paquetages VITAL
-117-
crire & Comprendre VHDL & AMS J Rouillard 2008
Paquetages VITAL
-118-
crire & Comprendre VHDL & AMS J Rouillard 2008
12.1.2 STD.TEXTIO
package TEXTIO is
type LINE is access string;
type TEXT is file of string;
type SIDE is (right, left);
subtype WIDTH is natural;
file input : TEXT open read_mode is "STD_INPUT";
file output : TEXT open write_mode is "STD_OUTPUT";
procedure READLINE(file f: TEXT; L: out LINE);
procedure READ(L:inout LINE; VALUE: out bit; GOOD : out BOOLEAN);
procedure READ(L:inout LINE; VALUE: out bit);
procedure READ(L:inout LINE; VALUE: out bit_vector;
GOOD : out BOOLEAN);
procedure READ(L:inout LINE; VALUE: out bit_vector);
procedure READ(L:inout LINE; VALUE: out BOOLEAN; GOOD : out BOOLEAN);
procedure READ(L:inout LINE; VALUE: out BOOLEAN);
procedure READ(L:inout LINE; VALUE: out character; GOOD : out BOOLEAN);
procedure READ(L:inout LINE; VALUE: out character);
procedure READ(L:inout LINE; VALUE: out integer; GOOD : out BOOLEAN);
procedure READ(L:inout LINE; VALUE: out integer);
procedure READ(L:inout LINE; VALUE: out real; GOOD : out BOOLEAN);
procedure READ(L:inout LINE; VALUE: out real);
procedure READ(L:inout LINE; VALUE: out string; GOOD : out BOOLEAN);
procedure READ(L:inout LINE; VALUE: out string);
procedure READ(L:inout LINE; VALUE: out time; GOOD : out BOOLEAN);
procedure READ(L:inout LINE; VALUE: out time);
procedure WRITELINE(file f : TEXT; L : inout LINE);
procedure WRITE(L : inout LINE; VALUE : in bit;
JUSTIFIED: in SIDE := right;
FIELD: in WIDTH := 0);
procedure WRITE(L : inout LINE; VALUE : in bit_vector;
JUSTIFIED: in SIDE := right;
FIELD: in WIDTH := 0);
procedure WRITE(L : inout LINE; VALUE : in BOOLEAN;
JUSTIFIED: in SIDE := right;
FIELD: in WIDTH := 0);
procedure WRITE(L : inout LINE; VALUE : in character;
JUSTIFIED: in SIDE := right;
FIELD: in WIDTH := 0);
procedure WRITE(L : inout LINE; VALUE : in integer;
JUSTIFIED: in SIDE := right;
FIELD: in WIDTH := 0);
procedure WRITE(L : inout LINE; VALUE : in real;
JUSTIFIED: in SIDE := right;
FIELD: in WIDTH := 0;
DIGITS: in NATURAL := 0);
procedure WRITE(L : inout LINE; VALUE : in string;
JUSTIFIED: in SIDE := right;
FIELD: in WIDTH := 0);
procedure WRITE(L : inout LINE; VALUE : in time;
JUSTIFIED: in SIDE := right;
FIELD: in WIDTH := 0;
UNIT: in TIME := ns);
end;
Paquetages VITAL
-119-
crire & Comprendre VHDL & AMS J Rouillard 2008
12.1.3 STD_LOGIC_TEXTIO
Une copie de TEXTIO mais le type BIT y est remplac par le type STD_LOGIC. Paquetage
non standard.
use STD.textio.all;
library IEEE;
use IEEE.std_logic_1164.all;
package STD_LOGIC_TEXTIO is
Paquetages VITAL
-120-
crire & Comprendre VHDL & AMS J Rouillard 2008
12.2 IEEE
12.2.1 IEEE.STD_LOGIC_1164
PACKAGE std_logic_1164 IS
-------------------------------------------------------------------
-- logic state system (unresolved)
-------------------------------------------------------------------
TYPE std_ulogic IS ( 'U', -- Uninitialized
'X', -- Forcing Unknown
'0', -- Forcing 0
'1', -- Forcing 1
'Z', -- High Impedance
'W', -- Weak Unknown
'L', -- Weak 0
'H', -- Weak 1
'-' -- Don't care
);
-------------------------------------------------------------------
-- unconstrained array of std_ulogic for use with
-- the resolution function
-------------------------------------------------------------------
TYPE std_ulogic_vector IS ARRAY ( NATURAL RANGE <> ) OF std_ulogic;
-------------------------------------------------------------------
-- resolution function
-------------------------------------------------------------------
FUNCTION resolved ( s : std_ulogic_vector ) RETURN std_ulogic;
-------------------------------------------------------------------
-- *** industry standard logic type ***
-------------------------------------------------------------------
SUBTYPE std_logic IS resolved std_ulogic;
-------------------------------------------------------------------
-- unconstrained array of std_logic for use in declaring signal arrays
-------------------------------------------------------------------
TYPE std_logic_vector IS ARRAY ( NATURAL RANGE <>) OF std_logic;
-------------------------------------------------------------------
-- common subtypes
-------------------------------------------------------------------
SUBTYPE X01 IS resolved std_ulogic RANGE 'X' TO '1';
-- ('X','0','1')
SUBTYPE X01Z IS resolved std_ulogic RANGE 'X' TO 'Z';
-- ('X','0','1','Z')
SUBTYPE UX01 IS resolved std_ulogic RANGE 'U' TO '1';
-- ('U','X','0','1')
SUBTYPE UX01Z IS resolved std_ulogic RANGE 'U' TO 'Z';
-- ('U','X','0','1','Z')
-------------------------------------------------------------------
-- overloaded logical operators
-------------------------------------------------------------------
FUNCTION "and" ( l : std_ulogic; r : std_ulogic ) RETURN UX01;
FUNCTION "nand" ( l : std_ulogic; r : std_ulogic ) RETURN UX01;
FUNCTION "or" ( l : std_ulogic; r : std_ulogic ) RETURN UX01;
FUNCTION "nor" ( l : std_ulogic; r : std_ulogic ) RETURN UX01;
FUNCTION "xor" ( l : std_ulogic; r : std_ulogic ) RETURN UX01;
FUNCTION "xnor" ( l : std_ulogic; r : std_ulogic ) return ux01;
FUNCTION "not" ( l : std_ulogic ) RETURN UX01;
-------------------------------------------------------------------
-- vectorized overloaded logical operators
-------------------------------------------------------------------
FUNCTION "and" ( l, r : std_logic_vector ) RETURN std_logic_vector;
FUNCTION "and" ( l, r : std_ulogic_vector ) RETURN std_ulogic_vector;
Paquetages VITAL
-121-
crire & Comprendre VHDL & AMS J Rouillard 2008
Paquetages VITAL
-122-
crire & Comprendre VHDL & AMS J Rouillard 2008
12.2.2 IEEE.STD_LOGIC_ARITH
library IEEE;
use IEEE.std_logic_1164.all;
package std_logic_arith is
type UNSIGNED is array (NATURAL range <>) of STD_LOGIC;
type SIGNED is array (NATURAL range <>) of STD_LOGIC;
subtype SMALL_INT is INTEGER range 0 to 1;
function "+"(L: UNSIGNED; R: UNSIGNED) return UNSIGNED;
function "+"(L: SIGNED; R: SIGNED) return SIGNED;
function "+"(L: UNSIGNED; R: SIGNED) return SIGNED;
function "+"(L: SIGNED; R: UNSIGNED) return SIGNED;
function "+"(L: UNSIGNED; R: INTEGER) return UNSIGNED;
function "+"(L: INTEGER; R: UNSIGNED) return UNSIGNED;
function "+"(L: SIGNED; R: INTEGER) return SIGNED;
function "+"(L: INTEGER; R: SIGNED) return SIGNED;
function "+"(L: UNSIGNED; R: STD_ULOGIC) return UNSIGNED;
function "+"(L: STD_ULOGIC; R: UNSIGNED) return UNSIGNED;
function "+"(L: SIGNED; R: STD_ULOGIC) return SIGNED;
function "+"(L: STD_ULOGIC; R: SIGNED) return SIGNED;
function "+"(L: UNSIGNED; R: UNSIGNED) return STD_LOGIC_VECTOR;
function "+"(L: SIGNED; R: SIGNED) return STD_LOGIC_VECTOR;
function "+"(L: UNSIGNED; R: SIGNED) return STD_LOGIC_VECTOR;
function "+"(L: SIGNED; R: UNSIGNED) return STD_LOGIC_VECTOR;
function "+"(L: UNSIGNED; R: INTEGER) return STD_LOGIC_VECTOR;
function "+"(L: INTEGER; R: UNSIGNED) return STD_LOGIC_VECTOR;
function "+"(L: SIGNED; R: INTEGER) return STD_LOGIC_VECTOR;
function "+"(L: INTEGER; R: SIGNED) return STD_LOGIC_VECTOR;
function "+"(L: UNSIGNED; R: STD_ULOGIC) return STD_LOGIC_VECTOR;
function "+"(L: STD_ULOGIC; R: UNSIGNED) return STD_LOGIC_VECTOR;
function "+"(L: SIGNED; R: STD_ULOGIC) return STD_LOGIC_VECTOR;
function "+"(L: STD_ULOGIC; R: SIGNED) return STD_LOGIC_VECTOR;
function "-"(L: UNSIGNED; R: UNSIGNED) return UNSIGNED;
function "-"(L: SIGNED; R: SIGNED) return SIGNED;
function "-"(L: UNSIGNED; R: SIGNED) return SIGNED;
function "-"(L: SIGNED; R: UNSIGNED) return SIGNED;
function "-"(L: UNSIGNED; R: INTEGER) return UNSIGNED;
function "-"(L: INTEGER; R: UNSIGNED) return UNSIGNED;
function "-"(L: SIGNED; R: INTEGER) return SIGNED;
function "-"(L: INTEGER; R: SIGNED) return SIGNED;
function "-"(L: UNSIGNED; R: STD_ULOGIC) return UNSIGNED;
function "-"(L: STD_ULOGIC; R: UNSIGNED) return UNSIGNED;
function "-"(L: SIGNED; R: STD_ULOGIC) return SIGNED;
function "-"(L: STD_ULOGIC; R: SIGNED) return SIGNED;
function "-"(L: UNSIGNED; R: UNSIGNED) return STD_LOGIC_VECTOR;
function "-"(L: SIGNED; R: SIGNED) return STD_LOGIC_VECTOR;
function "-"(L: UNSIGNED; R: SIGNED) return STD_LOGIC_VECTOR;
function "-"(L: SIGNED; R: UNSIGNED) return STD_LOGIC_VECTOR;
function "-"(L: UNSIGNED; R: INTEGER) return STD_LOGIC_VECTOR;
function "-"(L: INTEGER; R: UNSIGNED) return STD_LOGIC_VECTOR;
function "-"(L: SIGNED; R: INTEGER) return STD_LOGIC_VECTOR;
function "-"(L: INTEGER; R: SIGNED) return STD_LOGIC_VECTOR;
function "-"(L: UNSIGNED; R: STD_ULOGIC) return STD_LOGIC_VECTOR;
function "-"(L: STD_ULOGIC; R: UNSIGNED) return STD_LOGIC_VECTOR;
function "-"(L: SIGNED; R: STD_ULOGIC) return STD_LOGIC_VECTOR;
function "-"(L: STD_ULOGIC; R: SIGNED) return STD_LOGIC_VECTOR;
function "+"(L: UNSIGNED) return UNSIGNED;
function "+"(L: SIGNED) return SIGNED;
function "-"(L: SIGNED) return SIGNED;
Paquetages VITAL
-123-
crire & Comprendre VHDL & AMS J Rouillard 2008
Paquetages VITAL
-124-
crire & Comprendre VHDL & AMS J Rouillard 2008
Paquetages VITAL
-125-
crire & Comprendre VHDL & AMS J Rouillard 2008
12.2.3 IEEE.MATH_REAL
package MATH_real is
Paquetages VITAL
-126-
crire & Comprendre VHDL & AMS J Rouillard 2008
12.3 IEEE-VITAL
12.3.1 BNF Vital
o VITAL_control_generic_declaration ::= [ constant ] identifier_list : [ in ]
type_mark [ index_constraint ] [ := static_expression ] ;
o VITAL_design_file ::=VITAL_design_unit { VITAL_design_unit }
o VITAL_design_unit ::= context_clause library_unit | context_clause
VITAL_library_unit
o VITAL_entity_declarative_part ::= VITAL_Level0_attribute_specification
o VITAL_entity_generic_clause ::= generic ( VITAL_entity_interface_list ) ;
o VITAL_entity_header ::= [ VITAL_entity_generic_clause ] [
VITAL_entity_port_clause ]
o VITAL_entity_interface_declaration ::= interface_constant_declaration |
VITAL_timing_generic_declaration | VITAL_control_generic_declaration
o | VITAL_entity_port_declaration
o VITAL_entity_interface_list ::= VITAL_entity_interface_declaration { ;
VITAL_entity_interface_declaration }
o VITAL_entity_port_clause ::= port ( VITAL_entity_interface_list ) ;
o VITAL_entity_port_declaration ::= [ signal ] identifier_list : [ mode ]
type_mark [ index_constraint ] [ := static_expression ] ;
o VITAL_functionality_section ::= { VITAL_Variable_assignment_statement |
procedure_call_statement }
o VITAL_internal_signal_declaration ::= signal identifier_list : type_mark [
index_constraint ] [ := expression ] ;
o VITAL_Level_0_architecture_body ::= architecture identifier of entity_name is
VITAL_Level_0_ architecture_declarative_part begin architecture_statement_part
end [architecture] [ architecture_simple_name ] ;
o VITAL_Level_0_architecture_declarative_part ::=
VITAL_Level0_attribute_specification { block_declarative_item }
o VITAL_Level_0_entity_declaration ::= entity identifier is VITAL_entity_header
VITAL_entity_declarative_part end [entity] [ entity_simple_name ] ;
o VITAL_Level_1_architecture_body ::= architecture identifier of entity_name is
VITAL_Level_1_architecture_declarative_part begin
VITAL_Level_1_architecture_statement_part end [architecture] [
architecture_simple_name ] ;
o VITAL_Level_1_architecture_declarative_part ::=
VITAL_Level1_attribute_specification { VITAL_Level_1_block_declarative_item }
o VITAL_Level_1_architecture_statement_part ::=
VITAL_Level_1_concurrent_statement { VITAL_Level_1_concurrent_statement }
o VITAL_Level_1_block_declarative_item ::= constant_declaration |
alias_declaration
o | attribute_declaration | attribute_specification
o VITAL_internal_signal_declaration
o VITAL_Level_1_ concurrent_statement ::= VITAL_wire_delay_block_statement |
VITAL_negative_constraint_block_statement | VITAL_process_statement |
VITAL_primitive_concurrent_procedure_call
o VITAL_Level1_Memory_architecture_body ::= architecture identifier of
entity_name is VITAL_Level1_Memory_architecture_declarative_part begin
VITAL_Level1_Memory_architecture_statement_part end [architecture] [
architecture_simple_name ] ;
o VITAL_Level1_Memory_architecture_declarative_part ::=
VITAL_Level1_Memory_attribute_specification {
VITAL_Level1_Memory_block_declarative_item }
o VITAL_Level1_Memory_architecture_statement_part ::=
VITAL_Level1_Memory_concurrent_statement {
VITAL_Level1_Memory_concurrent_statement }
o VITAL_Level1_Memory_block_declarative_item ::= constant_declaration |
alias_declaration | attribute_declaration | attribute_specification |
VITAL_memory_internal_signal_declaration
o VITAL_Level1_Memory_concurrent_statement ::= VITAL_wire_delay_block_statement |
VITAL_negative_constraint_block_statement | VITAL_memory_process_statement
o | VITAL_memory_output_drive_block_statement
o VITAL_Level0_attribute_specification ::= attribute_specification
o VITAL_Level1_attribute_specification ::= attribute_specification
o VITAL_Level1_Memory_attribute_specification ::= attribute_specification
Paquetages VITAL
-127-
crire & Comprendre VHDL & AMS J Rouillard 2008
Paquetages VITAL
-128-
crire & Comprendre VHDL & AMS J Rouillard 2008
o VITAL_wire_delay_block_statement_part ::= {
VITAL_wire_delay_concurrent_procedure_call | VITAL_wire_delay_generate_statement
}
o VITAL_wire_delay_concurrent_procedure_call ::= concurrent_procedure_call
o VITAL_wire_delay_generate_parameter_specification ::= identifier in
range_attribute_name
o VITAL_wire_delay_generate_statement ::= generate_label : for
VITAL_wire_delay_generate_parameter_specification generate {
VITAL_wire_delay_concurrent_procedure_call } end generate [ generate_label ] ;
Paquetages VITAL
-129-
crire & Comprendre VHDL & AMS J Rouillard 2008
12.3.2 VITAL_TIMING
LIBRARY IEEE;
USE IEEE.Std_Logic_1164.ALL;
PACKAGE VITAL_Timing IS
TYPE VitalTransitionType IS ( tr01, tr10, tr0z, trz1, tr1z, trz0,
tr0X, trx1, tr1x, trx0, trxz, trzx);
SUBTYPE VitalDelayType IS TIME;
TYPE VitalDelayType01 IS ARRAY (VitalTransitionType RANGE tr01 to tr10)
OF TIME;
TYPE VitalDelayType01Z IS ARRAY (VitalTransitionType RANGE tr01 to trz0)
OF TIME;
TYPE VitalDelayType01ZX IS ARRAY (VitalTransitionType RANGE tr01 to trzx)
OF TIME;
TYPE VitalDelayArrayType IS ARRAY (NATURAL RANGE <>) OF VitalDelayType;
TYPE VitalDelayArrayType01 IS ARRAY (NATURAL RANGE <>) OF VitalDelayType01;
TYPE VitalDelayArrayType01Z IS ARRAY (NATURAL RANGE <>) OF VitalDelayType01Z;
TYPE VitalDelayArrayType01ZX IS ARRAY (NATURAL RANGE <>) OF VitalDelayType01ZX;
CONSTANT VitalZeroDelay : VitalDelayType := 0 ns;
CONSTANT VitalZeroDelay01 : VitalDelayType01 := ( 0 ns, 0 ns );
CONSTANT VitalZeroDelay01Z : VitalDelayType01Z := ( OTHERS => 0 ns );
CONSTANT VitalZeroDelay01ZX : VitalDelayType01ZX := ( OTHERS => 0 ns );
ATTRIBUTE VITAL_Level0 : BOOLEAN;
ATTRIBUTE VITAL_Level1 : BOOLEAN;
SUBTYPE std_logic_vector2 IS std_logic_vector(1 DOWNTO 0);
SUBTYPE std_logic_vector3 IS std_logic_vector(2 DOWNTO 0);
SUBTYPE std_logic_vector4 IS std_logic_vector(3 DOWNTO 0);
SUBTYPE std_logic_vector8 IS std_logic_vector(7 DOWNTO 0);
TYPE VitalOutputMapType IS ARRAY ( std_ulogic ) OF std_ulogic;
TYPE VitalResultMapType IS ARRAY ( UX01 ) OF std_ulogic;
TYPE VitalResultZMapType IS ARRAY ( UX01Z ) OF std_ulogic;
CONSTANT VitalDefaultOutputMap : VitalOutputMapType
:= "UX01ZWLH-";
CONSTANT VitalDefaultResultMap : VitalResultMapType
:= ( 'U', 'X', '0', '1' );
CONSTANT VitalDefaultResultZMap : VitalResultZMapType
:= ( 'U', 'X', '0', '1', 'Z' );
TYPE VitalTimeArrayT IS ARRAY (INTEGER RANGE <>) OF TIME;
TYPE VitalTimeArrayPT IS ACCESS VitalTimeArrayT;
TYPE VitalBoolArrayT IS ARRAY (INTEGER RANGE <>) OF BOOLEAN;
TYPE VitalBoolArrayPT IS ACCESS VitalBoolArrayT;
TYPE VitalLogicArrayPT IS ACCESS std_logic_vector;
TYPE VitalTimingDataType IS RECORD
NotFirstFlag : BOOLEAN;
RefLast : X01;
RefTime : TIME;
HoldEn : BOOLEAN;
TestLast : std_ulogic;
TestTime : TIME;
SetupEn : BOOLEAN;
TestLastA : VitalLogicArrayPT;
TestTimeA : VitalTimeArrayPT;
HoldEnA : VitalBoolArrayPT;
SetupEnA : VitalBoolArrayPT;
END RECORD;
FUNCTION VitalTimingDataInit RETURN VitalTimingDataType;
TYPE VitalPeriodDataType IS RECORD
Last : X01;
Rise : TIME;
Fall : TIME;
NotFirstFlag : BOOLEAN;
END RECORD;
CONSTANT VitalPeriodDataInit : VitalPeriodDataType
:= ('X', 0 ns, 0 ns, FALSE );
TYPE VitalGlitchKindType IS (OnEvent, OnDetect, VitalInertial, VitalTransport);
Paquetages VITAL
-130-
crire & Comprendre VHDL & AMS J Rouillard 2008
TYPE VitalGlitchDataType IS
RECORD
SchedTime : TIME;
GlitchTime : TIME;
SchedValue : std_ulogic;
LastValue : std_ulogic;
END RECORD;
TYPE VitalGlitchDataArrayType IS ARRAY (NATURAL RANGE <>)
OF VitalGlitchDataType;
TYPE VitalPathType IS RECORD
InputChangeTime : TIME; -- timestamp for path input signal
PathDelay : VitalDelayType; -- delay for this path
PathCondition : BOOLEAN; -- path sensitize condition
END RECORD;
TYPE VitalPath01Type IS RECORD
InputChangeTime : TIME; -- timestamp for path input signal
PathDelay : VitalDelayType01; -- delay for this path
PathCondition : BOOLEAN; -- path sensitize condition
END RECORD;
TYPE VitalPath01ZType IS RECORD
InputChangeTime : TIME; -- timestamp for path input signal
PathDelay : VitalDelayType01Z;-- delay for this path
PathCondition : BOOLEAN; -- path sensitize condition
END RECORD;
-- For representing multiple paths to an output
TYPE VitalPathArrayType IS ARRAY (NATURAL RANGE <> ) OF VitalPathType;
TYPE VitalPathArray01Type IS ARRAY (NATURAL RANGE <> ) OF VitalPath01Type;
TYPE VitalPathArray01ZType IS ARRAY (NATURAL RANGE <> ) OF VitalPath01ZType;
TYPE VitalTableSymbolType IS (
'/', -- 0 -> 1
'\', -- 1 -> 0
'P', -- Union of '/' and '^' (any edge to 1)
'N', -- Union of '\' and 'v' (any edge to 0)
'r', -- 0 -> X
'f', -- 1 -> X
'p', -- Union of '/' and 'r' (any edge from 0)
'n', -- Union of '\' and 'f' (any edge from 1)
'R', -- Union of '^' and 'p' (any possible rising edge)
'F', -- Union of 'v' and 'n' (any possible falling edge)
'^', -- X -> 1
'v', -- X -> 0
'E', -- Union of 'v' and '^' (any edge from X)
'A', -- Union of 'r' and '^' (rising edge to or from 'X')
'D', -- Union of 'f' and 'v' (falling edge to or from 'X')
'*', -- Union of 'R' and 'F' (any edge)
'X', -- Unknown level
'0', -- low level
'1', -- high level
'-', -- don't care
'B', -- 0 or 1
'Z', -- High Impedance
'S' -- steady value
);
SUBTYPE VitalEdgeSymbolType IS VitalTableSymbolType RANGE '/' TO '*';
TYPE VitalSkewExpectedT
TYPE VitalSkewDataType IS RECORD
ExpectedType : VitalSkewExpectedType;
Signal1Old1 : TIME;
Signal2Old1 : TIME;
Signal1Old2 : TIME;
Signal2Old2 : TIME;
END RECORD;
CONSTANT VitalSkewDataInit : VitalSkewDataType := (none,0 ns,0 ns,0 ns,0 ns );
FUNCTION VitalExtendToFillDelay (
CONSTANT Delay : IN VitalDelayType
) RETURN VitalDelayType01Z;
FUNCTION VitalExtendToFillDelay (
CONSTANT Delay : IN VitalDelayType01
Paquetages VITAL
-131-
crire & Comprendre VHDL & AMS J Rouillard 2008
) RETURN VitalDelayType01Z;
FUNCTION VitalExtendToFillDelay (
CONSTANT Delay : IN VitalDelayType01Z
) RETURN VitalDelayType01Z;
FUNCTION VitalCalcDelay (
CONSTANT NewVal : IN std_ulogic := 'X';
CONSTANT OldVal : IN std_ulogic := 'X';
CONSTANT Delay : IN VitalDelayType
) RETURN TIME;
FUNCTION VitalCalcDelay (
CONSTANT NewVal : IN std_ulogic := 'X';
CONSTANT OldVal : IN std_ulogic := 'X';
CONSTANT Delay : IN VitalDelayType01
) RETURN TIME;
FUNCTION VitalCalcDelay (
CONSTANT NewVal : IN std_ulogic := 'X';
CONSTANT OldVal : IN std_ulogic := 'X';
CONSTANT Delay : IN VitalDelayType01Z
) RETURN TIME;
PROCEDURE VitalPathDelay (
SIGNAL OutSignal : OUT std_logic;
VARIABLE GlitchData : INOUT VitalGlitchDataType;
CONSTANT OutSignalName : IN string;
CONSTANT OutTemp : IN std_logic;
CONSTANT Paths : IN VitalPathArrayType;
CONSTANT DefaultDelay : IN VitalDelayType := VitalZeroDelay;
CONSTANT Mode : IN VitalGlitchKindType := OnEvent;
CONSTANT XOn : IN BOOLEAN := TRUE;
CONSTANT MsgOn : IN BOOLEAN := TRUE;
CONSTANT MsgSeverity : IN SEVERITY_LEVEL := WARNING;
CONSTANT NegPreemptOn : IN BOOLEAN := FALSE;
CONSTANT IgnoreDefaultDelay : IN BOOLEAN := FALSE );
PROCEDURE VitalPathDelay01 (
SIGNAL OutSignal : OUT std_logic;
VARIABLE GlitchData : INOUT VitalGlitchDataType;
CONSTANT OutSignalName : IN string;
CONSTANT OutTemp : IN std_logic;
CONSTANT Paths : IN VitalPathArray01Type;
CONSTANT DefaultDelay : IN VitalDelayType01 :=
VitalZeroDelay01;
CONSTANT Mode : IN VitalGlitchKindType := OnEvent;
CONSTANT XOn : IN BOOLEAN := TRUE;
CONSTANT MsgOn : IN BOOLEAN := TRUE;
CONSTANT MsgSeverity : IN SEVERITY_LEVEL := WARNING;
CONSTANT NegPreemptOn : IN BOOLEAN := FALSE;
CONSTANT IgnoreDefaultDelay : IN BOOLEAN := FALSE;
CONSTANT RejectFastPath : IN BOOLEAN := FALSE );
PROCEDURE VitalPathDelay01Z (
SIGNAL OutSignal : OUT std_logic;
VARIABLE GlitchData : INOUT VitalGlitchDataType;
CONSTANT OutSignalName : IN string;
CONSTANT OutTemp : IN std_logic;
CONSTANT Paths : IN VitalPathArray01ZType;
CONSTANT DefaultDelay : IN VitalDelayType01Z :=
VitalZeroDelay01Z;
CONSTANT Mode : IN VitalGlitchKindType := OnEvent;
CONSTANT XOn : IN BOOLEAN := TRUE;
CONSTANT MsgOn : IN BOOLEAN := TRUE;
CONSTANT MsgSeverity : IN SEVERITY_LEVEL := WARNING;
CONSTANT OutputMap : IN VitalOutputMapType :=
VitalDefaultOutputMap;
CONSTANT NegPreemptOn : IN BOOLEAN := FALSE;
CONSTANT IgnoreDefaultDelay : IN BOOLEAN := FALSE;
CONSTANT RejectFastPath : IN BOOLEAN := FALSE
PROCEDURE VitalWireDelay (
SIGNAL OutSig : OUT std_ulogic;
SIGNAL InSig : IN std_ulogic;
CONSTANT twire : IN VitalDelayType);
Paquetages VITAL
-132-
crire & Comprendre VHDL & AMS J Rouillard 2008
PROCEDURE VitalWireDelay (
SIGNAL OutSig : OUT std_ulogic;
SIGNAL InSig : IN std_ulogic;
CONSTANT twire : IN VitalDelayType01);
PROCEDURE VitalWireDelay (
SIGNAL OutSig : OUT std_ulogic;
SIGNAL InSig : IN std_ulogic;
CONSTANT twire : IN VitalDelayType01Z );
PROCEDURE VitalSignalDelay (
SIGNAL OutSig : OUT std_ulogic;
SIGNAL InSig : IN std_ulogic;
CONSTANT dly : IN TIME);
PROCEDURE VitalSetupHoldCheck (
VARIABLE Violation : OUT X01;
VARIABLE TimingData : INOUT VitalTimingDataType;
SIGNAL TestSignal : IN std_ulogic;
CONSTANT TestSignalName: IN STRING := "";
CONSTANT TestDelay : IN TIME := 0 ns;
SIGNAL RefSignal : IN std_ulogic;
CONSTANT RefSignalName : IN STRING := "";
CONSTANT RefDelay : IN TIME := 0 ns;
CONSTANT SetupHigh : IN TIME := 0 ns;
CONSTANT SetupLow : IN TIME := 0 ns;
CONSTANT HoldHigh : IN TIME := 0 ns;
CONSTANT HoldLow : IN TIME := 0 ns;
CONSTANT CheckEnabled : IN BOOLEAN := TRUE;
CONSTANT RefTransition : IN VitalEdgeSymbolType;
CONSTANT HeaderMsg : IN STRING := " ";
CONSTANT XOn : IN BOOLEAN := TRUE;
CONSTANT MsgOn : IN BOOLEAN := TRUE;
CONSTANT MsgSeverity : IN SEVERITY_LEVEL := WARNING;
CONSTANT EnableSetupOnTest : IN BOOLEAN := TRUE;
CONSTANT EnableSetupOnRef : IN BOOLEAN := TRUE;
CONSTANT EnableHoldOnRef : IN BOOLEAN := TRUE;
CONSTANT EnableHoldOnTest : IN BOOLEAN := TRUE );
PROCEDURE VitalSetupHoldCheck (
VARIABLE Violation : OUT X01;
VARIABLE TimingData : INOUT VitalTimingDataType;
SIGNAL TestSignal : IN std_logic_vector;
CONSTANT TestSignalName: IN STRING := "";
CONSTANT TestDelay : IN TIME := 0 ns;
SIGNAL RefSignal : IN std_ulogic;
CONSTANT RefSignalName : IN STRING := "";
CONSTANT RefDelay : IN TIME := 0 ns;
CONSTANT SetupHigh : IN TIME := 0 ns;
CONSTANT SetupLow : IN TIME := 0 ns;
CONSTANT HoldHigh : IN TIME := 0 ns;
CONSTANT HoldLow : IN TIME := 0 ns;
CONSTANT CheckEnabled : IN BOOLEAN := TRUE;
CONSTANT RefTransition : IN VitalEdgeSymbolType;
CONSTANT HeaderMsg : IN STRING := " ";
CONSTANT XOn : IN BOOLEAN := TRUE;
CONSTANT MsgOn : IN BOOLEAN := TRUE;
CONSTANT MsgSeverity : IN SEVERITY_LEVEL := WARNING;
CONSTANT EnableSetupOnTest : IN BOOLEAN := TRUE;
CONSTANT EnableSetupOnRef : IN BOOLEAN := TRUE;
CONSTANT EnableHoldOnRef : IN BOOLEAN := TRUE;
CONSTANT EnableHoldOnTest : IN BOOLEAN := TRUE );
PROCEDURE VitalRecoveryRemovalCheck (
VARIABLE Violation : OUT X01;
VARIABLE TimingData : INOUT VitalTimingDataType;
SIGNAL TestSignal : IN std_ulogic;
CONSTANT TestSignalName: IN STRING := "";
CONSTANT TestDelay : IN TIME := 0 ns;
SIGNAL RefSignal : IN std_ulogic;
CONSTANT RefSignalName : IN STRING := "";
CONSTANT RefDelay : IN TIME := 0 ns;
CONSTANT Recovery : IN TIME := 0 ns;
Paquetages VITAL
-133-
crire & Comprendre VHDL & AMS J Rouillard 2008
Paquetages VITAL
-134-
crire & Comprendre VHDL & AMS J Rouillard 2008
12.3.3 VITAL_Primitives
LIBRARY IEEE;USE IEEE.Std_Logic_1164.ALL;
LIBRARY vital2000;USE vital2000.VITAL_Timing.ALL;
PACKAGE VITAL_Primitives IS
SUBTYPE VitalTruthSymbolType IS VitalTableSymbolType RANGE 'X' TO 'Z';
SUBTYPE VitalStateSymbolType IS VitalTableSymbolType RANGE '/' TO 'S';
TYPE VitalTruthTableType IS ARRAY ( NATURAL RANGE <>, NATURAL RANGE <> )
OF VitalTruthSymbolType;
TYPE VitalStateTableType IS ARRAY ( NATURAL RANGE <>, NATURAL RANGE <> )
OF VitalStateSymbolType;
CONSTANT VitalDefDelay01 : VitalDelayType01;
CONSTANT VitalDefDelay01Z : VitalDelayType01Z
FUNCTION VitalAND (
CONSTANT Data : IN std_logic_vector;
CONSTANT ResultMap : IN VitalResultMapType := VitalDefaultResultMap
) RETURN std_ulogic;
FUNCTION VitalOR (
CONSTANT Data : IN std_logic_vector;
CONSTANT ResultMap : IN VitalResultMapType := VitalDefaultResultMap
) RETURN std_ulogic;
FUNCTION VitalXOR (
CONSTANT Data : IN std_logic_vector;
CONSTANT ResultMap : IN VitalResultMapType := VitalDefaultResultMap
) RETURN std_ulogic;
FUNCTION VitalNAND (
CONSTANT Data : IN std_logic_vector;
CONSTANT ResultMap : IN VitalResultMapType := VitalDefaultResultMap
) RETURN std_ulogic;
FUNCTION VitalNOR (
CONSTANT Data : IN std_logic_vector;
CONSTANT ResultMap : IN VitalResultMapType := VitalDefaultResultMap
) RETURN std_ulogic;
FUNCTION VitalXNOR (
CONSTANT Data : IN std_logic_vector;
CONSTANT ResultMap : IN VitalResultMapType := VitalDefaultResultMap
) RETURN std_ulogic;
PROCEDURE VitalAND (
SIGNAL q : OUT std_ulogic;
SIGNAL Data : IN std_logic_vector;
CONSTANT tpd_data_q : IN VitalDelayArrayType01;
CONSTANT ResultMap : IN VitalResultMapType:= VitalDefaultResultMap );
PROCEDURE VitalOR (
SIGNAL q : OUT std_ulogic;
SIGNAL Data : IN std_logic_vector;
CONSTANT tpd_data_q : IN VitalDelayArrayType01;
CONSTANT ResultMap : IN VitalResultMapType:= VitalDefaultResultMap );
PROCEDURE VitalXOR (
SIGNAL q : OUT std_ulogic;
SIGNAL Data : IN std_logic_vector;
CONSTANT tpd_data_q : IN VitalDelayArrayType01;
CONSTANT ResultMap : IN VitalResultMapType:=VitalDefaultResultMap );
PROCEDURE VitalNAND (
SIGNAL q : OUT std_ulogic;
SIGNAL Data : IN std_logic_vector;
CONSTANT tpd_data_q : IN VitalDelayArrayType01;
CONSTANT ResultMap : IN VitalResultMapType:= VitalDefaultResultMap );
PROCEDURE VitalNOR (
SIGNAL q : OUT std_ulogic;
SIGNAL Data : IN std_logic_vector;
CONSTANT tpd_data_q : IN VitalDelayArrayType01;
CONSTANT ResultMap : IN VitalResultMapType := VitalDefaultResultMap
);
PROCEDURE VitalXNOR (
SIGNAL q : OUT std_ulogic;
SIGNAL Data : IN std_logic_vector;
Paquetages VITAL
-135-
crire & Comprendre VHDL & AMS J Rouillard 2008
Paquetages VITAL
-136-
crire & Comprendre VHDL & AMS J Rouillard 2008
FUNCTION VitalOR4 (
CONSTANT a, b, c, d : IN std_ulogic;
CONSTANT ResultMap : IN VitalResultMapType
:= VitalDefaultResultMap
) RETURN std_ulogic;
FUNCTION VitalXOR4 (
CONSTANT a, b, c, d : IN std_ulogic;
CONSTANT ResultMap : IN VitalResultMapType
:= VitalDefaultResultMap
) RETURN std_ulogic;
FUNCTION VitalNAND4 (
CONSTANT a, b, c, d : IN std_ulogic;
CONSTANT ResultMap : IN VitalResultMapType
:= VitalDefaultResultMap
) RETURN std_ulogic;
FUNCTION VitalNOR4 (
CONSTANT a, b, c, d : IN std_ulogic;
CONSTANT ResultMap : IN VitalResultMapType
:= VitalDefaultResultMap
) RETURN std_ulogic;
FUNCTION VitalXNOR4 (
CONSTANT a, b, c, d : IN std_ulogic;
CONSTANT ResultMap : IN VitalResultMapType
:= VitalDefaultResultMap
) RETURN std_ulogic;
PROCEDURE VitalAND2 (
SIGNAL q : OUT std_ulogic;
SIGNAL a, b : IN std_ulogic;
CONSTANT tpd_a_q : IN VitalDelayType01 := VitalDefDelay01;
CONSTANT tpd_b_q : IN VitalDelayType01 := VitalDefDelay01;
CONSTANT ResultMap : IN VitalResultMapType
:= VitalDefaultResultMap );
PROCEDURE VitalOR2 (
SIGNAL q : OUT std_ulogic;
SIGNAL a, b : IN std_ulogic;
CONSTANT tpd_a_q : IN VitalDelayType01 := VitalDefDelay01;
CONSTANT tpd_b_q : IN VitalDelayType01 := VitalDefDelay01;
CONSTANT ResultMap : IN VitalResultMapType
:= VitalDefaultResultMap );
PROCEDURE VitalXOR2 (
SIGNAL q : OUT std_ulogic;
SIGNAL a, b : IN std_ulogic;
CONSTANT tpd_a_q : IN VitalDelayType01 := VitalDefDelay01;
CONSTANT tpd_b_q : IN VitalDelayType01 := VitalDefDelay01;
CONSTANT ResultMap : IN VitalResultMapType
:= VitalDefaultResultMap );
PROCEDURE VitalNAND2 (
SIGNAL q : OUT std_ulogic;
SIGNAL a, b : IN std_ulogic;
CONSTANT tpd_a_q : IN VitalDelayType01 := VitalDefDelay01;
CONSTANT tpd_b_q : IN VitalDelayType01 := VitalDefDelay01;
CONSTANT ResultMap : IN VitalResultMapType
:= VitalDefaultResultMap );
PROCEDURE VitalNOR2 (
SIGNAL q : OUT std_ulogic;
SIGNAL a, b : IN std_ulogic;
CONSTANT tpd_a_q : IN VitalDelayType01 := VitalDefDelay01;
CONSTANT tpd_b_q : IN VitalDelayType01 := VitalDefDelay01;
CONSTANT ResultMap : IN VitalResultMapType
:= VitalDefaultResultMap );
PROCEDURE VitalXNOR2 (
SIGNAL q : OUT std_ulogic;
SIGNAL a, b : IN std_ulogic;
CONSTANT tpd_a_q : IN VitalDelayType01 := VitalDefDelay01;
CONSTANT tpd_b_q : IN VitalDelayType01 := VitalDefDelay01;
CONSTANT ResultMap : IN VitalResultMapType
:= VitalDefaultResultMap );
PROCEDURE VitalAND3 (
Paquetages VITAL
-137-
crire & Comprendre VHDL & AMS J Rouillard 2008
Paquetages VITAL
-138-
crire & Comprendre VHDL & AMS J Rouillard 2008
Paquetages VITAL
-139-
crire & Comprendre VHDL & AMS J Rouillard 2008
Paquetages VITAL
-140-
crire & Comprendre VHDL & AMS J Rouillard 2008
FUNCTION VitalMUX8 (
CONSTANT Data : IN std_logic_vector8;
CONSTANT dSelect : IN std_logic_vector3;
CONSTANT ResultMap : IN VitalResultMapType
:= VitalDefaultResultMap
) RETURN std_ulogic;
PROCEDURE VitalMUX (
SIGNAL q : OUT std_ulogic;
SIGNAL Data : IN std_logic_vector;
SIGNAL dSel : IN std_logic_vector;
CONSTANT tpd_data_q : IN VitalDelayArrayType01;
CONSTANT tpd_dsel_q : IN VitalDelayArrayType01;
CONSTANT ResultMap : IN VitalResultMapType
:= VitalDefaultResultMap );
PROCEDURE VitalMUX2 (
SIGNAL q : OUT std_ulogic;
SIGNAL d1, d0 : IN std_ulogic;
SIGNAL dSel : IN std_ulogic;
CONSTANT tpd_d1_q : IN VitalDelayType01 := VitalDefDelay01;
CONSTANT tpd_d0_q : IN VitalDelayType01 := VitalDefDelay01;
CONSTANT tpd_dsel_q : IN VitalDelayType01 := VitalDefDelay01;
CONSTANT ResultMap : IN VitalResultMapType
:= VitalDefaultResultMap );
PROCEDURE VitalMUX4 (
SIGNAL q : OUT std_ulogic;
SIGNAL Data : IN std_logic_vector4;
SIGNAL dSel : IN std_logic_vector2;
CONSTANT tpd_data_q : IN VitalDelayArrayType01;
CONSTANT tpd_dsel_q : IN VitalDelayArrayType01;
CONSTANT ResultMap : IN VitalResultMapType
:= VitalDefaultResultMap );
PROCEDURE VitalMUX8 (
SIGNAL q : OUT std_ulogic;
SIGNAL Data : IN std_logic_vector8;
SIGNAL dSel : IN std_logic_vector3;
CONSTANT tpd_data_q : IN VitalDelayArrayType01;
CONSTANT tpd_dsel_q : IN VitalDelayArrayType01;
CONSTANT ResultMap : IN VitalResultMapType
:= VitalDefaultResultMap );
FUNCTION VitalDECODER (
CONSTANT Data : IN std_logic_vector;
CONSTANT Enable : IN std_ulogic;
CONSTANT ResultMap : IN VitalResultMapType
:= VitalDefaultResultMap
) RETURN std_logic_vector;
FUNCTION VitalDECODER2 (
CONSTANT Data : IN std_ulogic;
CONSTANT Enable : IN std_ulogic;
CONSTANT ResultMap : IN VitalResultMapType
:= VitalDefaultResultMap
) RETURN std_logic_vector2;
FUNCTION VitalDECODER4 (
CONSTANT Data : IN std_logic_vector2;
CONSTANT Enable : IN std_ulogic;
CONSTANT ResultMap : IN VitalResultMapType
:= VitalDefaultResultMap
) RETURN std_logic_vector4;
FUNCTION VitalDECODER8 (
CONSTANT Data : IN std_logic_vector3;
CONSTANT Enable : IN std_ulogic;
CONSTANT ResultMap : IN VitalResultMapType
:= VitalDefaultResultMap
) RETURN std_logic_vector8;
PROCEDURE VitalDECODER (
SIGNAL q : OUT std_logic_vector;
SIGNAL Data : IN std_logic_vector;
SIGNAL Enable : IN std_ulogic;
CONSTANT tpd_data_q : IN VitalDelayArrayType01;
Paquetages VITAL
-141-
crire & Comprendre VHDL & AMS J Rouillard 2008
Paquetages VITAL
-142-
crire & Comprendre VHDL & AMS J Rouillard 2008
12.3.4 VITAL_MEMORY
LIBRARY IEEE;USE IEEE.STD_LOGIC_1164.ALL;
LIBRARY vital2000 USE vital2000.Vital_Timing.ALL;USE
vital2000.Vital_Primitives.ALL;
LIBRARY STD; USE STD.TEXTIO.ALL;
PACKAGE Vital_Memory IS
TYPE VitalMemoryArcType IS (ParallelArc, CrossArc, SubwordArc);
TYPE OutputRetainBehaviorType IS (BitCorrupt, WordCorrupt);
TYPE VitalMemoryMsgFormatType IS (Vector, Scalar, VectorEnum);
TYPE X01ArrayT IS ARRAY (NATURAL RANGE <> ) OF X01;
TYPE X01ArrayPT IS ACCESS X01ArrayT;
TYPE VitalMemoryViolationType IS ACCESS X01ArrayT;
CONSTANT DefaultNumBitsPerSubword : INTEGER := -1;
ATTRIBUTE VITAL_Level1_Memory : BOOLEAN;
TYPE VitalMemoryScheduleDataType IS RECORD
OutputData : std_ulogic;
NumBitsPerSubWord : INTEGER;
ScheduleTime : TIME;
ScheduleValue : std_ulogic;
LastOutputValue : std_ulogic;
PropDelay : TIME;
OutputRetainDelay : TIME;
InputAge : TIME;
END RECORD;
TYPE VitalMemoryTimingDataType IS RECORD
NotFirstFlag : BOOLEAN;
RefLast : X01;
RefTime : TIME;
HoldEn : BOOLEAN;
TestLast : std_ulogic;
TestTime : TIME;
SetupEn : BOOLEAN;
TestLastA : VitalLogicArrayPT;
TestTimeA : VitalTimeArrayPT;
RefLastA : X01ArrayPT;
RefTimeA : VitalTimeArrayPT;
HoldEnA : VitalBoolArrayPT;
SetupEnA : VitalBoolArrayPT;
END RECORD;
TYPE VitalPeriodDataArrayType IS ARRAY (NATURAL RANGE <>) OF
VitalPeriodDataType;
TYPE VitalMemoryScheduleDataVectorType IS ARRAY (NATURAL RANGE <> ) OF
VitalMemoryScheduleDataType;
TYPE VitalPortStateType IS (UNDEF, READ, WRITE, CORRUPT, HIGHZ);
TYPE VitalPortFlagType IS RECORD
MemoryCurrent : VitalPortStateType;
MemoryPrevious : VitalPortStateType;
DataCurrent : VitalPortStateType;
DataPrevious : VitalPortStateType;
OutputDisable : BOOLEAN;
END RECORD;
CONSTANT VitalDefaultPortFlag : VitalPortFlagType := (
MemoryCurrent => READ,
MemoryPrevious => UNDEF,
DataCurrent => READ,
DataPrevious => UNDEF,
OutputDisable => FALSE);
TYPE VitalPortFlagVectorType IS
ARRAY (NATURAL RANGE <>) OF VitalPortFlagType;
PROCEDURE VitalMemoryInitPathDelay (
VARIABLE ScheduleDataArray : INOUT VitalMemoryScheduleDataVectorType;
VARIABLE OutputDataArray : IN STD_LOGIC_VECTOR;
CONSTANT NumBitsPerSubWord : IN INTEGER := DefaultNumBitsPerSubword);
PROCEDURE VitalMemoryInitPathDelay (
Paquetages VITAL
-143-
crire & Comprendre VHDL & AMS J Rouillard 2008
Paquetages VITAL
-144-
crire & Comprendre VHDL & AMS J Rouillard 2008
Paquetages VITAL
-145-
crire & Comprendre VHDL & AMS J Rouillard 2008
Paquetages VITAL
-146-
crire & Comprendre VHDL & AMS J Rouillard 2008
Paquetages VITAL
-147-
crire & Comprendre VHDL & AMS J Rouillard 2008
Paquetages VITAL
-148-
crire & Comprendre VHDL & AMS J Rouillard 2008
Paquetages VITAL
-149-
crire & Comprendre VHDL & AMS J Rouillard 2008
Paquetages VITAL
-150-
crire & Comprendre VHDL & AMS J Rouillard 2008
Paquetages VITAL
-151-
crire & Comprendre VHDL & AMS J Rouillard 2008
Paquetages VITAL
-152-
crire & Comprendre VHDL & AMS J Rouillard 2008
12.4 Analogique
12.4.1 [AMS]IEEE.FUNDAMENTAL_CONSTANTS
library IEEE; use IEEE.MATH_REAL.all;
package FUNDAMENTAL_CONSTANTS is
-- some declarations
attribute SYMBOL : STRING;
attribute UNIT : STRING;
-- PHYSICAL CONSTANTS
-- electron charge <COULOMB>
-- NIST value: 1.602 176 462e-19 coulomb
-- uncertainty: 0.000 000 063e-19
constant PHYS_Q : REAL := 1.602_176_462e-19;
-- permittivity of vacuum <FARADS/METER>
-- NIST value: 8.854 187 817e-12 farads/meter
-- uncertainty: exact
constant PHYS_EPS0 : REAL := 8.854_187_817e-12;
-- permeability of vacuum <HENRIES/METER>
-- NIST value: 4e-7*pi henries/meter
-- uncertainty: exact
constant PHYS_MU0 : REAL := 4.0e-7 * MATH_PI;
-- Boltzmann's constant <JOULES/KELVIN>
-- NIST value: 1.380 6503e-23 joules/kelvin
-- uncertainty: 0.000 0024e-23:
constant PHYS_K : REAL := 1.380_6503e-23;
-- Acceleration due to gravity <METERS/SECOND_SQUARED>
-- NIST value: 9.806 65 meters/square second
-- uncertainty: exact
constant PHYS_GRAVITY : REAL := 9.806_65;
-- Conversion between Kelvin and degree Celsius
-- NIST value: 273.15
-- uncertainty: exact
constant PHYS_CTOK : REAL := 273.15;
-- object declarations
-- common scaling factors
constant YOCTO : REAL := 1.0e-24;
constant ZEPTO : REAL := 1.0e-21;
constant ATTO : REAL := 1.0e-18;
constant FEMTO : REAL := 1.0e-15;
constant PICO : REAL := 1.0e-12;
constant NANO : REAL := 1.0e-9;
constant MICRO : REAL := 1.0e-6;
constant MILLI : REAL := 1.0e-3;
constant CENTI : REAL := 1.0e-2;
constant DECI : REAL := 1.0e-1;
constant DEKA : REAL := 1.0e+1;
constant HECTO : REAL := 1.0e+2;
constant KILO : REAL := 1.0e+3;
constant MEGA : REAL := 1.0e+6;
constant GIGA : REAL := 1.0e+9;
constant TERA : REAL := 1.0e+12;
constant PETA : REAL := 1.0e+15;
constant EXA : REAL := 1.0e+18;
constant ZETTA : REAL := 1.0e+21;
constant YOTTA : REAL := 1.0e+24;
alias DECA is DEKA;
end package FUNDAMENTAL_CONSTANTS;
Paquetages VITAL
-153-
crire & Comprendre VHDL & AMS J Rouillard 2008
library IEEE;
use IEEE.FUNDAMENTAL_CONSTANTS.all;
package ELECTRICAL_SYSTEMS is
subtype VOLTAGE is REAL tolerance "DEFAULT_VOLTAGE";
subtype CURRENT is REAL tolerance "DEFAULT_CURRENT";
subtype CHARGE is REAL tolerance "DEFAULT_CHARGE";
subtype RESISTANCE is REAL tolerance "DEFAULT_RESISTANCE";
subtype CAPACITANCE is REAL tolerance "DEFAULT_CAPACITANCE";
subtype MMF is REAL tolerance "DEFAULT_MMF";
subtype FLUX is REAL tolerance "DEFAULT_FLUX";
subtype INDUCTANCE is REAL tolerance "DEFAULT_INDUCTANCE";
-- attribute declarations
-- Use of UNIT to designate units
attribute UNIT of VOLTAGE : subtype is "Volt";
attribute UNIT of CURRENT : subtype is "Ampere";
attribute UNIT of CHARGE : subtype is "Coulomb";
attribute UNIT of RESISTANCE : subtype is "Ohm";
attribute UNIT of CAPACITANCE : subtype is "Farad";
Paquetages VITAL
-154-
crire & Comprendre VHDL & AMS J Rouillard 2008
Paquetages VITAL
-155-
crire & Comprendre VHDL & AMS J Rouillard 2008
1 CLS DE CE MANUEL
2 QUOI, O, ZONES DCLARATIVES, ZONES DINSTRUCTIONS
3 ENVIRONNEMENT, BIBLIOTHQUES
4 HIRARCHIE ET STRUCTURE
5 MODLISATION DE BIBLIOTHQUES - VITAL
6 SYSTME
7 COMPORTEMENTAL
8 SYNCHRONE
9 ASYNCHRONE
10 SWITCH
13 Index 11 ANALOGIQUE
12 RFRENCES
13
14 TABLE DES FIGURES
15 BIBLIOGRAPHIE
A D
Acclrateurs hardware 40 D (bascule) 79
Affectation conditionnelle 87 Data-flow 87
Affectation slecte 88 Dclaration dentit 17
Affectation simple 87 Dclaration de configuration 19
Agrgat (rom ) 60 Dclaration de paquetage 19
Alatoires (gnrateur de squences pseudo-) 83 Dfaut (valeur par, ports) 33
Amplificateur oprationnel idal 107 Diode 106
Analogique 102 Disciplines 28
Appel concurrent de procdure 89 Disciplines.electrical_systems 28
Arguments (de sous-programmes) 24 Disciplines.energy_systems 28
Asynchrone 87 Disciplines.fluidic_systems 28
Disciplines.mechanical_systems 28
Disciplines.radiant_systems 28
B Disciplines.thermal_systems 28
Domain 104
Drapeau hdlc 55
Bascule d 79
Drapeau hdlc 69
Bascule jk 81
Bascule rs 80
Bascules 79
Bibliographie 163 E
Bibliothques 27
Bloc 20 Electrical_systems 28
Blocs gards 39 Encodeur de priorit 87
Energy_systems 28
Environnement 27
C Ethernet 49
Capacit 103
Changer le type (d'un port) 34 F
Chose compilable en tant que telle 17, 18, 19
Cls 7 Fichier (rom ) 60
Codage 77 Flot-de-donnes 87
Combinatoire synchronis 81 Fluidic_systems 28
Comparateur 112 Fonction 25
Comportemental 57 Fonction de rsolution 50
Comportemental synthtisable 68 Forage (des ports) 33
Conversion parallle srie 68 Fundamental_constants 28
Convertisseur analogique-digital 111
Convertisseur digital/analogique 109
Convertisseur digital-analogique 111 G
Corps darchitecture 18
Corps de paquetage 19
Gards (blocs) 39
Gnrateur de squences pseudo-alatoires 83
Gnration 35
Generic map 20
Gnricit 29
Index
-157-
crire & Comprendre VHDL & AMS J Rouillard 2008
Gnriques 35
Gnriques et gnration 35
N
Grande ram 58
Nrz 55, 90
H
O
Handshake 89
Hdlc 69 Open 33
Hirarchie 29 Ordre des ports 32
Hirarchie rcursive 36 Ou exclusif (en switch) 97
I P
Ieee 27 Parallle srie 68
Ieee.fundamental_constants 28 Partage (variable) 51
Ieee.material_constants 28 Port map 20
Ieee.math_complex 28 Ports 31
Ieee.math_real 28, 126 Ports (ordre) 32
Ieee.std_logic_1164 27, 121 Priorit (encodeur) 87
Ieee.std_logic_arith 28, 123 Procedural 22
Ieee.std_logic_signed 28 Procdure 24
Ieee.std_logic_textio 28 Procdure (appel concurrent) 89
Ieee.std_logic_unsigned 28 Processus 21
Insertion de zros 55 Protocole 49, 89
Instructions dclarations locales 20 Protocole 52
Interrupteur 106 Pseudo-alatoire 51
Pseudo-alatoires (gnrateur de squences) 83
J
R
Jk (bascule) 81
Radiant_systems 28
Ram 57
Ram (trs grande) 58
L Reconstitution dun signal cod nrz 90
Rcursivit (hirarchique) 36
Laisser ouvert (un port) 33 Rseau r/2r 109
Logique deux tats 13 Rsistance 102
Logique neuf tats 13 Rsistance thermique 103
Logique quarante six tats 13 Rsolution (fonction de) 50
Logique quatre tats 13 Return 25
Logique six tats 13 Rom 59
Rom agrgat 60
Rom fichier 60
M Rs (bascule) 80
Machine de mealy 74
Machine de mealy synchronise 76 S
Machine de medvedev 74
Machine de moore 72 Slecte (affectation) 88
Machines d'tats 72 Self 104
Material_constants 28 Squences pseudo-alatoires (gnrateur de) 83
Math_complex 28 Source de courant 105
Math_real 28, 126 Source de tension 105
Mealy (machine de) 74 Sous-programmes 23
Mealy synchronise (machine de) 76 Standard 27, 117
Mechanical_systems 28 Std 27
Medvedev (machine de) 74 Std.standard 27, 117
Modle mcanique 108 Std.textio 119
Modlisation mixte 109 Std_logic_ 1164 14
Moniteur 23 Std_logic_1164 27, 121
Moore (machine de) 72 Std_logic_arith 28, 123
Multiplexeur 88 Std_logic_signed 28
Index
-158-
crire & Comprendre VHDL & AMS J Rouillard 2008
Std_logic_textio 28
Std_logic_unsigned 28
V
Structure 29
Switch 95 Variables partages 51
Synchrone 79 Vhdl 1076-1987 10
Synchronis (combinatoire) 81 Vhdl 1076-1991 10
Synthtisable 68 Vhdl 1076-1993 10
Systme 49 Vhdl 1076-2000 11
Vhdl 1076-2002 11
Vhdl 1076-2008 11
Vhdl 7.2 10
T Vhdl-ams 1076.1-1999 11
Vhdl-ams 1076.1-2007 11
Tac-tac 108 Vital 117
Textio 119
Thermal_systems 28
Transmetteurs 49
Trs grande ram 58
W
Type protg 23
Work 27
U
Units de compilation 17
Index
-159-
crire & Comprendre VHDL & AMS J Rouillard 2008
1 CLS DE CE MANUEL
2 QUOI, O, ZONES DCLARATIVES, ZONES DINSTRUCTIONS
3 ENVIRONNEMENT, BIBLIOTHQUES
4 HIRARCHIE ET STRUCTURE
5 MODLISATION DE BIBLIOTHQUES - VITAL
6 SYSTME
14 Tables des figures 7 COMPORTEMENTAL
8 SYNCHRONE
9 ASYNCHRONE
10 SWITCH
11 ANALOGIQUE
12 RFRENCES
13 INDEX
14
15 BIBLIOGRAPHIE
LE SIGN-OFF ............................................................................................................................................................................... 9
CONTENU D'UNE ENTIT ............................................................................................................................................................. 17
CONTENU D'UNE ARCHITECTURE ................................................................................................................................................ 18
CONTENU D'UNE DCLARATION DE PAQUETAGE.......................................................................................................................... 19
CONTENU D'UN CORPS DE PAQUETAGE........................................................................................................................................ 19
CONTENU D'UNE DCLARATION DE CONFIGURATION ................................................................................................................... 20
CONTENU D'UN BLOC ................................................................................................................................................................. 21
CONTENU D'UN PROCESSUS ........................................................................................................................................................ 22
CONTENU D'UN PROCEDURAL ..................................................................................................................................................... 22
CONTENU D'UN TYPE PROTG ................................................................................................................................................... 23
CONTENU D'UNE PROCDURE ..................................................................................................................................................... 24
CONTENU D'UNE FONCTION ........................................................................................................................................................ 25
L'INSTANCE DU COMPOSANT ET SA CONFIGURATION AVEC UNE ENTIT DEMANDENT DEUX PORT MAP ET DEUX GENERIC MAP
....................................................................................................................................................................................... 29
CONNEXION EN CHANGEANT LA NUMROTATION DES PORTS ....................................................................................................... 32
UN ADDITIONNEUR N BITS ......................................................................................................................................................... 35
INSTANCES RCURSIVES ............................................................................................................................................................. 36
SCHMA D'UN MODLE VITAL.................................................................................................................................................. 40
UN RSEAU CSMA.................................................................................................................................................................... 49
EXEMPLE DE FICHIER AU FORMAT INTEL .................................................................................................................................. 62
SRIALISATEUR ......................................................................................................................................................................... 68
INSERTION ET DESTRUCTION DE ZROS ....................................................................................................................................... 69
MACHINE DE MOORE DEUX TATS .......................................................................................................................................... 72
MACHINE DE MOORE ................................................................................................................................................................. 73
CHRONOGRAMMES DE LA MACHINE DE MOORE .......................................................................................................................... 74
MACHINE DE MEALY DEUX TATS .......................................................................................................................................... 74
MACHINE DE MEALY ................................................................................................................................................................. 75
CHRONOGRAMMES DE LA MACHINE DE MEALY .......................................................................................................................... 76
ALAS SUR LA MACHINE DE MEALY ........................................................................................................................................... 76
MACHINE DE MEALY SYNCHRONISE ........................................................................................................................................ 76
BASCULE D ............................................................................................................................................................................... 79
LATCH ....................................................................................................................................................................................... 80
BASCULE RS ............................................................................................................................................................................. 80
BASCULE JK.............................................................................................................................................................................. 81
CHRONOGRAMMES D'UN COMPTEUR ASYNCHRONE IDAL ........................................................................................................... 82
CHRONOGRAMMES D'UN COMPTEUR ASYNCHRONE REL............................................................................................................. 82
CHRONOGRAMMES APRS SYNCHRONISATION ............................................................................................................................ 83
SCHMA BLOC D'UN GNRATEUR DE SQUENCE PSEUDO-ALATOIRE ......................................................................................... 83
CHRONOGRAMMES D'UN BLOC GARD AVEC DEUX AFFECTATIONS GARDES ............................................................................... 86
ENCODEUR DE PRIORIT ............................................................................................................................................................. 87
MULTIPLEXEUR ......................................................................................................................................................................... 88
HANDSHAKE .............................................................................................................................................................................. 89
CODAGE NRZ ........................................................................................................................................................................... 90
RECONSTITUTION DE LHORLOGE ............................................................................................................................................... 92
DCODAGE NRZ ....................................................................................................................................................................... 92
UNE PORTE NAND EN MOS...................................................................................................................................................... 95
UNE PORTE XOR EN MOS......................................................................................................................................................... 97
CHRONOGRAMMES DE L'ABSCISSE DES BOULES D'UN "TAC-TAC".............................................................................................. 109
RSEAU R/2R.......................................................................................................................................................................... 109
CONVERTISSEUR ANALOGIQUE/DIGITAL .................................................................................................................................. 112
CONVERGENCE DE LA CONVERSION A/D PAR ESSAIS SUCCESSIFS .............................................................................................. 115
[ASH1] The VHDL Cookbook (anglais), une bonne et brve introduction VHDL'87
Peter Ashenden
http://tams-www.informatik.uni-hamburg.de/vhdl/
doc/cookbook/VHDL-Cookbook.pdf
[ROU2] Aide Mmoire VHDL, une version pdf de celui qui est la fin de ce manuel.
Jacques Rouillard
http://www.rouillard.org/memovhdl.pdf
[TUT] L'excellent tutorial sur VHDL-AMS sur le site de rfrence [HAM] (anglais):
Ernst Christen, Kenneth Bakalar, Allen M. Dewey, Eduard Moser
http://tams-www.informatik.uni-hamburg.de/vhdl/doc/P1076.1/tutdac99.pdf
Bibliographie
-164-
Cet aide-mmoire peut tre dcoup ou photocopi, et agraf. Une version
lectronique pdf se trouve sur http://rouillard.org/memovhdl.pdf
J Rouillard 2008
Aide-mmoire VHDL
Jacques Rouillard 2007- 2008
Les types
Types numriques : integer, real, on se sert essentiellement des types prdfinis.
Types numrs Attributs sur types scalaires ou tableaux
type enum1 is (un, deux); T'HIGH borne max ou THIGH(dimension)
T'LOW borne min - idem
type enum2 is ('0', '1');
T'LEFT borne de gauche -- idem
type enum3 is ('B', bla, bli );
T'RIGHT borne de droite
Types structurs T'RANGE = XLEFT [down]to XRIGHT
Tableaux T'REVERSE_RANGE XRIGHT [down]to XLEFT
o type tableau is array (1 to 10) of integer; enum1POS(un) = 0
o type tableau is array (character) of bit; enum2VAL(1) = 1
o type tableau is array (10 downto 0, bit) of float;
Enregistrements
o type enreg is record a: integer; b: character; end record;
Types physiques: utilis pratiquement seulement avec TIME qui est prdfini.
Types accs La surcharge sur types numrs (voir aussi les sous-
type pointeur is access enreg; programmes page 5):
Types fichiers type enum1 is (un, deux);signal X1:enum1;
type enum2 is (bla, un); signal X2:enum2;
type text is file of string;
[AMS] Natures: voir page 6. X1 <= un; X2 <= un; --mais pas X1<=X2 !
Les objets enum1pos(un) vaut 0 et enum2pos(un) = 1
Constantes : smantique triviale : constant C : integer := 3 ;
Fichiers : smantique triviale sauf quon ne devrait ni les ouvrir (cela peut tre fait la
dclaration) ni les fermer (pour interdire la communication inter-process) : file F : text ;
Variables : dclares et utilises seulement dans les process et les sous-programmes (sauf
variables partages, ne pas utiliser hors conception niveau systme). Ont la mme smantique
que dans un langage de programmation. Peuvent tre de nimporte quel type. variable V :
le_type ;
Signaux : dclars dans toute zone concurrente (architecture, dclaration de paquetage) et utiliss
partout, y compris dans les process. Peuvent tre de tout type sauf accs et fichier. Peuvent tre
des port sils servent communiquer entre entits.
S<=valeur1; signal S : le_type ; ou port ( P : in le_type )
Leur smantique est diffrente de la variable : laffectation de signal (S <= valeur) na pas deffet
S<=valeur2; observable instantanment. La valeur est enfile dans un driver (il y a un driver par signal et par
process ou process quivalent) et prvue pour apparatre dans le futur, au plus tt un delta (un
cycle de simulation) plus tard. Quand la mise jour se fait, tous les drivers proposant une valeur
pour ce signal l cette
S'EVENT , boolean, S a chang de valeur
date l sont rsolus 14 S'ACTIVE boolean, S a t affect
et cest cette rsolution S'LAST_EVENT time, date du dernier vnement
qui devient la valeur S'LAST_ACTIVE time, date dernire affectation
15 S'LAST_VALUE avant dernire valeur En italique : rendent
observable . Voir le
X<=S; S'DELAYED(t) copie de S dcale des signaux.
cycle de simulation, page S'STABLE(t) boolean, S a t stable pendant t
5 S'QUIET(t) boolean, pas t affect pendant t
[AMS] terminaux: voir S'TRANSACTION boolean, bascule chaque affectation
page 6.
[AMS] quantits: voir page 6.
14
Cest l que les signaux forts lemportent sur les faibles ou que les conflits sont dtects. Voir le paquetage
STD_LOGIC_1164, section paquetages standards.
15
Avec pour consquence quon nobserve jamais dans le mme cycle la valeur quon vient de proposer.
VHDL en 12 pages - Jacques Rouillard 2007- 2008
-2 -
VHDL en 12 pages - Jacques Rouillard 2007- 2008
Les architectures peuvent tre en source ou en binaire, cela na pas dimportance pour ce qui est de
lutilisation. Faisons un XNOR (avec le NOT et le XOR).
Lentit appelante contient plusieurs zones : la dclaration de composants (les supports destins recevoir
les entits), la configuration (qui dit quelle entit va sur quel composant) et les instances (l o les
composants sont effectivement poss et connects.) On a besoin dun signal interne pour connecter les
deux botes.
library ressources_lib ;
architecture structure of XnorGate is
signal interne: std_logic; -- un signal pour connecter les deux portes.
-- dclaration des composants
component XorComp port(E1,E2:in std_logic;S: out std_logic);end component;
component NotComp port (E : in std_logic;S :out std_logic); end component;
-- configurations
for all: XorComp use entity ressources_lib.XorGate;16
for all: NotComp use entity ressources_lib.NotGate;
begin
-- instances
XnorInstance: XorComp port map (E1, E2, interne);
NotInstance : NotComp port map (interne, S) ;
end;
16
La configuration peut tre simple comme ici (simplement renvoyer une entit existante) ou encore spcifier de quelle
architecture on parle sil y en a plusieurs, et enfin dire explicitement quel port du composant correspond quel port de lentit.
Une forme plus complte (hors gnricit) est :
for ref-des-composants: nom-du-composant
use entity ressources_lib.entit(architecture)
port map (port-du-composant => port-de-lentit,)16
ref-des-composants peut tre le nom du label, une liste, ou others, ou all.
-3 -
VHDL en 12 pages - Jacques Rouillard 2007- 2008
Squentiel synchrone, machines dtat : il sagit ici de faire de la logique tat. Un tat peut
tre reprsent comme un lment de type numr. Par exemple si on veut dterminer si une entre
contient la squence 001 :
type type_etat is (debut,
il_y_a_eu_un_0,
il_y_a_eu_deux_0, bingo) ;
signal etat : type_etat :=
debut ;
comb: process(etat,entree)
begin
case etat is
when debut => marqueur<=0 ;
if entre=0 then etat_suivant<= il_y_a_eu_un_0;end if ;
when il_y_a_eu_un_0=> marqueur<=0 ;
if entree =0 then etat_suivant<=l_y_a_eu_deux_0; sync: process(ck, reset)
else etat_suivant <= debut ; end if ; begin
when il_y_a_eu_deux_0=> marqueur<=0 ; if reset=1 then
if entree =1 then etat_suivant <= bingo ; etat<=debut;
marqueur<=1 (si Mealy) ; end if ; elsif ckevent and ck=1
when bingo => marqueur<=1; then
if entree = 0 then etat<=etat_suivant;
etat_suivant <= end if;
il_y_a_eu_un_0; end process ;
else etat_suivant <=
debut; end if;
end case; CLK
end process;
entree
Pour la Simulation:
chaque front dhorloge, Debut un 0 debut un 0 deux 0 bingo debut un 0 tat
lentre est lue par la branche
correspondante du case; le marqueur
marqueur est mis 1 ou 0, et
ltat suivant est calcul.
Pour la Synthse : ici une synthse la main et en VHDL, sans aucune optimisation. Ltat va tre
cod (ici sur 2 bits, le codage est optimisable). 00=dbut, 01= etc.
-4 -
VHDL en 12 pages - Jacques Rouillard 2007- 2008
-5 -
VHDL en 12 pages - Jacques Rouillard 2007- 2008
Les quantits se dclarent aux mmes endroits quantity V across I1,I2 through T1 to T2;
-- V est la tension entre T1 et T2
que les signaux. Elles peuvent tre des ports de -- I1&I2 deux branches de courant parallles.
composants et d'entits.
Les instructions simultanes: se mettent en zone concurrente (comme les process)
quation simple: [label:] expression == expression; -- doit contenir au moins une quantit.
Instruction conditionnelle: [label:] if condition use {instructions simultanes}
{elsif condition use {instructions simultanes}}
[else {instructions simultanes}]end use [label];
Instruction slective: [label:] case slecteur use
{when choixx =>{instructions simultanes}}
end case [label];
Procdural: [label:] procedural begin
{instructions squentielles sauf wait et break
les quantits y sont vues comme des variables}
end procedural [label];
break on instruction concurrente avec quivalence
break for Q1 use Q2 => expression
squentielle, indispensable pour dire au noyau qu'une on S when condition;
discontinuit ncessite un recalcul des conditions "initiales".
Condition de solvabilit: La somme des quantits libres, des quantits de mode out et des quantits
through d'une unit doit tre gale au nombre d'quations (ou quations quivalentes). Ceci est une
condition ncessaire, mais ne garantit videmment pas la convergence.
-6 -
VHDL en 12 pages - Jacques Rouillard 2007- 2008
o Les units de compilation (design units) sont les portions de texte que lon peut
compiler et stocker en bibliothque. Les entits entity- (spcifications), les
architectures (implmentations), dclarations de paquetages package- (jeu de
ressources partageables) et implmentation de paquetage, les configurations
(isolement de toute linformation de configuration dun modle).
o Clause with : les bibliothques sont, pour le programmeur, des noms. Le lien
avec le systme de fichiers nest pas dans le langage. On appelle une bibliothque
par la clause with lib ; placer en tte dunit (avant les mots entity,
architecture, etc.). Ds quune bibliothque est rfrence, tous les noms qui sont
dedans sont visibles par la notation pointe : lib.entite ou lib.pack.objet.
o Clause use : on peut factoriser un prfixe trop encombrant crire, sous rserve
que cela ne cre pas dambiguts. La clause use prefixe.all ; peut tre mise
nimporte o dans une zone dclarative. En dessous, les objets dj visibles (et
seulement ceux-l) par la notation prefixe.objet deviennent visibles directement
(sauf conflit). use prefixe.objet ; moins utile, ne rend directement visible que
lobjet.
o Bibliothques par dfaut et standardises : il y a deux
bibliothques par dfaut (STD, WORK) et beaucoup de bibliothques trs utiles et
standardises : ex. IEEE qui contient IEEE.STD_LOGIC_1164. Voir page 8.
Chaque unit est prfixe doffice et par dfaut avec : with STD ; use
STD.STANDARD.all ; with WORK ; Pour VHDL-AMS, la bibliothque
DISCIPLINES contient tous les paquetages des diffrents domaines physiques:
electrical, mecanical, thermal, etc.
o Chaque entit peut avoir plusieurs architectures. Cest pourquoi celles-ci ont
un nom. Quand on veut simuler ou synthtiser, il faut dire quelle couple
entit/architecture ; au niveau de loutil (simulateur par ex.) cela dpend de
linterface. Dans le texte lui-mme, lors des configurations, la notation est : entite(archi).
o Les configurations : cest le moyen, dans une description structurelle, de dire chaque niveau de
hirarchie quelle couple entit/architecture on instancie. On utilise pour cela une
clause for X : composant use entity ent(arch) qui permet de passer
des arguments gnriques ou une association des ports (voir description
structurelle.) Une unit de configuration, compilable telle quelle, permet de
rassembler toutes les clauses de configuration dun modle en un seul fichier.
o La gnricit : paramtrise un modle. On lannonce lors des dclarations
dentit ou de composant : entity E is generic (X:integer) ;port();
end;. On indique sa valeur avant la simulation ou synthse, par un generic
map. for X :composant use entity ent(arch)generic map(3)
o La gnration : permet de crer du code rptitif ou
conditionnel, par programme. Cest du code qui sera
excut avant la simulation. Uniquement en zone concurrente (pas dans un
process).
if condition generate (instructions) end generate ;--pas de else.
for I in 1 to 10 generate (instructions) end generate;
Dans ce dernier cas, lindice I peut tre utilis dans les instructions pour indexer
des tableaux et construire des circuits complexes ; les bornes (ici 1 et 10) peuvent
venir dun argument gnrique. Attention ! on a vite fait davoir tellement de
combinaisons possibles que le circuit effectivement construit a de bonnes
chances de navoir jamais t test.
-7 -
VHDL en 12 pages - Jacques Rouillard 2007- 2008
Les paquetages standard : lenvironnement de base permettant de compiler est dans un jeu de
paquetages dont la visibilit est assure par dfaut (pas besoin de clause with).
STD.STANDARD : tous les types indispensables, comme INTEGER, BIT etc.
STD.TEXTIO : contient un jeu de primitives assez rustique, permettant de faire des entres sorties
textuelles sur fichier. Il faut lire ligne ligne des chanes de caractres (READLINE), puis on exploite
cette chane par dautres primitives de traitement de chane appeles READ. noter un
STD_LOGIC_TEXTIO qui nest pas standard mais bien commode.
Les paquetages IEEE : pour rendre VHDL plus utilisable, un jeu de paquetages ont t
standardiss. Ils sont distribus avec toutes les implmentations et sont compris par les outils de synthse.
Lorganisme normalisateur est IEEE ; certains paquetages dusage courant ne sont toutefois pas
standardiss bien qutant souvent placs dans la bibliothque IEEE..
IEEE.STD_LOGIC_1164 : cest le plus important de tous : bien des concepteurs ne se servent
jamais du type BIT dfini dans STD.STANDARD. Il fournit un type logique 9 valeurs : 'U' 'X'
'0' '1' 'Z' 'W' 'L' 'H' ' -' U pour uninitialized, valeur par dfaut dpose au dbut des simulations et
permettant de reprer les signaux qui nont pas t initialiss au bout dun temps raisonnable. Deux
systmes logiques (fort : 01X et faible :LHW low, high, weak conflict) permettent de grer les
forces : en cas de conflit entre un faible et un fort, cest le fort qui gagne, voir signaux page
165. On peut ainsi modliser des systmes drain ouvert par exemple. 0/L et
1/H ont le sens logique usuel. X/W signifient conflit . Z est la haute UX01ZWLH-
U UUUUUUUUU
impdance, pour un bus que personne ne prend par exemple. Le '-' veut dire X UXXXXXXXX
0 UX0X0000X
dont care et ne sert quen synthse pour permettre de ne pas sur-spcifier 1 UXX11111X
Z UX01ZWLHX
et laisser le synthtiseur optimiser (inversement, les valeurs UXW ne servent W UX01WWWWX
L UX01LWLWX
quau simulateur, on ne va pas spcifier un conflit). H UX01HWWHX
- UXXXXXXXX
IEEE.STD_LOGIC_ARITH : permet de faire de larithmtique sur
std_logic_vector Pour cela il fournit deux types signed et unsigned qui ont la mme dfinition
que std_logic_vector : array (natural range <>) of std_logic . Suivant la dfinition
des compatibilits de types en VHDL, tout std_logic_vector peut tre converti explicitement en
signed ou en unsigned. Les oprateurs arithmtiques sont ensuite dfinis dessus (et entre eux). On
peut ainsi crire des expressions comme signed (V1) + unsigned (V2). Attention ce que ceci
sera synthtis (les outils reconnaissent les paquetages standard) et que laddition nest pas gratuite.
Un paquetage NUMERIC_BIT, moins utilis, fait la mme chose sur bit_vector. Si on ne veut faire
que de larithmtique signe ou non-signe, deux autres paquetages non standardiss existent aussi
qui nobligent pas changer le type avant les opration : STD_LOGIC_SIGNED et
STD_LOGIC_UNSIGNED. On ne peut utiliser directement (avec une clause use) quun des deux
la fois.
IEEE.MATH_REAL et MATH_COMPLEX : permettent davoir les fonctions mathmatiques sur
entiers et rels.
IEEE.VITAL : (Vhdl Initiative Towards Asic Libraries). Cest un ensemble de paquetages
VITAL_TIMING,VITAL_PRIMITIVES et autres- permettant de dcrire les fonctions logiques de
bibliothques avec des primitives standard, en repoussant lextrieur du modle les questions
temporelles. Ainsi le mme modle peut tre simul logiquement et valid sans les dlais, puis
synthtis de telle sorte que les dlais obtenus par la synthse puissent tre rinjects dans le modle
initial sans avoir lditer. Un format (SDF) permet cette rtro-annotation qui peut aussi tre faite par
configuration.
Les paquetages DISCIPLINES : pour VHDL-AMS, dfinissent les natures, constantes et attributs
des diffrents domaines physiques: electrical, mechanical, thermal, etc. Ils utilisent deux paquetages de
ressources: IEEE.FUNDAMENTAL_CONSTANTS et IEEE.MATERIAL_CONSTANTS.
-8 -
VHDL en 12 pages - Jacques Rouillard 2007- 2008
rgler
Pas ok
Fondeur
-9 -
VHDL en 12 pages - Jacques Rouillard 2007- 2008
Difficults:
Lassociation : chaque fois quil faut passer des arguments rels des arguments formels. Si la
dclaration a la forme :
port (A,B,C : STD_LOGIC) ; -- (mme chose avec les arguments de sous-programmes)
Lassociation peut se faire
par position : port map (X,Y,Z) X va sur A, Y sur B et Z sur C
par nom : port map (A=>X, C=>Z, B=>Y) o lordre na pas dimportance.
mixte : port map (X, C=>Z, B=>Y) passer lassociation par nom est irrversible.
On peut associer des lments de tableaux ou de record :
port (A : STD_LOGIC_VECTOR(2 downto 0)) donnera
port map (A(0)=>X, A(1)=>Y, A(2)=>Z)
ou port map (A(1 downto 0)=>T,A(2)=>Z) si T est un vecteur de 2 bits.
On peut aussi, mais cest du vice car tout cela concours la rsolution de la surcharge, changer le type
et/ou appeler une fonction lors dune association entre ports et signal.
ex : port map(Fonc(A) => TypeDeA(X)) o les changement de type et appels de fonctions sur les
arguments rel/formel sont pertinents suivant la direction des ports (in/out/inout). Ici cas inout, il y a les
deux qui sont appeles selon le sens du flot. En mode in, seul lappel de gauche serait pertinent.
Enfin dans le cas des ports, on peut laisser un port ouvert (associ open). Certains outils admettent
quon associe un port une constante (0 pour mise la masse) mais ce nest pas standard : mieux vaut
associer un signal quon affectera avec la constante.
Dans le cas des sous-programmes, si un argument est du genre signal, on ne peut lui passer que des
signaux. Sil est du genre variable, on peut lui passer des variables ou des signaux dont seule la valeur
passera au sous-programme qui le verra comme variable.
La spcification de configuration : for all :composant use work.entity E(A) ;
On est souvent surpris de voir que la configuration ne marche plus lintrieur des blocs generate.
Pour de trs bonnes raisons impossibles expliquer rapidement, la porte de cette spcification ne
descend pas dans les blocs hirarchiques, il faut la rpter en utilisant ou bien la zone dclarative du
generate (versions rcentes de VHDL) ou linstruction block ici illustre:
for all :composant use work.entity E(A) ;
begin block ad hoc pour avoir une zone
X: composant port map -- sera bien configur dclarative et pouvoir rpter la
G :for I in 1 to 10 generate configuration. Y sera configur alors que
B:block sans le block il ne laurait pas t.
for all :composant use work.entity E(A); Si limplmentation autorise la zone
begin dclarative dans le generate, on peut
Y: composant port map
end block;
enlever les deux lignes o apparat le mot
end generate; block.
Contrle de la sensibilit: lcriture nave conduit souvent un gaspillage de temps lors de la simulation
alors que le fonctionnement est correct :
registre <= bus when csevent and cs=1 ; sera activ pour rien, sauf optimisations, chaque fois
que bus change et mme si cs ne passe 1 quune fois par sicle!
Solution : le process sensible seulement sur cs:
process(cs) begin if cs=1 then registre <= bus ; end if ; end process ;
Un driver par signal et par process: si un signal est affect dans un process, mme au bout dun quart
dheure, mme dans un test qui est toujours faux, ce process cre une contribution pour ce signal ds le
temps zro de la simulation avec la valeur par dfaut (U pour STD_LOGIC). Par ailleurs, quand un
process contribue pour un signal, cette contribution est fournie tant que le process ne tombe pas sur une
nouvelle affectation. Cela est vrai pour linitialisation. Il est donc prudent dinitialiser au dbut du process
(par exemple Z) tous les signaux affects ici et l dans un process complexe
VHDL-AMS: ds que l'on suppute qu'il y aura une discontinuit sur une quantit ou sa drive, il faut
faire un vnement cette occasion (attribut ABOVE par exemple) et un break sur cet vnement. Sinon
le simulateur, qui travaille par pas, va dpasser la discontinuit. Le break l'oblige revenir au pas
prcdent et recalculer une solution pour le point de la discontinuit qu'il peut interpoler, puis
recalculer des conditions "initiales".
-10 -
VHDL en 12 pages - Jacques Rouillard 2007- 2008
-11 -
VHDL en 12 pages - Jacques Rouillard 2007- 2008
-12 -