Cours VHDL 2018

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)
P
b
ta
r
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 système
(systm level)
Niveau TR
(register transfer level, RTL)
Niveau algorithmique
(algorithmic level)
Niveau logique
(gate level)
Niveau circuit
(circuit level)
moins abstrait
Niveau le plus abstrait (le moins détaillé).
Le système à concevoir est vu comme un
ensemble
de processus
communicants,
Niveau
architecture
Partitionnement
matériel-logiciel
mais
représentant co-design).
des fonctionnalités de
(hardware/software
Partie matérielle
très
haut niveau
comme
des processeurs,
La partie
matérielle
est décrite
au niveau
des
mémoires,
de
RTL sous
la forme des
d’une canaux
représentation
communication.
Partie logicielle
synchrone
du système décomposé en une
partie de
contrôle
et une (le
partie
opérative;
Niveau
le
moins
abstrait
plus
détaillé).
Basé
sur logicielle
l’algèbre de
Boole
avec
quelques
La
partie
est
décrite
à
un
niveau
Les
composants
de
base
sont
les
éléments
extensions
pour
introduire
les
aspects
algorithmique traditionnels
sous la forme
d’un
électriques
(transistors,
temporels
(délais).
La
correspondance
programme
constituésources..)
d’une dont
séquence
capacité,
résistance,
les
entre
équations
booléennes
et
portes
d’opérations.
comportements
sont représentés par des
logiques est immédiate.
équations mathématiques impliquant des
fonctions du temps ou de la fréquence. Le
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
logiques
(pour
un
circuit
combinatoire) ou à minimiser le
nombre d’états (pour un circuit
séquentiel)
représentant
la
fonction d’un bloc décrit au
niveau RTL.
Détermine la meilleure structure à
base de cellules standard dans
une technologie donnée ou la
meilleure programmation d’un
circuit FPGA.
Flot de synthèse logique
10
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);
end entity;
library ieee;
use ieee.std_logic_1164.all;
entity ... is
port (...
p: in std_logic);
end entity;
-- sans clause use
-- avec clause use
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;
use ieee.std_logic_1164.all;
A
B
ENTITY Add IS
port(A, B, Cin: in STD_LOGIC;
S, COut: out STD_LOGIC);
END ENTITY Add;
Cin
S
Add
Cout
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
process (A, B, Cin)
begin
if (A = '0' AND
Modification
des
valeurs des signaux de S <= '0 ’ after
end if;
sortie
if (A = '0' AND
S <= '1 ’ after
end if;
if (A = '0' AND
S <= '1 ’ after
...
end if;
wait on A,B,Cin;
end process;
end comportementale1 ;
fait référence à la déclaration
d’entité
B = '0' AND Cin = '0') then
5 ns; Cout <= '0 ’ after 5 ns;
B = '0' AND Cin = '1') then
5 ns; Cout <= '0 ’ after 5 ns;
B = '1' AND Cin = '0') then
5 ns; Cout <= '0 ’ after 5 ns;
-- Attente du prochain événement
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);
u1 : porteXOR
port map ( A, B, S1);
Chaque instance de composant
définit les associations entre
ses ports formels et ses ports
effectifs
u2 : porteET
port map ( S1, Cin, S3);
Etiquette (label):
u3 : porteXOR
port map ( S1, Cin, S);
u4 : porteOU
port map ( S2, S1, Cout);
obligatoire pour nommer
chaque instance de manière
unique.
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
B_tb
Add_1
A0
S0
B0
Cin_tb
Cin0
A_tb
Add_tb
Cout0
S_tb
Cout_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:
port
end for;
for all:
port
end for;
U0 use entity GATES.AND(bhv);
map (A => i1, B => i2, S2 <= z);
U1 use entity GATES.XOR(bhv)
map (S1 => i1, Cin => i2, S3 <= z);
-- XOR U1
……
end for; -- str
end for; -- DUT
end for; -- bench
end configuration add_tb_cfg_str;
35
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;
-q0
q1
q2
q3
modification des signaux de sortie
<= d0_reg after 5 ns;
<= d1_reg after 5 ns;
<= d2_reg after 5 ns;
<= 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;
signal int_clk: bit; -- horloge interne
39
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,
bit1: dlatch port map (d => d1, clk => int_clk,
bit2: dlatch port map (d => d2, clk => int_clk,
bit3: dlatch port map (d => d3, clk => int_clk,
-- génération de l’horloge interne
gate: and2 port map (en, clk, int_clk);
q
q
q
q
=>
=>
=>
=>
q0);
q1);
q2);
q3);
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,
s_q2, s_q3: bit;
41
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,
bit1: entity GATES.dlatch(bhv)
port map (d => d1, clk => int_clk,
bit2: entity GATES.dlatch(bhv)
port map (d => d2, clk => int_clk,
bit3: entity GATES.dlatch(bhv)
port map (d => d3, clk => int_clk,
-- instanciation directe de la porte and2
gate: entity GATES.and2(bhv)
port map (en, clk, int_clk);
end architecture str2;
q => q0);
q => q1);
q => q2);
q => q3);
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;
end process Carry;
end architecture bhv;
Demi additionneur 1bit
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;
end architecture bhv;
60
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
dffi: dff port map (clk, rst, qint(i-1), qint(i));
end generate int_cell;
internes
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