Chap02 - Concepts de Base Du Langage

1 Concepts de base du langage VHDL
Chapitre 02 :
Concepts de base du langage VHDL
Table des matières

Objectives du cours ............................................................................................................................... 2
2.1. A propos du VHDL ...................................................................................................................... 2
2.2. Structure du code ......................................................................................................................... 2
2.2.1. Déclaration de Librairie (Library) ....................................................................................... 3
2.2.1.1. Packages VHDL fondamentaux .................................................................................... 3
2.2.2. Entity ....................................................................................................................................... 4
2.2.3. Architecture .......................................................................................................................... 5
2.3. Types de donnée prédéfinis .......................................................................................................... 7
2.3.1. Types de donnée SIGNED et UNSIGNED ......................................................................... 10
2.4. Types de donnée définis par l’utilisateur .................................................................................. 11
2.4.1. Types de données basés sur les nombres entiers ................................................................. 11
2.4.2. Types de données énumérés .................................................................................................. 11
2.5. SUBTYPE définis par l’utilisateur ............................................................................................ 12
2.6. Opérateurs en VHDL .................................................................................................................. 15
2.6.1. Opérateurs d’assignements "<=", ":=", "=>" ....................................................................... 15
2.6.2. Opérateurs de concaténation "&" and "," ......................................................................... 15
2.6.3. Opérateurs logiques NOT, AND, NAND, OR, NOR, XOR, XNOR ................................. 15
2.6.4. Opérateurs arithmétiques +, –, *, /, **, ABS, REM, MOD................................................ 15
2.6.5. Opérateurs de décalage SLL, SRL, SLA, SRA, ROL, ROR ............................................. 16
2.6.6. Opérateurs de comparaison =, /=, >, <, >=, <= ................................................................... 16
2.7. Attributs ....................................................................................................................................... 16
2.7.1. Attributs relatifs à la plage ................................................................................................... 17
2.7.2. Attributs relatifs à la position............................................................................................... 17
2.7.3. Attributs relatifs à un évènement ......................................................................................... 17
2.8. Objets de donnée (Data object) .................................................................................................. 18
2.8.1. CONSTANT ........................................................................................................................... 18
2.8.2. SIGNAL.................................................................................................................................. 18
2.8.2.1. Déclaration optionnelle du signal .................................................................................. 18
2.8.2.2. Déclaration obligatoire du signal .................................................................................. 19
2.8.3. VARIABLE ............................................................................................................................ 20
Responsable de cours : Fatah YAHIAOUI

Objectives du cours
Introduction au langage de description matérielle VHDL
Comprendre la structure du code VHDL
Différencier entre un type de donné prédéfini et un type défini par l’utilisateur
Comprendre les opérateurs et les attributs en VHDL
Comprendre l’utilité des objets de donnée dans la description des circuits numériques.
2.1. A propos du VHDL

VHDL est un langage de description de matériel indépendant de la technologie et du fournisseur. Le
code décrit le comportement ou la structure d'un circuit électronique à partir duquel un circuit
physique conforme peut être déduit par un compilateur. Ses principales applications comprennent la
synthèse de circuits numériques sur des puces CPLD/FPGA et la génération de ces circuits pour la
fabrication d'ASIC (circuit intégré exclusivement dédié à une application).
VHDL est l'acronyme de langage de description matérielle VHSIC (Very High Speed Integrated
Circuit) et résulte d'une initiative financée par le ministère de la Défense des États-Unis dans les
années 1980. Il a été le premier langage de description matérielle normalisé par l'IEEE, par le biais des
normes 1076 et 1164.
Le VHDL permet la synthèse de circuits ainsi que la simulation de circuits. La première est la
traduction d'un code source en une structure matérielle qui implémente les fonctionnalités spécifiées ;
la seconde est une procédure de test pour s'assurer que ces fonctionnalités sont réalisées par le circuit
synthétisé.
Une fois que le code VHDL a été écrit, il peut être utilisé soit pour implémenter le circuit dans un
dispositif de carte programmable (Altera, Xilinx, Atmel, etc.) ou peut être soumis à une fonderie pour
la fabrication d'une puce ASIC. Actuellement, de nombreuses puces commerciales complexes sont
conçues selon une telle approche.
2.2. Structure du code

Cette section décrite la structure de base du code VHDL, qui consistes de trois parties :
déclarations de la bibliothèque (Library), entitie (Entity), et architecture.
Déclarations
LIBRARY
ENTITY Structure du code

VHDL
ARCHITECTURE

2.2.1. Déclaration de Librairie (Library)

Les déclarations de bibliothèques sont une liste de toutes les bibliothèques (Library) et des
paquets (Package) correspondants dont le compilateur aura besoin pour traiter la conception.
Deux d'entre eux (std et work) sont rendus visibles par défaut.
Un paquetage qui doit souvent être inclus dans cette liste est std_logic_1164, de la
bibliothèque ieee, qui définit un type logique à neuf valeurs appelé STD_ULOGIC et son
sous-type résolu, STD_LOGIC (ce dernier est la norme industrielle). Le principal avantage de
STD_LOGIC par rapport à BIT est qu'il permet les spécifications de haute impédance ('Z')
et de "don't care" ('-').
Pour déclarer une librairie, deux lignes de code sont nécessaires, l'une pour déclarer la
LIBRARY et l'autre mot clé USE pointant vers le paquet spécifique dans la librairie, comme
illustré ci-dessous

LIBRARY Nom de la bibliothèque;
USE Nom de la Bibliothèque. Nom du Package. Partie du Package;
Figure 2.1. Parties fondamentales de LIBRARY.
2.2.1.1. Packages VHDL fondamentaux

