Le Langage de

Description Matériel : VHDL

Dr. Mohammed Zakarya BABA-AHMED
Maitre de conférence classe A
[email protected]
1
 HDL (Hardware Description Language) ?
Est une instance d'une classe de langage informatique ayant pour but la description formelle d'un
système électronique.

Il peut généralement :
 Décrire le fonctionnement du circuit,
 Décrire sa structure,
 Servir à vérifier sa fonctionnalité par simulation ou preuve formelle.

Jusqu’aux années 80, les schémas étaient le principal moyen de décrire les circuits et systèmes
numériques.
Les langages de description de matériel (HDL) ont été développés et introduits dans les années
1980 pour spécifier les équations logiques à utiliser dans les PLD.
Ils avaient pour but de modéliser, donc de simuler, mais aussi de concevoir, des outils informatiques
permettant de traduire automatiquement une description textuelle en dessins de transistors. 2
 HDL (Hardware Description Language) ?

 À la différence d'un langage de programmation logiciel, la syntaxe et la sémantique

d'un HDL incluent des notations explicites pour exprimer le temps et la concurrence qui
sont les attributs principaux du matériel.

 Les classes de langages dont la seule caractéristique est de décrire un circuit par une
hiérarchie de blocs interconnectés est appelée une netlist.

 Un synthétiseur logique permet de transformer un circuit décrit dans un langage de

description de matériel en une netlist.

 Les HDL peuvent être utilisés pour décrire des systèmes numériques de haut niveau et
très détaillés au bas niveau (portes logiques).

3
 HDL
o Composant élémentaire
(porte logique)

o Circuits intégrés
(microprocesseur)
Niveau
d'abstraction o Cartes
(unité centrale)

o Systèmes
(calculateur)

o Processus 4
(système de navigation)
 Le but des HDLs ?
Le but des HDL est double :
➢ la simulation ➢ la synthèse
 L'un des objectifs des HDL est d'aboutir à une représentation  La synthèse est l’opération qui consiste, à partir du
exécutable d'un circuit, soit sous forme autonome, soit à fichier texte, à produire une netlist contenant le
l'aide d'un programme externe appelé simulateur. Cette schéma électrique destiné aux outils de placement-
forme exécutable comporte: routage (fichier binaire).
❖ une description du circuit à simuler,  En n'utilisant qu'un sous-ensemble d'un HDL, un
programme spécial appelé synthétiseur peut Générer
❖ un générateur de stimuli (vecteurs de test),
du hardware depuis HDL
❖ un dispositif implémentant la sémantique du langage et
 Le sous-ensemble du langage utilisé à ce propos est
l'écoulement du temps (résultats).
alors dit synthétisable.
 Il existe deux types de simulateurs:
 La synthèse nécessite un processus complexe afin
1/ à temps discret, généralement pour le numérique, d’optimiser un arrangement entre le temps et
2/ à temps continu pour l'analogique. l’espace.

Remarque: Des HDL existent pour ces deux types de

simulations.
5
 Les Principaux Langages HDLs ?
 ABEL "Advanced Boolean Expression  SystemC utilisant le C++ et qui permet de
Language", un langage de programmation en modéliser les interactions logiciel/matériel;
électronique (notamment pour la programmation
des PLD) développé par Data I/O Corporation en  Confluence, langage déclaratif GPL(General
1984, maintenant possédé par Lattice; Public License) pouvant générer du Verilog, du
VHDL, des modèles exécutables en C et des
 AHDL ("Altera HDL", langage propriétaire
d'Altera pour la programmation de leurs FPGA)
modèles de vérification formelle;
langage propriétaire essentiellement structurel  CUPL "Compiler for Universal Programmable
proche d'ABEL; Logic" langage propriétaire de Logical Devices;
 Verilog (Verilog HDL) qui mélange description Lancé par Assisted Technology en 1983.
structurelle et algorithmique ; utilisé pour la  VHDL-AMS (Analog and Mixed-Signal
conception d'ASICs (application-specific
extensions) : extension de VHDL destinée aux
integrated circuits) et de FPGAs (field-
programmable gate array).
circuits analogiques ou mixtes. Les langages
mixtes, qui sont souvent des extensions des
 VHDL légèrement plus abstrait que Verilog qui précédents. Ils permettent la modélisation des
est inspiré de l’ancien language orienté objet
systèmes à l'aide d'équations différentielles.
ADA (créer en 1980); 6
VHDL
7
 VHDL ?
Le programme VHSIC ( Very High Speed Integrated Circuits), impulsé par le département de la
défense des Etats-Unis dans les années 1970-1980, a donné naissance à un langage : VHSIC-HDL,
connu sous le nom de VHDL .

Le langage de description VHDL est ensuite devenu une norme IEEE en 1987. Révisée en 1993 puis en 2002
pour supprimer quelques ambiguïtés et améliorer la portabilité du langage, cette norme est vite devenue un
standard en matière d'outils de description de fonctions logiques.
A ce jour, on utilise le langage VHDL pour :
 concevoir des ASIC,
 programmer des composants programmables du type SPLD, CPLD et FPGA,
8
 concevoir des modèles de simulations numériques ou des bancs de tests.
 Le but du VHDL ?

 Le but d'un langage de description matériel tel que le VHDL est de faciliter le développement d'un
circuit numérique en fournissant une méthode rigoureuse de description du fonctionnement et de
l'architecture du circuit désirée.

 L'étape suivante consiste à synthétiser cette description matérielle pour obtenir un composant
réalisant les fonctions désirées, à l'aide d'éléments logiques concrets (portes logiques, bascules ou
registres). Ceux-ci seront implémentés, selon la technologie utilisée, soit directement en transistors
(dans le cas d'un ASIC), ou en se basant sur les éléments programmables des FPGA.

 Le VHDL ayant une double fonction (simulation et synthèse), une partie seulement du VHDL est
synthétisable, l'autre existant uniquement pour faciliter la simulation (écriture de modèles
comportementaux et de test benches).

9
 Avantage du VHDL

 Les avantages du langage VHDL :

❖ La portabilité.

❖ La conception de haut niveau.

❖ La possibilité de décrire des systèmes très complexes en quelques lignes de code.

❖ De plus, le VHDL :
peut être simulé,
peut être traduit en schéma de portes logiques.
10
 Environnement du VHDL
