REPUBLIQUE ALGERIENNE DEMOCRATIQUE ET POPULAIRE

MINISTERE DE L’ENSEIGNEMENT SUPERIEUR ET DE LA RECHERCHE SCIENTIFIQUE

Université de Mohamed El-Bachir El-Ibrahimi - Bordj Bou Arreridj

Faculté des Sciences et de la technologie

09/12/2020
PROGRAMMATION VHDL

HAMADACHE Fouzia
PLAN DU COURS
• Introduction
1

09/12/2020
• Langages de description matérielle
2

• Concept du langage VHDL

3

• Constituants d’un programme VHDL

4

• Formalismes d’architectures
5

• Description flot de données

6

• Description comportementale
7
2
• Description structurelle
8
 INTRODUCTION

09/12/2020
 La conception d’un circuit numérique
graphiquement est très efficace mais si le circuit
logique est grand comportant des centaines de
portes, il est difficile de le représenter
graphiquement et prend beaucoup de temps, on a
donc besoin d’un langage qui présente une
syntaxe qui aide à décrire le circuit, on cherche
alors un langage de description matérielle.

3
LANGAGES DE DESCRIPTION MATÉRIELLE
 Un langage de description matérielle HDL (Hardware

09/12/2020
Description Language) est une représentation
textuelle d'un comportement temporel ou d'une
structure d'un circuit.

Verilog

AHDL

HDL
VHDL

4
SystemC
 LANGAGE VHDL

09/12/2020
V H D L

VHSIC
Very High Language
Speed Hardware Description
Integrated
Circuit

5
 Le langage VHDL a été écrit dans les années 70
pour la simulation de circuits électroniques. On
l’a ensuite étendu en lui rajoutant des extensions
pour permettre la conception (synthèse) de

09/12/2020
circuits logiques programmables
(P.L.D. Pro- grammable Logic Device).
 VHDL est un langage de programmation pour la
conception de systèmes numérique.
 Il autorise plusieurs méthodologies de conception
(comportemental, flot de données, structurel) tout
en étant d'un très haut niveau d'abstraction en
électronique (il est indépendant de la technologie
utilisée : FPGA, CPLD, ASIC, etc.). Cette
abstraction permet d'ailleurs de le simuler sur
ordinateur avant de programmer la moindre
puce.
6
 CONCEPT DU LANGAGE VHDL
 Les commentaires débutent par deux signes tirets.

09/12/2020
 Les instructions se terminent par un point virgule

 Les éditeurs actuels affichent les mots réservés du

langage en couleur
 Le langage n’est pas sensible à la casse.

7
 TYPES DE DONNÉES EN VHDL
 VHDL est un langage typé où il est obligatoire

09/12/2020
de spécifier le type des objets utilisés.

Numériques

Scalaires Enumérés

Physique

Tableau
Types
Composites

Enregistrement

Fichier

8
Accés
 TYPE EN VHDL
 Le type (TYPE) définit le format des données et
l’ensemble des opérations légales sur ces

09/12/2020
données.
 type type_name is type_definition;
 Exemples:
 type COULEUR is (ROUGE, JAUNE, BLEU,
VERT, ORANGE) ;
 type QUATRE_ETATS is ( ’X’ , ’ 0 ’ , ’ 1 ’ , ’Z ’ ) ;
 type Year is ( Jan , Feb ,Mar ,Apr , Jun , Jul ,Aug
, Sep , Oct Nov , Dec ) ;

9
 SOUS-TYPE EN VHDL

09/12/2020
 Un sous-type (SUBTYPE) n’est pas un nouveau
type, mais plutôt une restriction (contrainte) sur
les valeurs d’un type de base.
subtype subype_name is type_name [ contrainte ]
subtype Semester1 is Year range Jan to Jun ;
subtype Semester2 is Year range Jul to Dec

Remarque:
range permet d'indiquer l'intervalle

10
 TYPES NUMÉRIQUES

09/12/2020
Types
numériques

Entiers Réels
11
 TYPES ENTIERS