La liste ci-dessous présente les principaux packages VHDL ainsi que leurs librairies d'origine.
Ces packages peuvent être trouvés dans les librairies qui accompagnent votre logiciel de
synthèse/simulation.
Library std
 Package standard: Définit les types de base VHDL (BOOLEAN, BIT, BIT_VECTOR,
INTEGER, NATURAL, POSITIVE, etc.) et autres opérateurs logiques, arithmétiques,
de comparaison et de décalage.
Library ieee
 Package std_logic_1164 : Définit le type à neuf valeurs STD_ULOGIC et son sous-
type résolu STD_LOGIC (8 états). Seuls les opérateurs logiques sont inclus, ainsi que
certaines fonctions de conversion de type.

 Package numeric_ std : Définit les types numériques SIGNED et UNSIGNED, avec
STD_LOGIC comme type de base. Comprend également les opérateurs logiques,
arithmétiques, de comparaison et de décalage.
Packages non standard

Les deux bibliothèques ci-dessus (STD, IEEE) sont normalisées par l'IEEE. Les paquets
suivants sont des partages communs fournis par les vendeurs d'EDA (Electronic Design
Automation).
 Package std_logic_arith : Définit les types numériques SIGNED et UNSIGNED.
Inclut quelques opérateurs arithmétiques, de comparaison et de décalage, ainsi que
quelques fonctions de conversion de type, comme : conv_integer(p),
conv_unsigned(p,b), conv_signed(p,b), and conv_std_logic_vector(p,b).
 Package std_logic_signed : Définit les opérateurs arithmétiques, de comparaison et
certains opérateurs de décalage pour le type STD_LOGIC_VECTOR comme s'il était
SIGNÉ.
 Package std_logic_unsigned : Définit les opérateurs arithmétiques, de comparaison et
certains opérateurs de décalage pour le type STD_LOGIC_VECTOR comme s'il était
SANS SIGNE.
Exemple 2.1: Conversion de donnée

LIBRARY ieee;
USE ieee.std_logic_1164.all;
USE ieee.std_logic_arith.all;
...
SIGNAL a: UNSIGNED (7 DOWNTO 0);
SIGNAL b: UNSIGNED (7 DOWNTO 0);
SIGNAL y: STD_LOGIC_VECTOR (7 DOWNTO 0);
...
y <= CONV_STD_LOGIC_VECTOR ((a+b), 8);
- - a+b est converti de UNSIGNED en une valeur STD_LOGIC_VECTOR de 8 bits, puis

affecté à y.
Une autre alternative consiste à utiliser le package std_logic_signed ou std_logic_unsigned
de la bibliothèque ieee.
Ces paquets permettent d'effectuer des opérations avec des données
STD_LOGIC_VECTOR comme si les données étaient de type SIGNED ou UNSIGNED,
respectivement.
Outre les fonctions de conversion de données décrites ci-dessus, plusieurs autres sont
souvent proposées par les fournisseurs d'outils de synthèse.
2.2.2. Entity
L'entité est une liste avec les spécifications de tous les ports d'E/S en cours de conception.
Elle permet également de déclarer des paramètres génériques, ainsi que plusieurs autres

déclarations, corps de sous-programmes et instructions concurrentes. Sa syntaxe est présentée

ci-dessous
ENTITY nomEntity IS
[GENERIC (nom de constante : type de constante := valeur de constante ;
nom de constante : type de constante := valeur de constante ;
. . .);]
PORT (nom du port: mode de signal type de signal;
nom du port: mode de signal type de signal;
. . .);
END nomEntity;
 GENERIC (facultatif) : permet la déclaration de constantes génériques, qui peuvent

ensuite être utilisées partout dans le code.
Exemple :
GENERIC (n : INTEGER:=16).
 Mode de signal : IN, OUT, INOUT, BUFFER. Les deux premiers sont unidirectionnels, le
troisième est bidirectionnel, et le quatrième est nécessaire lorsqu'un signal de sortie doit
être lu en interne. La Figure 2.2 montre les modes de signal possibles en VHDL.
 Type de signal : Les deux catégories possibles des types de signal (types de donnée)
prédéfinis (voir la section 2.3) sont des scalaires ou des vecteurs. On cite quelques types
les plus fréquemment cité :
Scalaires : BIT, STD_LOGIC, STD_ULOGIC, and BOOLEAN.
Vecteurs : BIT_VECTOR, STD_LOGIC_VECTOR, STD_ULOGIC_VECTOR,
INTEGER, SIGNED, and UNSIGNED.
Figure 2.2 Mode de signal en VHDL.
2.2.3. Architecture
L'architecture est la description du comportement interne du circuit. Cette partie contient le
code proprement dit. Il peut être concurrent ou séquentiel. Sa syntaxe est présentée ci-dessous
Architecture nomArchitecture of nomEntity is

[Partie déclarative]
Begin
( code VHDL : les instructions )
End nomArchitecture;

 Partie déclarative (facultative) : Peut contenir des objets de données de type SIGNAL,
plus les déclarations COMPONENT.
 Code : Peut-être concurrent, séquentiel ou mixte. Pour être séquentiel, les déclarations
doivent être placées à l'intérieur d'un PROCESS. Cependant, dans son ensemble, le code
VHDL est toujours concurrent, ce qui signifie que toutes ses parties sont traitées en
"parallèle", sans priorité. Par conséquent, tout PROCESS est compilé de manière
concurrente avec toutes les autres instructions situées à l'extérieur de celui-ci.
Exemple 2.2: Multiplexeur