• Plateforme : PC/Station
✓ Éditeurs de texte,
✓ Compilateur
✓ Synthèse
✓ Simulateurs
✓ Interfaces graphiques (courbes stimulis & résultats)

• Notion de projets
✓ Un analyseur (transformation du code VHDL en éléments logiques de base)
✓ Un Place & Route (placement et connection des éléments logiques dans le composant).

• Bibliothèque communes (IEEE) et bibliothèques utilisateur (WORK)

✓ bibliothèques : IEEE
✓ paquetages IEEE
✓ paquetages standards 11

✓ paquetages propriétaires
 Outils VHDL

Beaucoup de logiciels prennent en charge toutes ces fonctionnalités :

• VIVADO
• Xillinx ISE
• Altera Quartus
• Lattice ISP Lever
• Altium Designer
• etc...

12
SPARTRAN 3E réf XC3S500E -FG320

13
NEXYS 3: SPARTRAN 6 réf XC6LX16-CS324

14
NEXYS 3: SPARTRAN 6 réf XC6LX16-CS324

15
ALTERA: DE2-115

16
 Développement du VHDL

• Une description VHDL : est un ensemble de fichiers d’extension .Vhd permettant :

➢ Édition des fichiers VHDL

➢ Faire référence aux bibliothèques et paquetages nécessaires (IEEE , WORK)
➢ Compilation
➢ Simulation
➢ Synthèse

➢ Suite ? ASIC , FPGA

17
 Les unités de compilation VHDL

L'analyse d'un modèle VHDL peut s'effectuer sur des parties du code ou
"unités de compilation". Il existe 5 types d'unités de compilation :

• Entité (vue externe)

• Architecture (vue interne)
• Configuration (couple: entité-architecture)
• Paquetage (déclarations globales, …)
• Corps du paquetage (sous-programmes, …) 18
19
 Les unités de compilation VHDL

• Entité

Signaux d’entrée Signaux de sortie

Syntaxe:

entity mon_circuit is
port (les signaux d’entrée : in (type des signaux);
les signaux de sortie: out (type des signaux));
end mon_circuit;
20
 Les unités de compilation VHDL
• Architecture

Signaux d’entrée
? Signaux de sortie

Syntaxe:

architecture exemple of mon_circuit is