09/12/2020
 Le type entier INTEGER est un type numérique
prédéfinis définit sur 32 bits  231 ,231  1
 
type integer is range -2147483647 to 2147483647 ;
2 sous types sont définis:
subtype natural is integer range 0 to integer’high ;
subtype positive is integer range 1 to integer’high ;
 Exemples de types non prédéfinis :
type Byte is range 0 to 255;
type Bit_Index is range 31 downto 0 ;
 Remarque:
La notation INTEGER’HIGH représente le plus grand
élément du type INTEGER. La notation ’HIGH est un
12
attribut de type.
 TYPES RÉELS

09/12/2020
 Le type réel REAL est un type numérique
prédéfinis définit sur 32 bits
type REAL is range -1.0E38 to +1.0E38;

 Exemples de types non prédéfinis :

type Signal_Level is range -15.0 to +15.0;
type Probabilité is range 0.0 to 1.0 ;

13
 TYPES ÉNUMÉRÉS

09/12/2020
Types
énumérés

Std_logic et
Bit et Character
Std_logic_vec boolean
bit_vector tor
et String

14
 BIT ET BIT_VECTOR

09/12/2020
type bit is ( ’ 0 ’ , ’ 1 ’ ) ;
type bit_vector is (natural range 0 to 7) of bit;
type bit_vector is (natural range 7 downto 0) of bit;

15
 STD_LOGIC ET STD_LOGIC_VECTOR
 Le type std_logic permet de représenter tous les états
réels d’un signal, ils seront toujours utilisés pour
modéliser les signaux dans les circuits. Ce type peut

09/12/2020
prendre 9 états:
’U’ : non défini (non initialisé)
’X’ : inconnu forcé
’O’ : zéro forcé
’1’ : un forcé
’Z’ : haute impédance
’W’ : inconnu faible (Weak)
’L’ : zéro faible
’H’ : un faible
’-’ : indifférent (Don’t care)
 type std_logic is ( ’U’ , ’X’ , ’ 0 ’ , ’ 1 ’ , ’Z ’ , ’W’ , ’L’ , ’H’ , ’-’)
;
 type std_logic_vector is (natural range <>) of std_logic ; 16
 BOOLEAN ET CHARACTER
 type boolean is ( true, false) ;

09/12/2020
 type character is ( NUL, SOH, STX, ETX,...,
'0','1', ...);
 Types CHARACTER et STRING

Les variables de type CHARACTER prennent 95

valeurs différentes correspondant à une partie du
jeux de caractères ASCII (tous les caractères sans
les codes de contrôle)
 Le type STRING résulte de l'association de
plusieurs éléments de type CHARACTER.
 D’autres types énumérés peuvent être définis par
l’utilisateur, par exemple :
17
type Mixed is ( False , ’A’ , ’B’ ) ;
 TYPE PHYSIQUE
 VHDL permet de définir des types physiques pour représenter
une grandeur physique, comme le temps, la tension, etc...

09/12/2020
 Un type physique est la combinaison d'un type entier et d'un
système d'unité.
Le type TIME, est le seul type physique prédéfini
type time is range $- to $+ dépend de la machine
units
f s ; unité de base (femtoseconde)
ps = 1000 fs ;
ns = 1000 ps ;
us = 1000 ns ;
ms = 1000 us ;
s e c = 1000 ms ;
min = 60 sec ;
hr = 60 min ;
18
end units ;
 TYPE TABLEAU
 Un type tableau (ARRAY) est un type composite
déclarant une collection de valeurs de même type

09/12/2020
de base. Un type tableau peut être
monodimensionnel (avec un indice) ou
multidimensionnel (avec plusieurs indices).
type Word is array (31 downto 0) of bit ;
type Address is range 0 to 255;
type Memory is array ( Address ) of Word ;

19
 FICHIERS

09/12/2020
type File_name is file of File_type ;
Exemples:
type File_str is file of String ;
type File_bat is file of natural ;

20
 TYPE ENREGISTREMENT
 Un type enregistrement (RECORD) est un type