Cet exemple d'introduction montre la conception d'un multiplexeur 4 vers 1. Le circuit est
représenté sur la figure 2.3(a), et la fonctionnalité souhaitée est exprimée dans la table de
vérité de Figure 2.3(b)
(a) (b)
Figure 2.3. Multiplexeur de l’exemple 2.2.
SOLUTION
Un code VHDL pour cet exemple est présenté à la Figure 2.4. Notez qu'il contient les trois
sections de code décrites ci-dessus. Le paquetage supplémentaire est précisément
std_logic_1164 (lignes 2 et 3).
L'entité se trouve aux lignes 5 à 9, sous le nom de Multiplexeur4vers1 (n'importe quel nom
peut être choisi sauf les mots réservés en VHDL) et contient trois signaux d'entrée et un signal
de sortie (notez les modes IN et OUT). Les signaux a à d et y ont une largeur de 8 bits et sont
de type STD_LOGIC_VECTOR; dans a et b et y, l'indexation va de 7 à 0. Le type de sel a été
déclaré comme INTEGER, bien qu'il puisse également être BIT, entre autres options.
L'architecture est dans les lignes 11-18, avec le nom myarch (peut être n'importe quel nom, y
compris le même nom que celui de l'entité). Dans sa partie déclarative (entre les mots
ARCHITECTURE et BEGIN), aucun signal interne n’a été déclaré. L'Affectation sélection
(décrite en détails dans le chapitre prochain) est utilisé pour décrire le fonctionnement du
circuit Multiplexeur come on peut le voir aux lignes 13-17.
Notez que les lignes 1, 4, 10 et 19 ont été incluses uniquement pour améliorer l'organisation et
la lisibilité du code (" -- " est utilisé pour les commentaires). Enfin, le VHDL n'est pas
sensible à la casse, mais pour faciliter la visualisation des lettres majuscules ont été employées
pour les mots VHDL réservés.

Figure 2.4. Code VHDL pour le circuit de la figure 2.3 (exemple 2.2).
Figure 2.4. Résultats de la simulation du circuit (Multiplexeur) déduit avec le code de la

figure 2.3.
Les résultats de la simulation obtenus avec le code ci-dessus sont présentés à la Figure 2.4.
Notez que les signaux d'entrées sont précédés d'une flèche avec un "I" (Input) marqué à
l'intérieur, tandis que la flèche pour le signal de sortie à un "O" (Output) marqué à l'intérieur.
Les entrées peuvent être choisies librement, tandis que la sortie est calculée et tracée par le
simulateur. Comme on peut le constater, le circuit se comporte comme prévu.
2.3. Types de donnée prédéfinis

Les types de donnée prédéfinis proviennent des Library/Package énumérés ci-dessus. Ceux
qui sont synthétisables sont listés dans le Tableau 2.1, qui indique leur nom, la bibliothèque/le
package d'origine et les valeurs synthétisables.
Tableau 2.1. Types de donnée synthétisables prédéfinis avec Library/Package d'origine et
valeurs synthétisables respectives.

Types de donnée prédéfinis Library/Package valeurs synthétisables sans

restrictions
BIT, BIT_VECTOR std/standard ‘0’, ‘1’
BOOLEAN std/standard TRUE, FALSE
INTEGER std/standard -(231-1) au +(231-1)
Longueur 32 bit
NATURAL std/standard 0 au +(231-1)
Partie positive seulement
POSITIVE std/standard 1 au +(231-1)
Partie positive seulement
CHARACTER std/standard 256 symboles d’alphabet
STRING std/standard Ensemble de caractères
REAL std/standard peu de support de synthèse
STD_(U)LOGIC, Entrée: ‘0’ ou ‘L’, ‘1’ ou ‘H’
ieee/std_logic_1164
STD_(U)LOGIC_VECTOR Sortie: ‘0’ ou ‘L’, ‘1’ ou ‘H’,’-‘
ou ‘X’, et ‘Z’
UNSIGNED, SIGNED ieee/numeric_std, Pareille comme:
ieee/std_logic_arith STD_LOGIC_VECTOR
ieee/std_logic_signed
ieee/std_logic_unsigned
 BIT (and BIT_VECTOR): 2-level logic (‘0’, ‘1’)

Exemples:
SIGNAL x: BIT;
-- x est déclaré comme un signal à une valeur de type BIT.
SIGNAL y: BIT_VECTOR (3 DOWNTO 0);
-- y est un vecteur de 4 bits, le bit le plus à gauche étant le MSB.
x <= '1';
-- x est un signal à un seul bit, dont la valeur est '1'.
-- Notez que des guillemets simples (' ') sont utilisés pour un bit unique.
y <= "0111";
-- y est un signal de 4 bits, dont la valeur est "0111" (MSB='0').
-- Notez que des guillemets doubles (" ") sont utilisés pour les vecteurs.
 STD_LOGIC (and STD_LOGIC_VECTOR): Système logique à 8 valeurs introduit

dans la norme IEEE 1164.
‘X’ Inconnu (Synthétisable)
‘0’ Niveau ‘0’ (Synthétisable)
‘1’ Niveau ‘1’ (Synthétisable)
‘Z’ Haute impédance (Synthétisable buffer à trois états (Tri-state buffer))
‘W’ Faible inconnu
‘L’ Niveau faible (Low)
‘H’ Niveau Haut (High)
‘-’ Peu importe la valeur

 STD_ULOGIC (and STD_ULOGIC_VECTOR): Système logique à 9 valeurs

introduit dans la norme IEEE 1164 (‘U’, ‘X’, ‘0’, ‘1’, ‘Z’, ‘W’, ‘L’, ‘H’, ‘-’). Ce dernier
comprend une valeur logique supplémentaire, "U", qui signifie "non résolu".
 signed(taille_vecteur) et unsigned(taille_vecteur)
Exemples:
SIGNAL y: signed (3 DOWNTO 0);
-- y est un vecteur de 4 bits de valeurs positives ou négatives.
SIGNAL y: unsigned (3 DOWNTO 0);
-- y est un vecteur de 4 bits de valeurs positives.
 Exemples :