partie déclarative optionnelle : types, constantes, signaux locaux, composants.
begin
corps de l’architecture.
(suite d’instructions parallèles : affectations de signaux; processus explicites; blocs;
instanciation (i.e. importation dans un schéma) de composants.
21
end exemple ;
 Les unités de compilation VHDL
• Exemple

Library ieee ;
Use ieee.std_logic_1164.all ;

Entity porte_et is
Port (A, B: in std_logic;
O: out std_logic);
end porte_et ;

Architecture arch_porte_et of PORTE_ET is

begin
O <= A and B;
end arch_porte_et;
 Les unités de compilation VHDL

• La configuration:

Syntaxe :
configuration configuration_name of entity_name is for architecture_name

for label|others|all: comp_name

use entity [lib_name.]comp_entity_name(comp_arch_name) |
use configuration [lib_name.]comp_configuration_name
[generic map (...)]
[port map (...)] ;
end for;
...
end for;
end configuration_name;
23
 Les unités de compilation VHDL
• Exemple de configuration:
Library Ieee; Library Ieee;
Use Ieee.Std_logic_1164.All; Use Ieee.Std_logic_1164.All;
Entity Ha_entity Is Entity Ha_comp_entity Is
Port ( Port (
bit1 : In Std_logic; I_bit1 : In Std_logic;
bit2 : In Std_logic; I_bit2 : In Std_logic;
sum : Out Std_logic; O_sum : Out Std_logic;
carry : Out Std_logic O_carry : Out Std_logic
); );
End Ha_entity; End Ha_comp_entity;

Architecture Ha_arch Of Ha_entity Is Architecture Ha_comp_arch_1 Of Ha_comp_entity Is

Component Ha_comp_entity Is Begin
Port (
I_bit1 : In Std_logic; O_sum <= I_bit1 Xor I_bit2;
I_bit2 : In Std_logic; O_carry <= I_bit1 And I_bit2;
O_sum : Out Std_logic;
O_carry : Out Std_logic End Ha_comp_arch_1;
);
End Component Ha_comp_entity;
Begin use work.all;
Ha_inst : Ha_comp_entity configuration HA_Config of HA_Entity is
Port Map (
bit1 => I_bit1, for HA_Arch
bit2 => I_bit2,
sum => O_sum,
for HA_Inst : HA_Comp_Entity
carry => O_carry); use entity work.HA_Comp_Entity(HA_Comp_Arch_1);
End Ha_arch; end for;
end for; 24
end HA_Config;
• La configuration:
• Considérez ce diagramme, par exemple: Entité A
(A des architectures A1, A2 et A3)
......
......
......
Entité B Entité C
(A des architectures B1, B2) (A l'architecture C1 et C2)

• Maintenant, la configuration fonctionne comme une liste de pièces:

Entité Architecture
A -> A2 CONFIGURATION cfg_A of A IS FOR A2 END FOR;
END cfg_A;

B -> B2 CONFIGURATION cfg_B of B IS FOR B2 END FOR;

END cfg_B;

C -> C1 CONFIGURATION cfg_C of C IS FOR C1 END FOR;

END cfg_C;

• VHDL utilisera ces architectures pour votre entité spécifiée.

25
 Les unités de compilation VHDL
• Paquetage:
Syntaxe:
package PKG1 is
✓ constant C1 : integer;
✓ procedure cvt(I : in std_logic_VECTOR; o: out integer);
✓ function cvt(I : in std_logic_VECTOR) return POSITIVE);
✓ component CMP
generic (N : integer);
port (A, B : in std_logic; Y : out std_logic);
end component;
end PKG1;
Et il faut faire la référence du paquage au début du fichier x.vhd qui utilise les éléments du paquage.
use work.PKG1.all;
entity COMP is
port(..... 26
.....
.....;
 Les unités de compilation VHDL
• Le corps de paquetage:
Syntaxe:

package body PKG1 is

constant C1 : integer := 16;
procedure cvt(I : in STD_LOGIC_VECTOR; o: out integer) is
begin
o := cvt(I);
end cvt;
function cvt(I : in STD_LOGIC_VECTOR) return integer is
begin
return ( cvt_std_logic_vector_int(I) );
end cvt;
end PKG1
27
 LA SÉMANTIQUE DU LANGAGE VHDL
• Les mots clés:
abs, access, after, alias, all, and, architecture, array, assert, attribute,
begin, block, body, buffer, bus, case, component, configuration, constant,
disconnect, downto, else, elsif, end, entity, exit, file, for, function,
generate, generic, guarded, if, in, inout, is, label, library, linkage, loop,
map, mod, nand, new, next, nor, not, null, of, on, open, or, others, out,
package, port, procedure, process, range, record, register, rem, report,
return, select, severity, signal, subtype, then, to, transport, type, units,
until, use, variable, wait, when, while, with, xor.

• Les identificateurs:

Servent à nommer les objets du langage (constantes, variables, signaux).

28
 LA SÉMANTIQUE DU LANGAGE VHDL
• Règles à respecter:
✓ Ils commencent par une lettre,
✓ Ils contiennent des lettres, des chiffres et des traits bas (_),
✓ Ils ne doivent pas contenir deux traits bas consécutifs (_ _),
✓ Ils ne doivent ni commencer, ni finir par un trait bas,
✓ Un identificateur ne doit pas excéder une ligne de programme,
✓ La différence minuscule majuscule n'est pas significative,
✓ Ils doivent être différents des mots clés.

• Les commentaires:
✓ -- 2 traits consécutifs indiquent que le reste de la ligne est du commentaire.
✓ Ils sont liés à la ligne
✓ Ils sont nécessaires à la compréhension du modèle mais totalement ignorés
par le compilateur.
29
 LA SÉMANTIQUE DU LANGAGE VHDL
Le langage VHDL exploite 4 objets différents:

✓ Les signaux: ils portent les informations des liaisons

d’entrée, des liaisons de sortie et des liaisons internes.
✓ Les constantes: elles reçoivent leurs valeurs au moment de
leurs déclarations.
✓ Les variables: elles ne sont déclarées et utilisées que dans
les processus, les fonctions et les procédures. L’assignation
initiale est facultative.
✓ Les ports: ils sont les signaux d'entrées et de sorties de la
fonction décrite : ils représentent en quelques sortes les
signaux des broches du composant VHDL en cours de
description.
30
 LA SÉMANTIQUE DU LANGAGE VHDL
➢ VHDL permet de manipuler des objets typés
➢ Un objet est le contenant d'une valeur d'un type donné
➢ Tout objet doit être typé (sauf indice de boucle)
➢ Un type définit l'ensemble des valeurs et l'ensemble des
opérations disponibles sur cet objet

Les types de données:

✓ Les types énumérés
✓ Les types numériques non énumérés
✓ Les types utilisateurs

31
 LA SÉMANTIQUE DU LANGAGE VHDL
Les types énumérés:

• Type BIT: ce type peut prendre deux valeurs : ‘0’ ou

‘1’. Ces deux valeurs ne sont pourtant pas suffisantes
pour satisfaire les besoins de la synthèse logique : par
exemple, l'état haute impédance n'est pas envisagé !
• Type BIT_VECTOR: ce type permet de manipuler des
grandeurs résultant de l'association d'éléments de type
BIT (i.e. des vecteurs de bits ou mot).
• Type BOOLEAN: ce type ne peut prendre que deux
valeurs différentes : TRUE (vrai) ou FALSE (faux)

32
 LA SÉMANTIQUE DU LANGAGE VHDL
Les types énumérés:
• Types STD_LOGIC et STD_LOGIC_VECTOR: ces types sont inclus
dans la bibliothèque IEEE 1164,
✓ STD_LOGIC : 9 valeurs décrivant tous les états d’un signal logique
‘U’ : non initialisé**
‘X’ : niveau inconnu, forçage fort** (**) Utile pour la simulation
‘0’ : niveau 0, forçage fort (*) Utile pour la synthèse
‘1’ : niveau 1, forçage fort
‘Z’ : haute impédance *
‘W’ : niveau inconnu, forçage faible**
‘L’ : niveau 0, forçage faible
‘H’ : niveau 1, forçage faible
‘-’ : quelconque (don’t care) *
✓ STD_LOGIC_VECTOR : vecteur de STD_LOGIC
• Pour utiliser ces types il faudra inclure les directives suivantes dans le code
source.
library ieee; 33

use ieee.std_logic_1164.all;
 LA SÉMANTIQUE DU LANGAGE VHDL
Les types énumérés:

✓ Types CHARACTER et STRING :

Les variables de type CHARACTER prennent 95 valeurs
différentes correspondant à une partie du jeux de caractères
ASCII. Le type STRING résulte de l'association de plusieurs
éléments de type CHARACTER.

✓ Type SEVERITY_LEVEL:
Ce type est employé avec une fonction spécifique aux
programmes de tests et permet de caractériser le niveau de
gravité programmable lors d'incidents de simulation. Les
variables de ce type peuvent prendre les valeurs suivantes :
NOTE, WARNING, ERROR, FAILURE. 34
 LA SÉMANTIQUE DU LANGAGE VHDL

Les types numériques non énumérés:

✓ Type INTEGER: valeurs signées codées sur 32 bits.

✓ Type REAL: l'étendue des valeurs dépend du

compilateur VHDL et la norme VHDL impose des
valeurs aux puissances de 10 au moins comprises entre
-38 et +38.

✓ Sous-types NATURAL: ce type correspond en fait à

une restriction du type INTEGER dans on conserve
toutes les valeurs supérieures ou égales à 0.
35
 LA SÉMANTIQUE DU LANGAGE VHDL

Les types numériques non énumérés:

✓ Sous-types POSITIVE: De la même façon, le sous-type

POSITIVE est une restriction du type INTEGER dont
seules les valeurs supérieures à 0 sont conservées.

✓ Types UNSIGNED et SIGNED: ces types UNSIGNED et

SIGNED utilisent pour base des vecteurs de bits. L'éventail
des valeurs que peut couvrir une variable ou un signal de
type UNSIGNED ou SIGNED dépendra du nombre de bits
qui lui sera attribué lors de la déclaration.

36
 LA SÉMANTIQUE DU LANGAGE VHDL

Les types utilisateurs:

✓ Types énumérés définis par l'utilisateur:

Il est possible de créer de nouveaux types de données.

✓ Types numériques non énumérés définis par l'utilisateur:

Pour la création de type non énuméré, le VHDL dispose du mot
clé RANGE faisant office de directive et permettant de
spécifier l'intervalle des valeurs valides pour le type créé.

37
 LA SÉMANTIQUE DU LANGAGE VHDL
Les types utilisateurs:

✓ Enregistrement : RECORD:
Lorsque des informations de toute nature doivent être réunies,
VHDL permet la création d'un type spécifique qui autorisera la
manipulation de toutes ces données sous un même identificateur,
appelé enregistrement. On utilise alors le mot clé record.

✓ Types vectoriels:
Les types utilisateurs qui viennent d'être décrits sont des
scalaires. On peut aussi créer des types vectoriels dont on fixe le
nombre d'éléments dans la déclaration du type ou lors de la
déclaration de l'instance. Ces types reposent sur le mot clé array.
38
 LA SÉMANTIQUE DU LANGAGE VHDL
Les opérateurs:
❖ Opérateurs d'affectation:
Le VHDL utilise deux opérateurs d'affectations:
➢ Affectation à un signal: pour réaliser une affectation à un
signal, on utilise l'opérateur <= EXEMPLE S <= not A;
➢ Affectation à une variable: l'affectation à une variable
exploite l'opérateur := EXEMPLE i := i + 1

❖ Opérateurs relationnels:
Ils sont valables avec des signaux et des variables scalaires et
vectoriels.
=, /= (différent), <, <=, >, >= EXEMPLE IF A>B THEN …
la différence entre l'opérateur relationnel <= et l'opérateur
d'affectation <= est effectuée par le compilateur en fonction de 39

son contexte d'utilisation.

 LA SÉMANTIQUE DU LANGAGE VHDL
Les opérateurs:
❖ Opérateurs logiques:
Ils s'appliquent à des signaux ou des variables de types
booléens, bits et dérivés : BIT, BIT_VECTOR, STD_LOGIC,
STD_LOGIC_VECTOR, BOOLEAN.
➢ AND, OR, NAND, NOR et XOR.
➢ and n’est pas prioritaire par rapport à or (utiliser des
parenthèses)
➢ Dans le cas d'opérandes de types STD_LOGIC_VECTOR ou
BIT_VECTOR, l'opération logique s'effectue BIT à BIT (cela
implique des opérandes de tailles identiques pour les
opérateurs binaires).

40
 LA SÉMANTIQUE DU LANGAGE VHDL
Les opérateurs:
❖ Opérateurs arithmétiques:
Ils sont définis pour les types entiers et réels.
+ , -, *, / (division entière), ** (exponentiation), mod (modulo),
rem (reste de la division), abs (valeur absolue).

❖ Opérateur de concaténation:
L'opérateur de concaténation & permet de manipuler des
tableaux de tout type et de différentes tailles pour en réaliser
l'association sous un autre label de dimension plus i.

A <= "1100";
B <= "0011"; 41

C <= A & B; --c <= "11000011"

 LA SÉMANTIQUE DU LANGAGE VHDL
Les opérateurs:
Classement par priorité croissante :
❑ AND, OR, NAND, NOR et XOR.
❑ +, - et & (add, sub , concaténation de chaînes et signaux).
❑ Opérateurs de signe : (opérateurs unaires) +, -
❑ Opérateurs de multiplication : *, / (division entière),
❑ mod (modulo),
❑ rem (reste de la division).
❑ ** (exponentiation),
❑ abs (valeur absolue),
❑ et not (opérateur logique unaire).
❑ Fonctions
❑ sll (shift left logical), sla (shift left arithmetic),
❑ sra (shift right arithmetic), srl (shift right logical),
❑ rol (rotate left), ror (rotate right), 42
❑ xnor (exclusive nor).
 LES INSTRUCTIONS
Instructions concurrentes:

❑ Propriétés:

✓ L’ordre d’écriture des instructions n’a pas d’importance (c’est le

parallélisme).
✓ Une instruction concurrente décrit une opération qui porte sur des
signaux (entrée, interne) pour produire d’autres signaux (interne,
sortie).
✓ Tous les signaux mis en jeu dans l’architecture sont disponibles au
même moment.
✓ Le corps d’architecture est décrit dans un ou plusieurs styles.
✓ Le style n’est pas imposé par le type de logique (combinatoire ou
séquentielle) ou le type de traitement des données (parallèle ou
séquentiel).
43
✓ Trois styles peuvent coexister au sein d’une même architecture.
 LES INSTRUCTIONS
Instructions concurrentes:

❑ Propriétés:

✓ Le VHDL est un langage concurrent ➠ le système à modéliser peut

être divisé en plusieurs blocs agissant en parallèle.

✓ L'instruction concurrente est exécutée quand un évènement sur

certains de ses signaux apparait:
➠ Instanciation de composants
➠ Process
➠ Affectation de signaux
➠ Appel de procédure
➠ Assertion
➠ Bloc
➠ Génération
44
 LES INSTRUCTIONS
Instructions concurrentes:

❑ Instanciation de composants
Création d'un composant dont le modèle est défini ailleurs (hiérarchie).

architecture structurelle of porte_xor is

.....
begin
U3 : PORTE_ET port map (S1,B,S3);
U5 : PORTE_OU port map (S3,S4,S);
U1 : INVERSEUR port map (A,S1);
U4 : PORTE_ET port map (A =>A,B =>S2,O=>S4);
U2 : INVERSEUR port map (B,S2);
end structurelle; 45
 LES INSTRUCTIONS
Instructions concurrentes:

❑ Process
Ne contient que des instructions séquentielles
Un process "vit" toujours ➠ cyclique
Doit être controlé par sa liste de sensibilité ou des synchronisations
internes (wait).
process ( liste de sensibilité) process process (A,B)
Déclarations Déclarations begin
if a = b then o <= ‘0’ ;
begin begin else o <=‘1’;
instructions séquentielles wait on (liste de signaux) end if;
........ instructions séquentielles end process;

end process; ........

end process;
46

Remarque: Ne pas mettre une liste de sensibilité et un ( ou des) wait !!

 LES INSTRUCTIONS
Instructions concurrentes:

❑ Affecter des valeurs à des signaux:

Affectation simple:
Signal <= forme d'onde { délai }; Exemple S<= ‘1’; / S<= A; / S<= A xor b;

Affectation conditionnelle:

Signal <= forme d'onde 1 when condition 1 else forme d'onde 2;

Exemple
Entity vecteur is Architecture when_else of vecteur is
Port (A: in std_logic_vector (3 downto 0); begin
S: out std_logic_vector (1 downto 0)); S<= ''11'' when A=''0101'' else
end vecteur; ''01'' when A=''0110'' else 47

''10'' when A=''1101'';

end when_else;
 LES INSTRUCTIONS
Instructions concurrentes:

❑ Affecter des valeurs à des signaux:

Affectation sélective:

with expression select

Signal <= forme d'onde 1 when choix 1, 48

forme d'onde 2 when choix 2,

forme d'onde 3 when OTHERS;

Exemple
Architecture with_select of vecteur is
begin
with A select
S<= ''11'' when ''0101'',
''01'' when ''0110'',
''10'' when ''1101'',
''00'' when others;
end with_select;
 LES INSTRUCTIONS
Instructions concurrentes:
❑ L'appel de procédures:
Dans le cas d'un appel concurrent les paramètres sont des signaux ou des constantes
sensible à un événement sur les paramètres d'entrée.

{label:} Procedure nom_de_la_procedure (liste des paramètres);

❑ Les assertions
Surveille une condition et génère un message si la condition est fausse
On y associe un niveau d'erreur qui peut être pris en compte par le simulateur

{label:} assert condition report {message du rapport } severity {niveau_de_gravité };

Le niveau de gravité peut être défini comme le niveau note, warning, error or failure suivant le résultat de la simulation.

Exemple: assert (J /= C) report "J = C" severity note; 49

 LES INSTRUCTIONS
Instructions concurrentes:
❑ Les blocs
✓ Similaires à un process mais contiennent des instructions concurrentes
✓ Le "block" permet :
– la hiérarchisation des instructions concurrentes et des déclarations locales
– de synchroniser les instructions du bloc avec l'extérieur de ce dernier

label : block { condition de garde optionnelle}

-- déclarations locales
begin
-- instructions concurrentes
end block label;
50
Remarque: Il est préférable d’éviter l’instruction BLOCK dans les petits programmes (circuits) ou quand vous avez la
possibilité d'utiliser des instanciations des composants car l'instruction block est utilisé plus pour la lisibilité du code VHDL.
 LES INSTRUCTIONS
Instructions concurrentes:
❑ L'instruction "generate"
Raccourci d'écriture ➠ élaboration itérative ou conditionnelle d'instructions
concurrentes
❖ forme conditionnelle :
➥les instructions sont générées si la condition est vraie
{label :} if condition_booléenne generate
........
suite d'instructions concurrentes
end generate {label} ;
❖ forme itérative :
➥génération de structures répétitives indicées
{label :} for nom_de_l'index in intervalle_discret generate
......... -- l'index n'a pas besoin d'être déclaré 51

instructions concurrentes
end generate {label} ;
 LES INSTRUCTIONS
Instructions séquentielles:

❑ Propriétés:

✓ Elles sont utilisées dans les process ou les corps de sous-programmes.

✓ Elles permettent des descriptions comportementales:

➠ Affectation de variables
➠ Affectation séquentielles de signaux
➠ Instruction de synchronisation
➠ Instructions de contrôle
➠ Appels de procédure
➠ Assertion
➠ Null
52
 LES INSTRUCTIONS

Instructions séquentielles:

❑ Affectation de variables: (Changement immédiat)

resul := 4;
resul := resul + 1;

❑ Affectation de signal: (affecte une valeur future)

S <= ‘4’ after 10 ns; -- On parle du programme bien sure et
S2 <= S1 after 20 ns; --non pas du programme test bench
53

Remarque : on peut affecter un signal à un autre mais pas une sortie à une autre
 LES INSTRUCTIONS
Instructions séquentielles:
❑ structure de test : if….then…..else
if condition booléenne then .....;
else ......;
end if;
Exemple
Architecture if_then of vecteur is
begin
process (A)
begin
if A=''0101'' then S<= ''11'' ;
else if A=''0110'' then S<= ''01'' ;
else if A=''1101'' then S<= ''10'' ;
end if;
end if;
end if;
end process;
end if_then;
 LES INSTRUCTIONS
Instructions séquentielles:
❑ structure de choix : case

case expression is
when valeur1 => ........; Exemple
when valeur2 => ........; Architecture case_is of vecteur is
begin
when valeur3 => ........; process (A)
when others => .........; begin
case A is
end case; when ''0101'' => S<= ''11'' ;
when ''0110'' => S<= ''01'' ;
when ''1101'' => S<= ''10'' ;
when others => S<= ''00'' ;
end case;
end process;
end case_is; 55
 LES INSTRUCTIONS
Instructions séquentielles:
❑ structure de boucle: LOOP Exemples

1/ U1:while A>B loop

{label:} while condition loop A<= ‘‘0000’’;
...... end loop u1;
end loop {label};
2/ U2:for I in 1 to 10 loop
{label:} for INDICE in 1 to 10 loop if (REPEAT = '1')
...... then I := I-1;
end if;
end loop {label}; end loop u2;
-- INDICE n'est pas à déclarer, il est du type integer
-- N'est pas visible de l'extérieur, pas modifiable
56
 LES INSTRUCTIONS

Instructions séquentielles:
❑ WAIT

wait on ... until... for...;

wait on clock, data;
wait on clock until data = '1';
wait on clock until data ='1' for 30 ns;
wait for 10 ns;
wait until clock = '1';
wait;
57
 LES INSTRUCTIONS
Instructions séquentielles:
❑ Appel de procédure
Process
begin
....
test_valeur (A,B);
....
end Process; -- Appel en séquentiel
❑ Return
Utilisé dans les sous-programmes pour revenir à l'appelant.
return; -- cas d'une procédure
58
return valeur; -- cas d'une fonction
 LES INSTRUCTIONS
Instructions séquentielles:
❑ ASSERT
assert S_OUT /= "0000"
report "S_OUT est nul "
severity warning; -- testé en séquentiel
❑ NULL
case A is
when "001" => S <=...... ;
when "101" => S <=...... ;
when "110" => S <=...... ;
when others => NULL;
59
end case;
 LES INSTRUCTIONS

❑ Next:
next [ etiquette ] [ when condition ] ;

Permet de passer à l’itération suivante d’une boucle.

❑ Exit:
exit [ etiquette ] [ when condition ] ;

Permet de provoquer une sortie de boucle.

60
 CONVERSION DE TYPES DE DONNÉES
❖ Conversion de types de données:
✓ Convertir EXPLICITEMENT un type en un autre.
✓ les types à représentation entière ou flottante,
✓ les tableaux de même dimension et de type d'indices convertibles.

❖ Conversion d'un entier vers std_logic_vector.

Z <= conv_std_logic_vector (X, Y);
X : le paramètre entier à convertir et Y: le nombre de bits.
❖ Conversion d'un std_logic_vector vers entier.
X <= conv_integer (Z);
61

Z: la valeur binaire (std_logic_vector) à convertir

 CONVERSION DE TYPES DE DONNÉES

❖ conv_std_logic_vector(x, y) est une fonction de conversion fournie dans

le package ieee.std_logic.unsigned et ieee.std_logic.arith qui a besoin de
2 paramètres : le paramètre entier à convertir et le nombre de bits.
ex: Z <= conv_std_logic_vector(12, 8); z <= ‘‘00001100’’;
❖ conv_integer(z) est une fonction de conversion fournie dans le package
ieee.std_logic.unsigned et ieee.std_logic.arith qui a besoin d’un seul
paramètre : la valeur binaire (std_logic_vector) à convertir.
ex: X <= conv_integer(‘‘00001100’’); x <= 12; 62
 LES ATTRIBUTS
▪ Associés à des types ou à des objets

▪ Valeurs dynamiques

▪ Prédéfinis mais possibilité d'attributs utilisateurs

▪ Ils portent :
✓ sur les types scalaires
✓ sur les tableaux
✓ sur des signaux

▪ Simplification de l'écriture et généricité (Héritage paramétré

par des objets ou types existants)
63

▪ Les attributs se note avec une ' après le type ou l'objet

 LES ATTRIBUTS
Les attributs sur types
Exemple :
type GAMME is (DO,RE,MI,FA,SOL,LA,SI);
subtype INDEX is integer range 16 downto 0 ;
INDEX'left =16 GAMME'val(3) =FA
INDEX'right = 0 GAMME'pos(LA) =5
INDEX'low = 0 GAMME'pos(DO) =0
INDEX'high =16 GAMME'pred(RE) =DO
GAMME'right =SI INDEX'succ(13) =14
GAMME'high =SI INDEX'rightof(13) =12
GAMME'val(INDEX'leftof(0)) =RE
64
Le dépassement de dimension sur le type provoque une erreur :
GAMME'succ(SI) = erreur !!!
 LES ATTRIBUTS