composite déclarant une collection de valeurs

09/12/2020
dont les types de base peuvent être différents,
c-a-d permet de rassembler plusieurs valeurs de
type différents appelées champs. On pourra
accéder aux valeurs par notation pointée.
type Record_name is record
Champ_1 : bit ;
Champ_2 : real ;
Autre_champ : type_énuméré ;
end record ;
21
 CLASSES D’OBJETS
 VHDL reconnait quatre classes d’objets : les

09/12/2020
constantes, les variables, les fichiers et les
signaux. Tout objet peut prendre des valeurs d’un
certain type, prédéfini ou non.

Classes
d’objets

Constantes Variables Signaux Fichiers

22
 CONSTANTES
 Une constante (constant) a par définition une valeur fixe
définie une fois pour toute.

09/12/2020
 Déclaration

constant constant_name:constant_type :=constant_value ;

o Exemples

constant PI : real := 3 . 1416 ;

constant periode : time := 5 ns ;
Constant Null_BitVector:bit_vector(15 downto 0) := (others => ’ 0 ’ ) ;

23
 VARIABLES
 Une variable (variable) est un objet dont la
valeur est modifiable par affectation.

09/12/2020
 Déclaration

Variable variable_name :variable_type ;

 Affectation

Variable_name:=expression;
 Exemples:

variable count : natural ;

Variable High : boolean;

24
 SIGNAUX
 En VHDL, le signal est une information qui existe
physiquement dans le circuit.
Déclaration

09/12/2020


Signal signal_name :signal_type ;

 Affectation
Signal_name<=expression;
 Exemples:

signal S : bit_vector(15 downto 0 ) := (others => ’ 0 ’ ) ;

signal CLK: bit := ’0 ’ ;

25
 FICHIERS
 Un type fichier définit une information qui est
stockée dans des fichiers externes. Les éléments d’un

09/12/2020
fichier peuvent être de n’importe quel type scalaire,
enregistrement ou tableau monodimensionnel.
 A chaque déclaration de type fichier sont associées
implicitement les opérations suivantes :
ouverture du fichier (file_open),
fermeture du fichier (file_close),
lecture du fichier (read),
détection de la fin de fichier (endfile),
écriture dans le fichier (write).

26
 OPÉRATEURS

09/12/2020
Opérateurs

logiques décalage relationnels

arithmétiques

27
 OPÉRATEURS LOGIQUES
 Les opérateurs logiques sont définis pour les types :
 Bit, bit_vector , std_logic et std_logic_vector

09/12/2020
28
 OPÉRATEURS ARITHMÉTIQUES
 Les opérateurs numériques sont définis pour les types
numériques. L’utilisation de ses opérateurs pour le

09/12/2020
type std_logic_vector nécessitera l’utilisation d’une
bibliothèque , il est recommandé d’utiliser uniquement
le paquetage normalisé numeric_Std

29
 OPÉRATEURS RELATIONNELS
 Les opérateurs relationnels sont définis pour les
types scalaires et tableaux de scalaires, mais les

09/12/2020
deux opérandes doivent être de même type.

30
 OPÉRATEURS DE DÉCALAGE
 Les opérateurs relationnels sont définis pour les
types scalaires et tableaux de scalaires.

09/12/2020
31
 OPÉRATEUR DE CONCATÉNATION
 L’opération de concaténation notée &, permet de
construire un vecteur à partir de deux ou plusieurs

09/12/2020
vecteurs, c’est une simple juxtaposition des valeurs.
 Exemple:

signal A, B : std_logic_vector(7 downto 0) := "10111111";

B <= A(7 downto 2) & "00" ;

32
 ATTRIBUTS
 Un attribut (attribute) permet d’accéder aux propriétés
associées aux types et aux objets VHDL.

09/12/2020
Obj’Attribut
Il existe des attributs sur les types, sur les objets de type
tableau et sur les signaux.
Les principaux attributs de type , de tableaux et de
signaux :

33
 CONSTITUANTS D’UN PROGRAMME VHDL
 Une description VHDL est constitué de trois sections