x1 <= "00101011’’; --bit, bit_vector, signed, or unsigned
x2 <= "0010_1011’’ ; --le trait de soulignement est autorisé pour faciliter la visualisation
x3 <= ‘‘10011’’ ; --Représentation binaire de la valeur décimale 19
x4 <= B‘‘10011’’ ; --Représentation binaire de la valeur décimale 19
x5 <= O‘‘23’’ ; --Représentation octal de la valeur décimale 19
x6 <= X‘‘13’’ ; --Représentation hexadécimal de la valeur décimale 19
n <= 1500 ; --Entier
m <= 1_500 ; --Entier, le trait de soulignement est autorisé
IF lecture THEN --Boolean, execute IF lecture=TRUE
Exemple 2.3. Utilisation de type de donnée

On considère les définitions des signaux suivants :
SIGNAL a: BIT;
SIGNAL b: BIT_VECTOR(7 DOWNTO 0);
SIGNAL c: BIT_VECTOR(1 TO 16);
SIGNAL d: STD_LOGIC;
SIGNAL e: STD_LOGIC_VECTOR(7 DOWNTO 0);
SIGNAL f: STD_LOGIC_VECTOR(1 TO 16);
SIGNAL g: INTEGER RANGE -35 TO 35;
SIGNAL h: INTEGER RANGE 0 TO 255;
SIGNAL i: NATURAL RANGE 0 TO 255;
a. Combien de bits le compilateur attribuera-t-il à chacun de ces signaux ?
b. Expliquez pourquoi les assignements ci-dessous sont légales (correctes)
a <= b(5);
c(16) <= b(0);
c(1) <= a;
b(5 DOWNTO 1) <= c(8 TO 12);
e(1) <= d;
e(2) <= f(16);
f(1 TO 8) <= e(7 DOWNTO 0);
b <= "11110000";
a <= '1';
d <= 'Z';

e <= (0=>'1', 7 =>'0', OTHERS =>'Z'); -- e <= "0ZZZZZZ1";
c. Expliquez pourquoi les assignements ci-dessous sont illégales (incorrectes)

a <= 'Z';
a <= d;
c(16) <= e(0);
f(5 TO 9) <= e(7 DOWNTO 2);
2.3.1. Types de donnée SIGNED et UNSIGNED
Comme mentionné précédemment dans la section 2.2.1.1, ces types sont définis dans le
package std_logic_arith de la bibliothèque ieee. Leurs syntaxes sont illustrées dans les
exemples ci-dessous.
Exemples :
SIGNAL x: SIGNED (7 DOWNTO 0);
SIGNAL x: UNSIGNED (0 TO 3);
Remarquez que leur syntaxe est similaire à celle de STD_LOGIC_VECTOR, et non à celle
d'un INTEGER, comme on aurait pu s'y attendre.
Une valeur UNSIGNED est un nombre jamais inférieur à zéro. Par exemple, "0101"
représente le chiffre décimal 5, tandis que "1101" signifie 13. Si l'on utilise plutôt le type
SIGNED, la valeur peut être positive ou négative (au format complément à deux). Ainsi,
"0101" représenterait la valeur décimale 5, tandis que "1101" signifierait -3.
Pour utiliser les types de données SIGNED ou UNSIGNED, il faut déclarer le package
std_logic_arith, de la bibliothèque ieee. Malgré leur syntaxe, les types de donnée SIGNED ou
UNSIGNED sont principalement destinés aux opérations arithmétiques, c'est-à-dire que,
contrairement à STD_LOGIC_VECTOR, ils acceptent les opérations arithmétiques. En
revanche, les opérations logiques ne sont pas autorisées. En ce qui concerne les opérations
relationnelles (comparaison), il n'y a pas de restrictions.
Exemple : Opérations Légal ou Illégal avec des types de donnée SIGNED/ UNSIGNED
LIBRARY IEEE ;
USE IEEE.STD_LOGIC_1164.ALL ;
USE IEEE.STD_LOGIC_ARITH.ALL ; -- Package STD_LOGIC_ARITH est nécessaire
…
SIGNAL a : SIGNED (7 DOWNTO 0);
SIGNAL b : SIGNED (7 DOWNTO 0);
SIGNAL x : SIGNED (7 DOWNTO 0);
….
v <= a + b; -- légal (opération arithmétique AUTORISER)
w <= a AND b; --illégal (opération logique PAS AUTORISER)
Exemple : Opérations Légal ou Illégal avec des types de donnée STD_LOGIC_VECTOR

LIBRARY IEEE ;

USE IEEE.STD_LOGIC_1164.ALL ; -- Package STD_LOGIC_ARITH n’est pas nécessaire
…..
SIGNAL a : STD_LOGIC_VECTOR (7 DOWNTO 0);
SIGNAL b : STD_LOGIC_VECTOR (7 DOWNTO 0);
SIGNAL x : STD_LOGIC_VECTOR (7 DOWNTO 0);
….
v <= a + b; -- illégal (opération arithmétique PAS AUTORISER)
w <= a AND b; -- légal (opération logique AUTORISER)
Malgré la contrainte mentionnée ci-dessus, il existe un moyen simple de permettre aux
données de type STD_LOGIC_VECTOR de participer directement aux opérations
arithmétiques. Pour cela, la bibliothèque ieee fournit deux packages, std_logic_signed et
std_logic_unsigned, qui permettent d'effectuer des opérations avec de donnée
STD_LOGIC_VECTOR comme si les donnée étaient de type SIGNED ou UNSIGNED,
respectivement.
Exemple : Opérations arithmétiques avec STD_LOGIC_VECTOR.
LIBRARY IEEE ;
USE IEEE.STD_LOGIC_1164.ALL ; -- Package STD_LOGIC_ARITH n’est pas nécessaire
USE IEEE.STD_LOGIC_UNSIGNED.ALL ; -- Package STD_LOGIC_UNSIGNED inclus
…….
SIGNAL a : STD_LOGIC_VECTOR (7 DOWNTO 0);
SIGNAL b : STD_LOGIC_VECTOR (7 DOWNTO 0);
SIGNAL x : STD_LOGIC_VECTOR (7 DOWNTO 0);
….
v <= a + b; -- légal (opération arithmétique AUTORISER)
w <= a AND b; -- légal (opération logique AUTORISER)
2.4. Types de donnée définis par l’utilisateur

 VHDL permet également à l'utilisateur de définir ses propres types de donnée.
 L’utilisateur peut les créer à l’aide de l’instruction TYPE.
 Deux catégories de types de donnée définis par l'utilisateur sont présentées ci-dessous