Les attributs sur tableaux
Exemple :
subtype OCTET is bit_vector (7 downto 0) ;
type MEMOIRE is array (positive range <>, positive range <>) of bit ;
variable DATA : OCTET ;
variable ECRAN : MEMOIRE (1 to 640 , 1 to 480) ;
OCTET'left = 7 ECRAN'right(1) = 640
OCTET'high = 7 ECRAN‘left(2) = 1
OCTET'range : 7 downto 0 ECRAN'range(1) : 1 to 640
OCTET'reverse_range : 0 to 7 DATA'right = 0
ECRAN'reverse_range(2) : 480 downto 1
OCTET'lenght = 8 ECRAN'range(2) : 1 to 480

Les attributs ne s'appliquent pas sur un type tableau non contraint : 65

MEMOIRE
 LES ATTRIBUTS
Les attributs sur signaux
Exemple :

clk'event
clk'event and clk = '1'
❖ Renvoie la valeur booléenne true si le signal clk,
de type bit, vaut 1 après un changement de
valeur, ce qui revient à tester la présence d’une
transition montante de ce signal.
66
 PROGRAMMATION MODULAIRE
Les fonctions
Une fonction retourne au programme appelant une valeur unique,
elle a donc un type.

➢ Déclaration :
function nom [ ( liste de paramètres formels ) ]
return nom_de_type ;