fondamentales :

09/12/2020
 Library declarations : contient la liste de toutes les
librairies utilisées dans cette conception (design).
 Entity : spécifie les pins I/O du circuit (pins d’entrée et
sortie)
 Architecture : contient le code VHDL proprement dit
qui décrit le comportement du circuit.

34
 LIBRAIRIES OU BIBLIOTHÈQUES
 Toute description VHDL a besoin de bibliothèques.
 La structure d’une librairie est donnée par :

09/12/2020
Le code sous forme de fonctions , procédures et composant
sont placés dans un paquetage et sont compilés dans la
librairie de destination.
 Pour déclarer une librairie deux lignes sont nécessaires :

 une précise les noms des librairies utilisées (clauses

Library)
 Une précise les déclarations qui doivent être visibles (clause
use).
35
Library library_name;
Use library_name.package_name.package.parts
 Trois librairies et 3 paquetages sont nécessaire
dans une conception :

09/12/2020
 Les librairies std et work sont visibles par défaut
donc pas la peine de les déclarer, seule la librairie
IEEE doit être implicitement déclarée .

36
 LIBRAIRIE WORK

09/12/2020
 Librairie work : comme son nom l’indique la
librairie de travail dans laquelle sont rangées les
unités compilées (tous les fichiers .vhd et tous les
fichiers créés par le compilateur et le
simulateur).
 C’est la seule bibliothèque dans laquelle il est
possible d’écrire (modification d’unités existantes
ou insertion de nouvelles unités). Toutes les
autres bibliothèques ne peuvent être accédées
qu’en mode de lecture.

37
 LIBRAIRIE STD

09/12/2020
Librairie STD

Package Package textio

standard

38
PACKAGE STANDARD

09/12/2020
39
 PACKAGE TEXTIO

09/12/2020
 Entrées et sorties par fichiers en VHDL
 Types definis : line text side width
Functions definis: readline read
writeline write endline

40
 LIBRAIRIE IEEE

09/12/2020
Library IEEE

Std_logic Std_logic
Std_logic _unsigned Std_logic
_1164 _arith _signed 41
 DESCRIPTION D’UNE ENTITÉ
 L’entité décrit l'interface du circuit avec le monde
extérieur. Il faut spécifier les ports, leur sens et leur

09/12/2020
type.
 Déclaration d’une entité:

Entity entity_name is
Generic declaration;
Port declaration;
End entity_name;

Remarque: Max plus II exige que le nom de l’entité soit

le même que le nom du fichier.

42
 GENERIC DECLARATION
 La généricité est un moyen de transmettre une
information à un bloc.

09/12/2020
 generic declaration

Generic (constant_name : type:=value);

43
 PORT DECLARATION
 Les Ports 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.

09/12/2020
 Port declaration:
Port(port_name: signal_mode signal_type;
port_name: signal_mode signal_type;
port_name: signal_mode signal_type
);
Signal_mode: signal_type:

44
 EXEMPLES

09/12/2020
 Ecrire les entités des schémas suivants :

45
 DESCRIPTION D’UNE ARCHITECHTURE
 Le corps d’architecture décrit le fonctionnement
interne du bloc logique. C'est la vue interne du
système, la syntaxe est la suivante :

09/12/2020
 Il est possible de créer plusieurs architectures
pour une même entité. Chacune de ces
architectures décrira l'entité de façon différente.

46
 FORMALISMES D’ARCHITECTURES
 Trois grands formalismes coexistent pour décrire les
architectures :

09/12/2020
Description
structurelle

Description
comporteme
ntale
Description
flot de
données

47
 DESCRIPTION FLOT DE DONNÉES
 C’est une description d’équations logiques, elle écrit
explicitement les fonctions booléennes que l'on veut voir
implémentées ça correspond à l’implémentation niveau
porte logiques ou bien résume la table de vérité.

09/12/2020
 Cette description utilise les instructions concurrentes, les
