Manuel VHDL
Manuel VHDL
Manuel VHDL
Institut REDS
Manuel VHDL
synthèse
et
simulation
Version partielle septembre 2007
(Chapitres : 1, 2, 3, 4, 6, 7, 9, 10, 15)
Etienne Messerli
Version 6-a
Septembre 2007
Auteur et version du manuel
Version :
Initiale : Manuel VHDL pour la synthèse automatique
Yves Sonnay, étudiant à l'EIVD, octobre 1998
4ème révision : E. Messerli, professeur à l'EIVD, mai 2003
5ème révision : E. Messerli, professeur à la HEIG-VD, septembre 2005
Remise à jour complète (rajout chapitre 8 et 11 sur VHDL avancé)
Remise à jour :
6ème révision : E. Messerli, professeur à la HEIG-VD, septembre 2007
Complété notion avancée, quelques corrections
Je remercie tous les utilisateurs de ce manuel de m’indiquer les erreurs qu’il comporte.
De même, si des informations semblent manquer ou sont incomplètes, elles peuvent
m’être transises, cela permettra une mise à jour régulière de ce manuel.
Contact
6-1.1.Décalage de vecteurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
6-2. Affectation de valeur hexadécimale .................................. 48
6-3. Notation d'agrégat et others ............................................... 49
6-4. Remplacement du type de port "buffer" ............................ 50
6-5. Les attributs ....................................................................... 51
6-5.1.Les attributs pré-définis pour les scalaires . . . . . . . . . . . . . . . . 52
6-5.2.Les attributs pré-définis pour les tableaux (array) . . . . . . . . . . 52
6-5.3.Les attributs pré-définis pour les signaux . . . . . . . . . . . . . . . . 54
Préambule
rectement ces notions avec le chapitre 9 (9-1 à 9-3 et 9-5) et les exercices as-
sociés.
L’étape suivante est d’améliorer l’utilisation du langage, mais toujours pour
décrire des systèmes combinatoires. Il s’agira d’utiliser des instructions sé-
quentielles. Le lecteur commence ainsi à entrer dans le monde VHDL en uti-
lisant des descriptions comportementales ou algorithmiques. Le passage
incontournable sera l’étude de l’instruction process (paragraphe 3-5). Ensuite,
il lira le chapitre 4, la suite du chapitre 9 (paragraphe 9-4) et il pratiquera les
exercices.
Dès que le lecteur se sentira assez sûr avec ces thèmes, il pourra étudier l’uti-
lisation du paquetage Numeric_Std, chapitre 7, et l’appliquer aux exercices
correspondant.
La prochaine étape consiste à aborder la description de systèmes séquentiels.
Le lecteur lira le chapitre 10 et applique les notions avec les exercices.
Les notions de simulation sont décomposées en trois parties. Une partie géné-
rale (chapitre 12) et un chapitre pour expliquer la simulation de systèmes
combinatoires (chapitre 13) ou séquentiels (chapitre 14). Le lecteur peut com-
mencer l’étude de la simulation après avoir maîtrisé la description des systè-
mes combinatoires.
Finalement, le lecteur pourra aborder les notions avancées et les descriptions
réutilisable (chapitres 8 et 11)
Nous pouvons proposer deux démarches au lecteur. Voici la première démar-
che qui commence par les descriptions synthétisables:
• Description de systèmes combinatoires
• Description de systèmes séquentiels
• Simulation des systèmes combinatoires
• Simulation des systèmes séquentiels
• Notions avancées et descriptions génériques
La seconde démarche propose d’imbriquer plus intensément la simulation
avec l’étude du langage pour la synthèse. Cette démarche à l’avantage d’inté-
grer plus rapidement les deux utilisations du langage. Voici cette seconde dé-
marche:
• Description de systèmes combinatoires
• Simulation des systèmes combinatoires
• Description de systèmes séquentiels
• Simulation des systèmes séquentiels
• Notions avancées et descriptions génériques
Manuel partiel, site internet REDS
Introduction
Description VHDL
synthétisable Fichier de simulation
VHDL
(test bench)
SYNTHETISEUR
(traduction)
Manuel partiel, site internet REDS
VHDL
Description logique fichier SIMULATEUR
fonctionnelle
netlist VHDL
temporelle
Placement routage
(intégration)
1-3.1 Historique
Au début des années 80, le département de la défense américaine
(DOD) désire standardiser un langage de description et de documentation
des systèmes matériels ainsi qu'un langage logiciel afin d'avoir une indé-
pendance vis-à-vis de leurs fournisseurs. C'est pourquoi, le DOD a décidé
de définir un langage de spécification. Il a ainsi mandaté des sociétés pour
établir un langage. Parmi les langages proposés, le DOD a retenu le langa-
ge VHDL qui fut ensuite normalisé par IEEE. Le langage ADA est très
proche, car celui-ci a servit de base pour l'établissement du langage VHDL.
La standardisation du VHDL s'effectuera jusqu'en 1987, époque à la-
quelle elle sera normalisée par l'IEEE (Institute of Electical and Electro-
nics Engineers). Cette première normalisation a comme objectif:
• La spécification par la description de circuits et de systèmes.
• La simulation afin de vérifier la fonctionnalité du système.
• La conception afin de tester une fonctionnalité identique mais
décrite avec des solutions d'implémentations de différents
niveaux d'abstraction.
En 1993, une nouvelle normalisation par l'IEEE du VHDL a permis
d'étendre le domaine d'utilisation du VHDL vers:
• La synthèse automatique de circuit à partir des descriptions.
• La vérification des contraintes temporelles.
• La preuve formelle d'équivalence de circuits.
Il existe un autre langage de haut niveau pour la description de matériel.
Il s'agit du langage VERILOG. La société Cadence est à l'origine de ce lan-
gage. Ce langage est aussi normalisé par IEEE.
tous les vendeurs d'outils EDA. Cela permet aux industriels d'investir sur
un outil qui n'est pas qu'une mode éphémère, c'est un produit commercia-
lement inévitable. Techniquement, il est incontournable car c'est un langa-
ge puissant, moderne et qui permet une excellente lisibilité, une haute
modularité et une meilleure productivité des descriptions. Il permet de
mettre en oeuvre les nouvelles méthodes de conception.
Il est à noter toutefois un inconvénient qui est la complexité du langage.
En effet, ce langage s'adresse à des concepteurs de systèmes électroniques,
qui n'ont pas forcément de grandes connaissances en langages de program-
mation.
D'autres fausses idées circulent sur le langage VHDL. Celui-ci n'assure
Manuel partiel, site internet REDS
;;;;
1-3.3 Ensemble synthétisable du VHDL
L'ensemble du VHDL n'est pas utilisable pour la synthèse automatique.
;;;;
Ensemble du VHDL
;;;;
Sous-ensemble
synthétisable
--Affectation simple
Y <= (not C and B) or (A and C and not D);
--Affectation conditionnelle
A_Eq_B <= '1' when Val_A = Val_B else '0';
--Déclaration d’entité
entity Nom_Du_Module is
zone pour d’autres instructions
end Nom_Du_Module;
Manuel partiel, site internet REDS
Objet suffixe
port d’entrée _i
port de sortie _o
port entrée/sortie _io
signal interne _s
architecture textuelle
signal interne aucun
schéma bloc
Manuel partiel, site internet REDS
constante _c
variable _v
Spécifique pour un banc de test (test-bench)
signaux de stimuli _sti
signaux observés _obs
signaux de référence _ref
Tableau 2-1 : Liste des suffixes utilisés au REDS
Polarité préfixe
• Les variables.
• Les signaux.
• Les fichiers.
Les constantes permettent de paramètrer des valeurs non modifiables
lors de l'exécution de la description. Elles permettent d’améliorer la lisibi-
lité de la description. Elles sont un peu utilisées dans les descriptions en
vue de la synthèse. Leur principale utilisation sera dans les fichiers de si-
mulation. Les fichiers seront uniquement utilisés dans les bancs de test.
Les classes d'objet signal et variable seront présentées dans les paragra-
phes suivants. Nous pouvons dire qu'une variable appartient au monde soft.
Celle-ci n'a pas de réalité physique. Par contre, un signal appartient au
monde hard. Celui-ci représente une équipotentielle, il aura donc une re-
présentation physique dans le circuit décrit.
Les opérateurs relationnels sont définis pour tous les types scalaires et
les tableaux de scalaires. Mais les deux opérandes doivent être du même
type.
Les opérateurs de décalages et de rotation sont définis pour tous les ty-
pes scalaires et les tableaux de scalaires. Ces opérateurs ont été rajouté
dans la norme VHDL-93.
* multiplication dépend
/ division dépend
mod modulo, sur entiers entier
rem reste, sur entiers entier
Les opérateurs divers s'effectue sur des types différents selon la fonc-
tion. Le tableau ci-dessous donne les types utilisables pour chaque opéra-
tion.
L'affectation est aussi valable si B est un signal. Dans tous les cas, le type
de l'expression de droite doit être identique à celui de la variable.
défini (don't care). De plus en simulation, nous avons besoin d'un état non
pour indiquer des conflits, un signal non initialisé, ...
Library IEEE;
use IEEE.Std_Logic_1164.all;
’0’ -- Forcing 0
’1’ -- Forcing 1
Manuel partiel, site internet REDS
’H’ -- Weak 1
Dans l’industrie c’est le type Std_Logic qui est principalement utilisé. C’est
celui que nous utilisons dans ce manuel
---------------------------------------------------------------------------------------------------
-- *** industry standard logic type ***
---------------------------------------------------------------------------------------------------
subtype Std_Logic is resolved Std_uLogic;
2-4 Le temps
Comme indiqué précédemment, le signal n'est pas un récipient que l'on
peut vider ou remplir à loisir, comme une variable. C'est un objet qui a des
liens, il a un passé, un présent et un futur. Nous devons associer à un signal
un ensemble de valeurs. La notion de temps est indispensable pour repré-
senter cet ensemble d'informations. Le langage VHDL associe à chaque si-
gnal un pilote qui contient toutes ces informations.
10 ns 20 ns 30 ns 40 ns 50 ns
'0' '1' ....
'0' '1' '0' '1' '0'
Le résultat de l'opération A >= B est soit vrai, soit faux. Il s’agit d’un
résultat de type boolean. Il n’est pas possible d’affecté le résultat au signal
Y car celui-ci est de type Std_Logic. Si l'on veut rendre cette partie de des-
cription correcte en VHDL, il faut l'écrire comme suit:
architecture Type of exemple
signal A, B, Y : Std_Logic;
begin
Y <= '1' when (A >= B) else '0';
end;
On remarque, cette fois-ci, que les 2 valeurs affectées au signal Y sont
bien du même type, soit de type Std_Logic.
Manuel partiel, site internet REDS
library
configuration package
package
package
entity
library
package
architecture package
package
Unité de conception
2-6.1 L'entité
L'entité est une vue externe du module, elle définit toutes les entrées et
sorties.
Syntaxe générale de l'entité:
entity Nom_Du_Module is
port ( Nom_Entrée_1 :inType_Du_Signal;
Nom_Entrée_2 :inType_Du_Signal;
...
Nom_Sortie_1 :outType_Du_Signal;
Nom_E_S_1 :inoutType_Du_Signal );
end Nom_Du_Module;
Remarque:
Manuel partiel, site internet REDS
Les entrées et les sorties d'un module sont toujours représentées par
un port, il en existe 4 différents types, qui sont:
• in : port d'entrée.
• out : port de sortie.
• inout : port bidirectionnel (utilisation pour des bus).
• buffer : port de sortie qui peut être relu (ne pas utiliser)
Un signal de type buffer ne peut pas être connecté directement avec un
signal de type out (le VHDL est typé). Il est nécessaire d’utiliser un cast.
Cela n’est pas très pratique. Nous déconseillons l’utilisation de ce type !
Nous verrons plus tard comment se passer de ce type en utilisant un signal
interne dans l’architecture (Voir “Remplacement du type de port "buffer"”,
page 50.).
Afin d'être plus concret, nous allons vous présenter, comme exemple,
l'entité d'un multiplexeur 8 -> 1 avec 3 entrées de sélection.
MUX8to1
0 0
Sel G --
3 2 7
A 0
B 1
C 2
D 3 Y Y
E 4
F 5
G 6
H 7
entity MUX8to1 is
port(Sel : in Std_Logic_Vector (2 downto 0);
A,B,C,D,E,F,G,H : in Std_Logic;
Y : out Std_Logic);
end MUX8to1;
2-6.2 L'architecture
L'architecture décrit le comportement du module. Le langage VHDL
permet de décrire le comportement de différentes façons. Dans ce manuel
Manuel partiel, site internet REDS
nous allons traiter les description synthétisable et les bancs de test. Ceux-
ci seront étudié ultérieurement (Voir “Simulation et bancs de test”,
page 129.). Les autres types de description ne seront pas présentées ici
(exemple: description de spécification)
Nous allons commencer par les descriptions synthétisables. Dans la lit-
térature, ce niveau de description est appelé RTL (Register Transfert Le-
vel). Nous distinguerons différentes possibilités de descriptions
synthétisables, soit:
• Logique: Equations logiques, description du fonctionne-
ment directement avec des équations logiques.
• TDV: Table de vérité, description du fonctionnement
avec une table de vérité (utilisation de l'instruc-
tion with ... select).
• Flot_Don: Flot de données, description du fonctionnement
très proche du fonctionnement logique (utilisa-
tion des instructions concurrentes <=, when ...
else ou with ... select)
• Comport: Comportementale, description du fonctionne-
ment en décrivant le comportement (exemple:
description avec un process et de l'instruction if
... then ... else)
• M _Etat: Machine d'état, description du fonctionnement à
l'aide d'une machine d'état
• Struct: Structurelle, description du module en donnant
les interconnexions entre différents sous modu-
les (description hiérarchique avec l'instanciation
de composant)
Dans des chapitres ultérieurs, des exemples complets seront donnés
pour les 6 types d'architecture décrits ci-dessus.
--Zone de déclaration
begin
Instructions_Concurrentes;
process ( Liste_De_Sensibilité )
begin
Instructions_Séquentielles;
Manuel partiel, site internet REDS
end process;
end Type_D_Architecture;
Dans un circuit logique, toutes les portes fonctionnent simultanément.
On dit alors que les portes fonctionnent de manière concurrente, c'est à dire
que l'ensemble des opérations se déroulent en parallèle. Il est simple de
comprendre que toutes les parties d'un circuit fonctionnent simultanément.
Le langage VHDL a été créé dans le but de pouvoir décrire le compor-
tement d'un circuit. Le langage dispose donc d'instructions concurrentes.
Cette notion est particulière au langage de description de matériel. Elle
n'existe pas dans les langages de programmation conventionnel.
Parfois, il est plus performant de décrire le comportement en utilisant
un algorithme en utilisant une instruction tel que le if .. then .. else . C'est
la raison de l’existence, dans le langage VHDL, d’une instruction concur-
rente particulière, l’instruction process. Celle-ci permet de décrire le com-
portement du circuit avec des instructions séquentielles. A l'intérieur de
cette instruction le déroulement des instructions est séquentiel.
Nous allons étudier, dans un premier temps les instructions concurren-
tes. Ensuite nous aborderons les instructions séquentielles.
Afin d'être plus concret, nous allons donner l'architecture du multi-
plexeur 8 ->1 avec 3 entrées de sélection déjà présenté au paragraphe pré-
cédent “L'entité”, page 24.
Exemple 2- 10 : Multiplexeur 8 to 1
Remarque:
Le terme others affecte au signal l’état logique mentionné, et ceci pour
tous les autres états logiques du signal de commande qui n’ont pas été cités
précédemment.
end Flot_Don;
Dans l'exemple ci-dessus, le terme others, couvre les cas: "XXX", "ZZZ",
"HHH", "UUU", "01U", "-1-", etc. du vecteur Sel, si celui-ci est de type
Std_Logic_Vector. Ces états ne sont pas utilisés en synthèse mais existe
pour le type Std_Logic (9 états, voir § 3.3).
--Déclaration du composant
component AND2
port(A, B : in Std_Logic;
S : out Std_Logic );
end component;
--configuration
for all : AND2 use entity work.AND2(Logique);
begin
--Instanciation du composant
Manuel partiel, site internet REDS
end Struct;
Dans le cas où toutes les connections ne sont pas utilisées il est possible
d’utiliser le mot clé open. Voici un exemple d’instanciation d’un compara-
teur ou une sortie n’est pas utilisée.
--Déclaration du composant
component Comp
port(A, B : in Std_Logic_Vector(3 downto 0);
EG, PP, PG : out Std_Logic );
end component;
--configuration
for all : Comp use entity work.Comp(Flot_Don);
begin
--Instanciation du composant
U1: Comp port map(A =>Nbr_1,
B =>Nbr_2,
PP =>open, --non conecte
EG =>N1_EG_N2,
PG =>N1_PG_N2
);
end Struct;
Remarques:
• Le processus est traité en un seul bloc. C'est une instruction con-
currente. Par contre son contenu va être traité séquentiellement
(voir instructions séquentielles).
• Lorsque l’instruction process est utilisée avec une liste de sensi-
bilité, l’instruction wait est interuite à l’intérieur du process.
• Les signaux seront affectés lors de l’endormissement du proces-
sus. Cela a lieu soit à la fin (end process) ou lors d'une attente
(wait …). Le temps n'évolue pas lors de l'évaluation d'un proces-
sus (exécution des instructions séquentielles).
• A l'intérieur d'un processus, il est possible d'utiliser des varia-
bles. Celles-ci seront immédiatement misent à jours.
• Un processus est activé uniquement lorsqu'un des signaux de la
liste de sensibilité changent.
• Lorsqu'il y a plusieurs processus dans la même architecture, il est
utile de leur donner un nom. Ce qui est possible sous l'appella-
tion label.
Remarque:
L'affectation ne modifie pas la valeur actuel du signal. Celle-ci modifie
les valeurs futurs. Le temps n’évolue pas lors de l’évaluation d’un process.
L’affectation sera donc effective uniquement lors de l’endormissement du
process. Voir “L'instruction processus”, page 34.
L'instruction when ... else n'est pas utilisable à l'intérieur d'un process.
C'est une instruction concurrente. L'instruction séquentielle correspondan-
te est l'instruction conditionnelle (if then else), voir paragraphe suivant.
...
else
--Zone pour instructions séquentielles
end if;
Nous reprenons la description du détecteur de priorité (3 entrées et une
sortie sur 2 bits) pour démontrer l’utilisation de l’instruction conditionnel-
le.
end Comport;
end Comport;
Remarque:
Le cas others n'est jamais utilisé pour les combinaisons logiques de Sel.
Mais le type Std_Logique comprend 9 états ('X', 'U', 'H', etc.). Le vecteur Sel
de 2 bits comprend donc 81 combinaisons et pas seulement 4! Il est indis-
pensable de prévoir ces combinaisons dans la description. Lors de la simu-
lation si Sel est différent d'une des 4 combinaisons logiques("00", "01", "10",
"11"), les sorties sont affectées avec l'états 'X' pour indiquer qu'il y a un pro-
blème dans le fonctionnement du démultiplexeur.
Manuel partiel, site internet REDS
Visseries et astuces
Remarque:
L’affectation en hexadécimal ne fonctionne que pour des vecteurs mul-
tiples de 4 bits. Si vous avez un vecteur de 30 bits à affecter vous pouvez
opérer comme suit:
--Soit les signaux suivants:
signal Vect30a, Vect30b : Std_Logic_Vector(29 downto 0);
constant Cst32 : Std_Logic_Vector(31 downto 0) := x"3A79B2E2";
--Nous pouvons dés lors affecter les vecteur 30 bits comme suit :
Remarque:
Il existe aussi la possibiltié de faire des affectation en octal, soit :
Vecteur <= (’1’, ’0’, ’0’, ’1’) ; --idem que <= "1001"
L’agrégat est très utile pour affecter plusieurs bits d’un vecteur à la
même valeur avec le mot clé others. Il est dès lors pas nécessaire de con-
naître la taille de celui-ci. Cette fonction est indispensable pour obtenir des
descriptions génériques (taille variable des vecteurs).
La syntaxe de l’affectation d’un vecteur à "00..00" est la suivante:
Vecteur <= (others => ’0’);
Nous verrons plus loin que cette notion d’agrégat utilisé avec les attri-
buts permet d’écrire des descriptions paramétrables.
library IEEE;
use IEEE.Std_Logic_1164.all;
entity Exemple is
port( A, B : in Std_Logic;
X : out Std_Logic;
Y : buffer Std_Logic);
end Exemple;
Y <= A nor B;
X <= Y or B;
end Logique;
Nous conseillons dans un tel cas, d’utiliser un type de port out et de créer
un signal interne. Celui-ci pourra être relu et le signal de sortie reste avec
le type de port out. Nous donnons ci-dessous la modification de l’exemple
avec la déclaration d’un signal interne avec le sufixe .._s.
Manuel partiel, site internet REDS
library IEEE;
use IEEE.Std_Logic_1164.all;
entity Exemple is
port( A, B : in Std_Logic;
Y : out Std_Logic;
X : out Std_Logic );
end Exemple;
end Logique;
Exemple 6- 5 : Utilisation d’une sortie avec l’utilisation du type out et d’un signal interne
sont pas utile pour l’utilisateur. De plus, ils ne sont pas utilisés au niveau
du langage VHDL.
Nous ne mentionnerons pas tous les attributs pré-définis. Nous allons
uniquement donner les plus utilisés. Nous laisserons le lecteur ce référer à
la norme ou à un livre pour voir la liste complète des attributs pré-définis.
T’image(X)
Cet attribut retourne la chaîne de caractères qui correspond à X pour le
type T. Cette attribut est très utile pour afficher une valeur dans la fenêtre
du simulateur. Nous donnons ci-dessous un exemple d’utilisation avec un
signal de type Integer.
entity Exemple is
port( ...
CPT : out Std_Logic_Vector (7 downto 0);
...
end Exemple;
Exemple 6- 7 : Utilisation des attributs sur les tableaux pour les déclarations
library IEEE;
use IEEE.Std_Logic_1164.all;
use IEEE.Numeric_Std.all; --Fonction conversion
To_Unsigned
entity Exemple_tb
end Exemple_tb;
begin
...
process
begin
....
--Boucle pour parcourir toutes les combinaisons
for I in 0 to (2**(Entrees_sti'length)-1) loop
end Test_Bench;
Exemple 6- 8 : Utilisation attributs sur les tableaux dans un fichier de simulation avec uti-
lisation de l’instruction for ..loop
Ces attributs sont aussi valable pour des types ou sous-types de tableau.
Cette possibilité est plus rarement utilisée. Nous expliquons le fonctionne-
ment avec un sous-type.
--déclaration d’un sous-type
subtype T_Bus_Adr : Std_Logic_Vector(11 downto 0);
Affectations
du signal S '1' '1' '0'
au temps t 10 ns 20 ns 40 ns
Manuel partiel, site internet REDS
Paquetage Numeric_Std
et opérations arithmétiques
Le langage VHDL étant typé, il est interdit d'affecter ensemble deux si-
gnaux de types différents. Il faut donc utiliser des fonctions d'adaptation ou
de conversion pour affecter des nombres ayant des différents types de re-
présentation.
Il est à noter que le passage directe entre un Std_Logic_Vector et un entier
est impossible. Il est nécessaire de passer par les types Unsigned ou Signed.
Nous allons vous présenter dans les prochains paragraphe les différentes
possibilités de conversion ou d’adaptation.
Vous trouverez dans les annexes un résumé de ces différentes conver-
sion et adaptation réalisé par la société A.L.S.E. (Advanced Logic Synthe-
sis for Electronics, Paris), voir “Conversion vecteurs et nombres entiers”,
Manuel partiel, site internet REDS
page 173.
--Exemples d'additions :
Somme <= N_A + N_B;
Somme <= N_A + "0001";
Manuel partiel, site internet REDS
A
Y
B
library IEEE;
use IEEE.Std_Logic_1164.all;
entity Non_Ou is
port(A, B : in Std_Logic;
Y : out Std_Logic);
end Non_Ou;
Y <= A nor B;
end Logique;
A B C D
Sortie
Y
library IEEE;
use IEEE.Std_Logic_1164.all;
entity Schema is
port(A, B, C, D : in Std_Logic;
Sortie : out Std_Logic);
end Schema;
Sortie <= X or Y;
end Logique;
G2..0 GRAY
Binaire pur BP2..0
0 0 0 0 0 0
0 0 1 0 0 1
0 1 0 0 1 1
0 1 1 0 1 0
Manuel partiel, site internet REDS
1 0 0 1 1 1
1 0 1 1 1 0
1 1 0 1 0 0
1 1 1 1 0 1
Tableau 9-1 : Table de vérité d’un transcodeur Gray - binaire pur
library IEEE;
use IEEE.Std_Logic_1164.all;
entity Gray_BinPur is
port(G : in Std_Logic_Vector(2 downto 0);
BP : out Std_Logic_Vector(2 downto 0));
end Gray_BinPur;
with G select
BP <= "000" when "000",
"001" when "001",
"011" when "010",
"010" when "011",
"111" when "100",
"110" when "101",
"100" when "110",
"101" when "111",
"XXX" when others; -- simulation
end TDV;
Val_A
Comparateur A_EQ_B
Val_B
library IEEE;
use IEEE.Std_Logic_1164.all;
entity Comp_Eq is
port(Val_A, Val_B : in Std_Logic_Vector( 3 downto
0);
A_Eq_B : out Std_Logic);
end Comp_Eq;
end Flot_Don;
library IEEE;
use IEEE.Std_Logic_1164.all;
use IEEE.Numeric_Std.all;
entity Comp_Eq is
port(Val_A, Val_B : in Std_Logic_Vector(3 downto 0);
A_Eq_B : out Std_Logic);
end Comp_Eq;
end Flot_Don;
ment d’un système numérique. Nous montrons cette démarche avec le cas
d’un démultiplexeur (voir “Description algorithmique d’un démulti-
plexeur 1 à N”, page 96).
DMUX1_4
0 0 0 Y0
Sel A
1 3 1 Y1
Manuel partiel, site internet REDS
2 Y2
Enable EN 3 Y3
library IEEE;
use IEEE.Std_Logic_1164.all;
entity DMUX1_4 is
port ( Sel : in Std_Logic_Vector (1 downto 0);
Enable : in Std_Logic;
Y : out Std_Logic_Vector (3 downto 0) );
end DMUX1_4;
process(Sel ,Enable)
begin
end Comport;
library IEEE;
use IEEE.Std_Logic_1164.all;
use IEEE.Numeric_Std.all;
entity DMUX1_16 is
port( Sel : in Std_Logic_Vector (3 downto 0);
Sorties: out Std_Logic_Vector (15 downto 0)
);
end DMUX1_16;
process(Sel)
begin
--toutes les sorties sont desactivees
Sorties <= (others => '0'); --valeur par defaut
--active la sortie selectionnee
Sorties( To_Integer(Unsigned(Sel)) )<= ’1’;
end process;
end Comport;
library IEEE;
use IEEE.Std_Logic_1164.all;
use IEEE.Numeric_Std.all;
entity DMUX1_16 is
port( Sel : in Std_Logic_Vector (3 downto 0);
Enable : in Std_Logic;
Sorties: out Std_Logic_Vector (15 downto 0)
);
end DMUX1_16;
process(Sel, Enable)
begin
--toutes les sorties sont desactivees
Sorties <= (others => '0'); --valeur par defaut
--active la sortie selectionnee si enable actif
Sorties( To_Integer(Unsigned(Sel)) )<= Enable;
end process;
end Comport;
Décodeur CS_A
CS_B
Adresse d'adresse
8 CS_C
en héxa en décimal
0 à 2F 0 à 47 1 0 0
30 à 4F 48 à 79 0 1 0
50 à 7F 80 à 127 0 0 1
80 à FF 128 à 255 0 0 0 Zone libre
Tableau 9-2 : Plan d’aderssage du décodeur
Library IEEE;
use IEEE.Std_Logic_1164.all;
use IEEE.Numeric_Std.all;
entity Dec_Ad is
port(Adresse : in Std_Logic_Vector(7 downto 0);
CS_A, CS_B, CS_C : out Std_Logic );
end Dec_Ad;
process(adresse)
begin
case To_Integer(unsigned(Adresse)) is
when 0 to 47 => CS_A <= '1'; --adresse 0 a 2F
when 48 to 79 => CS_B <= '1'; --adresse 30 a 4F
when 80 to 127 => CS_C <= '1'; --adresse 50 a 7F
when 128 to 255 => null; --zone libre
when others => CS_A <= 'X'; --simulation
CS_B <= 'X'; --simulation
CS_C <= 'X'; --simulation
end case;
end process;
end Comport;
entity Hierarchie is
port(Port_Entrees : in Type_Port_Entrees;
Port_Sorties : out Type_Port_Sorties);
end Hierarchie;
begin
end Struct;
Remarques:
• Les composants qui sont déclarés dans l'architecture sont les
modules VHDL qui sont utilisés lors de l'assemblage du fichier
structurel. Lors de cette déclaration, il est indispensable de lister
dans l'ordre les signaux d'entrée et sortie du module.
• Les signaux d'interconnexion qui sont déclarés dans l'architec-
Manuel partiel, site internet REDS
MUX
Valeur 0
4 Val_Cal
4
INCR 1
Val_Inc
Sel
Figure 9- 8 :
Library IEEE;
use IEEE.Std_Logic_1164.all;
use IEEE.Numeric_Std.all;
entity Incr is
port(Valeur : in Std_Logic_Vector(3 downto 0);
Val_Inc : out Std_Logic_Vector(3 downto 0) );
end Incr;
begin
end Comport;
Library IEEE;
use IEEE.Std_Logic_1164.all;
entity MUX2_1 is
port (In0, In1 : in Std_Logic_Vector(3 downto 0);
Sel : in Std_Logic;
Y : out Std_Logic_Vector(3 downto 0) );
end MUX2_1;
end Comport;
Library IEEE;
use IEEE.Std_Logic_1164.all;
entity Unit_Cal is
port ( Valeur : in Std_Logic_Vector(3 downto 0);
Sel : in Std_Logic;
Val_Cal : out Std_Logic_Vector(3 downto 0) );
end Unit_Cal;
begin
end Struct;
D D Q Q
CLK
Manuel partiel, site internet REDS
ar
Reset
library IEEE;
use IEEE.Std_Logic_1164.all;
entity DFF is
port(Reset : in Std_Logic; --reset asynchrone
CLK : in Std_Logic;
D : in Std_Logic;
Q : out Std_Logic );
end DFF;
------------------------------------------------------
-- processus decrivant la memorisation (registre)
------------------------------------------------------
Mem: process(CLK, Reset)
begin
if (Reset = '1') then
Q <= '0';
elsif Rising_Edge(CLK) then
Q <= D;
end if;
end process;
end Comport;
Remarque:
La description du flip-flop D est simple. Il n'y a pas de décodeur d'état
futur et de décodeur de sortie. La description comprend uniquement le pro-
cessus de mémorisation.
D D Q Q
G G
library IEEE;
use IEEE.Std_Logic_1164.all;
entity LatchD is
port(G : in Std_Logic; --entrée de commande
D : in Std_Logic;
Q : out Std_Logic );
end LatchD;
------------------------------------------------------
-- processus decrivant la memorisation (registre)
------------------------------------------------------
Mem: process(G, D)
begin
if (G = '1') then
Q <= D;
end if;
end process;
end Comport;
Manuel partiel, site internet REDS
Si les sorties dépendent des entrées, connecter celles-ci sur le décodeur de sorties
REG
Actions_Asynchrone
Horloge
library IEEE;
use IEEE.Std_Logic_1164.all;
use IEEE.bibliothèques_utiles.all;
entity Nom_Du_Module is
port ( Nom_Entrée : in Std_Logic;
....
Nom_Sortie : out Std_Logic);
end Nom_Du_Module;
begin
Manuel partiel, site internet REDS
-----------------------------------------------------------------------------
-- Description decodeur d'etat futur (combinatoire)
-----------------------------------------------------------------------------
Etat_Futur <= .... when Condition_1 else
.... when Condition_2 else
...;
-----------------------------------------------------------------------------
-- processus decrivant la memorisation (registre)
-----------------------------------------------------------------------------
Mem: process(Horloge, Actions_asynchrone )
begin
if (Action_asynchrone = '1') then
Etat_Present <= Etat_Initial;
elsif Rising_Edge(Horloge) then
Etat_Present <= Etat_Futur;
end if;
end process;
-----------------------------------------------------------------------------
-- Description decodeur de sorties (combinatoire)
-----------------------------------------------------------------------------
Sortie <=.... when Etat_present = Etat_i else
.... when Etat_present = Etat_j else
....;
end Type_De_Description;
Dans la forme de base donnée ci-dessus, les décodeurs sont décrit avec
l’instruction concurrente when ... else. Il est possible de décrire ces déco-
deurs avec des instructions séquentiels (dans un process) dans les cas plus
complexes. Le décodeur d'état futur et le décodeur de sorties dépendant des
mêmes entrées sont parfois réunis.
REG_4
Reset R
Set_s 2S
Enable G1
Horloge C2
Manuel partiel, site internet REDS
Val 1,2 D Q Q
Entrées Sorties
Reset Set_s
Enable Horloge D Q+
asynchrone synchrone
H X X X X L
L H X ↑ X H
L L L ↑ X Q
L L H ↑ Val Val
Remarque:
Lorsque la sortie vaut Q, cela veut dire que le registre garde son état pré-
sent.
Voici la description synthétisable de ce registre en utilisant la structure
proposée précédemment.
library IEEE;
use IEEE.Std_Logic_1164.all;
entity Reg_4 is
port(Reset : in Std_Logic; --reset asynchrone
Set_s : in Std_Logic; --set synchrone
Enable : in Std_Logic;
Horloge : in Std_Logic;
Val : in Std_Logic_Vector(3 downto 0);
Q : out Std_Logic_Vector(3 downto 0) );
end Reg_4;
------------------------------------------------------
-- processus decrivant la memorisation (registre)
------------------------------------------------------
Mem: process(Horloge, Reset)
begin
if (Reset = '1') then
Q_Present <= (others => '0');
elsif Rising_Edge(Horloge) then
Q_Present <= Q_Futur;
end if;
end process;
------------------------------------------------------
-- Description decodeur d'etat futur et de sorties
------------------------------------------------------
Q <= Q_Present;
end Comport;
CTRDIV10
Reset_L R
Load_L M1
M2 CT=9 RCO
Enable G3
Horloge C4 / 2,3 +
Manuel partiel, site internet REDS
Entrées Sorties
Reset Load
Enable Horloge Val CPT+
asynchrone synchrone
H X X X X 0000
L H X ↑ Val Val
L L H ↑ X CPT + 1
L L L ↑ X CPT
library IEEE;
use IEEE.Std_Logic_1164.all;
use IEEE.Numeric_Std.all;
entity CPTDIV10 is
port(Horloge, Reset_L : in Std_Logic;
Load_L, Enable : in Std_Logic;
Val : in Std_Logic_vector(3 downto 0);
Cpt : out Std_Logic_Vector(3 downto 0);
RCO : out Std_Logic );
end CPTDIV10;
Manuel partiel, site internet REDS
--Calcul du report
RCO <= '1' when (Cpt_present = 9) else '0';
end Comport;
Un disque peut tourner dans les 2 sens de rotation possibles, le sens ho-
raire et le sens anti-horaire. Deux capteurs A et B sont disposés à 90° l'un
de l'autre, autour du disque. Le disque est "polarisé" de façon à ce que les
capteurs détectent un état logique haut ('1') sur une demi-circonférence du
disque, et un état logique bas ('0') sur l'autre demi-circonférence. Il s'agit à
l'aide de la séquence de valeurs lues sur les capteurs A et B, de déterminer
dans quel sens tourne le disque.
Nous donnons ci-après un dessin schématique du système permettant la
détection du sens de rotation.
Manuel partiel, site internet REDS
Capteur A
Sens horaire
'1'
'0' '1'
Sens anti-horaire
'0'
Capteur B
10/0
Capt_B, Capt_A / Sens
Etat_i
code
Etat_a
11/0 "00" 10/0
00/1 01/1
00/1
10/1
11/1
11/1
01/0
00/0
Etat_c
"11"
01/0
Figure 10- 7 :
Remarque:
Le graphe d'états est directement donné simplifié sans aucun dévelop-
pement ou explication. La conception d’une machine séquentielles ne fait
pas partie des objectifs de ce manuel.
Le graphe des états obtenu précédemment est utilisé pour la description
en VHDL du système. Le graphe définit quel est l’état futur en fonction de
l’état présent et des entrées. Cela correspond au décodeur d’état futur. De
même le graphe indique pour chaque état présent la valeur des sorties. Il
s’agit dans ce cas du décodeur de sortie.
Dans la description VHDL de la machine d’état, donnée ci-après, nous
avons fusionné les deux décodeurs. Nous avons utilisé un seul process pour
Manuel partiel, site internet REDS
library IEEE;
use IEEE.Std_Logic_1164.all;
entity Detect_Sens is
port ( Reset : in Std_Logic; --reset asynchrone
Horloge : in Std_Logic;
Capt_A : in Std_Logic;
Capt_B : in Std_Logic;
Sens : out Std_Logic );
end Detect_Sens;
------------------------------------------------------
--Description du decodeur d'etat futur et de sorties
------------------------------------------------------
Fut: process(Capt_BA, Etat_Present)
begin
case Etat_Present is
when Etat_a =>
if (Capt_BA = "00") then
Etat_Futur <= Etat_a;
Sens <= '1';
elsif (Capt_BA = "01") then
Etat_Futur <= Etat_b;
Sens <= '1';
elsif (Capt_BA = "10") then
Etat_Futur <= Etat_a;
Sens <= '0';
else --cas (Capt_BA = "11")
Etat_Futur <= Etat_d;
Sens <= '0';
end if;
Manuel partiel, site internet REDS
------------------------------------------------------
-- processus decrivant la memorisation (registre)
------------------------------------------------------
Mem: process(Horloge, Reset)
begin
if (Reset = '1') then
Etat_Present <= Etat_a;
elsif Rising_Edge(Horloge) then
Etat_Present <= Etat_Futur;
Manuel partiel, site internet REDS
end if;
end process;
end M_Etat;
Annexes
Voici la liste des normes IEEE pour le langage VHDL. Nous les
avons classé selon leur date d'édition.
• 1980Début du projet financé par le DoD
• 1987Standard IEEE Std 1076-1987 (VHDL 87)
• 1993Standard IEEE Std 1164-1993 (Std_Logic_1164)
• 1993Standard IEEE Std 1076-1993 (VHDL 93)
• 1994Approbation ANSI (ANSI/IEEE Std 1076-1993)
• 1995Standard IEEE Std 1076.4 (Vital_Primitive et Vital_Timing)
• 1996Standard IEEE Std 1076.2 (Mathematical Packages)
• 1997Standard IEEE Std 1076.3 (Numeric_Bit et Numeric_Std)
• 1999Standard IEEE Std 1076.6
(Standard for VHDL Register Transfer Level Synthesis)
• 2000 : Standard IEEE Std 1076-2000 (VHDL 2000)
• 2002 : Standard IEEE Std 1076-2002 (VHDL 2002)
abs if reject
access impure rem
after in report
alias inertial return
all inout rol
Manuel partiel, site internet REDS
and is ror
architecture
array label select
assert library severity
attribute linkage signal
loop shared
begin sla
block map sll
body mod sra
buffer srl
bus nand subtype
new
case next then
component nor to
configuration not transport
constant null type
disconnect of unaffected
downto on units
open until
else or use
elsif others
end out variable
entity
exit package wait
port when
file postponed while
for procedure with
function process
pure xnor
generate xor
generic range
group record
guarded register
(VHDL93)
Vectors
"Cast"
Convertion
Signed
Std_Logic_Vector(s)
Manuel partiel, site internet REDS
To_integer(s)
unsigned(v) To_unsigned(i,Nbits)
To_integer(u)
std_logic_vector(s)
Unsigned
Numbers
Il est important de bien distinguer les cas ou il y a une adaptation de type
(cast) ou une conversion. Le passage entre le type Std_Logic_Vector et les
types Unsigned ou Signed est une simple adaptation (cast). Il n’y a pas de
conversion de la valeur. Dans les deux cas il s’agit d’un tableau (array) de
Std_Logic.
15-5 Bibliographie
[1] Le langage VHDL,
Jacques Weber, Maurice Meaudre,
DUNOD, 2001,
ISBN : 2-10-004755-8
[2] VHDL : méthodologie de design et techniques avancées,
Thierry Schneider,
DUNOD, 2001,
ISBN : 2-10-005371-X
[3] VHDL, Introduction à la synthèse logique,
Manuel partiel, site internet REDS
Phillippe Larcher,
EYROLLES, 1997,
ISBN : 2-212-09584-8
[4] Digital System Design with VHDL,
Mark Zwolinski,
Prentice Hall, 2000
[5] Circuits numériques et synthèse logique, un outil : VHDL,
J. Weber, M. Meaudre,
Masson, 1995,
ISBN : 2-225-84956-0
[6] VHDL du langage à la modélisation,
R. Airiau, J.-M. BergÈ, V. Olive, J. Rouillard,
Presse Polytechniques et Universitaires Romandes, 1998,
ISBN : 2-88074-361-3
[7] VHDL Made Easy!,
D. Pellerin et D. Taylor,
Hardcover, 1996