➢ Corps de la fonction :
function nom [ ( liste de paramètres formels ) ]
return nom_de_type is
[ déclarations ]
begin
67
instructions séquentielles
end [ nom ] ;
 PROGRAMMATION MODULAIRE
Exemple
➢ Declaration :
Function bit_count (a: std_logic_vector(3 downto 0))
return integer;
➢ Corps de la fonction :
Function bit_count (a: std_logic_vector(3 downto 0))
return integer is
variable count:std_logic:='0';
begin
for i in 0 to 3 loop
if a(i)='1'then
count:= count+1;
end if;
end loop;
return count; 68

end bit_count;
 PROGRAMMATION MODULAIRE
Les fonctions
Le corps d’une fonction ne peut pas contenir d’instruction wait,
les variables locales, déclarées dans la fonction, cessent d’exister
dès que la fonction se termine.

➢ Utilisation :

nom ( liste de paramètres réels )

Lors de son utilisation, le nom d’une fonction peut apparaître

partout, dans une expression, où une valeur du type correspondant
peut être utilisée.
69
 PROGRAMMATION MODULAIRE
Les procédures
Une procédure, comme une fonction, peut recevoir du
programme appelant des arguments : constantes, variables ou
signaux. Donc une procédure peut renvoyer un nombre quelconque
de valeurs au programme appelant.