: les entiers (integer) et les énumérés (enumerated).
2.4.1. Types de données basés sur les nombres entiers
Syntaxe:
TYPE nom_type IS RANGE taille_type;
Exemples:
TYPE note IS RANGE 0 TO 20;

TYPE temperature IS RANGE –5 TO 120;
2.4.2. Types de données énumérés
Syntaxe:

TYPE nom_type IS (noms_états);
Exemples:
TYPE ma_logique IS (‘0’, ‘1’ , ‘Z’) ; -- Un sous-ensemble défini par l'utilisateur de STD_LOGIC
TYPE couleur IS (vert, rouge, bleu, blanc);
TYPE etatMachine IS (arret, marche, defaillant);
2.5. SUBTYPE définis par l’utilisateur

Un SUBTYPE est un TYPE avec une contrainte. Sa syntaxe est la suivante :
SUBTYPE nom_subtype IS nom_type RANGE taille_subtype;
Exemples : Les sous-types ci-dessous sont dérivés des types présentés dans les exemples
précédents.
SUBTYPE natural IS INTEGER RANGE 0 TO INTEGER 'HIGH ;
-- Comme prévu, NATURAL est un sous-type (sous-ensemble) de INTEGER.
SUBTYPE ma_logique IS STD_LOGIC RANGE '0' TO 'Z' ;

-- Rappelons que STD_LOGIC = ('X', '0', '1', 'Z', 'W', 'L', 'H', '-').
-- Par conséquent, ma_logique = ('0', '1', 'Z').
SUBTYPE ma_coleur IS coleur RANGE vert TO bleu ;

-- Puisque coleur = ( vert, rouge, bleu, blanc), alors
-- ma_couleur = ( vert, rouge, bleu).
2.6. Tableaux (Arrays)

Les tableaux (ARRAY) sont des collections d'objets du même TYPE. Ils peuvent être
unidimensionnels (1D), bidimensionnels (2D) ou unidimensionnels par unidimensionnels
(1Dx1D). Elles peuvent également être de dimensions supérieures.
La figure 2.6 illustre la construction de tableaux de données. Une valeur unique (scalaire) est
représentée en (a), un vecteur (tableau 1D) en (b), un tableau de vecteurs (tableau 1Dx1D) en
(c), et un tableau de scalaires (tableau 2D) en (d).
En effet, les types de donnée VHDL prédéfinis (vus dans la section 2.3) ne comprennent que
les catégories scalaire (un seul bit) et vectorielle (tableau unidimensionnel de bits). Les types
prédéfinis synthétisables dans chacune de ces catégories sont les suivants :
Scalaires : BIT, STD_LOGIC, STD_ULOGIC, and BOOLEAN.
Vecteurs : BIT_VECTOR, STD_LOGIC_VECTOR, STD_ULOGIC_VECTOR,

INTEGER, SIGNED, and UNSIGNED.

Figure 2.6. Illustration des tableaux de données, (a) scalaire, (b) 1D, (c) , et (d) 2D.
Comme on peut le constater, il n'y a pas de tableaux 2D ou 1Dx1D prédéfinis, qui, le cas
échéant, doivent être spécifiés par l'utilisateur. Pour ce faire, le nouveau TYPE doit d'abord
être défini, puis le nouveau SIGNAL, VARIABLE ou CONSTANTE peut être déclaré en
utilisant ce type de donnée. La syntaxe ci-dessous doit être utilisée.
Pour spécifier un nouveau type de tableau :
TYPE nom_type IS ARRAY (taille_tableau) OF type_donnee;
Pour utiliser le nouveau type de tableau :
SIGNAL nom_signal : nom_type [ :=valeur_initiale];
Dans la syntaxe ci-dessus, un SIGNAL a été déclaré. Cependant, il pourrait également s'agir
d'une CONSTANTE ou d'une VARIABLE. Notez que la valeur initiale est facultative (pour la
simulation uniquement).
Exemples de tableaux 1D (ligne unique) :

TYPE vecteur IS ARRAY (7 DOWNTO 0) OF STD_LOGIC; -- tableau 1 × 8
TYPE vecteur_bit IS ARRAY (NATURAL RANGE <>) OF BIT;
--tableau non contrainte. La taille du vecteur « BIT_VECTOR » n’est pas déclarée

-- NATURAL RANGE <>, indique que la seule restriction est que la plage doit se situer
dans la plage NATURELLE.
Exemple : tableau (Array) 1Dx1D (4 rangées de 8 éléments chacune).

Supposons que nous voulions construire un tableau contenant quatre vecteurs, chacun de taille
huit bits.
Il s'agit alors d'un tableau 1Dx1D (voir figure 2.6). Appelons chaque vecteur par vector, et le
tableau complet par matrix.
L'implémentation du tableau serait alors la suivante (remarquez qu'un signal, appelé x, de type
matrix, a été déclaré à titre d'exemple) :
TYPE vector IS ARRAY (7 DOWNTO 0) OF STD_LOGIC ; -- tableau 1D

TYPE matrix IS ARRAY (0 TO 3) OF vector ; -- tableau 1Dx1D / --tableau 4 × 8
SIGNAL x : matrix ;

Exemple : une autre solution pour la déclaration du tableau (Array) 1Dx1D.