signaux évoluent de manière asynchrone les uns par
rapport aux autres (c’est la transcription du parallélisme
réel). 
 Dans un circuit : toutes les portes fonctionnent
simultanément tous les signaux évoluent de manière
concurrente.
 L’ordre d’écriture pour ces instructions est indifférent.

Assignation
conditionnelle

Assignation Assignation
simple sélectionnée

48
Instructions
concurrentes
 ASSIGNATION SIMPLE
 output_signal <= expression ;
 Exemple:

09/12/2020
S  A B
C  A.B

Library ieee;
Use ieee.std_logic_1164.all;
ENTITY half_adder IS
PORT(A,B: IN BIT ;
S, C : OUT BIT);
END half_adder;
ARCHITECTURE half_adder_dataflow1 OF half_adder IS
BEGIN
S <= A xor B; 49
C <= A and B;
END full_adder_dataflow1;
ASSIGNATION CONDITIONNELLE WHEN-ELSE
 output_signal <= exp1 when cond1 else
exp2 when cond2 else
……….

09/12/2020
exp n-1 when cond n-1 else
exp n;
exp : expressions en fonction des entrées
cond : conditions en fonction des entrées
library IEEE;
use IEEE.std_logic_1164.all;
entity half_adder is
port (a,b : in std_logic;
s,c : out std_logic);
end half_adder;
ARCHITECTURE half_adder_dataflow2 OF half_adder IS
BEGIN
S <= ‘0’ when (a=‘0’ and b=‘0’) else
‘0’ when (a=‘1’ and b=‘1’) else
‘1’;
C <= ‘1’ when (a=‘1’ and b=‘1’) else
‘0’; 50
END full_adder_dataflow2;
 ASSIGNATION SÉLECTIONNÉE
WITH-SELECT-WHEN
 With expression select
output_signal <= exp1 when choice1,
exp2 when choice2,

09/12/2020
……….
exp n when others;
exp : expressions en fonction des entrées
choice : conditions en fonction des entrées
library IEEE;
use IEEE.std_logic_1164.all;
entity half_adder is
port (a,b : in std_logic;
s,c : out std_logic);
end half_adder;
ARCHITECTURE half_adder_dataflow3 OF half_adder IS
Signal t:std_logic_vector(1 downto 0);
BEGIN
T<=a&b;
With t select
S <= ‘0’ when ‘’00’’, ‘0’ when ‘’11’’, ‘1’ when others; 51
S <= ‘1’ when ‘’11’’, ‘0’ when others;
END full_adder_dataflow3;
 FORMALISME COMPORTEMENTALE
 Cette description fournit un algorithme qui décrit le
comportement du circuit de manière très semblable à
un langage de programmation informatique, on
précise le fonctionnement voulu à l'aide d'une suite

09/12/2020
d'instructions séquentielles de contrôles plus ou
moins évoluées (conditions, boucles, etc.), dans une
instruction concurrente qui est le processus (process)
qui définit une portion de code dont les instructions
sont exécutées séquentiellement.
 La syntaxe de process est la suivante :
Architecture arch_name of entity_name is
begin
Process_name : process (liste de sensibilité)
Process_declarations;
Begin
Instructions séquentielles du process;
End process process_name;
End arch_name ; 52
RÈGLES DE FONCTIONNEMENT DE PROCESS
 Tous les processus sont exécutés en parallèle.
 Le process est exécuté en un seul bloc puisque

09/12/2020
c’est une instruction concurrente, par contre son
contenu est traité séquentiellement les unes
après les autres dans l’ordre ou elles sont écrites.
 Le processus s’exécute répétitivement quand un
signal de la liste de sensibilité change.
 Le process doit avoir une liste de sensibilité ou
bien wait statement à la fin.
 les signaux ne changent de valeur qu'à
la fin du process
 Remarque : le nom du process est facultatif mais
devient nécessaire s’il ya plusieurs process dans
53
une même architecture
 INSTRUCTIONS SÉQUENTIELLES
 Une instruction séquentielle ne peut apparaître que
dans un processus.

09/12/2020
Boucles