➢ Déclaration :
procedure nom [ ( liste de paramètres formels ) ];
➢ Corps de la fonction :
procedure nom [ ( liste de paramètres formels ) ] is
[ déclarations ]
begin
instructions séquentielles 70

end [ nom ] ;
 PROGRAMMATION MODULAIRE
Les procédures
Dans la liste des paramètres formels, la nature des arguments doit
être précisée :

procedure exemple ( signal a, b : in bit ; signal s : out bit ) ;

Le corps d’une procédure peut contenir une instruction wait,

Les variables locales, déclarées dans la procédure, cessent
d’exister dès que la procédure se termine.

➢ Utilisation :

nom ( liste de paramètres réels )

71
 PROGRAMMATION MODULAIRE
Exemple
➢ Declaration :
Procedure parity2 (a:in std_logic_vector;signal p:out
std_logic);

➢ Corps de la fonction :
Procedure parity2 (a:in std_logic_vector;signal p:out
std_logic) is
variable b:std_logic:='0';
begin
for i in a'range loop
b:= b xor a(i);
end loop;
p <= b;
end parity2; 72
 PROGRAMMATION MODULAIRE
Les paquetages
Un paquetage permet de rassembler des déclarations et des sous
programmes, utilisés fréquemment dans une application, dans un
module qui peut être compilé à part, et rendu visible par
l’application au moyen de la clause use.
Les paquetages standard ou dite prédéfinis.
Un compilateur VHDL est toujours assorti d’une librairie, décrite
par des paquetages, qui offre à l’utilisateur des outils variés.
Les paquetages créés par l’utilisateur.
L’utilisateur peut créer ses propres paquetages. Cette possibilité
permet d’assurer la cohérence des déclarations dans une
application complexe, évite d’avoir à répéter un grand nombre de
fois ces mêmes déclarations et donne la possibilité de créer une
librairie de fonctions et procédures adaptée aux besoins des
73
utilisateurs.
 PROGRAMMATION MODULAIRE