Une autre façon de construire le tableau 1Dx1D ci-dessus serait la suivante :
TYPE matrix IS ARRAY (0 TO 3) OF STD_LOGIC_VECTOR(7 DOWNTO 0);
Du point de vue de la compatibilité de donnée, cette dernière solution pourrait être
avantageuse par rapport à celle de l'exemple précédent.
Exemple : tableau en 2D.

Le tableau ci-dessous est réellement bidimensionnel. Remarquez que sa construction n'est pas
basée sur des vecteurs, mais plutôt entièrement sur des scalaires.
TYPE matrix2D IS ARRAY (0 TO 3, 7 DOWNTO 0) OF STD_LOGIC;

-- 2D array / -- 4 × 8 array
Exemple : Initialisation d'un tableau (array).

Comme le montre la syntaxe ci-dessus, la valeur initiale d'un SIGNAL ou d'une VARIABLE
est facultative. Cependant, lorsque l'initialisation est nécessaire, elle peut être effectuée
comme dans les exemples ci-dessous.
... :="0001" ; -- pour un tableau 1D
... :=('0', '0', '0', '1') ; -- pour un tableau 1D
... :=(('0', '1', '1', '1'), ('1', '1', '1', '0')) ; -- pour un tableau 1Dx1D ou tableau 2D
Exemple 2.4: Affectations légales et illégales de tableaux.

Les affectations dans cet exemple sont basées sur les définitions de types et les déclarations de
signaux suivantes :
TYPE vector IS ARRAY (7 DOWNTO 0) OF STD_LOGIC; -- 1D array

TYPE array1 IS ARRAY (0 TO 3) OF vector; -- 1Dx1D array
TYPE array2 IS ARRAY (0 TO 3) OF STD_LOGIC_VECTOR(7 DOWNTO 0); -- 1Dx1D
TYPE array3 IS ARRAY (0 TO 3, 7 DOWNTO 0) OF STD_LOGIC; -- 2D array
SIGNAL x: vector;
SIGNAL y: array1;
SIGNAL v: array2;
SIGNAL w: array3;
--------- Affectations scalaires légales : ---------------

-- Les affectations scalaires (un seul bit) ci-dessous sont toutes légales,
-- car le type "de base" (scalaire) est STD_LOGIC pour tous les signaux (x,y,v,w).
x(0) <= y(1)(2); -- remarquez deux paires de parenthèses (y est 1Dx1D)

x(1) <= v(2)(3); -- deux paires de parenthèses (v est 1Dx1D)
x(2) <= w(2,1); -- une seul paire de parenthèse (w est 2D)
y(1)(1) <= x(6);

y(2)(0) <= v(0)(0);

y(0)(0) <= w(3,3);
w(1,1) <= x(7);
w(3,0) <= v(0)(3);
2.6. Opérateurs en VHDL

VHDL fournit une série d'opérateurs qui sont répartis dans les six catégories ci-dessous. Les
quatre dernières sont résumées dans le Tableau 2.2, ainsi que les types de données autorisés.
2.6.1. Opérateurs d’assignements "<=", ":=", "=>"

"<=" Utilisé pour attribuer des valeurs aux signaux.
" :=" Utilisé pour attribuer des valeurs aux variables, aux constantes ou aux valeurs
initiales.
"=>" Utilisé avec le mot clé OTHERS pour attribuer des valeurs aux tableaux.
Exemples :
sig1 <= '1'; -- affectation à un signal à un seul bit
sig2 <= "00001111"; -- affectation à un signal multibit
sig3 <= (OTHERS => '0'); --résultat est sig3 <= "00...0"
VARIABLE var1: INTEGER := 0; -- affectation de la valeur initiale
var2 := "0101"; -- affectation à une variable multibit
2.6.2. Opérateurs de concaténation "&" and ","

Ces opérateurs sont employés pour regrouper des valeurs.
Exemples : Les affectations à x, y et z ci-dessous sont équivalentes.
CONSTANT k: BIT_VECTOR(3 DOWNTO 0) := "1100";
x <= ('Z', k(2 DOWNTO 1), "11111"); -- result: x <= "Z1011111"
y <= 'Z' & k(2 DOWNTO 1) & "11111"; -- result: y <= "Z1011111"
z <= (7 => 'Z', 5 => '0', OTHERS => '1'); -- result: z < ="Z1011111"
2.6.3. Opérateurs logiques NOT, AND, NAND, OR, NOR, XOR, XNOR
Le seul opérateur logique ayant la priorité sur les autres est NOT.
Exemples :
x <= a NAND b; -- résultat: x = (a.b)'
y <= NOT(a AND b); -- résultat: comme ci-dessus
z <= NOT a AND b; -- résultat: x = a'. b
2.6.4. Opérateurs arithmétiques +, –, *, /, **, ABS, REM, MOD

Ce sont les opérateurs classiques : addition, soustraction, multiplication, division,
exponentiation, valeur absolue, reste, et modulo. Ils sont également résumés dans le Tableau
2.2 avec les types de données autorisés.
Exemples :
x <= (a + b)**N;
y <= ABS(a) + ABS(b);
z <= a/(a + b);
2.6.5. Opérateurs de décalage SLL, SRL, SLA, SRA, ROL, ROR

Les opérateurs de décalage sont présentés dans le Tableau 2.2 avec les types de données
autorisés. Leurs significations sont décrites ci-dessous.
SLL (shift left logical) : Les données sont décalées vers la gauche avec des '0' dans les
positions vides.
SRL (shift right logical) : Les données sont décalées vers la droite avec des '0' dans les
positions vides.
SLA (shift left arithmetic) : Les données sont décalées vers la gauche avec le bit le plus à
droite dans les positions vides.
SRA (shift right arithmetic) : Les données sont décalées vers la droite avec le bit le plus à
gauche dans les positions vides.
ROL (rotation vers la gauche) : Décalage circulaire vers la gauche.
ROR (rotation vers la droite) : Décalage circulaire vers la droite.
Exemples :
a <= "11001";
x <= a SLL 2; --résultat: x <= "00100"
y <= a SLA 2; --résultat: y <= "00111"
2.6.6. Opérateurs de comparaison =, /=, >, <, >=, <=

