Vous êtes sur la page 1sur 69

Université Abdelmalek Essaadi

Faculté des Sciences et Techniques – Al Hoceima


Matser SER – S3

Master Systèmes Embarqués & Robotique

VHDL

Élaboré par: M. Nabil BENAYA

2018-2019
Introduction – Qu’est ce que VHDL

Vhsic Hardware Description


Language

Vhsic : Very High Speed Integrated Circuit

Langage de description de systèmes matériels

2
Introduction – Qu’est ce que VHDL

Système matériel:

Il s’agit d’un schéma mettant en oeuvre :


– un certain nombre de composants
– des connexions entre composants

3
Introduction – Qu’est ce que VHDL

• Langage pour décrire la structure et le comportement de


systèmes électroniques, en particulier des circuits digitaux (ASIC, FPGA,
. . . ).

• Langage puissant
(Il supporte plusieurs niveaux d’abstraction et autorise des
descriptions
hiérarchiques: descriptions comportementales (fonctionnelles) aussi
bien
que structurelles.
VHDL favorise une approche hiérarchique pour la description d’un
circuit complexe)

• Standard IEEE.
(Standardisation afin d’assurer une portabilité des programmes tant en
synthèse qu’en simulation)
4
Introduction – Qu’est ce que VHDL

• Indépendant de la technologie cible.


(même langage peut servir à programmer un circuit de quelques
centaines de portes, et à concevoir un circuit intégré qui en contient des
é
li it millions)
b
r ta
P o
• Indépendant de la méthodologie de conception.

• Indépendant des outils de conception.


(le même programme est accepté par des logiciels de CAO divers)

• VHDL n’est pas un langage de programmation


(c’est un langage de description (spécification) de système)

5
VHDL - Historique et évolution..

• 1980: le département de défense américain lance un appel d’offre


pour un langage qui permettrait de décrire tous les systèmes
électroniques utilisés. Motivation affichée: réutilisabilité et réduction
des coûts de conception.

• 1983: trois compagnies (Intermetics, IBM, Texas Instruments)


commencent le développement.

• 1985: première version officielle de VHDL (version 7.2).


• 1986: VHDL est donné à IEEE pour en faire un standard.
• 1987: Standard IEEE 1076-1987.
• 1993: Standard IEEE 1076-1993.
• 1999: Standard IEEE 1076.6-1999
• 2002: Standard IEEE 1076-2002 ( dernière version qui fournit une
présentation complète de VHDL).
6
VHDL – Niveaux d’abstraction

L’ensemble des modèles considérés ici est celui des systèmes