Instructions
sélectives

Instructions
conditionnelles

54
 IF-THEN-ELSIF-ELSE
if boolean-expr-1 then sequential-statements;

09/12/2020
elsif boolean-expr-2 then sequential-statements ;
elsif boolean-expr-3 then sequential-statements;
else sequential-statements;
end if;

55
 CASE-WHEN
case expression is
when choice1 => Instruction séquentielle;

09/12/2020
when choice2 => Instruction séquentielle;
……
when others => Instruction séquentielle;
end case;

56
 FOR AND WHILE LOOP
Boucle FOR
Loop_label : for identifier in range

09/12/2020
Loop
Instructions séquentielles;
end loop Loop_label;

Boucle While
Loop_label : while condition
Loop
Instructions séquentielles;
end loop Loop_label;
57
 INSTRUCTION WAIT
• Wait on nom signaux de la liste de sensibilité ;
Wait until expression booléenne;

09/12/2020
•

• Wait for expression du temps;

58
 EXEMPLE DEMI ADDITIONNEUR IF-THEN
architecture comp of half_adder is
Begin

09/12/2020
process(a,b)
begin
if (a=‘0’ and b=‘0’ ) then
s <= ‘0’;
c<=‘0’;
elsif (a=‘1’ and b=‘0’ ) then
s= ‘1’;
c<=‘0’;
elsif (a=‘0’ and b=‘1’ ) then
s= ‘1’;
c<=‘0’;
else
s= ‘1’;
c<=‘1’;
end if; 59
end process;
end comp;
 DESCRIPTION STRUCTURELLE
 On décrit le circuit comme une série de boîtes
noires (composants) interconnectées au moyen de

09/12/2020
signaux.
 Une description structurelle se compose de trois
rubriques :

Instanciation
des
composants
Déclaration
des signaux
internes

Déclaration des
composants utilisés
60
 DÉCLARATION DES COMPOSANTS UTILISÉS
 Si le composant n’est pas décrit dans un autre design,
il est nécessaire de déclarer la paire entité/architecture
du composant qui doit être utilisé.

09/12/2020
 Lorsqu’on utilise des composants déjà décrit dans un
design ceci suppose que les composants sont compilés
et stockés dans la bibliothèque WORK, il suffit de
déclarer ces composants.
 Un composant doit être déclaré dans la zone
architecture
 Le mot clé component sert à déclarer le prototype
d'interconnexion. La syntaxe est presque identique à
celle de l'entité :
architecture nom_architecture of nom_entité is
component component_identifier
port (input_signals : in type;
output_signals : out type);
61
end component;
 DÉCLARATION DES SIGNAUX INTERNES
 La déclarations de signaux internes, destinés à
interconnecter les composants suivant la syntaxe

09/12/2020
suivante:
architecture nom_architecture of nom_entité is
component component_identifier
port (input_signals : in type;
output_signals : out type);
end component;
signal: internal_signals: signal_type:=initialization;

62
 INSTANCIATION DES COMPOSANTS
 L’instanciation des composants c’est l’'appel des
composants et leur emplacement dans le design.

09/12/2020
 Un composant peut être appelé plusieurs fois dans un
même circuit. Pour différencier ces mêmes composants,
il est nécessaire de leur donner un nom d'"instance".
 L’instanciation associe des signaux aux ports et des
valeurs aux paramètres génériques de ce sous-
composant.

63
Architecture architecture_name of entity_name is
component component_identifier

09/12/2020
port (input_signals : in type;
output_signals : out type);
end component;
signal: internal_signals: signal_type:=initialization;
Begin
Instance1_name: component1_identifier port map(
port_name=>signal_name, …);
Instance2_name: component2_identifier port map(
port_name=>signal_name, …);
end architecture_name; 64
 EXEMPLE
--entity xor
library ieee; use ieee.std_logic_1164.all;
entity P_XOR is port( C, D: in std_logic; E: out std_logic); end P_XOR;
architecture FLOW1 of P_XOR is begin E <= C xor D; end FLOW1;