Les opérateurs de comparaison sont également présentés dans le Tableau 2.2 avec les types de
données autorisés.
Exemple :
IF a >= b THEN x <= '1';
Tableau 2.2. Opérateurs synthétisables prédéfinis et types de données prédéfinis autorisés.
Type d’opérateur Opérateurs prédéfinies Types de données prédéfinis

Logique NOT, AND, NAND, OR, BOOLEAN, BIT, BIT_VECTOR,
NOR, XOR, XNOR STD_(U)LOGIC,
STD_(U)LOGIC_VECTOR,(UN)SIGNED
Arithmétique +, –, *, /, **, ABS, REM, INTEGER, NATURAL, POSITIVE,
MOD (UN)SIGNED, REAL
Décalage SLL, SRL, SLA, SRA, BIT_VECTOR, (UN)SIGNED
ROL, ROR
Comparaison =, /=, >, <, >=, <= BOOLEAN, BIT, BIT_VECTOR, INTEGER,
NATURAL, POSITIVE, (UN)SIGNED,
CHARACTER, STRING, REAL
2.7. Attributs
Les attributs VHDL prédéfinis peuvent être répartis dans les trois catégories suivantes :
1. Attributs relatifs à la plage ;

2. Attributs relatifs à la position ; et

3. Attributs relatifs à l'événement.
2.7.1. Attributs relatifs à la plage
Les attributs de donnée prédéfinis et synthétisables sont les suivants :

d'LOW : Renvoie l'indice inférieur du tableau
d'HIGH : Renvoie l'indice supérieur du tableau
d'LEFT : Renvoie l'indice du tableau le plus à gauche
d'RIGHT : Retourne l'index le plus à droite du tableau
d'LENGTH : Retourne la taille du vecteur
d'RANGE : Retourne la plage du vecteur
d'REVERSE_RANGE : Retourne la plage de vecteurs dans l'ordre inverse
Exemple : Considérons le signal suivant :