Les librairies
Une librairie est une collection de modules VHDL qui ont déjà
été compilés. Ces modules peuvent être des paquetages, des entités
ou des architectures.
Une librairie par défaut, work, est systématiquement associée à
l’environnement de travail de l’utilisateur. Ce dernier peut ouvrir
ses propres librairies par la clause library :

library nom_de_la_librairie ; exemple Library IEEE;

La façon dont on associe un nom de librairie à un, ou des,

chemins, dans le système de fichiers de l’ordinateur, dépend de
l’outil de développement utilisé.
74
 LES PAQUETAGES DE LA LIBRAIRIE IEEE
• Le type STD_LOGIC {'U', 'X', '0', '1', 'Z', 'W', 'L', 'H', '-'}

• type BOOLEAN is (FALSE, TRUE);

• type BIT is ('0','1');

• type CHARACTER is (null, .... ascii, .... DEL);

• type SEVERITY_LEVEL is (NOTE, WARNING, ERROR, FAILURE);

• -- Types numériques prédéfinis:

❑ type INTEGER -2_147_483_648 to 2_147_483 647;
❑ type REAL is range -16#0.7FFFFF8#E+32 to 16#0.7FFFFF8#E+32;

• -- Type TIME prédéfini:

❑ type TIME is range -922337203685475808 to 9223_372_036_854_775_807
units fs; -- femtoseconde = 10-15 sec / 10 15 sec= 9223 sec ≈ 3 heures
1ps= 1000 fs
75
1ns= 1000ps ……. 1sec= 100 ms………
1hr= 60mn;
 LES PAQUETAGES DE LA LIBRAIRIE IEEE

-- Fonction:
permet de donner l'heure courante de simulation.
❑ function now return time;

-- les déclarations des sous-types : natural, positive, string et bit_vector.

❑ subtype natural is integer range 0 to integer'high;
❑ subtype positive is integer range 1 to integer'high;

-- Types tableaux prédéfinis:

❑ type string is array (positive range <>) of character;
❑ type STD_LOGIC_VECTOR is array(natural range <>) of STD_LOGIC;
76
 MODÉLISATION EN VHDL

❑ Les 3 niveaux de description:

❖ La description en flot de données.

❖ La description comportementale.

❖ La description structurelle.
77
 LES NIVEAUX DE DESCRIPTION
La description en flot de données
✓ Utiliser des instructions concurrentes d’assignation de signal.
✓ Description de la manière dont les données circulent de signal
en signal, ou d’une entrée vers une sortie
✓ Trois types d’instructions :
étiquette : … <= …
étiquette : … <= … when … else …
étiquette : with … select … <= … when …

✓ L’ordre d’écriture des instructions d’assignation de signaux est 78

quelconque (le parallélisme).

 LES NIVEAUX DE DESCRIPTION
La description comportementale
✓ Utiliser des instructions concurrentes d’appel de processus.
✓ Certains comportements peuvent être décrits de façon
algorithmique ; il faut alors les définir comme des processus.
✓ Dans l’architecture utilisatrice, un processus est considéré comme
une instruction concurrente.
✓ Instruction d’appel de processus :
étiquette: process
déclarations
begin
Instructions séquentielles
end process; 79
 LES NIVEAUX DE DESCRIPTION
La description comportementale
✓ L’ordre d’écriture des instructions d’appel de processus est quelconque.
✓ Un processus contient des instructions séquentielles qui ne servent qu’à traduire
simplement et efficacement, sous forme d’un algorithme, le comportement d’un
sous-ensemble matériel.
✓ À l’intérieur d’un processus, trois types d’instruction d’assignation de signaux
et deux types d’instruction d’itération
… <= …
if … then … else …
case … when …
for … loop …
while … loop … 80

✓ L’ordre d’écriture des instructions à l’intérieur du processus est déterminant.

 LES NIVEAUX DE DESCRIPTION
La description structurelle
❑ Instructions concurrentes d’instanciation de composant.
❑ Interconnexion de composants (component), à la manière
d’un schéma, mais sous forme d’une liste.
❑ Dans l’architecture utilisatrice, un composant peut être
considéré comme une boîte noire.
❑ Un composant est instancié à l’aide d’une instruction d’appel
de composant :
étiquette : nom_composant port map ( liste des entrées et sorties );
❑ L’ordre d’écriture des instructions d’instanciation de composants est
81

quelconque. Mais la liste doit suivre l’ordre des E/S déclaré auparavant
 LES NIVEAUX DE DESCRIPTION
La description structurelle
❑ Par définition, un composant est aussi un système
logique (un sous-système) ; à ce titre, il doit aussi être
décrit par un couple (entity, architecture) dans lequel
sont définis ses entrées-sorties et son comportement.
❑ Le corps d’architecture du composant (le
comportement) est décrit selon un ou plusieurs
Descriptions ; par exemple, un composant peut faire
appel à d’autres composants.
❑ Un composant peut être rangé dans une bibliothèque.
82
 LES NIVEAUX DE DESCRIPTION