09/12/2020
-- Entité AND
library ieee; use ieee.std_logic_1164.all;entity P_AND is port( C, D: in
std_logic; E: out std_logic); end P_AND; architecture FLOW2 of
P_AND is begin E <= C and D; end FLOW2;
--entity half adder
library ieee;use ieee.std_logic_1164.all;
entity HA is
port( A, B: in std_logic; S, C: out std_logic);
end HA;
architecture FLOW3 of HA is begin
component P_AND port(C, D: in std_logic; E:out std_logic);end component
P_AND;
component P_XOR port(C, D: in std_logic; E:out std_logic);end component
P_XOR;
begin i1: P_XOR port map(A, B, S); i2: P_AND port map(A,B, C);
end FLOW3;
 GÉNÉRICITÉ
 Un composant peut être générique en définissant les
paramètres qui seront vus comme des constantes à chaque
instance de composant.

09/12/2020
 De même l'entité associée au composant doit comporter la
clause generic pour déclarer le(s) paramètre(s).
 Architecture architecture_name of entity_name is
component component_identifier
generic ( generic_name: type :=initialization);
port (input_signals : in type;
output_signals : out type);
end component;
signal internal_signals: signal_type:=initialization;
Begin
Instance1_name:component1_identifier
generic map(generic_name=>parameter _value);
port map( port_name=>signal_name, …);
66
end architecture_name;
 EXEMPLE
 architecture arc of mult is
component ADD

09/12/2020
generic ( N : positive range 0 to 16);
port (
A: in std_logic_vector(N-1 downto 0);
B: in std_logic_vector(N-1 downto 0);
S: out std_logic_vector(N-1 downto 0));
end component;
signal OP1,OP2,S std_logic_vector(N-1 downto 0);
...
--
begin
inst_ADD : ADD generic map(N=>12);
port map(A=>OP1, B=>OP2,S=>S);
... 67
end arc;
 GÉNÉRATION D’INSTRUCTIONS
FOR-GENERATE
 Utilisé pour implanter des composants ou des équations de
façon répétitive.

09/12/2020
 label : for parameter in range generate
{declarations
Begin
concurrent_statements
end generate label ;
 Exemple:
G: for I in 0 to N-1 generate
inst: FA port map(A(I), B(I), C(I), sum(I), C(I+1));
end generate G;
 label : if condition generate
declarations
begin
concurrent_statements
end generate label ; 68
 LOGIQUE SÉQUENTIELLE
 en logique séquentielle, on parle de bascules et
d’horloge.

09/12/2020
 A chaque front montant/descendant, l’état des bascules
change donc les circuits séquentiels nécessitent
l’utilisation d’un process dont clk est un signal de la
liste de sensibilité.

69
 BASCULES D AVEC CLK

09/12/2020
library IEEE; library IEEE;
use IEEE.std_logic_1164.all; use IEEE.std_logic_1164.all;
entity DFF is entity DFF is
port (D,clk : in std_logic; port (D,clk : in std_logic;
q : out std_logic); q : out std_logic);
end DFF; end DFF;
ARCHITECTURE ARCH_DFF OF DFF ARCHITECTURE ARCH_DFF OF DFF
IS IS
BEGIN BEGIN
Process(clk) Process(clk)
Begin Begin
If(clk’event and clk=‘1’) then If(clk’event and clk=‘0’) then
Q<=D; Q<=D;
End if; End if; 70
End process; End process;
END ARCH_DFF; END ARCH_DFF;
 BASCULES D AVEC CLK ET RST
library ieee;
use ieee.std_logic_1164.all;
entity FFD is

09/12/2020
port( D, Reset, CLK: in std_logic; Q: out std_logic);
end FFD;
architecture ARCH_FFD of FFD is
begin
process(CLK, Reset)
begin
if Reset = '0' then
Q <= '0';
elsif (clk’event and clk=‘1’) then
Q <= D;
end if;
end process;
end ARCH_FFD; 71
BASCULE AVEC CIRCUIT COMBINATOIRE

09/12/2020
72