SIGNAL d : STD_LOGIC_VECTOR (7 DOWNTO 0) ;
Puis :
d'LOW=0, d'HIGH=7, d'LEFT=7, d'RIGHT=0, d'LENGTH=8, d'RANGE=(7 downto 0),
d'REVERSE_RANGE=(0 to 7).
Exemple : Considérons le signal suivant :
SIGNAL x : STD_LOGIC_VECTOR (0 TO 7) ;
Alors les quatre instructions LOOP ci-dessous sont synthétisables et équivalentes.
FOR i IN RANGE (0 TO 7) LOOP ...
FOR i IN x'RANGE LOOP ...
FOR i IN RANGE (x'LOW TO x'HIGH) LOOP ...
FOR i IN RANGE (0 TO x'LENGTH-1) LOOP ...
2.7.2. Attributs relatifs à la position
Si le signal est de type énuméré, alors :

d'VAL(pos) : Retourne la valeur à la position spécifiée
d'POS(valeur) : Retourne la position de la valeur spécifiée
d'LEFTOF(value) : Retourne la valeur à la position à gauche de la valeur spécifiée
d'VAL(ligne, colonne) : Retourne la valeur à la position spécifiée ; etc.
2.7.3. Attributs relatifs à un évènement
Considérons un signal s. Alors :

s'EVENT : Retourne vrai quand un événement se produit sur s
s'STABLE : Retourne vrai si aucun événement ne s'est produit sur s.
s'ACTIVE : Retourne vrai si s = '1'.
s’QUIET <time> : Renvoie vrai si aucun événement ne s'est produit pendant le temps
spécifié.
s'LAST_EVENT : Renvoie le temps écoulé depuis le dernier événement
s'LAST_ACTIVE : Retourne le temps écoulé depuis le dernier s = '1'.
s'LAST_VALUE : Renvoie la valeur de s avant le dernier événement ; etc.
Bien que la plupart des attributs de signaux ne servent qu'à des fins de simulation, les deux
premiers de la liste ci-dessus sont synthétisables, s'EVENT étant le plus utilisé d'entre eux.
Exemples : Les quatre affectations présentées ci-dessous sont synthétisables et

équivalentes. Elles retournent VRAI lorsqu'un événement (un changement) se produit sur
clk, ET si cet événement est un front montant se produit sur clk.
IF (clk'EVENT AND clk='1')... -- Déclaration du front montant à clk=’1’
IF (NOT clk'STABLE AND clk='1')... -- Attribut STABLE utilisé avec IF
WAIT UNTIL (clk'EVENT AND clk='1'); -- Utilisation de l'attribut EVENT avec WAIT
IF RISING_EDGE (clk)... -- appel à une fonction
2.8. Objets de donnée (Data object)

Il existe trois types d'objets en VHDL : CONSTANT, SIGNAL et VARIABLE.
2.8.1. CONSTANT
Une constante peut être déclarée et utilisée pratiquement partout (entité, architecture, package,
composant, bloc, configuration et sous-programmes). Sa syntaxe est présentée ci-dessous.
(Les constantes peuvent également être déclarées à l'aide de l'instruction GENERIC vue à la
section Entity).
Syntaxe :
CONSTANT nom_objet : Type := valeur;
Exemples:
CONSTANT ensembles_bit : BIT_VECTOR := “1001”;
CONSTANT n : NATURAL := 6;
2.8.2. SIGNAL
Les signaux définissent les E/S du circuit et les fils internes. Sa syntaxe est présentée ci-
dessous. La valeur initiale n'est là encore que pour les simulations.
Syntaxe :
SIGNAL nom_objet : Type [:= valeur_initiale];
Exemples:
SIGNAL control: BIT := '0';
SIGNAL count: INTEGER RANGE 0 TO 100;
SIGNAL y: STD_LOGIC_VECTOR (7 DOWNTO 0);
2.8.2.1. Déclaration optionnelle du signal

Exemple:
architecture descrip1 of circuit is

begin
S<= A and B or C;
end descrip1;

signal sig : std_logic;
begin
sig <= A and B;
S<= sig or C;
end descrip1;
2.8.2.2. Déclaration obligatoire du signal

Exemple:
circuit
entity circuit is
port ( A,B,C : in std_logic;
So, Sb : out std_logic);
end circuit;
begin
So <= A and B or C;
S<= not So;
end descrip1;

Utilisation du signal output
entity circuit is
port ( A,B,C : in std_logic;
So, Sb : out std_logic);
end circuit;
signal output : std_logic;
begin
output <= A and B or C;
So<= output;
Sb<= not output;
end descrip1;
2.8.3. VARIABLE
Les variables ne peuvent être déclarées et utilisées que dans des sous-programmes
(PROCESS, FUNCTION, ou PROCEDURE dans notre définition plus large), elles ne
représentent donc que des informations locales. Sa syntaxe est présentée ci-dessous. La valeur
initiale n'est là encore que pour les simulations.
Syntaxe :
VARIABLE nom_objet : Type [:= valeur_initiale];
Exemples:
VARIABLE control: BIT := '0';
VARIABLE count: INTEGER RANGE 0 TO 100;
VARIABLE y: STD_LOGIC_VECTOR (7 DOWNTO 0) ;

Chap02 - Concepts de Base Du Langage

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Chap02 - Concepts de Base Du Langage

Transféré par

Droits d'auteur :

Formats disponibles

1 Concepts de base du langage VHDL

Table des matières

Responsable de cours : Fatah YAHIAOUI

2.1. A propos du VHDL

2.2. Structure du code

ENTITY Structure du code

Responsable de cours : Fatah YAHIAOUI

2.2.1. Déclaration de Librairie (Library)

Figure 2.1. Parties fondamentales de LIBRARY.

2.2.1.1. Packages VHDL fondamentaux

Responsable de cours : Fatah YAHIAOUI

Packages non standard

Exemple 2.1: Conversion de donnée

- - a+b est converti de UNSIGNED en une valeur STD_LOGIC_VECTOR de 8 bits, puis

Responsable de cours : Fatah YAHIAOUI

déclarations, corps de sous-programmes et instructions concurrentes. Sa syntaxe est présentée

 GENERIC (facultatif) : permet la déclaration de constantes génériques, qui peuvent

Figure 2.2 Mode de signal en VHDL.

Architecture nomArchitecture of nomEntity is

Responsable de cours : Fatah YAHIAOUI

Exemple 2.2: Multiplexeur

Figure 2.3. Multiplexeur de l’exemple 2.2.

Responsable de cours : Fatah YAHIAOUI

Figure 2.4. Résultats de la simulation du circuit (Multiplexeur) déduit avec le code de la

2.3. Types de donnée prédéfinis

Responsable de cours : Fatah YAHIAOUI

Types de donnée prédéfinis Library/Package valeurs synthétisables sans

 BIT (and BIT_VECTOR): 2-level logic (‘0’, ‘1’)

 STD_LOGIC (and STD_LOGIC_VECTOR): Système logique à 8 valeurs introduit

Responsable de cours : Fatah YAHIAOUI

 STD_ULOGIC (and STD_ULOGIC_VECTOR): Système logique à 9 valeurs

Exemple 2.3. Utilisation de type de donnée

Responsable de cours : Fatah YAHIAOUI

e <= (0=>'1', 7 =>'0', OTHERS =>'Z'); -- e <= "0ZZZZZZ1";

c. Expliquez pourquoi les assignements ci-dessous sont illégales (incorrectes)

2.3.1. Types de donnée SIGNED et UNSIGNED

Exemple : Opérations Légal ou Illégal avec des types de donnée STD_LOGIC_VECTOR

Responsable de cours : Fatah YAHIAOUI

USE IEEE.STD_LOGIC_1164.ALL ; -- Package STD_LOGIC_ARITH n’est pas nécessaire

2.4. Types de donnée définis par l’utilisateur

2.4.1. Types de données basés sur les nombres entiers

TYPE nom_type IS RANGE taille_type;

TYPE note IS RANGE 0 TO 20;

2.4.2. Types de données énumérés

Responsable de cours : Fatah YAHIAOUI

TYPE nom_type IS (noms_états);

2.5. SUBTYPE définis par l’utilisateur

SUBTYPE nom_subtype IS nom_type RANGE taille_subtype;

SUBTYPE ma_logique IS STD_LOGIC RANGE '0' TO 'Z' ;

SUBTYPE ma_coleur IS coleur RANGE vert TO bleu ;

2.6. Tableaux (Arrays)

Vecteurs : BIT_VECTOR, STD_LOGIC_VECTOR, STD_ULOGIC_VECTOR,

Responsable de cours : Fatah YAHIAOUI

TYPE nom_type IS ARRAY (taille_tableau) OF type_donnee;

Pour utiliser le nouveau type de tableau :

SIGNAL nom_signal : nom_type [ :=valeur_initiale];

Exemples de tableaux 1D (ligne unique) :

--tableau non contrainte. La taille du vecteur « BIT_VECTOR » n’est pas déclarée

Exemple : tableau (Array) 1Dx1D (4 rangées de 8 éléments chacune).

TYPE vector IS ARRAY (7 DOWNTO 0) OF STD_LOGIC ; -- tableau 1D

Responsable de cours : Fatah YAHIAOUI

Exemple : une autre solution pour la déclaration du tableau (Array) 1Dx1D.

Exemple : tableau en 2D.