Exemple

83
 SIMULATIONS

VHDL est à la fois un langage de synthèse et de simulation.

✓ Un testbench VHDL est un code VHDL destiné à la

vérification, par simulation, du bon fonctionnement d’un
système, lui-même décrit en VHDL.

✓ Dans l’industrie, les testbenches jouent un rôle très

important ; ils sont intégrés dans les spécifications d’un
système
84
 SIMULATIONS

▪ Simulation avec un fichier de test (testbench)

Recommandée

➢ Méthodique

➢ Gain de temps énorme

▪ Simulation directe (à éviter, sauf si vous avez des

simulations déjà tester auparavant)
85
 SIMULATIONS
Simulations directe

▪ Charger le composant à simuler dans le simulateur.

▪ Faire varier entrée par entrée à chaque pas de simulation.
▪ Si on a 1 circuit : horloge + reset + 10 entrées !
▪ Pour un test exhaustif : 2¹¹ +1 possibilités.
▪ Si 1 possibilité 5 sec.
▪ Alors il faut ~ 170 min. = ~ 3heures juste pour fixer les entrées.
86
 SIMULATIONS
Procédure de test

87
 SIMULATIONS
Simulation par fichier de test (testbench)
❑ On veut simuler un composant nommé A :
❑ Créer un composant B sans entrées-sorties(fichier test).
❑ Déclarer le composant A à simuler.
❑ Déclarer des signaux internes
✓ Autant de signaux que les entrées-sorties du composant
❑ Instancier le composant A : placer le composant A dans le
composant B puis le connecter aux signaux internes. 88
 SIMULATIONS
Simulation par testbench
❑ En VHDL :
Les entrées : lecture seulement
Les sorties : écriture seulement
❑ Compilation
❑ Chargement dans le simulateur
❑ Choix des signaux à observer
❑ Lancement de la simulation
❑ Résultat sur la fenêtre des courbes 89
 SIMULATIONS

Fichiers de test ?

❑ Écrit à la main

❑ Fichier modèle (copié puis modifié)

❑ Généré par l’outil puis complété par le scénario des entrées !

90
 SIMULATIONS
Le code VHDL d'un banc de test
❑ Structure du fichier pour le système à tester
Entité (Entrés,sorties)
Architecture
Déclarations
Instructions
❑ Structure du fichier pour le banc de test:
Entité (ni entrée, ni sortie)
Architecture
Déclaration de composant du système à tester
Déclaration des signaux de test
91

Instruction d'instanciation
Instructions de génération de stimuli (entrées )
 SIMULATIONS
Code du système à tester (une porte xor)

Library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;

Entity porte_xor is
Port ( a : in STD_LOGIC;
b : in STD_LOGIC;
x : out STD_LOGIC);
end porte_xor;

Architecture Behavioral of porte_xor is

Begin
x <= a xor b;
end Behavioral;
92
 SIMULATIONS
Code du banc de test
Library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;

ENTITY TEST_PORTEXOR IS
END TEST_PORTEXOR;

ARCHITECTURE behavior OF TEST_PORTEXOR IS Begin

-- Component Declaration for the Unit Under Test (UUT) -- Instantiate the Unit Under Test (UUT)
COMPONENT porte_xor uut: porte_xor PORT MAP (
PORT( a : in std_logic; a => a,
b : in std_logic; b => b,
x : out std_logic ); x => x
END COMPONENT; );
-- Signal Declaration -- Generate stimuli
signal a : std_logic := '0'; a <= '1' after 100 ns, '0' after 300 ns;
signal b : std_logic := '0'; b <= '1' after 150 ns, '0' after 350 ns;
signal x : std_logic; END behavior;
93
 SIMULATIONS
Instructions VHDL destinées à la génération de stimuli
❑Instructions concurrentes:

❖ L’instruction concurrente d’affectation à temps non nul : <= after

a <='1'after 100 ns,'0' after 300 ns;-- à placer dans
b <='1'after 150 ns,'0’after 350 ns; -- le corps d’architecture

❖ Les instructions d’appel de processus

stim_proc: process
begin 94

-- insérer des instructions séquentielles ici

end process;
 SIMULATIONS
❑ Instructions séquentielles d’un processus:

❖ Remarques préliminaires
✓ Un processus destiné à la génération de stimuli n’a pas de liste de
sensibilité.
✓ Un processus est cyclique (durée de vie = durée de simulation);
arrivé à son mot clé final end process, il se ré-exécute toujours,
sauf si auparavant il est endormi avec une instruction d’attente
inconditionnelle (wait).
✓ Un processus contient des instructions d’affectation de valeur et
obligatoirement des instructions de contrôle de type wait.
exemple: (wait for 20 ns;)

95
 SIMULATIONS
❑L’instruction séquentielle d’attente conditionnelle : wait for

❖ L’instruction wait for est utilisée pour contrôler le processus.

Elle permet de placer des points d’arrêt momentanés.
stim_proc: process -- pas de liste de sensibilité
begin
wait for 100 ns; a <= '1';
wait for 50 ns; b <= '1';
wait for 100 ns; a <= '0';
wait for 50 ns; b <= '0';
end process;
96
 SIMULATIONS
❑ L’instruction séquentielle d’attente inconditionnelle : wait
❖ L’instruction wait suspend indéfiniment le processus
à partir de l’instant où le simulateur l’exécute.
stim_proc: process
begin
wait for 100 ns; a <= '1';
wait for 50 ns; b <= '1';
wait for 100 ns; a <= '0';
wait for 50 ns; b <= '0';
wait; -- suspension du processus
end process;
97
 SIMULATIONS
❑ L’instruction séquentielle d’itération : for loop
constant n : positive := 10; -- dans la zone de déclaration de l’architecture
begin -- début du corps d’architecture
boucle: process
begin
loop1: for i in 1 to n-1 loop
a <= '1';
wait for i*100 ns;
a <= '0';
wait for (n-i)*100 ns;
end loop;
end process;
b <= '1' after 10 us;
98
99
MERCI POUR
VOTRE
AIMABLE
ATTENTION
100