matériels (hardware systems), c’est-àdire des systèmes réalisés sous la
forme de circuits intégrés. Ces modèles peuvent être classés en termes
de niveaux d’abstraction (abstraction levels)
plus abstrait
Niveau le plus abstrait (le moins détaillé).
Niveau système Le système à concevoir est vu comme un
(systm level) ensemble
Niveau de processus
architecture communicants,
Partitionnement matériel-logiciel
Niveau TR mais représentant co-design).
(hardware/software des fonctionnalités de
Partie matérielle
(register transfer level, RTL) très haut niveau
La partie comme
matérielle des processeurs,
est décrite au niveau
des
RTL sousmémoires,
la forme desd’une canaux
représentationde
Niveau algorithmique
communication.
Partie logicielle
synchrone du système décomposé en une
(algorithmic level)
partie de
Niveau le contrôle
moins et une (le
abstrait partie
plus opérative;
détaillé).
Basé
La sur logicielle
partie l’algèbre deest Boole
décriteavec
à un quelques
niveau
Niveau logique Les composants
extensions pourde base sont
introduire les
leséléments
aspects
(gate level)
algorithmique traditionnels
électriques sous la forme d’un
(transistors,
temporels
programme (délais). La correspondance
constituésources..)
d’une dontséquence
capacité,
entre résistance,
équations booléennes et les
portes
d’opérations.
comportements sont représentés par des
Niveau circuit logiques est immédiate.
(circuit level) équations mathématiques impliquant des
fonctions du temps ou de la fréquence. Le
moins abstrait temps et la fréquence sont des variables
7
réelles.
VHDL – Simulation et synthèse
Simulation logique:

La simulation logique a pour but la vérification de circuits intégrés


de (très) grande taille (V)LSI ((Very) Large Scale Integration, 50’000 à
1’000’000 de transistors). Il s’agit de circuits fonctionnant en mode
logique qu’il n’est pas possible de vérifier au niveau électrique vu
l’énorme quantité d’information qu’il faudrait stocker et gérer au
niveau du transistor.
La simulation logique est une technique de simulation rapide basée
sur l’évaluation de fonctions logiques et la propagation d’événements
dans le modèle

8
VHDL – Simulation et synthèse
Algorithme de la simulation logique

L’élément de base d’un calculateur est constitué par l’unité centrale de


traitement (UCT, CPU : Central Processing Unit).

9
VHDL – Simulation et synthèse
Synthèse logique

La synthèse logique détermine une architecture au niveau logique en


identifiant les portes logiques nécessaires à la réalisation des blocs
définis au niveau RTL et en déterminant une interconnexion optimale de
ces portes.

Cherche à réécrire les équations


Détermine la meilleure structure à logiques (pour un circuit
base de cellules standard dans combinatoire) ou à minimiser le
une technologie donnée ou la nombre d’états (pour un circuit
meilleure programmation d’un séquentiel) représentant la
circuit FPGA. fonction d’un bloc décrit au
niveau RTL.

10
Flot de synthèse logique
VHDL – Simulation et synthèse
Synthèse logique

11
VHDL – Simulation et synthèse
Synthèse architecturale

La synthèse architecturale détermine une architecture au niveau RTL


en identifiant les ressources matérielles nécessaires à la réalisation des
opérations utilisées dans un algorithme. Deux tâches principales sont
effectuées:
• Un séquencement (scheduling) détermine l’ordre d’exécution
des opérations dans le temps sur un certain nombre de pas de
contrôle. Le séquencement détermine la partie contrôle (control
part) du système.

• Une allocation de ressources (resource sharing and binding)


assigne les opérations à un nombre limité de ressources
matérielles disponibles. L’allocation détermine la partie
opérative (datapath) du système (p. ex. ALUs, additionneurs,
multiplieurs, registres, mémoires..) et les ressources nécessaires
au transfert de données (steering logic) (p. ex. bus,
multiplexeurs). 12
VHDL – Simulation et synthèse
Synthèse architecturale

13
VHDL – Simulation et synthèse

Synthèse physique

La synthèse physique a pour but de produire une description

géométrique du circuit. Au niveau le plus détaillé, cette description

géométrique consiste en plusieurs couches de polygones, chaque couche

correspondant à un masque utilisé pour la fabrication. Les positions

relatives des polygones définissent des composants électroniques

(transistors) et des interconnexions (wires).

14
VHDL – Simulation et synthèse

Synthèse physique

La synthèse physique effectue deux tâches principales: le placement


(placement) et le routage(routing).

• Le placement à pour fonction d’assigner des positions aux cellules


faisant partie du circuit. Ces cellules peuvent être de complexités
variables allant du simple transistor, en passant par une porte
logique, jusqu’à une macro cellule (mémoire, ALU).

• Le routage a pour fonction de tirer les fils d’interconnexion entre


les cellules sans générer de croisements. L’objectif du routage est de
minimiser la longueur des interconnexions, ainsi que le nombre de
contacts et de vias.
15
VHDL – Simulation et synthèse

Synthèse physique

16
VHDL – Structure du langage

Bibliothèques

La compilation d’une unité de conception génère un fichier dont le


format n’est pas standard et donc dépend de l’outil VHDL utilisé.

Le résultat de la compilation est stocké dans une bibliothèque de


conception (design library) qui est physiquement, p. ex., un répertoire Unix
ou un dossier Windows.

Un modèle VHDL ne considère que des bibliothèques logiques et


l’association à des emplacement physiques doit être faite dans
l’environnement VHDL utilisé.

17
VHDL – Structure du langage

Bibliothèques

VHDL possède deux bibliothèques logiques prédéfinies:

• La bibliothèque de nom logique WORK est le dépositaire de toutes les


unités de conception compilées.
C’est en fait la seule bibliothèque dans laquelle il est possible d’ajouter et
de modifier des éléments.

• La bibliothèque de nom logique STD est prédéfinie et contient deux


unités: le paquetage STANDARD, qui inclut les définitions des types,
opérateurs et sous-programmes prédéfinis, et le paquetage TEXTIO, qui
inclut les définitions et les sous-programmes relatifs au traitement de
fichiers textes.
18
VHDL – Structure du langage

Bibliothèques

• Les bibliothèques sont déclarée avec le mot clé library, elle dépendent
des outils utilisés.

• Elle contiennent des paquetages que l’on déclare vouloir utiliser avec le
mot clé use:
use BIBLIOTHEQUE.PAQUETAGE.all;

• La bibliothèque par défaut est WORK. WORK est aussi le nom


symbolique de la bibliothèque dans laquelle sont stockés les résultats.

• La bibliothèque STD est une bibliothèque standard fournie avec le


langage , elle contient des définitions des types et des fonctions de base
(integer, bit,...).

19
VHDL – Structure du langage

Bibliothèques

• Par défaut, les outils considère que l’on utilise les bibliothèques STD et
WORK, il y a donc implicitement:
library STD;
library WORK;

• En général, on utilise la librairie suivante IEEE qui définit le type


std_logic:
library ieee;

20
VHDL – Structure du langage
Bibliothèques

Déclaration de bibliothèque pour accès aux éléments du paquetage IEEE

STD_LOGIC_1164.
library ieee;
entity ... is
port (...
p: in ieee.std_logic_1164.std_logic); -- sans clause use
end entity;

library ieee;
use ieee.std_logic_1164.all;
entity ... is
port (...
p: in std_logic); -- avec clause use
end entity;

Toute unité de conception possède une clause de contexte (déclaration de bibliothèque + clause
use) implicite.
library std, work;
use std.standard.all;

21
VHDL – Structure du langage
Unités de conception

Il existe cinq unités de conception permettant de décrire les


composants:
• L’entité: description de l’interface du composant (le nom et ses ports
d’entrée/sortie)
• L’architecture décrit l’intérieur du composant. Il peut y avoir plusieurs
architectures pour le même composant (ex: une pour la simulation, une
pour la synthèse).
L’architecture contient des processus.
• La configuration indiquant quelle architecture utiliser pour chaque
entité.
• La déclaration de paquetage. Un paquetage est une collection d’objets
réutilisables (constantes, types, composants, procédures)
• Le corps de paquetage

22
VHDL – Structure du langage
Entité (Entity)

L’entité est la description de l’interface du circuit (boite noire) . Elle


correspond au symbole dans les représentations schématiques.

library ieee;
A
use ieee.std_logic_1164.all; S
B Add

ENTITY Add IS Cin Cout


port(A, B, Cin: in STD_LOGIC;
S, COut: out STD_LOGIC);
END ENTITY Add;

23
VHDL – Structure du langage
Architecture

L’architecture décrit le fonctionnement souhaité pour un circuit ou


une partie du circuit (description interne du circuit).

En effet le fonctionnement d’un circuit est généralement décrit par


plusieurs modules VHDL. Il faut comprendre par module le couple
ENTITE/ARCHITECTURE. L’architecture établit à travers les instructions
les relations entre les entrées et les sorties.

On peut avoir un fonctionnement purement combinatoire, séquentiel


voire les deux séquentiel et combinatoire.

24
VHDL – Structure du langage
Modèle comportementale

• Description du fonctionnement du système : algorithmes, machine


d’états

• Algorithme proche de ceux des langages de programmation

• Le temps peut intervenir : permet de coller à la réalité par le respect des


temps de traversée

• Une description haut niveau est d’abord comportementale : elle sert de


référence pour la suite de la conception

25
VHDL – Structure du langage
Architecture comportementale Nom de l’architecture

architecture comportemental1 of Add is


begin fait référence à la déclaration
process (A, B, Cin) d’entité
begin
if (A = '0' AND B = '0' AND Cin = '0') then
Modification des
valeurs des signaux de S <= '0 ’ after 5 ns; Cout <= '0 ’ after 5 ns;
sortie end if;
if (A = '0' AND B = '0' AND Cin = '1') then
S <= '1 ’ after 5 ns; Cout <= '0 ’ after 5 ns;
end if;
if (A = '0' AND B = '1' AND Cin = '0') then
S <= '1 ’ after 5 ns; Cout <= '0 ’ after 5 ns;
...
end if;
wait on A,B,Cin; -- Attente du prochain événement
end process;
end comportementale1 ;
26
VHDL – Structure du langage
Architecture structurelle

• description par structure : liste d’éléments et interconnexions.


• ne fait pas intervenir le temps : connexions permanentes.

La Figure ci-dessous représente une vue structurelle d’un additionneur

27
VHDL – Structure du langage
Architecture structurelle

architecture structurelle1 of Add is


component porteOU -- Déclaration de composant
port ( e1 : in STD_LOGIC;
e2 : in STD_LOGIC;
s : out STD_LOGIC );
end component;
component porteET
port ( e1 : in STD_LOGIC;
e2 : in STD_LOGIC;
s : out STD_LOGIC );
end component;
component porteXOR
port ( e1 : in STD_LOGIC;
e2 : in STD_LOGIC;
s : out STD_LOGIC );
end component;
signal S1, S2, S3 : STD_LOGIC; --Déclaration des
-- signaux d’interface
28
VHDL – Structure du langage
Architecture structurelle

begin
u0 : porteET
port map ( A, B, S2);
Chaque instance de composant
u1 : porteXOR définit les associations entre
port map ( A, B, S1); ses ports formels et ses ports
effectifs
u2 : porteET
port map ( S1, Cin, S3);
Etiquette (label):
u3 : porteXOR
port map ( S1, Cin, S); obligatoire pour nommer
chaque instance de manière
u4 : porteOU unique.
port map ( S2, S1, Cout);

end structurelle1;
29
VHDL – Structure du langage
Environnement de test

L’environnement de test (testbench) d’un modèle VHDL peut être


lui-même décrit comme un modèle VHDL.

Le modèle à tester est instancié comme un composant d’un


modèle qui ne possède pas d’interactions avec le monde extérieur.
Le reste du modèle définit les stimulis à appliquer au composant
testé et un traitement éventuel des résultats obtenus aux sorties du
composant.
DUT : Design Under Test
Add_1
A_tb A0
S0 S_tb
B_tb B0
Cin_tb Cin0 Cout0 Cout_tb

Add_tb
30
VHDL – Structure du langage
Environnement de test

Un environnement de test VHDL est usuellement un mélange de


structure et de comportement.

Testbench de l’aditionneur:

-- Bibliothèques
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

--Entity
ENTITY Add_tb IS
END Add_tb;

--Architecture
ARCHITECTURE test OF Add_tb IS

31
VHDL – Structure du langage
Environnement de test

Testbench de l’aditionneur:
COMPONENT Add_1
PORT(A0 : in std_logic;
B0 : in std_logic;
Cin0 : in std_logic;
S0 : out std_logic;
Cout0 : out std_logic);
END COMPONENT;

-- Déclaration des signaux de test --


signal A_tb, B_tb,Cin_tb, S_tb, Cout_tb: std_logic;

BEGIN
-- Instanciation du composant à tester -- DUT : Design
Under Test
DUT: Add_1 PORT MAP (A0=>A_tb,B0=>B_tb,Cin0=>Cin_tb,
S0=>S_tb,Cout0=>Cout_tb);

32
VHDL – Structure du langage
Environnement de test

Testbench de l’aditionneur:

-- Création des signaux de test (Stimulis) --


process
BEGIN
A_tb <='0'; B_tb <='0'; Cin_tb <='0'; -- 000
wait for 20 ns;
A_tb <='1'; -- 100
wait for 20 ns;
A_tb <='0'; B_tb <='1'; -- 010
wait for 20 ns;
-- …
END PROCESS;
END test;

33
VHDL – Structure du langage
Configuration

La déclaration de configuration définit la vue de plus haut niveau


d’un modèle. Elle définit les associations globales entre les instances de
composants d’une architecture et les entités de conception disponibles
dans une bibliothèque (WORK ou autre).

Déclaration de configuration pour le test du modèle comportemental:

configuration add_tb_cfg_bhv of add_tb is


for bench
for DUT: add_1 use entity WORK.add(bhv)
port map (A => A0, B => B0, Cin => C0,
S <= S0, Cout <= Cout0);
end for; -- DUT
end for; -- bench
end configuration add_tb_cfg_bhv;
34
VHDL – Structure du langage
Configuration
Le test de l’architecture structurelle de l’additionneur requiert la définition d’une autre
configuration sans qu’il soit nécessaire de modifier le modèle de l’environnement de test.

Déclaration de configuration pour le test du modèle structurel:

library GATES;
configuration add_tb_cfg_str of add_tb is
for bench
for DUT: add_1 use entity WORK.add(str)
port map (A0, B0, Cin0, S0, Cout0);

for str
for all: U0 use entity GATES.AND(bhv);
port map (A => i1, B => i2, S2 <= z);
end for;
for all: U1 use entity GATES.XOR(bhv)
port map (S1 => i1, Cin => i2, S3 <= z);
end for; -- XOR U1
……
end for; -- str
end for; -- DUT
end for; -- bench 35
end configuration add_tb_cfg_str;
VHDL – Structure du langage
Exemple

Réalisez un registre 4bits avec VHDL?

36
VHDL – Structure du langage
Exemple : Registre 4bits

Déclaration d’entité du registre 4 bits.

entity reg4 is
port (
d0, d1, d2, d3: in bit; -- données d’entrée
en, clk: in bit; -- signal de contrôle et
horloge
q0, q1, q2, q3: out bit -- données de sortie
);
end entity reg4;

37
VHDL – Structure du langage
Exemple : Registre 4bits
Architecture comportementale du registre 4 bits.
architecture bhv of reg4 is
begin
process is
variable d0_reg, d1_reg, d2_reg, d3_reg: bit;
begin
if en = ’1’ and clk = ’1’ then
-- mémorisation des entrées
d0_reg := d0;
d1_reg := d1;
d2_reg := d2;
d3_reg := d3;
end if;
-- modification des signaux de sortie
q0 <= d0_reg after 5 ns;
q1 <= d1_reg after 5 ns;
q2 <= d2_reg after 5 ns;
q3 <= d3_reg after 5 ns;
-- attente du prochain événement sur l’un des
signaux d’entrée
wait on d0, d1, d2, d3, en, clk;
end process;
end architecture bhv;
38
VHDL – Structure du langage
Exemple : Registre 4bits

Architecture structurelle du registre 4 bits.

architecture str of reg4 is


-- déclaration des composants utilisés
component and2 is
port (i1, i2: in bit; z: out bit);
end component and2;
component dlatch is
port (d, clk: in bit; q: out bit);
end component dlatch;
39
signal int_clk: bit; -- horloge interne
VHDL – Structure du langage
Exemple : Registre 4bits

Architecture structurelle du registre 4 bits.

begin

-- instances de latches
bit0: dlatch port map (d => d0, clk => int_clk, q => q0);
bit1: dlatch port map (d => d1, clk => int_clk, q => q1);
bit2: dlatch port map (d => d2, clk => int_clk, q => q2);
bit3: dlatch port map (d => d3, clk => int_clk, q => q3);
-- génération de l’horloge interne
gate: and2 port map (en, clk, int_clk);

end architecture str;

40
VHDL – Structure du langage
Exemple : Registre 4bits

Environnement de test du registre 4 bits.

entity reg4_tb is
end entity reg4_tb;

architecture bench of reg4_tb is


component c_reg4 is
port (p_d0, p_d1, p_d2, p_d3, p_en, p_clk: in bit;
p_q0, p_q1, p_q2, p_q3: out bit);
end component c_reg4;

signal s_d0, s_d1, s_d2, s_d3, s_en, s_clk, s_q0, s_q1, 41


s_q2, s_q3: bit;
VHDL – Structure du langage
Exemple : Registre 4bits

Environnement de test du registre 4 bits.

begin
-- composant à tester

UUT: c_reg4 port map (p_d0 => s_d0, p_d1 => s_d1, p_d2 =>
s_d2, p_d3 => s_d3,
p_en => s_en, p_clk => s_clk,
p_q0 => s_q0, p_q1 => s_q1, p_q2 => s_q2, p_q3 => s_q3);

-- stimulis
s_clk <= not s_clk after 20 ns; -- période de 40 ns
process
begin
s_en <= ’0’;
s_d0 <= ’1’; s_d1 <= ’1’; s_d2 <= ’1’; s_d3 <= ’1’;
wait for 40 ns;
s_en <= ’1’;
wait for 40 ns; 42
VHDL – Structure du langage
Exemple : Registre 4bits

Environnement de test du registre 4 bits.

-- Suite du composant à tester

s_d0 <= ’0’; s_d2 <= ’0’;


wait for 40 ns;
s_en <= ’0’; s_d1 <= ’0’; s_d3 <= ’0’;
wait for 40 ns;
s_en <= ’1’;
wait; -- stop définitif
end process;
end architecture bench;

43
VHDL – Structure du langage
Exemple : Registre 4bits

Déclaration de configuration du registre 4 bits.

On suppose que l’entité de conception reg4(bhv) a déjà été compilée


sans erreur dans la bibliothèque WORK.

--Déclaration de configuration pour le test du modèle


comportemental du registre 4 bits.
configuration reg4_tb_cfg_bhv of reg4_tb is
for bench
for UUT: c_reg4 use entity WORK.reg4(bhv)
port map (d0 => p_d0, d1 => p_d1, d2 => p_d2, d3 => p_d3,
en => p_en, clk => p_clk,
q0 => p_q0, q1 => p_q1, q2 => p_q2, q3 => p_q3);
end for; -- UUT
end for; -- bench
end configuration reg4_tb_cfg_bhv;
44
VHDL – Structure du langage
Exemple : Registre 4bits
Déclaration de configuration du registre 4 bits.
--Déclaration de configuration pour le test du modèle
structurel du registre 4 bits.

library GATES;
configuration reg4_tb_cfg_str of reg4_tb is
for bench
for UUT: c_reg4 use entity WORK.reg4(str)
port map (p_d0, p_d1, p_d2, p_d3, p_en, p_clk,
p_q0, p_q1, p_q2, p_q3);
for str
for all: dlatch use entity GATES.dlatch(bhv);
end for;
for all: and2 use entity GATES.and2(bhv)
port map (a => i1, b => i2, z => z);
end for; -- and2
end for; -- str
end for; -- UUT
end for; -- bench
end configuration reg4_tb_cfg_str;
45
VHDL – Structure du langage

Instanciation directe

L’instanciation directe a été introduite en VHDL-93 pour offrir une


version simplifiée du mécanisme de configuration. Il n’est plus nécessaire
de déclarer de composants et de configuration. Chaque instance est
directement associée à une entité de conception.
Chaque instance doit être associée indépendamment à une entité de
conception. Il n’est pas possible d’utiliser de spécification for all dans ce
cas.

46
VHDL – Structure du langage
Instanciation directe

--Configuration du registre 4bits par instanciation directe.

library GATES;
architecture str2 of reg4 is
signal int_clk: bit; -- signal interne
begin
-- instanciations directes des latches
bit0: entity GATES.dlatch(bhv)
port map (d => d0, clk => int_clk, q => q0);
bit1: entity GATES.dlatch(bhv)
port map (d => d1, clk => int_clk, q => q1);
bit2: entity GATES.dlatch(bhv)
port map (d => d2, clk => int_clk, q => q2);
bit3: entity GATES.dlatch(bhv)
port map (d => d3, clk => int_clk, q => q3);
-- instanciation directe de la porte and2
gate: entity GATES.and2(bhv)
port map (en, clk, int_clk);
end architecture str2; 47
VHDL – Structure du langage
Spécification de configuration

La spécification de configuration (configuration specification) est une


autre forme de configuration qui ne définit pas une nouvelle unité de
conception. Elle revient à définir l’association d’une instance de
composant avec son entité de conception correspondante directement dans
le corps d’architecture, en nécessitant toutefois toujours une déclaration de
composant préalable.

Dans ce cas, la déclaration de configuration de l’environnement de test


(Code du slide 45) s’en trouve simplifiée puisqu’il n’est plus nécessaire de
spécifier la configuration de l’architecture str (la partie for str ... end for;
n’est plus nécessaire).

48
VHDL – Structure du langage
Spécification de configuration

-- Utilisation de spécifications de configurations pour


l’architecture structurelle du registre 4 bits;

library GATES;
architecture str2 of reg4 is
component and2 is
port (i1, i2: in bit; z: out BIT);
end component and2;
for all: and2 use entity GATES.and2(bhv) port map (i1, i2, z);

component dlatch is
port (d, clk: in BIT; q: out BIT);
end component dlatch;
for all: dlatch use entity GATES.dlatch(bhv);

...
begin
...
end architecture str2; 49
VHDL – Structure du langage
Processus

L’instruction concurrente de base en VHDL est le processus (process).


Tout modèle VHDL peut se décrire de manière équivalente comme un
ensemble de processus communiquant par l’intermédiaire de signaux .

VHDL définit deux classes d’objets particulières pour représenter des


données sur lesquelles un processus peut agir:

• Les signaux (signal) ont une visibilité (scope) globale dans un


modèle et permettent de partager des données entre processus.

• Les variables (variable) ont une visibilité locale dans un


processus et permettent de stocker des valeurs intermédiaires lors de
l’exécution des instructions séquentielles d’un processus.

50
VHDL – Structure du langage
Processus

entity demi_add is
port (A, B: in bit; S, CO: bit);
end entity demi_add;

architecture bhv of demi_add is


begin
Sum: process
begin
S <= A xor B;
wait on A, B;
end process Sum;

Carry: process
begin
CO <= A and B;
wait on A, B; Demi additionneur 1bit
end process Carry;
end architecture bhv;
51
VHDL – Structure du langage
Synchronisation de processus

L’instruction wait permet de définir la (les) condition(s) d’activation


d’un processus. Elle peut prendre plusieurs formes.

La forme:

wait on liste-de-signaux;
-- p. ex.
wait on S1, S2, S3;

active un processus dès qu’un événement survient sur l’un des signaux de
la liste. La liste des signaux forme une liste de sensibilité (sensitivity list).

52
VHDL – Structure du langage
Synchronisation de processus

L’instruction wait permet de définir la (les) condition(s) d’activation


d’un processus. Elle peut prendre plusieurs formes.

La forme:
wait until condition;
-- p. ex.
wait until CLK = ’1’; -- activation sur le flanc montant du signal CLK
wait on CLK until CLK = ’1’; -- forme équivalente

active un processus dès que la condition est vraie. Les signaux impliqués
dans la condition forment une liste de sensibilité. Si la liste est vide,
l’instruction wait stoppe le processus de manière définitive.

53
VHDL – Structure du langage
Synchronisation de processus

L’instruction wait permet de définir la (les) condition(s) d’activation


d’un processus. Elle peut prendre plusieurs formes.

La forme:
wait for délai;
-- p. ex.
wait for 10 ns;

active un processus après un temps de suspension spécifié par le délai.

La forme générale:

wait on liste-de-signaux until condition for délai;

est possible. Le processus est activé dès la première condition d’activation


(événement sur un signal et condition vraie) ou après le temps écoulé.
54
VHDL – Généricité

Utilisée pour passer des informations au modèle. C'est le cas lorsqu'on


veut avoir un modèle générique réutilisable (exemple: Registre de taille N
bits, additionneur à N entrées... La valeur de N est passée en paramètre
générique).

C’est un moyen de transmettre une information à un bloc :


- Vu de l’extérieur du bloc, la généricité == paramètre
- Vu de l’intérieur du bloc, paramètres == constantes

Dont les intérêts sont :


- description de composants généraux
- permettre la réutilisation des composants ( description des
bibliothèques par des modèles génériques).

55
VHDL – Généricité

VHDL permet le développement de modèles dont le comportement ou


la structure peuvent être paramétrés au moyen de trois mécanismes
complémentaires:
• Les paramètres génériques.
• Les objets d’interface non contraints.
• L’instruction concurrente generate.

56
VHDL – Généricité
Paramètres génériques :

Un exemple typique d’utilisation de paramètres génériques est la


spécification de paramètres temporels permettant de caractériser le même
comportement dans des conditions différentes.
Modèle d’un flip-flop D avec ses caractéristiques temporelles: temps de
propagation, temps de prépositionnement (setup time) et temps de
maintien (hold time)

Temps de maintien
Temps de
prépositionnement
Temps de propagation
57
VHDL – Généricité

Modèle de flip-flop D pour lequel les caractéristiques temporelles


(temps de propagation Tpd_clk_q, temps de prépositionnement (setup
time) Tsu_d_clk et temps de maintien (hold time) Th_d_clk) sont définis
comme des paramètres génériques.

entity dff is
generic (
Tpd_clk_q, -- temps de propagation
Tsu_d_clk, -- temps de pré-positionnement
Th_d_clk: delay_length -- temps de
maintien
);
port (clk, d: in bit; q: out bit);
end entity dff;
58
VHDL – Généricité

Le corps d’architecture est composé de trois processus concurrents.


• processus behavior : définit le comportement du composant en tenant
compte du temps de propagation.
• processus check_setup : vérifie le temps de pré-positionnement.
• processus check_hold : vérifie le temps de maintien.

59
VHDL – Généricité
Le corps d’architecture est composé de trois processus concurrents.

architecture bhv of dff is


begin
behavior:
q <= d after Tpd_clk_q when clk = ’1’ and clk’event;

check_setup: process is
begin
wait until clk = ’1’;
assert d’last_event => Tsu_d_clk report "Setup violation";
end process check_setup;

check_hold: process is
begin
wait until clk’delayed(Th_d_clk) = ’1’;
assert d’delayed’last_event => Th_d_clk report "Hold
violation";
end process check_hold;
60
end architecture bhv;
VHDL – Généricité

L’instanciation du composant flip-flop D avec paramètres génériques.

FF1: entity WORK.dff(bhv)


generic map (Tpd_clk_q => 4 ns, Tsu_d_clk => 3 ns, Th_d_clk => 1 ns)
port map (clk => master_clk, d => data, q => data_reg);

61
VHDL – Généricité
Objets d’interface non contraints :
entity reg is
port (clk, rst: in bit;
d: in bit_vector;
q: out bit_vector);
begin
assert d’length = q’length;
end entity reg;

architecture bhv of reg is


begin
process (clk, rst) is
constant zero: bit_vector(q’range) := (others => ’0’);
-- ou: constant zero: bit_vector(q’length-1 downto 0) :=
(others => ’0’);
begin
if rst = ’1’ then
q <= zero;
elsif clk’event and clk = ’1’ then
q <= d; -- erreur si d’length /= q’length!
end if;
end process;
end architecture bhv;
62
VHDL – Généricité
Instruction generate :
L’instruction concurrente generate permet de dupliquer des
instructions concurrentes de manière itérative ou conditionnelle.
La Figure ci-dessous illustre la structure d’un registre à décalage
générique de N bits.

63
VHDL – Généricité
Instruction generate :

entity shiftreg is
generic (nbits: positive := 8);
port (clk, rst, d: in bit; q: out bit);
end entity shiftreg;

architecture str of shiftreg is

component dff is
port (clk, rst, d: in bit; q: out bit);
end component dff;

signal qint: bit_vector(1 to nbits-1);

64
VHDL – Généricité
Instruction generate :

architecture str of shiftreg is


..
begin
cell_array: for i in 1 to nbits generate

first_cell: if i = 1 generate -- première cellule


dff1: dff port map (clk, rst, d, qint(1));
end generate first_cell;

int_cell: if i > 1 and i < nbits generate --cellules internes


dffi: dff port map (clk, rst, qint(i-1), qint(i));
end generate int_cell;

last_cell: if i = nbits generate -- dernière cellule


dffn: dff port map (clk, rst, qint(nbits-1), q);
end generate last_cell;
end generate cell_array;
end architecture str;
65
VHDL – Généricité
Exemple : ET n bits

entity Et_N is
generic ( N : Natural )
port ( Entrees : in std_logic_vector ( 1 to N ) ;
sortie : out std_logic );
end Et_N ;

architecture comportement of Et_N is


begin
process
variable V : std_logic := ‘1’ ;
begin
for i in 1 to N loop
V := V and Entrees (i) ;
end loop ;
Sortie <= V after 10 ns ;
end process ;
end comportement;

66
VHDL – Généricité
Exemple : ET n bits

entity AdditionneurN is
generic (N : Natural);
port (
X, Y : in std_logic_vector ( N-1 downto 0) ;
Cin : in std_logic;
S : out std_logic_vector (N-1 downto 0);
Cout : out std_logic);
end AdditionneurN ;

architecture structurelle of AdditionneurN is

component Add
port (
A, B, Cin : in std_logic;
S, Cout : out std_logic);
end component;

signal C : std_logic_vector(0 to N);

67
VHDL – Généricité
Exemple : ET n bits

entity AdditionneurN is
..
end AdditionneurN ;

architecture structurelle of AdditionneurN is


..

begin
for I in 0 to N-1 generate
Instance : Add
port map (X(I), Y(I), C(I), S(I), C(i+1));
end generate;
C(0) <= Cin;
Cout <= C(N);

end structurelle ;

68
69