04 Modélisation Des Systèmes Numériques

REPUBLIQUE ALGERIENNE DEMOCRATIQUE ET POPULAIRE
MINISTERE DE L’ENSEIGNEMENT SUPERIEUR ET DE LA

RECHERCHE SCIENTIFIQUE
UNIVERCITE M’HAMED BUGARA DE BOUMERDES

FACULTE DES SCIENCES – DEPARTEMENT PHYSIQUE
Spécialité : INFOTRONIQUE
&
IMAGERIE ET APPARAILLAGE BIOMEDICALE
V.Tourtchine et M.Izouin
MODELISATION DES SYSTEMES NUMERIQUES
DANS L'ENVIRONNEMENT Xilinx ISE 13.2 (VHDL)
Manuscrit élaboré selon le programme officiellement agréé et

confirme par le Conseil Scientifique de la Faculté des Sciences
BOUMERDES - 2012
-0-
V.Tourtchine et M.Izouine. Initiation au langage VHDL. Application pour la modélisation des
systèmes numériques.
Table des matières

PAGE
Introduction Générale.............................................................................. 4
Chapitre 1 : Les concepts de base du langage VHDL................................. 5

1.1 Description générale ....................................................................................................... 5
1.1.1 Les règles de base du VHDL ................................................................................. 6
1.1.2 La déclaration de l’entité ......................................................................................... 6
1.1.3 La déclaration de l’architecture ............................................................................. 7
1.2 Les signaux intermédiaires .......................................................................................... 10
1.3 Assignation conditionnelle et assignation sélectionnée des signaux .................... 11
1.3.1 Assignation conditionnelle des signaux ............................................................. 11
1.3.2 Assignation sélectionnée des signaux ............................................................... 12
1.4 Type de données .......................................................................................................... 13
Chapitre 2 : Objets et types de données .......................................................... 14

2.1 Les signaux ................................................................................................................... 14
2.1.1 Déclaration d’un signal............................................................................................. 15
2.1.2 Initialisation des signaux .......................................................................................... 15
2.1.3 Utilisation des signaux ............................................................................................. 16
2.2 Les types et sous-types ............................................................................................... 16
2.2.1 Les types « scalaires » ......................................................................................... 16
2.2.2 Les types « composites » ..................................................................................... 17
2.2.3 Les types « accès »............................................................................................... 21
2.2.4 Les types « fichiers » ............................................................................................ 21
2.3 Les opérations de base sur les objets ....................................................................... 21
2.3.1 Les opérations logiques ........................................................................................... 21
2.3.2 Les opérations relationnelles ................................................................................... 21
2.3.3 Les opérations d’addition ......................................................................................... 22
2.3.4 Les opérations de multiplication............................................................................... 22
2.3.5 Les opérations de signe ........................................................................................... 22
2.3.6 Les opérations de décalage..................................................................................... 22
2.3.7 Autres opérations ..................................................................................................... 23
2.4 Les attributs ................................................................................................................... 23
1
Chapitre 3 : Les différentes descriptions d’une architecture ............... 24

3.1 Description par flots de données................................................................................. 24
3.2 Description comportementale ...................................................................................... 25
3.2.1 Le PROCESS ......................................................................................................... 25
3.2.2 Les variables et les constantes ........................................................................... 27
3.2.3 Description avec l’instruction IF........................................................................... 28
3.2.4 Description avec l’instruction CASE ................................................................... 30
3.2.5 Description avec les boucles (LOOP) ................................................................ 30
3.2.5.1 Répétitions itératives (FOR) ......................................................................... 31
3.2.5.2 Répétitions conditionnelles (WHILE) .......................................................... 32
3.3 Description structurelle ................................................................................................. 33
3.3.1 Instanciation ........................................................................................................... 34
3.3.1.1 Instanciation par position .............................................................................. 35
3.3.1.2 Instanciation par nom .................................................................................... 35
3.3.1.3 Instanciation mixte ......................................................................................... 36
Chapitre 4 : La modélisation des circuits séquentiels ............................. 37

4.1 Introduction ..................................................................................................................... 37
4.2 Les opérations synchrones et asynchrones .............................................................. 38
4.3 Les LATCHS................................................................................................................... 38
4.3.1 LATCH R-S ............................................................................................................. 39
4.3.2 LATCH RSH ........................................................................................................... 40
4.3.3 LATCH D ................................................................................................................. 42
4.4 Les FLIP-FLOPS ........................................................................................................... 43
4.4.1 Flip-Flop D .............................................................................................................. 44
4.4.2 Flip-Flop J-K ........................................................................................................... 46
4.4.3 Flip-Flop T ............................................................................................................... 48
4.5 Compteurs et Registres ................................................................................................ 50
4.5.1 Compteurs .............................................................................................................. 50
4.5.1.1 Compteurs asynchrones ............................................................................... 50
4.5.1.1.1 Description d’un compteur asynchrone 2 bits ......................................... 51
4.5.1.1.2 Description d’un décompteur asynchrone 3 bits..................................... 53
4.5.1.1.3 Délai de propagation dans un compteur asynchrone ............................ 56
4.5.1.1.4 Compteur asynchrone modulo N .............................................................. 57
4.5.1.2 Compteurs synchrones ................................................................................. 58
4.5.1.2.1 Description d’un compteur synchrone 2 bits ........................................... 59
4.5.1.2.2 Description d’un décompteur synchrone 3 bits ....................................... 62
4.5.1.2.3 Délai de propagation dans un compteur synchrone .............................. 64
4.5.1.2.4 Compteur synchrone modulo N................................................................. 64
4.5.1.3 Compteurs avec choix pour le mode : comptage/décomptage .............. 67
2
4.5.1.4 Méthode de conception d’un compteur synchrone ................................... 68

4.5.2 Les registres ........................................................................................................... 73
4.5.2.1 Registre à décalage ....................................................................................... 73
4.5.2.1.1 Registre à décalage à droite ...................................................................... 73
4.5.2.1.2 Registre à décalage à gauche ................................................................... 77
Application : Registre avec mode de décalage à droite ou à gauche ..................... 79
4.5.2.2 Type de registres à décalage ....................................................................... 84

4.5.2.2.1 Registre à entrée série et sortie série ...................................................... 84
4.5.2.2.2 Registre à entrée série et sortie parallèle ................................................ 86
4.5.2.2.3 Registre à entrée parallèle et sortie série ................................................ 88
4.5.2.2.4 Registre à entrée parallèle et sortie parallèle ......................................... 91
4.5.3 Registre universel .................................................................................................. 91
Chapitre 5 : Machine à états finis(FSM) ............................................................ 95

5.1 Introduction....................................................................................................................... 95
5.1.1 Types d’FSM .......................................................................................................... 95
5.1.2 Représentation d’FSM .......................................................................................... 96
- Diagramme d’état ................................................................................................ 96
- Diagramme ASM ................................................................................................. 96
5.2 Développement de code VHDL d’FSM.......................................................................... 100
5.3 Exemple de conception.................................................................................................. 103
5.3.1 Détecteur de front montant .................................................................................... 103
5.3.2 Circuit anti-rebond .................................................................................................. 107
Annexe ............................................................................................................................... 111

Annexe 1. Guide d’installation de Xilinx ISE 13.2 ............................................................... 111
Annexe 2. Guide pratique d’utilisation de Xilinx ISE 13.2 ................................................... 123
Annexe 3. Liste des mots réservés...................................................................................... 132
3
Introduction générale
VHDL est l’acronyme de VHSIC HDL (Very High Speed Integrated Circuit
Hardware Description Language), c’est un langage de description matérielle qui a
été créé dans les années 1980 à la demande du département de la défense
américaine (DOD).
La première version du VHDL accessible au public a été publiée en 1985, et a fait

l’objet d’une norme internationale en 1986 par l’institut des ingénieurs électriciens et
électroniciens (IEEE).
De nos jours, le langage VHDL devient un outil indispensable pour la conception des
systèmes électroniques intégrés, il est proposé par la grande majorité des sociétés
de développement et la commercialisation d’ASIC et d’FPGA telle que la société
américaine Xilinx.
Avec un langage de description matérielle et un FPGA (Field Programmable Gate

Array), un concepteur peut développer rapidement et simuler un circuit numérique
sophistiqué, de l’implémenter sur une carte de prototypage, et de vérifier son
fonctionnement.
Toutefois, les concepts VHDL ne sont pas toujours simples à comprendre, cette
brochure introduit les principaux concepts de ce langage à travers d’exemples
concrets.
Cette brochure est présentée en cinq chapitres, et trois annexes.
Les descriptions VHDL des circuits ont été développées avec l’outil Xilinx ISE 13.2.
Dans le premier chapitre, on présente les concepts de base du langage VHDL, les
objets et types de données seront présentés dans le deuxième chapitre, ainsi que
les opérations applicables sur ces derniers, on verra les différents styles de
description d’une architecture dans le troisième chapitre, on modélisera des circuits
séquentiels dans le quatrième chapitre et enfin on traite les machines à états finis
(FSM) dans le cinquième chapitre.
Un guide pratique d’utilisation de l’outil Xilinx ISE 13.2 est donné en annexe.
4
Chapitre 1
Les concepts de base du langage VHDL.
1.1 Description générale :
Prenons comme exemple le circuit intégré 7400 (Figure 1.1(a)). Ce dernier est constitué de
quatre portes logiques NAND à deux entrées (Figure 1.1(b)).
Figure 1.1 Circuit intégré 7400 (Vue externe (a) et vue interne (b)).
La description du circuit intégré 7400 en langage VHDL est donnée par le listing 1.1
Listing 1.1 Description VHDL du circuit intégré 7400.
5
1.1.1 Les règles de base du VHDL :
- Les deux premières lignes définissent les bibliothèques et les paquetages dont nous avons
besoin pour la conception de notre circuit. Dans notre code, on fait appel au paquetage
std_logic_1164 qui se trouve dans la bibliothèque IEEE.
Les bibliothèques et les paquetages nous permettent d’utiliser les types et les opérateurs
disponibles en VHDL.
1.1.2La déclaration de l’entité :
L’entité correspond au circuit vu de l’extérieur (Figure 1.1(a)), et comprend essentiellement

les entrées-sorties du circuit. La première ligne d’une entité (ligne 4 du code) indique le nom
du circuit, ‘’CI_7400’’dans notre exemple. Les entrées - sorties du circuit sont des ports qui
doivent avoir le format suivant :
NOM_DU_PORT : MODE TYPE ;
Le mode d’un port peut être : - IN s’il s’agit d’une entrée
- OUT s’il s’agit d’une sortie
- INOUT s’il s’agit d’une entrée - sortie (port bidirectionnel)
- BUFFER s’il s’agit d’une sortie rebouclée en entrée
Pour le TYPE du port, il faut savoir que le langage VHDL est un langage typé, c’est-à-dire
que chaque objet manipulé doit avoir un type de données.
Dans le listing 1.1, le type du port utilisé est STD_LOGIC. Il est défini dans le paquetage
STD_LOGIC_1164, et possède neuf états :
Etat Définition
0 Niveau logique 0, forçage fort
1 Niveau logique 1, forçage fort
Z Haute impédance
U Niveau non initialisé
X Niveau inconnu, forçage fort
- Niveau quelconque (Don’t care)
L Niveau logique 0, forçage faible
H Niveau logique 1, forçage faible
W Niveau inconnu, forçage faible
6
Si le type du signal utilisé est un bus de données, on utilise alors le type

STD_LOGIC_VECTOR qui est défini comme étant un tableau unidimensionnel d’éléments
de type STD_LOGIC.
Exemple :
Soit le signal d’entré A de 8 bits, on le déclarera en VHDL comme suit :
A : in std_logic_vector ( 7 downto 0 ) ;
Ou bien :
A : in std_logic_vector (0 to 7);
La différence entre les deux expressions est l’indice du MSB et du LSB. Dans la première
expression, l’indice du MSB est A(7), celui du LSB est A(0). Dans la deuxième expression,
l’indice du MSB est A(0), celui du LSB est A(7).
Remarque :
On peut utiliser le type bit à la place de std_logic, et le type bit_vector à la place de

std_logic_vector, la différence entre eux est que le type bit ne possède que deux état : ‘0’
et ‘1’ ce qui est très limité car il faut prendre en considération les autres états, c’est pourquoi
on préfère le type std_logic au type bit.
1.1.3La déclaration de l’architecture :
L’architecture du circuit correspond au circuit vu de l’intérieur (Figure 1.1 (b)), et comprend

essentiellement la description des opérations du circuit. Nous pouvons associer plusieurs
architectures à une entité, mais pas le contraire. La différence des architectures réside dans
leurs noms :
Architecture NOM_DE_L’ARCHITECTURE of NOM_DE_L’ENTITE is
Dans notre exemple, le nom de l’architecture est behavioral.
La description principale d’une architecture comprend toujours les deux mots réservés
‘’BEGIN’’ et ‘’END’’ (ligne 11 et 16 successivement). Les expressions des opérations du
circuit se trouvent entre elles. Ces expressions sont des instructions qui s’exécutent en
concurrence contrairement à un langage informatique comme le langageC, où les
instructions s’exécutent séquentiellement.
7
Exemple 1 : Comparateur 1 bit
Les entrées du comparateur sont : A, B
Les sorties du comparateur sont : EG (égale), PG (plus grand), PP (plus petit).
Table de vérité du et équations booléennes du comparateur :
A B EG PG PP EG  A.B  A.B
0 0 1 0 0
0 1 0 0 1 PG  A.B
1 0 0 1 0
1 1 1 0 0 PP  A.B
Le schéma du circuit du comparateur :
Figure 1.2 Schéma du comparateur.
La description du comparateur en langage VHDL :
Listing 1.2 Description VHDL du comparateur.

8
Simulation :
Exemple 2 - Additionneur complet 1 bit :
Les entrées de l’additionneur sont : A, B, Ri.
Les sorties de l’additionneur sont : S (somme), Rout (retenue).
Table de vérité et équations booléennes de l’additionneur :
A B Ri S Rout
0 0 0 0 0
0 0 1 1 0
S  A  B  Ri
0 1 0 1 0
0 1 1 0 1 Rout  A.B  A.Ri  B.Ri
1 0 0 1 0
1 0 1 0 1
1 1 0 0 1
1 1 1 1 1
Le schéma du circuit du l’additionneur :
Le code VHDL de l’additionneur :
Figure 1.4 Schéma de l’additionneur complet 1 bit à partir de deux demi-additionneurs.
10
Listing 1.3 Description VHDL d’un additionneur complet 1 bit.
Simulation :
1.2. Les signaux intermédiaires :
Les signaux intermédiaires correspondent aux connexions qui se trouvent à l’intérieur d’un
circuit. Pour bien comprendre la notion et l’utilisation de ces signaux, prenons l’exemple de
notre additionneur complet 1 bit de la figure 1.3. On peut le concevoir à partir de deux
demi-additionneurs et une porte logique OR (figure 1.4).
Figure 1.4 Schéma de l’additionneur complet 1 bit à partir de deux demi-additionneurs.
11
Le code VHDL de la figure 1.7 :
Listing 1.4 Description VHDL d’un additionneur complet 1 bit en utilisant les
signaux
intermédi
aires.
1.3Assignation conditionnelle et assignation sélectionnée des signaux :
Les instructions d’assignation conditionnelles et d’assignation sélectionnées aux

signaux sont exécutées en concurrence. Leurs comportements sont similaires aux
instructions IF et CASE qu’on verra dans le chapitre 2, qui ont quant à eux, des
instructions qui s’exécutent séquentiellement.
1.3.1 Assignation conditionnelle des signaux :
Le format d’une assignation conditionnelle des signaux est le
suivant : Signal_1<= valeur_expression_1 WHEN
choix_1 ELSE
valeur_expression_2 WHEN choix_2 ELSE
valeur_expressio
n_n ;
12
Exemple :
Soit un multiplexeur 2 vers 1.
Il a comme entréesA, B, SEL, et comme sortie S (Figure 1.5).
Figure 1.5 Multiplexeur 2 vers 1.
Avec l’assignation conditionnelle des signaux, la description en VHDL du multiplexeur de la

figure 1.5 est la suivante :
Listing 1.5 Description VHDL d’un multiplexeur 2 vers 1 avec l’assignation conditionnelle.
Simulation :
13
1.3.2 Assignation sélectionnée des signaux :
Le format d’une assignation de selection des signaux est le suivant :
WITH sélecteur SELECT
Signal_1 <= valeur_expression_1 WHEN choix_1,
valeur_expression_2 WHEN choix_2,
valeur_expression_3 WHEN choix_3,
valeur_expression_n WHEN OTHERS ;
Exemple :
Prenons le multiplexeur 2 vers 1 précédent (Figure 1.5).
Avec l’assignation de sélection des signaux, la description en VHDL du multiplexeur de la

figure 1.5 est la suivante :
Listing 1.6 Description VHDL du multiplexeur 2 vers 1 avec l’assignation de sélection.
Remarque :
Dans l’assignation conditionnelle des signaux, il n’y a pas de point virgule après le ELSE.
Dans l’assignation de selection des signaux, il faut faire attention à ne pas oublier la virgule à
la fin de chaque expression de choix, et ne pas oublier de spécifier l’expression à exécuter si
aucun choix n’a été trouvé (WHEN OTHERS).
1.4 Types de données :
En langage VHDL, comme en langage de programmation de haut niveau, les types de

données sont une représentation abstraitedes données stockées.
14
Ces types de données peuvent représenter un fil de connexion dans un circuit, ou bien un
ensemble de fils de connexion.
Chaque type de données en langage VHDL possède un ensemble de valeurs et d’opérations

bien définies.
La correspondance entre les types de données est très stricte, il n’est pas possible par
exemple d’affecter directement la valeur d’un type de données entier (INTEGER) à un type
de donnéesSTD_LOGIC_VECTOR, pour y remedier, des fonctions de conversion de types
bien définis sont disponilbes.
Les types de données dans le langage VHDL ainsi que les fonctions de conversion sont
abordés dans le prochain chapitre (Objets et types de données).
15
Chapitre 2
Objets et types de données.
Lors de la description d’un système électronique, la représentation des données qui y

sont traitées est une opération délicate car le langage VHDL est un langage typé, c’est-à-dire
que chaque objet manipulé possède un type bien défini.
Les trois types de base utilisés lors d’une description VHDL sont :
- Les signaux
- Les variables
- Les constants
Chaque objet déclaré possède un type de données spécifique ainsi qu’un ensemble de
valeurs possibles.
Les valeurs que peut prendre un objet dépendent de la définition du type utilisé pour cet
objet, par exemple un objet de type STD_LOGIC possède 9 valeurs (états) possibles ; ‘0’,
‘1’, ‘U’, ‘X’, ‘Z’, ‘W’, ‘L’, ‘H’, ‘-‘, tandis qu’un objet de type bit n’en possède que deux; ‘0’ et ‘1’.
Chaque objet est spécifié par un identificateur, ce dernier doit respecter les conventions
d’écriture suivantes :
- Débuter par un caractère alphabétique, les caractères suivants peuvent être

alphabétiques ou numériques.
- Seul le caractère « _ » (underscore) peut être utilisé dans un identificateur, mais
qu’une seule fois c’est-à-dire qu’une succession de ce caractère est interdite.
- La longueur d’un identificateur est limitée à celle d’une ligne.
Note :
- Le langage VHDL ne respecte pas la casse c’est-à-dire qu’il ne fait pas la différence
entre minuscules et majuscules.
- A l’intérieur d’un programme VHDL, un commentaire est introduit par deux tirets ; - -
- On ne peut pas utiliser certains mots comme identificateur car ils sont réservés à la
syntaxe VHDL, cette liste de mots réservés est donnée en annexe.
2.1 Les signaux :
Les signaux sont des objets qui sont utilisés pour connecter des éléments concurrents
(comme par exemple, lors des instanciations des composants, les processus, et les
assignations concurrentes), de la même façon que les fils sont utilisés pour connecter des
composants dans un circuit électronique ou dans un schéma.
Un signal peut être déclaré globalement dans un package externe, ou localement à l’intérieur
d’une architecture ou d’un bloc.
16
2.1.1 Déclaration d’un signal :
La déclaration d’un signal se fait avec le mot réservé SIGNAL comme suit :
Un signal doit avoir au minimum un nom et un type.
Dans l’exemple ci-dessus, le signal est nommé « SIG » et est déclaré à l’intérieur de
l’architecture « RTL », et est du type standard STD_LOGIC.
Si plusieurs signaux du même type sont nécessaires dans une conception, on peut les
spécifier dans une seule déclaration comme suit :
2.1.2 Initialisation des signaux :
Un signal peut être initialisé à une valeur spécifique comme suit :
Le symbole d’initialisation est « := ».
Dans l’exemple ci-dessus, on initialise le signal « A » de type STD_LOGIC_VECTOR de

taille 4 à une valeur initiale ‘0’ :
Pour l’initialisation du signal « B », on a utilisé une notation par agrégat.
Au lieu d’écrire seize fois l’état ‘0’ (Pire si on avait un bus de 128 Mbit) :
On a utilisé un agrégat qui est un moyen d’indiquer la valeur de chaque élément d’un type
composé.
17
2.1.3 Utilisation des signaux :
L’utilisation des signaux est principalement utilisée lorsqu’on a besoin de déplacement

d’informations entre les différentes parties fonctionnelles d’une conception, comme par
exemple entre deux composants connectés.
Les signaux peuvent être aussi utilisés pour décrire des expressions logiques complexes.
Les objets de types variables et constants sont traités dans le prochain chapitre (Les
différents styles de description d’une architecture).
2.2 Les types et sous-types :
Les types de données VHDL se divisent en quatre catégories :
2.2.1 Les types « scalaires » :

La valeur d’un objet de ce type est constituée par un seul élément, cette valeur est
énumérée dans le cas d’un type énuméré.
Les types standards entrant dans cette catégorie sont les types entiers (INTEGER),
les types réels à virgule flottante (REAL), les types physiques (TIME), et les types
énumérés.
- Les types entiers (INTEGER) :
Ces des types dont les valeurs sont des entiers.
La norme VHDL précise que cet intervalle doit au minimum aller de – (231-1) à (231-1).
Ce type contient deux sous-types :
o NATURAL : contient les valeurs naturelles.
o POSITIVE : contiens les valeurs positives.
- Les types Réels (REAL) :
Ce sont des types dont les valeurs sont des réels.
La norme VHDL précise que cet intervalle doit au minimum aller de – (1038) à (1038).
- Les types physiques :
Ce sont des grandeurs qui peuvent être analogiques ou numériques telles que la
tension électrique, l’intensité du courant, capacité d’un condensateur, temps…etc.
Un type physique est défini par son intervalle de variation, par son unité de base et
par des unités multiples éventuelles.
Le type TIME est un type standard prédéfini en VHDL.
18
- Les types énumérés :

Un objet est énuméré si toutes les valeurs qu’il peut prendre sont énumérées.
Les types prédéfinis du type énuméré sont :
o BIT :
Défini comme (‘0’, ‘1’).
o STD_LOGIC :
Défini comme (‘U’, ‘X’, ‘0’, ‘1’, ‘Z’, ‘W’, ‘L’, ‘H’, ‘-‘).
o BOOLEAN :
Défini comme (false, true).
o CHARACTER :
Les types de données« caractère » en VHDL sont similaires à ceux d’un
langage de programmation de haut niveau, ils peuvent être utilisés pour
représenter une chaine de caractères.
(…,’A’, ‘B’, ‘C’,…’0’, ‘1’, ‘2’,…)
o SEVERITY_LEVEL :
Ce type de données est particulier, il possède quatre valeurs possibles :
NOTE, WARNING, ERROR, FAILURE
Il est très utile d’utiliser ce type de données lors des simulations, par exemple,
pour demander au simulateur d’arrêter la simulation lorsqu’il détecte une
erreur.
2.2.2 Les types « composites » :

Le type « composites »représente un ensemble de valeurs, et est divisé en deux
classes :
- Les types « composites » tableaux (ARRAY) :
Un objet de type tableau (ARRAY) est un ensemble d’un ou de plusieurs éléments du
même type.
On accède à l’élément d’un tableau par un ou plusieurs indices.
Exemple d’une déclaration d’un tableau :
La déclaration du tableau ci-dessus indique que le tableau dont le nom est

« MON_TABLEAU » est constitué de 16 éléments, où chaque élément est du type
std_logic.
On peut associer un objet de type « MON_TABLEAU » comme suit :
19
Remarque :
Généralement les tableaux à deux dimensions (matrices) ne sont pas supportés par les
outils de synthèse, mais ils sont utiles pour décrire les tests de stimuli, les éléments de
mémoires, ou autre donnée qui requièrent une forme de tableaux à deux dimensions.
Quelques exemples de déclarations des tableaux unidimensionnels et bidimensionnels :
Explication :
a. type A is array (7 downto 0) of std_logic;
« A » est un tableau à une dimension, de taille 8 (7 downto 0) dont les éléments sont tous
de type std_logic(figure 2.1).
Figure 2.1
b. type B is array (0 to 3) of A;
« B » est un tableau à une dimension de taille 4 (0 to 3) dont les éléments sont de type
« A », c’est-à-dire des tableaux de taille 8 (7 downto 0) dont les éléments sont de type
std_logic(figure 2.2).
Figure 2.2
20
c. type C is array (0 to 3) of std_logic_vector (7 downto 0);
« C » est un tableau à une dimension de taille 4 (3 downto 0) dont les éléments sont de type
std_logic_vector de taille 8 (7 downto 0) (figure 2.3).
Figure 2.3
d. type D is array (0 to 3, 7 downto 0) of std_logic;
« D » est un tableau à deux dimensions de taille 4x8 (0 to 3, 7 downto 0) dont les éléments
sont de type std_logic (figure 2.4).
Figure 2.4
Les déclarations des signaux :
21
Exemple d’assignations :
Pour comprendre le principe, prenons comme exemple l’affectation suivante :
L’emplacement n°0du signal x reçoit le contenu l’emplacement n°2 qui se trouve dans
l’emplacement n°1du signal y (figure 2.5).
Figure 2.5
- Les types « composites » articles (RECORD) :

Un objet de type article (RECORD) est un ensemble d’éléments appelé champs, qui
peuvent être de mêmetype ou de typesdifférents.
Exemple d’une déclaration d’un article :
L’article ci-dessus dont le nom est « MON_ARTICLE » est constitué de trois champs
(CLOCK, DATA, X) (figure 2.6).
Figure 2.6
22
2.2.3 Les types « accès » (Access) :

Ces types fournissent des références vers des objets de la même manière que les
pointeurs qui fournissent des références vers des données dans un langage de
programmation de haut niveau.
2.2.4 Les types « fichiers » (File) :

Ce sont des objets de référence qui contiennent une séquence de valeurs.
Les valeurs de chaque type de données se trouvent dans un intervalle défini, par exemple
l’intervalle de type de données entier (INTEGER) est [-2147483647, +2147483647].
Le langage VHDL nous permet de spécifier un sous-ensemble de valeurs d’un type, par
exemple la déclaration suivante crée un objet de type entier qui ne peut avoir que des
valeurs positives allant de 0 à 255 :
Remarquez la déclaration « range », cette dernière permet de vérifier lors de la synthèse et

de la simulation que la valeur d’un objet n’est pas en dehors de son intervalle de variation.
On peut déclarer un sous-type d’un type de données, par exemple la déclaration ci-dessous
crée un sous-type (SHORT) du type scalaire entier (INTEGER) avec un intervalle limité :
2.3 Les opérations de base sur les objets :
Le langage VHDL nous permet de faire plusieurs opérations sur les objets, suivant leurs
types et le type du résultat de l’opération.
2.3.1 Les opérations logiques :
Les opérations logiques AND, OR, NAND, NOR, XOR, NXOR sont utilisées pour décrire des
opérations booléennes, ou pour effectuer des opérations au niveau des bits.
Opération Description Type d’opération Type de résultat

AND Le ‘ET’ logique Tout type binaire ou booléen Même type
OR Le ‘OU’ logique Tout type binaire ou booléen Même type
NAND Le ‘NON ET’ logique Tout type binaire ou booléen Même type
NOR Le ‘NON OU’ logique Tout type binaire ou booléen Même type
XOR Le ‘XOR’ logique Tout type binaire ou booléen Même type
NXOR Le ‘NXOR’ logique Tout type binaire ou booléen Même type
2.3.2 Les opérations relationnelles :
Les opérations relationnelles testent les valeurs relatives de types scalaires.
Le résultat d’une opération relationnelle est toujours une valeur booléenne TRUE ou FALSE.
23

= Egalité Tout type Booléen
/= Inégalité Tout type Booléen
< Strictement inférieure Tout type Booléen
<= Inférieure ou égale Tout type Booléen
> Strictement supérieure Tout type Booléen
>= Supérieure ou égale Tout type Booléen
2.3.3 Les opérations d’addition :
Les opérations d’addition peuvent être utilisées pour décrire des fonctions arithmétiques ou
des opérations de concaténations.

+ Addition Tout type numérique Même type
- Soustraction Tout type numérique Même type
& concaténation Tout type numérique Même type
2.3.4 Les opérations de multiplication :
Les opérations de multiplication peuvent être utilisées pour décrire des fonctions
arithmétiques ou de types numériques.

* Multiplication Tout type entier ou flottant Même type
/ Division Tout type entier ou flottant Même type
MOD Modulo Tout type entier Même type
REM Reste Tout type entier Même type
2.3.5 Les opérations de signe :
Les opérations de signes sont utilisées pour spécifier le signe (positif ou négatif).

+ Positif Tout type numérique Même type
- Négatif Tout type numérique Même type
2.3.6 Les opérations de décalage :
Les opérations de décalage permettent de faire des opérations de décalage ou de rotations

au niveau des bits ou d’objet de type booléens.

SLL Décalage à gauche (logique) Entier, bit, ou booléen Même type
SRL Décalage à droite (logique) Entier, bit, ou booléen Même type
SLA Décalage à gauche (arithmétique) Entier, bit, ou booléen Même type
SRA Décalage à droite arithmétique Entier, bit, ou booléen Même type
ROL Rotation à gauche (logique) Entier, bit, ou booléen Même type
ROR Rotation à droite (logique) Entier, bit, ou booléen Même type
24
2.3.7 Autre opérations :
Les opérations d’exponentiation, ou de valeur absolue peuvent être appliquées à des objets
de type numérique.

** Exponentiation Tout type entier ou flottant Même type
ABS Valeur absolue Tout type numérique Même type
NOT Le ‘NON’ logique Tout type binaire ou booléen Même type
2.4 Les attributs :
Un attribut est une caractéristique du VHDL qui permet d’extraire des informations
supplémentaires à propos d’un type de données ou d’un signal.
Il y’a deux classes d’attributs :
- Les attributs prédéfinis.

- Les attributs utilisateurs.
Nous rencontrerons des attributs prédéfinis tout au long de cette brochure et nous les
présenterons au fur et à mesure de leur nécessité, néanmoins nous citerons ci-dessous les
principaux attributs prédéfinis les plus utilisés.
Attribut Description
Il nous informe sur la position de l’élément X par un nombre
Attribut POS(X) entier.
Il nous informe sur la valeur contenue de la position X.

Attribut VAL(X)
Il nous informe sur la valeur contenue de l’élément qui précède

Attribut PRED(X)
la position X.
Il nous informe sur la valeur contenue de l’élément qui succède
Attribut SUCC(X)
la position X.
Il exprime la valeur la plus à gauche dans la déclaration du type.
Attribut LEFT
Attribut RIGHT Il exprime la valeur la plus à droite dans la déclaration du type.

Il exprime la plus grande valeur dans la déclaration du type.
Attribut HIGH
Attribut LOW Il exprime la plus petite valeur dans la déclaration du type.
Il exprime le nombre d’éléments d’un indice.

Attribut LENGTH
Il exprime l’intervalle de variation de sa borne gauche à sa

Attribut RANGE
borne droite
Attribut Il exprime l’intervalle de variation de sa borne droite à sa borne
REVERSE_RANGE gauche.
25
Chapitre 3
Les différents styles de descriptions d’une architecture
En VHDL, il existe plusieurs styles descriptions d’une architecture qui diffèrent les unes des
autres.
Les trois descriptions principales sont :
- Description par flot de données.

- Description comportemental (appelée aussi procédural).
- Description structurelle.
Il existe aussi des styles de descriptions mixtes, ces derniers combinent les trois styles de
descriptions citées auparavant, et enfin une description très importante pour la simulation qui
est l’architecture de test.
Nous présentons dans ce chapitre, les différentsstyles de descriptions qu’on a citées.
3.1 Description par flot de données :
C’est une description qui décrit la façon dont les données transitent à l’intérieur d’un circuit.
Les codes VHDL vus précédemment étaient des descriptions de type flot de données.
Elle se base sur des expressions booléennes (les opérateurs logiques) des fonctions de
sorties en fonction des entrées.
Prenons comme exemple un multiplexeur 4 vers 1 (Figure 3.1) et décrivons-le avec le style
de description flot de données (Listing 3.1).
Figure 3.1 Symbole logique d’un multiplexeur 4 vers 1.
26
Listing 3.1 Description VHDL avec le style de description flot de données d’un multiplexeur
4 vers 1.
Simulation :
3.2 Description comportementale :
Appelée aussi description procédurale, elle décrit le comportement d’un circuit selon des
conditions (IF), des cas (CASE, WHILE), et des boucles (FOR).
C’est une description qui comporte des processus (PROCESS) qui s’exécutent en parallèles.
Les instructions à l’intérieur d’un processus s’exécutent séquentiellement.
Il faut bien faire la différence entre les modes d’exécutions parallèles et séquentielles.
3.2.1 Le PROCESS :
On utilise le PROCESS pour faciliter la modélisation d’un système.

27
On peut le considérer comme une boite noire où il y’a des instructions à l’intérieur qui
s’exécutentséquentiellement (Figure 3.2).
Ces PROCESS comportent une grande variété de construction, mais il faut faire attention
quand on les utilise car beaucoup d’entre eux n’ont pas une homologie matérielleclaire, et
conduisent souvent à des implémentations complexes, ou ne peuvent pas être synthétisés
dans le cas où ils sont mal codés.
Les PROCESS sont exécutés en concurrence (Figure 3.2).
Figure 3.2 Schéma d’exécution des PROCESS.
Un PROCESS comprend une liste appelée, liste de sensibilité.
Cette liste contient les noms des signaux qui activent ce PROCESS.
Exemple :
La liste de sensibilité de ce PROCESS est (A, B).
L’instruction dans le PROCESSne s’exécute que lorsqu’il y’a un changement d’état dans le
signal A ou B.
Ainsi, à chaque changement d’état du signal A ou B, l’instruction S <= A and B est
exécutée. 28
3.2.2 Les variables et les constantes :
On a vu qu’en VHDL il y’a trois types d’objet ; les signaux, les variables et les constantes.
Une variable est un objet auquel on peut affecter, à tout moment, la valeur qu’on désire, elle
ne peut être déclarée qu’à l’intérieur d’un PROCESS.
Exemple de déclaration des variables :
Une constante permet de paramétrer une valeur non modifiable lors de l’exécution de la
description, elle peut être déclarée dans un PROCESS (constante locale), ou en dehors de
celui-ci (constante globale).
Exemple de déclaration des constantes :
Dans le code ci-dessus, la constante de la ligne 11 est une constante globale, déclarée en
dehors du PROCESS, contrairement à la ligne 15, où elle est locale au PROCESS.
Comparaison entre variable et signal :
Type d’objet Assignation

<=
Utilité Etendu Comportement Usage
Dans les
Représente Mise à jour
Signal entités, les
un fil de Globale après un temps
architectures,
connexion (cycle delta)
les packages.
:=
Représente
Dans des
Variable une Mise à jour
Locale exécutions
information immédiate
séquentielles.
locale
29
3.2.3 Description avec l’instruction if :
La description avec l’instruction ifcommence avec le mot réservé

if condition_1 then
if et se termine avec les deux mots réservés end if ;(remarquer
séquence_instructions_1 ;
l’espace entre end et if suivie d’un point-virgule ;)ensuite vient la
elsif condition_2 then
condition, suivie par le mot réservé then .
séquence_instructions_2 ;
Exemple 1 :
else
if signal_x = ‘1’ then
séquence_instruction_3 ;
y <= ‘0’ ;
end if ;
end if ;
La condition est vraie quand la valeur du signal « signal_x » est à l’état logique ‘1’, et elle
est fausse dans le cas contraire.
Quand la condition est vraie, les instructions entre « if » et « end if » sont exécutées.
Dans notre exemple, le signale « y » recevra le niveau logique ‘0’, si la valeur du signal
« signal_x » vaudra le niveau logique ‘1’, dans le cas contraire les instructions entre « if »
et « end if » ne seront pas exécutées.
Exemple 2 :
Dans cet exemple, il y’a un signal nommé « s » qui dépend de la valeur du if (a > 5) then
signal nommé « a ».
s <= ‘1’;
Les tests se font séquentiellement.
elsif (a < 3 then) then
Le signal « s »recevra le niveau logique ‘1’ si la valeur du signal « a » sera
s <= ‘0’;
supérieure à 5, si cette dernière sera inférieure à 3, alors le signal « s »
else
recevra le niveau logique‘0’.
s <= ‘z’;
Si par contre, aucune des conditions précédentes ne seront satisfaites alors
end if;
lesignal « s » recevra l’état de la haute impédance.
Remarque :
A l’intérieur du bloc « if » et « end if », quand un « else »précède un « if », ils sont collés et

le « e » est éliminé à la fin de « else » (elsif).
30
Exemple pratique :
On étudie les mêmes circuits vus précédemment, pour qu’on puisse faire la différence entre
les différents styles de descriptions d’une architecture en VHDL.
Soit un multiplexeur 4 vers 1 donnée à la figure 3.1.
La description de ce circuit en VHDL est donnée par le listing 3.2.
Listing3.2Multiplexeur 4 vers 1 avec la description « if ».
Simulation :
31
3.2.4 Description avec l’instruction CASE :

case instruction is
La description avec l’instruction case est utilisée lorsque la
when choix_1 => instruction_1 ;
valeur d’un signal peut être utilisée pour choisir entre un certain
nombre d’actions. when choix_2 => instruction_2;
Cette description débute avec le mot réservé « case » suivi when choix_3 => instruction_3;
par une instruction, et le mot-clé « is ». …
L’instruction entre « case » et « is », renvoie une valeur qui when others => instruction_n;
correspond à un des choix qui se trouvent dans les déclarations « WHEN » et « OTHERS ».
Important :
La description avec l’instruction case doit obligatoirement avoir le choix « others » à la fin, si
toutes les valeurs de l’expression ne sont pas énumérées.
Exemple :
On donne dans le listing 3.3 une autre architecture de l’entité mux_4v1,décrit avec la
description « case ».
Listing 3.3Architecture VHDL d’un multiplexeur 4 vers 1 avec la description « case ».
3.2.5 Description avec les boucles (loop) :
En VHDL, les boucles sont utilisés quand il y’a répétition d’une opération. Les répétitions
peuvent être itératives (for), conditionnelles (while), et infinie (loop). On étudie dans ce
chapitre les 2 premières boucles.
32
3.2.5.1Répétitions itératives (for) :
La syntaxe simplifiée d’une boucle for est :
forindice inintervalle_boucle loop
instructions_séquentielles ;
end loop;
La boucle forest basée sur un indice, et répète les instructions séquentielle pour un nombre
fixe d’itérations (intervalle_boucle).
Exemple :
L’utilisation de la boucle for est montré par un exemple simple : description d’un circuit xor
de 4 bits (listing3.4).
Listing 3.4Description VHDL d’uncircuit numérique xor de 4 bits décrit avec la boucle
« for ».
Commentaire :
Le nombre d’itérations de la boucle est 4 (3 downto 0).
L’indice de la boucle est« I », ce dernierest local (c’est-à-dire qu’il n’appartientqu’à la boucle)

et n’a pas besoin d’être déclarée.
L’indice prends toujours la valeur qui est à gauche dans l’intervalle d’itération, dans notre
exemple, l’indice« I » vaudra 3 dans la première itération, 2 dans la deuxième itération, 1
dans la troisième itération, et enfin 0 dans la quatrième itération.
33
3.2.5.2 Répétitions conditionnelle (while) :
La syntaxe simplifiée d’une boucle while est :
while condition_booléenne loop
instructions_séquentielles ;
end loop;
La boucle while est une variante de la boucle for, mis à part que l’incrémentation de l’indice
de la boucle while se fait tant que la condition booléenne associée est vraie.
Exemple :
L’utilisation de la boucle while est démontré par le même exemple vu avec la boucle for :
description d’un circuit xor de 4 bits (listing 3.5).
Listing 3.5Description VHDL d’un circuit numérique xor de 4 bits décrit avec la boucle
« while ».
Commentaire :
L’indice de la boucle est la variable locale I qu’on a initialisé au pare avant à 0 :
variable I : integer := 0 ;
Le nombre d’itérations de la boucle est 4 ( I< 5).
L’instruction S(I) <= A(I) xor B(I) ;va s’exécuter tant que la condition sera vrai (c’est à dire
tant que la variable I sera strictement inférieure à 5).
34
3.3 Description structurelle :
Lorsqu’on a un système électronique composé, on peut structurer et séparer ces

composants en des blocs plus petits pour les décrire plus simplement.
L’avantage d’une telle description est la simplicité et la rapidité de la synthèse.
Pour comprendre le principe de cette description, prenons comme exemple l’additionneur

complet 1 bit de la figure 1.4.
Cet additionneur est composé de deux demi-additionneurs et une porte logique OR (figure
3.3).
Figure 3.3 Schéma d’un additionneur complet 1 bit
Les deux demi-additionneurs et la porte logique OR peuvent être considérés comme des
blocs.
Chaque bloc est appelé « component » (composant), et est une instance du modèle.
Pour différencier ses derniers, chaque instance à un nom distinct.
Chaque bloc doit être décrit séparément (c’est-à-dire avoir son entité et l’architecture
associée) (listing 3.6 et listing 3.7).
Listing 3.6 Description VHDL d’une porte logique OR.

35
Listing 3.7 Description VHDL d’un demi-additionneur 1 bit.
Dans l’architecture de l’additionneur complet 1 bit, il faut déclarer les composants

(component) utilisés, ainsi que leurs broches d’entrée-sortie pour faire les interconnexions
nécessaires (listing 3.8).
Listing 3.8 Déclaration des composants de l’additionneur complet 1 bit.
Nous avons besoin des signaux intermédiaires pour décrire l’assemblage des instances
utilisées.
3.3.1 Instanciation :
Il s’agit de mettre en correspondance chaque broche de chacune des instances des

composants avec les ports auquel il est connecté.
Il y’a trois types d’instanciation :
- Instanciation par position

- Instanciation par nom
- Instanciation mixte
36
3.3.1.1 Instanciation par position :
L’instanciation par position consiste à interconnecter pour chaque instance, les signaux
connectés à ses broches exactement selon l’ordre choisi dans la déclaration « component »
(listing 3.9).
Listing 3.9 Description structurelle d’un additionneur complet 1 bit avec instanciation par
position.
3.3.1.2 Instanciation par nom :
L’instanciation par nom consiste à interconnecter pour chaque instance, les signaux
connectés à ses broches sans respecter l’ordre choisi dans la déclaration « component »
(listing 3.10).
Il faut cependant utiliser le symbole « => » pour la correspondance entre les broches de
l’instance et le signal auquel elle est connectée.
37
Listing 3.10 Description structurelle d’un additionneur complet 1 bit avec instanciation par
nom.
3.3.1.3 Instanciation mixte (listing 3.11):
L’instanciation mixte permet d’utiliser les instanciations par position et par nom en même
temps, mais dans ce cas-là, l’instruction « port map » autorise une association par position
pour commencer, ensuite une association par nom pour finir.
On ne peut pas faire le contraire.
Listing 3.11 Description structurelle d’un additionneur complet 1 bit avec instanciation mixte
38
Chapitre 4 (Partie 1)
La modélisation des circuits séquentiels
4.1 Introduction :
Les bascules sont les éléments de base des circuits séquentiels.
Dans ce chapitre, nous allons d’abord décrire en VHDL ces bascules, puis on modélisera
des circuits séquentiels complexes.
Nous rappelons que dans les circuits séquentiels, les sorties ne dépendent pas que des
entrées, mais aussi de la valeur de l’état de sortie précédente.
Le modèle général d’un circuit séquentiel est montré dans la figure 4.1.
Comme on peut le constater, un circuit séquentiel est composé d’un circuit combinatoire et
d’un élément de mémoire (bascules).
Le circuit combinatoire reçoit deux signaux d’entrées ; un signal primaire (régi par
l’environnement du circuit) et un signal secondaire (régi par l’élément de mémoire).
La partie combinatoire du circuit séquentiel possède deux sorties ; une sortie primaire qui
contrôle les opérations, et une sortie secondaire utilisée pour la spécification de l’état qui
sera assumé par la mémoire.
Les variables de sortie secondaire sont appelées variables d’excitation et dépendent du type
de la bascule utilisée.
Figure 4.1 Modèle général d’un circuit séquentiel.
39
4.2 Les opérations synchrones et asynchrones :
Les circuits séquentiels peuvent être classés en deux catégories :
- Les circuits séquentiels synchrones.

- Les circuits séquentiels asynchrones.
Dans les circuits synchrones, l’état de la variable de sortie change à des instants discrets du
temps, ce dernier est sous le contrôle d’une pulsation synchrone appelée horloge.
Dans les circuits séquentiels synchrones, les changements de l’état de la variable de sortie
se font lors des transitions de l’horloge.
Ces transitions sont des fronts montants (de ‘0’ à ‘1’) ou des fronts descendants (de ‘1’ à ‘0’)
(figure 4.2).
En VHDL, la fonction des fronts d’une horloge (nommée par exemple CLK) est :
- Pour les fronts montants :
CLK’event and CLK=’1’ ou bien : rising_edge(CLK);
- Pour les fronts descendants :
CLK’event and CLK = ‘0’ ou bien falling_edge(CLK);
Dans les circuits séquentiels asynchrones, les changements de l’état de la variable de sortie
peuvent changer à des instants irréguliers.
Figure 4.2 Signal d’horloge.
4.3 Les LATCHS :
Le modèle vu dans la Figure 4.1 montre bien que l’unité mémoire est la partie essentielle
d’un circuit séquentiel.
40
L’unité de mémoire se compose généralement d’une série de LATCHES (Verrous).
4.3.1 LATCH R-S (Figure 4.3) :
C’est un LATCH à deux entrées R (RESET), S (SET) et deux sorties complémentaires Q et

Q.
(a) (b)
Figure 4.3 (a) LATCH R-S formé avec des portes logiques NOR et (b) LATCH R-S formé
avec des portes logiques NAND.
Le LATCH R-S a un très grand inconvénient, c’est son état indéterminé (état interdit). Dans
le cas où le LATCH est formé avec des portes logiques NOR (figure 4.3 – (a)), l’état
indéterminé arrive quand les entrées R et S sont à ‘1’.
Dans le cas où le LATCH est formé avec des portes logiques NAND (figure 4.3 – (b)), l’état
indéterminé arrive quand les entrées R et S sont à ‘0’.
Table de vérité d’un LATCH R-S (à base de NOR) :
R S Q(t) Q (t+1)
0 0 Q Q
0 1 1 0
1 0 0 1
1 1 Etat indéterminé Etat indéterminé
Figure 3.4Symbole logique d’un LATCH R-S
Table de vérité d’un LATCH R-S (à base de NOR) : (à base de NOR).
R S Q(t) Q (t+1)
0 0 Etat indéterminé Etat indéterminé
0 1 1 0
1 0 0 1
1 1 Q Q Figure 3.5Symbole logique d’un LATCH R-S
(à base de NAND).
41
Listing 4.1 Description VHDL du LATCH R-S.
Figure 4.6 Résultat de la simulation du LATCH R-S.
4.3.2 LATCH RSH :
C’est un LATCH R-S avec une troisième entrée qui sert d’activation (figure 4.7).
Figure 4.7 Symbole logique du LATCH RSH.

42
Table de vérité :
H R S Q(t) Q (t+1)
0 0 0 Q Q
0 0 1 Q Q
0 1 0 Q Q
0 1 1 Q Q
1 0 0 Q Q
1 0 1 1 0
1 1 0 0 1
1 1 1 Etat indéterminé Etat indéterminé
Listing 4.2 Description en VHDL du LATCH RSH.
Remarque :
On a supposé que l’état indéterminé arrive lorsque les signaux d’entrées R et S sont à ‘1’.
43
Figure 4.6 Résultat de la simulation du LATCH RSH.
4.3.3 LATCH D :
Un LATCH R-S peut être converti en un autre LATCH, connu sous le nom de LATCH D, en
ajoutant un inverseur (Figure 4.7).
Figure 4.7 LATCH D.
Table de vérité du LATCH D :
H D Q(t+1) Q (t+1)
0 - Q Q
1 0 0 1
1 1 1 0
La figure 4.7 montre un LATCH D construit à partir d’un LATCH R-S à base de porte
logique NAND.
Comme on peut le voir sur la table de vérité du LATCH D, la sortie Q suit l’entrée D si
l’entrée H = ‘1’. Si l’entrée H est à ‘0’, la sortie Q garde l’état précédent.
L’avantage du LATCH D par rapport au LATCH R-S, c’est qu’il n’y a pas une combinaison
qui produira un état indéterminé.
La description en VHDL du LATCH D est donnée par le listing 4.3.

44
Listing 4.3 Description en VHDL du LATCH D.
Figure 4.8 Résultat de la simulation du LATCH D.
4.4 Les FLIP-FLOPS :
Un FLIP-FLOP, comme un LATCH possède deux états stables, mais contrairement au

LATCH, les transitions (changement d’état de sortie) se font lors des fronts (montant ou
descendant) et non pas par des niveaux.
La figure 4.9 montre les chronogrammes d’un LATCH D et d’un FLIP-FLOP D.
45
Figure 4.9 Chronogramme d’un LATCH D et d’un Flip-Flop D.
4.4.1 Flip-Flop D :
L’entrée « D » est transférée à la sortie « Q » lors d’un front (montant ou descendant)

d’horloge (c’est-à-dire du niveau logique ‘0’ au niveau logique ’1’ ou bien le contraire).
Prenons comme exemple un Flip-Flop D actif sur front montant.
Symbole logique (figure 4.10) et table de vérité :
Set Reset Clk D Q(t+1) Q (t+1)

0 0 - - 0 1
0 1 - - 1 0
1 0 - - 0 1
1 1 0 - Q Q
1 1 1 - Q Q
1 1 - Q Q
1 1 0 0 1
1 1 1 1 0
Figure 4.10 Symbole logique d’un Flip-Flop D.
Remarque :
Lorsque les deux entrées « Reset » et « Set » sont à l’état logique ‘0’, une priorité doit être
conçue soit pour « Reset », soit pour « SET ».
46
Listing 4.4 Description en VHDL d’un Flip-Flop D.
Figure 4.11 Résultat de la simulation du Flip-Flop D.
47
4.4.2Flip-Flop J-K :
Le Flip-Flip J-K a les fonctions similaires du LATCH R-S, avec l’entrée J qui est équivalente
à l’entrée S (mise à ‘1’), et l’entrée K qui est équivalente à l’entrée R (remise à ‘0’).
Contrairement au LATCH R-S, le Flip-Flop J-K ne possède pas des combinaisons d’entrée
qui donneront un état indéterminé.
Prenons comme exemple un Flip-Flop J-K actif sur front descendant.
Symbole logique (figure 4.12) et table de vérité :
Set Reset Clk J K Q(t+1) Q (t+1)

0 0 - - - 0 1
0 1 - - - 1 0
1 0 - - - 0 1
1 1 0 - - Q Q
1 1 1 - - Q Q
1 1 - - Q Q
1 1 0 0 Q Q
1 1 0 1 0 1
1 1 1 0 1 0
Figure 4.12 Symbole logique d’un Flip-Flop J-K. 1 1 1 1 Q Q
Remarque :
Si les entrées J et K sont à ‘1’, la sortie prend l’inverse de l’état précédent.
J  1
  Q  Q
K  1
La description en VHDL du Flip-Flop J-K est donnée par le listing 4.5.
48
Listing 4.5 Description en VHDL d’un Flip-Flop J-K.
Figure 4.13 Résultat de la simulation du Flip-Flop J-K.
49
4.4.3 Flip-Flop T:
Connu aussi sous le nom de « trigger flip-flop », le flip-flip T possède une seule entrée de
données.
Le symbole logique d’un flip-flip T (actif sur front montant) est montré dans la figure 4.14.
Symbole logique du Flip-Flop T et ça table de vérité :
Clk T Q(t+1) Q (t+1)

0 - Q Q
1 - Q Q
- Q Q
0 Q Q
1 Q Q
Figure 4.14 Symbole logique d’un flip-flop T
(Actif sur front montant).
Lorsque le flip-flop T détecte un front montant sur l’horloge Clk et que T = ‘1’, la sortie
prend la valeur inverse de l’état précédent.
Listing 4.6 Description en VHDL d’un Flip-Flop T.

50
Figure 4.13 Résultat de la simulation du Flip-Flop T.
51
Chapitre 4 (Partie 2)
La modélisation des circuits séquentiels complexes
4.5 Compteurs et Registres :
Les compteurs et les registres sont des circuits logiques séquentiels, ils ont une architecture
similaire, c’est-à-dire qu’ils comprennent des bascules mises en cascade, reliées ou non
avec un système logique combinatoire.
Dans cette deuxième partie du chapitre 4, on va étudier plusieurs types de compteurs, ainsi
que les registres.
4.5.1 Compteurs :
Les compteurs sont principalement utilisés dans les applications de comptage.
Plusieurs types de compteurs existent, suivant l’application, ils peuvent être synchrones ou
asynchrones, compter ou décompter.
4.5.1.1 Compteurs asynchrones :
Un compteur asynchrone, est un ensemble de flip-flop mises en cascade, où la sortie d’un

Flip-Flop pilote l’entrée d’horloge de la bascule suivante.
Dans un compteur asynchrone, l’horloge (CLK) est appliquée uniquement à la première

bascule, (appelé bascule d’entrée).
L'entrée d'horloge d’une bascule (n+1) provient de la sortie de la bascule (n).
La figure 4.14 représente un schéma général d’un compteur asynchrone de n bits, formé à
partir de bascules JK actives sur front descendant.
Figure 4.14 Schéma général d’un compteur d’ondulation de n bits.
52
4.5.1.1.a) Description d’un compteur asynchrone 2 bits :
La figure 4.15 montre un compteur asynchrone 2 bits.
Noter que l’horloge CLK n’est appliquée qu’au premier Flip-Flop (FF0) qui représente le bit le
moins significatif (LSB) du compteur.
La seconde bascule (FF1), est pilotée par le signal de sortie Q de la première bascule (FF0).
La bascule FF0 change d'état au front descendant de l'horloge CLK.
La bascule FF1 change d’état au front descendant du signal de sortie Q de la première

bascule (FF0).
Par conséquent, les changements d’états des deux bascules n’arrivent jamais en même
temps.
Figure 4.15 Compteur asynchrone 2 bits.
Diagramme de temps :
Examinons le fonctionnement de base du compteur asynchrone de la figure 4.15 en

appliquant des impulsions d’horloge (CLK) et en observant les sorties de chaque Flip-Flop.
La figure 4.16 illustre les changements d’états des Flip-Flops en fonction de l’horloge.
Les entrées (J et K) des deux bascules sont mises à l’état logique ‘1’, et on suppose que
l’état initial de chaque bascule est à l’état logique ‘0’.
Figure 4.16 Diagramme du temps du compteur de la figure 4.15.
53
On voit dans la figure 4.16 qu’un front descendant du signal d’horloge (CLK) change l’état
de sortie Q0 de la première bascule (FF0), tandis qu’il n’y a aucun changement dans la
deuxième bascule, cette dernière (FF1) change d’état lorsqu’elle détecte un front descendant
de la première bascule (FF0).
Table de vérité des transitions du compteur de la figure 4.15 :
CLK Valeurs Q1(t) Q0(t) Q1(t+1) Q0(t+1)

0 0 0 0 1
1 0 1 1 0
2 1 0 1 1
3 1 1 0 0
Description VHDL du compteur de la figure 4.15 :
Notre compteur est composé de deux Flip-Flop JK actives sur front descendant, donc on
commence par décrire un Flip-Flop JK actif sur front descendant (listing 4.7) sans prendre
en compte le signal RESET et SET (comme on la fait dans le listing 4.5), car ils n’y figurent
pas dans la figure 4.15.
Listing 4.7 Description VHDL d’un Flip-Flop JK

54
La description VHDL du compteur de la figure 4.15 est donnée par le listing 4.8.
Listing 4.8 Description VHDL du compteur de la figure 4.15.
Figure 4.16 Simulation du compteur asynchrone 2 bits.
On voit bien que c’est un compteur asynchrone 2 bits.
4.5.1.1.b) Description d’un décompteur asynchrone 3 bits:
Les séquences d’états d’un décompteur 3 bitssont données par le tableau ci-dessous, le
schéma de ce compteur est donné par la figure 4.17.
Notons que pour 3 bits, il nous faut 3 bascules.
55
CLK Valeur Q2(t) Q1(t) Q0(t) Q2(t+1) Q1(t+1) Q0(t+1)

7 1 1 1 1 1 0
6 1 1 0 1 0 1
5 1 0 1 1 0 0
4 1 0 0 0 1 1
3 0 1 1 0 1 0
2 0 1 0 0 0 1
1 0 0 1 0 0 0
0 0 0 0 1 1 1
Figure 4.17 Schéma d’un décompteur asynchrone 3 bits.
Examinons le fonctionnement de base du compteur asynchrone de la figure 4.17 en

La figure 4.18 illustre les changements d’états des Flip-Flops en fonction de l’horloge.
Le délai de propagation n’est pas pris en considération.
Les entrées (J et K) des deux bascules sont mises à l’état logique ‘1’, et on suppose que
l’état initial de chaque bascule est à l’état logique ‘0’.

56
de sortie Q0 de la première bascule (FF0), tandis qu’il n’y a aucun changement dans les
deux autres bascules.
La bascule FF1 change d’état lorsqu’elle détecte un front descendant de la première bascule
(FF0).
La bascule FF2 change d’état lorsqu’elle détecte un front descendant de la bascule (FF1).
La description VHDL de ce compteur est donnée par le listing 4.9.
Figure 4.19 Simulation du décompteur asynchrone 3 bits.
57
4.5.1.1.c) Délai de propagation dans un compteur asynchrone :
Dans les diagrammes de temps qu’on a vus ultérieurement, le temps de propagation des
signaux n’était pas pris en considération pour la compréhension du fonctionnement des
compteurs.
En réalité, un compteur asynchrone possède un majeur problème, les changements d’états

des signaux de sorties des bascules ne se font pas en même temps, mais après un certain
délai de propagation.
D’abord, l’effet de l’horloge n’est pris en considération que par la première bascule.
L’effet de la première bascule est ensuite ressenti par la deuxième bascule, donc la
deuxième bascule doit attendre par l’intermédiaire de la première bascule l’effet de l’horloge
et ainsi de suite pour les bascules qui suivent.
Pour comprendre ce concept, étudions le chronogramme de la figure 4.20 qui représente un

diagramme de temps d’un compteur asynchrone 4 bits (le temps de propagation est pris en
considération).
Figure 4.20 Délai de propagation dans un compteur 3 bits.
Les numéros (en vert) dans le diagramme de temps de la figure 4.20 correspondent à ce
qui suit :
1 : Le temps de la transition de l’état logique ‘1’ à l’état logique ‘0’ (T PHL), correspond au
temps de propagation de l’horloge (CLK) à Q0.
2 : Le temps de la transition de l’état logique ‘0’ à l’état logique ‘1’ (T PLH), correspond au
temps de propagation de Q0 à Q1.
3 : Le temps de la transition de l’état logique ‘0’ à l’état logique ‘1’ (T PLH), correspond au
temps de propagation de Q1 à Q2.
La somme des délais de propagation de toutes les bascules doit être inférieure à la période
de l’horloge.
58
4.5.1.1.d) Compteur asynchrone modulo N :
Un compteur asynchrone modulo N est un compteur qui compte de 0 jusqu’à N-1, il possède
N états.
Prenons comme exemple, un compteur asynchrone modulo 6
Pour cela, il nous faut au minimum trois bascules.
Le schéma de ce compteur est donné par la figure 4.21.
Figure 4.21 Schéma d’un compteur asynchrone modulo 6 formé par des bascules JK
activent par front descendant.
Pour réaliser un compteur modulo N, il faut que le compteur se remette à 0 après l’état (N-1),
donc il faut utiliser les entrées de réinitialisation (RESET).
Dans le schéma de la figure 4.21, on a utilisé une autre appellation de RESET : Clr (Clear).
Dans le cas d’un compteur modulo 6, il faut que le comptage soit interrompu après le 5 et
soit remis à 0 pour recommencer.
La description VHDL de ce compteur est donnée par le listing 4.10.
59
Figure 4.22 Simulation du compteur asynchrone modulo 6.
4.5.1.2 Compteurs synchrones :
Un compteur synchrone est un compteur où toutes les bascules qui le constituent sont
synchronisées avec une horloge commune, par conséquent, toutes les bascules changent
d’états en même temps.
Le délai de propagation dans le cas d’un compteur synchrone est égal au délai de
propagation d’une seule bascule, ce qui le rend indépendant du nombre de bascules
utilisées (c’est-à-dire indépendant de sa taille), c’est un avantage par rapport aux compteurs
asynchrones vus précédemment.
60
La figure 4.23 représente un schéma général d’un compteur synchrone de n bits, formé à
partir de bascules JK actives sur front descendant.
Figure 4.23 Schéma général d’un compteur synchrone de n bits.
4.5.1.2.a) Description d’un compteur synchrone 2 bits :
La figure 4.24 montre le schéma d’un compteur synchrone 2 bits.
Noter que l’horloge CLK est appliquée aux deux Flip-Flops, FF0 et FF1, où FF0 représente
le bit le moins significatif (LSB) du compteur et FF1 représente le bit le plus significatif
(MSB).
Les changements d’états des deux bascules arrivent en même temps, car ils sont pilotés par
la même horloge (CLK), ce qui est un avantage.
Figure 4.24 Schéma d’un compteur synchrone 2 bits.
Examinons le fonctionnement de base du compteur synchrone de la figure 4.24 en

La figure 4.25 illustre les changements d’états des Flip-Flops en fonction de l’horloge. 61
de sortie Q0 de la première bascule (FF0), tandis qu’il n’y a aucun changement dans la
deuxième bascule.
La bascule FF1 change d’état lorsqu’elle détecte un front descendant de l’horloge (CLK) et
un front descendant de la première bascule (FF0) en même temps.
La description VHDL du compteur de la figure 4.24 :
On va décrire notre compteur (figure 4.24) avec une description structurelle (Listing 11).
Listing 4.11 Description VHDL d’un compteur synchrone 2 bits avec une description
structurelle.
62
Comme on l’a déjà cité, plusieurs méthodes existent pour décrire nos circuits.
Décrivons un autre compteur synchrone avec une description comportementale.
Prenons comme exemple, un compteur synchrone 3 bits actif sur front montant, sa
description en VHDL est donnée par le listing 4.12 et le schéma résultant est donné par la
figure 4.26.
On a utilisé un autre paquetage utile pour cette modélisation « numeric_std », cette

dernière nous permet de manipuler des opérations arithmétiques de base telles que
l’addition et la soustraction (+, -), mais aussi de manipuler des nombres signés et non-
signés.
comportementale.
Figure 4.26 Simulation du compteur synchrone 2 bits.
61
Figure 4.26 Simulation du compteur synchrone 3 bits modélisé avec le style de description
comportementale.
4.5.1.2.b) Description d’un compteur synchrone 3 bits :
La figure 4.27 montre un compteur synchrone 3 bits.
Noter que l’horloge CLK est appliquée au trois Flip-Flops, FF0, FF1 et FF2 où FF0
représente le bit le moins significatif (LSB) du compteur, et FF2 représente le bit le plus
significatif (MSB).
Figure 4.27 Compteur synchrone 3 bits.
On comprend aisément le fonctionnement du compteur de la figure 4.27 en examinant ses

séquences d’états comme indiqué dans le tableau suivant :
CLK Valeur Q2(t) Q1(t) Q0(t) Q2(t+1) Q1(t+1) Q0(t+1)

0 0 0 0 0 0 1
1 0 0 1 0 1 0
2 0 1 0 0 1 1
3 0 1 1 1 0 0
4 1 0 0 1 0 1
5 1 0 1 1 1 0
6 1 1 0 1 1 1
7 1 1 1 0 0 0
62
Le diagramme de temps du compteur synchrone 3 bits est montré dans la figure 4.28.
La description VHDL du compteur de la figure 4.27 :
structurelle.
63
Figure 4.29 Simulation du compteur synchrone 3 bits modélisé avec le style de description
structurelle.
4.5.1.2.c) Délai de propagation dans un compteur synchrone :
Les bascules dans un compteur synchrone sont pilotées par la même horloge, par
conséquent les changements d’états de ces bascules se font tous en même temps, ce qui
présente un très grand avantage par rapport aux compteurs asynchrones.
La figure 4.30 illustre un diagramme de temps d’un compteur synchrone 2 bits.
D : délai de propagation, qui est le temps de transition de l’horloge (CLK) jusqu’à Q0 de la

première bascule.
Figure 4.30 Diagramme de temps d’un compteur synchrone 2 bits.
4.5.1.2.d) Compteur synchrone modulo N :
Etudions un compteur synchrone très connu et beaucoup utilisé dans les applications de
comptage et d’affichage de celle-ci : Les décades (compteur synchrone modulo 10).
Un compteur décade possède 10 états, c’est avec 4 bits (4 bascules) qu’il est conçu.
Le schéma d’un tel compteur est montré dans la figure 4.31.
64
Figure 4.31 Schéma d’un compteur décade synchrone.
Le diagramme du temps :
Figure 4.32 Diagramme du temps du compteur décade synchrone.
On comprend aisément le fonctionnement d’un compteur synchrone décade en examinant la

table de vérité ci-dessous, et en suivant son schéma donnée par la figure 4.31.
On voit que la première bascule (FF0) agit sur front descendant de l’horloge (CLK), et n’est
dépendante que de celle-ci. Les équations booléennes de ce compteur sont données par :
J0=1 J1=Q0.Q3 J2=Q0.Q1 J3=Q0.Q1.Q2

   
 K0=1  K1=Q0.Q3  K2=Q0.Q1  K3=Q0.Q1
65
CLK Valeur Q3(t) Q2(t) Q1(t) Q0(t) Q3(t+1) Q2(t+1) Q1(t+1) Q0(t+1)
0 0 0 0 0 0 0 0 1
1 0 0 0 1 0 0 1 0
2 0 0 1 0 0 0 1 1
3 0 0 1 1 0 1 0 0
4 0 1 0 0 0 1 0 1
5 0 1 0 1 0 1 1 0
6 0 1 1 0 0 1 1 1
7 0 1 1 1 1 0 0 0
8 1 0 0 0 1 0 0 1
9 1 0 0 1 0 0 0 0
Décrivons en VHDL, le compteur décade synchrone avec les deux styles de description,
comportementale (listing 4.14) et structurelle (listing 4.15).
Listing 4.14 Description VHDL avec le style comportemental d’un compteur décade.
66
Listing 4.15 Description VHDL d’un compteur décade synchrone une description
structurelle.
Figure 4.33 Simulation du compteur synchrone décade modélisé avec le style de description
structurelle.
4.5.1.3 Compteur avec choix pour le mode : comptage/décomptage
C’est un compteur qui peut compter ou décompter, on l’appellecompteur bidirectionnel.

En général, les compteurs bidirectionnels peuvent changer de mode après n’importe quelle
séquence.
67
V.Tourtchine et M.Izouine. Initiation au langage VHDL. Application pour la modélisation des systèmes
numériques.
La figure 4.34 montre le schéma d’un compteur bidirectionnel 3 bits.
Figure 4.34 Schéma d’un compteur synchrone 3 bits avec mode de comptage.
Le tableau qui suit montre les transitions du compteur selon le choix du mode de comptage.
Mode de comptage
Comptage Décomptage
CLK Valeur Q2(t) Q1(t) Q0(t) Q2(t+1) Q1(t+1) Q0(t+1) Q2(t+1) Q1(t+1) Q0(t+1)
0 0 0 0 0 0 1 1 1 1
1 0 0 1 0 1 0 0 0 0
2 0 1 0 0 1 1 0 0 1
3 0 1 1 1 0 0 0 1 0
4 1 0 0 1 0 1 0 1 1
5 1 0 1 1 1 0 1 0 0
6 1 1 0 1 1 1 1 0 1
7 1 1 1 0 0 0 1 1 0
Notons le mode de comptage par P et le mode de décomptage par R.
Les équations booléennes de ce compteur sont données par :
J0 = 1 J1 = (Q0.P) + (Q0.R) J2 = (Q0.Q1.P) + (Q0.Q1.R)

  
K0 = 1 K1 = (Q0.P) + (Q0.R) K2 = (Q0.Q1.P) + (Q0.Q1.R)




Le diagramme de temps du compteur bidirectionnel est donné par la figure 4.35.

68
Figure 4.35 Diagramme du temps du compteur synchrone bidirectionnel.
Description en VHDL du compteur bidirectionnel (Listing 4.16) :
Listing 4.16 Description VHDL d’un compteur bidirectionnel 4 bits.
69
Figure 4.36 Simulation du compteur synchrone bidirectionnel 4 bits modélisé avec le style
de description comportementale.
4.5.1.4 Méthode de conception d’un compteur synchrone :
Pour concevoir un compteur synchrone, il faut suivre les étapes suivantes :
A) Etablir le nombre de bascules nécessaires : n
log x
Avec n 
log2
B) Etablir la « table des transitions du compteur », c’est-à-dire la table de vérité des
états présents et futurs du compteur.
C) Etablir la table des transitions des bascules en fonction de la table des transitions du
compteur.
D) Simplifier les équations des entrées des bascules à l’aide des tableaux de Karnaugh.
E) Implémentation du compteur.
Remarque :
log x
Dans le cas où le résultat de n n’est pas un nombre entier, le ramener à un nombre
log2
entier à la valeur supérieur.
Par exemple pour : 23,4 il faut 24 bascules.

Exemple :
Conception d’un compteur GRAY 3 bits.
A) Nombre de bascules nécessaires : 3

B) Table des transitions du compteur :
70
Etat présent Etats suivant

Q2(t) Q1(t) Q0(t) Q2(t+1) Q1(t+1) Q0(t+1)
0 0 0 0 0 1
0 0 1 0 1 1
0 1 1 0 1 0
0 1 0 1 1 0
1 1 0 1 1 1
1 1 1 1 0 1
1 0 1 1 0 0
1 0 0 0 0 0
C) Table des transitions des bascules :
On suppose qu’on veut concevoir un compteur formé par des bascules type JK actives sur
front descendant.
Table de transition de la bascule JK :
Q(t) Q(t+1) J K
0 0 0 X
0 1 1 X
1 0 X 1
1 1 X 0
A partir de la table de transition de la bascule JK, on peut établir la table des transitions
des bascules en fonction des états présents et futurs du compteur :
Q2(t) Q1(t) Q0(t) Q2(t+1) Q1(t+1) Q0(t+1) J2 K2 J1 K1 J0 K0

0 0 0 0 0 1 0 X 0 X 1 X
0 0 1 0 1 1 0 X 1 X X 0
0 1 1 0 1 0 0 X X 0 X 1
0 1 0 1 1 0 1 X X 0 0 X
1 1 0 1 1 1 X 0 X 0 1 X
1 1 1 1 0 1 X 0 X 1 X 0
1 0 1 1 0 0 X 0 0 X X 1
1 0 0 0 0 0 X 1 0 X 0 X
D) A l’aide des tableaux de Karnaugh, on va simplifier les expressions des équations

Q2(t)Q1(t)\Q0(t)
d’entrées des bascules en fonction des états présents du compteur0: 1
00 X 0
J0 : Q2(t)Q1(t)\Q0(t) 0 1 K0 : 01 X 1
00 1 X 11 X 0
01 0 X 10 X 1
11 1 X
10 0 X
Q2(t)Q1(t)\Q0(t) 0 1
00 X X
Q2(t)Q1(t)\Q0(t) 0 1 01 0 0
J1 : K1 :
00 0 1 11 0 1
71
01 X X 10 X X
11 X X
10 0 0
Q2(t)Q1(t)\Q0(t) 0 1
J2 : 00 0 0
K2 :
Q2(t)Q1(t)\Q0(t) 0 1
01 1 0
00 X X
11 X X
01 X X
10 X X
11 0 0
10 1 0
On obtient les expressions des entrées des bascules JK suivantes :
 J0  Q2.Q1  Q2.Q1  Q2  Q1

K 0  Q2.Q1  Q2.Q1  Q2  Q1

 J1  Q2.Q0

K1  Q2.Q0
 J2  Q1.Q0
  
K2  Q1.Q0
E) Implémentation du compteur :
Figure 4.37 Schéma d’un compteur GRAY 3 bits.
72
4.5.2 Les registres :
Les registres sont principalement utilisés pour le stockage de données.
Nous sommes tous familiers avec le rôle et l’utilisation des différents types de registres
utilisés à l’intérieur d’un microprocesseur, ou d’un microcontrôleur.
Un registre est un circuit séquentiel synchrone qui est formé principalement par des
bascules D.
La capacité de stockage d’un registre dépend du nombre de bascules qui le constituent.
Le schéma d’un registre à n bits formé par des bascules type D qui s’activent sur front
montant est représenté par la figure 4.38.
Figure 4.38 Schéma général d’un registre à n bits.
4.5.2.1 Registre à décalage :
Un registre à décalage est un registre qui décale ses données à droite ou à gauche à travers
des bascules mises en cascade.
4.5.2.1.a) Registre à décalage à droite :
C’est un registre qui décale ses données à droite lorsqu’un signal d’horloge (CLK) est
appliqué à l’ensemble de bascules qui le constituent.
Dans un tel registre, l’état logique de la sortie Qn de la nièmebascule est reproduite à la

sortie Qn+1 de la (n+1) ième bascule.
Prenons un exemple d’un registre à décalage à droite, formé par 3 bascules type D qui
s’activent sur front montant.
Le schéma de ce registre est donné par la figure 4.39.

73
Figure 4.39 Schéma d’un registre à décalage à droite.
Figure 4.40 Diagramme de temps du registre à décalage de la figure 4.39.
On voit que la donnée DATA passe à la première bascule (FF0) après une impulsion
d’horloge (CLK), après une autre impulsion d’horloge, cette donnée est transmise de la
première bascule (FF0) vers la deuxième bascule (FF1), et après une autre impulsion
d’horloge, la donnée DATA est transmise de la deuxième bascule (FF1) vers la troisième
bascule (FF2).
Autrement dit, la donnée DATA est transmise à la première bascule (FF0) après une
impulsiond’horloge (CLK), cette donnée est transmise à la deuxième bascule (FF1) après
deux impulsionsd’horloge, et elle est transmise à la troisième bascule (FF2) après trois
impulsions d’horloges.
On utilise ce genre de registre dans les circuits de temporisation, car on peut obtenir une
temporisation de n’importe quelle durée, il suffit de calculer le nombre de bascules
nécessaires ainsi que la fréquence d’horloge à appliquer sur celles-ci.
Modélisons en VHDL, le registre de la figure 4.39, par une description structurelle (listing
4.18) et part une description comportementale (listing 4.19).
74
Tout d’abord, donnons le code VHDL d’un Flip-Flop D actif sur front montant (listing 4.17).
Remarque : Le Flip-Flop D de la figure 4.29 ne possède pas les entrées asynchrones (SET
et RESET).
Listing 4.17 description VHDL d’un Flip-Flop D actif sur front montant.
Listing 4.18 Description structurelle en VHDL d’un registre à décalage à droite.

75
Listing 4.19 Description comportementale en VHDL d’un registre à décalage à droite.
Simulation :
Figure 4 .41 Simulation du registre à décalage à droite.
Le chronogramme de la figure 4.41 en vert représente le résultat de la simulation du registre

à décalage décrit avec le style de description structurelle, celui en bleu représente le résultat
de la simulation du registre à décalage décrit avec le style de description comportementale.
76
4.5.2.1.b) Registre à décalage à gauche :
C’est un registre qui décale ses données à gauche lorsqu’un signal d’horloge (CLK) est
appliqué à l’ensemble de bascules qui le constituent.
Dans un tel registre, l’état logique de la sortie Qn de la nièmebascule est reproduite à la

sortie Qn-1 de la (n-1) ième bascule.
Prenons un exemple d’un registre à décalage à gauche, formé par 4 bascules type D qui
s’activent sur front montant.
Le schéma de ce registre est donné par la figure 4.42.
Figure 4.42 Schéma d’un registre à décalage à gauche.
Figure 4.43 Diagramme de temps du registre à décalage de la figure 4.42.
La donnée DATA est transmise à la première bascule (FF0) après quatre impulsions
d’horloge (CLK).
77
Modélisons en VHDL, le registre de la figure 4.42, par une description structurelle (listing
4.20) en utilisant le composant décrit en listing 4.17, et par une description
comportementale (listing 4.21).
Listing 4.20 Description structurelle en VHDL d’un registre à décalage à gauche.
Listing 4.21 Description comportementale en VHDL d’un registre à décalage à gauche.

78
Simulation :
Figure 4 .44 Simulation du registre à décalage à gauche.
Le chronogramme de la figure 4.44 en vert représente le résultat de la simulation du registre

à décalage décrit avec le style de description structurelle, celui en bleu représente le résultat
de la simulation du registre à décalage décrit avec le style de description comportementale.
Application : Registre à décalage avec mode de décalage à droite ou à gauche :
C’est un registre qui peut décaler ses données à droite ou à gauche suivant le choix du
mode de décalage choisi.
On peut concevoir un tel registre en combinant les deux registres étudiés précédemment et
en ajoutant une entrée supplémentaire (MODE) pour la sélection du mode de décalage tel
que :
0  Décalage à droite
MODE  
1  Décalage à gauche
Le schéma de la figure 4.45 montre un exemple d’un registre à décalage avec mode de
décalage formé de quatre bascules type D qui s’activent sur front montant.
Dans la figure 4.45, l’entrée DATA_R représente la donnée à décaler à droite, et l’entrée
DATA_L représente la donnée à décaler à gauche.
79
Figure 4.45 Schéma d’un registre à décalage avec mode de décalage (à droite ou à
gauche).
Figure 4.46 Diagramme du temps du registre à décalage de la figure 4.45. Modélisons en
VHDL le registre à décalage avec mode de décalage avec les deux styles de
descriptions, structurelle (listing 4.23) et comportementale (listing 4.24).
Distinguons d’abord les composants à modéliser pour le style de description structurelle

(figure 4.47).
80
Figure 4.47 Les composants utilisés dans la description VHDL avec le style structurel du
registre à décalage de la figure 4.45.
Le bloc en rouge de la figure 4.47 représente les bascules type D qu’on a déjà modélisées
dans le listing 4.17.
On remarque que le bloc en vert de la figure 4.47 possède quatre entrées, et une sortie.
Les opérations effectuées au niveau de ce bloc sont basiques (and, or) ; modélisons-le en
VHDL avec le style de description : flot de données.
Listing 4.22 Description en VHDL du bloc en vert de la figure 4.47.
La figure qui se trouve à droite du listing 4.22 est un agrandissement du bloc en vert du
registre, les signaux intermédiaires y sont illustrés, ainsi que ses quatre entrées et la sortie.
81
Listing 4.23 Description structurelle en VHDL du registre à décalage de la figure 4.45.
Lorsqu’on a affaire à des circuits électroniques complexes, c’est difficile de ne pas faire
appel au style de description structurelle, car comme on l’a déjà cité auparavant, c’est un
style qui structure notre circuit dans des blocs faciles à manipuler.
Néanmoins, il faut faire très attention lorsqu’on instancie les composants qu’on veut utiliser
dans le circuit, car l’inconvénient du style structurel, c’est qu’on peut se tromper lorsqu’on
instancie des composants et on s’y perd assez vite lorsqu’on manipule un gros système.
La simulation du registre à décalage de la figure 4.45 est donnée dans la figure 4.48.
82
Figure 4 .48 Simulation du registre à décalage de la figure 4.45.
Listing 4.24 Description comportementale en VHDL du registre à décalage de la figure 4.45.
83
4.5.2.2 Types de registres à décalage :
Les registres sont également utilisés pour la conversion de données (sérielles en parallèles,
ou parallèles en sérielles).
C’est la façon dont les données sont chargées dans le registre, et la façon de lecture de ces
données qui identifie le type de registre.
On distingue quatre types de registre à décalage :
a) Registre à entrée série et sortie série.

b) Registre à entrée série et sortie parallèle.
c) Registre à entrée parallèle et sortie série.
d) Registre à entrée parallèle et sortie parallèle.
La figure 4.49 illustre les différents types de registre cité ci-dessus.
Figure 4.49 Types de registres à décalage.
4.5.2.2.a) Registre à entrée série et sortie série :
Dans ce type de registre, les données sont chargées en série, et lues en série.
Le schéma de la figure 4.50 montre un exemple de ce type de registre formé par quatre
bascules type D qui s’activent sur front montant.
Ce type de registre est utilisé dans les circuits de temporisation.
Comme on l’a déjà cité ultérieurement, on peut avoir n’importe quel délai souhaité, avec un
nombre de bascules et une fréquence d’horloge déterminés.
84
Figure 4.50 Schéma d’un registre à décalage à entrée série et sortie série.
Figure 4.51 Diagramme de temps du registre de la figure 4.50.
On voit bien que la sortie reçoit la donnée après quatre impulsions d’horloge (CLK).
Listing 4.25 Description comportementale en VHDL du registre à décalage à entrée série et

sortie série.
85
Simulation :
Figure 4.52 Simulation du registre à décalage à entrée série et sortie série.
4.5.2.2.b) Registre à entrée série et sortie parallèle :
Dans ce type de registre, les données sont chargées en série, et lues en parallèle.
Le schéma de la figure 4.53 montre un exemple de ce type de registre formé par quatre
bascules type D qui s’activent sur front montant.
Figure 4.53 Schéma d’un registre à décalage à entrée série et sortie parallèle.
Figure 4.54 Diagramme de temps du registre de la figure 4.53.

86
Listing 4.26 Description comportementale en VHDL du registre à décalage à entrée série et

sortie parallèle.
Simulation :
Figure 4.56 Simulation du registre à décalage à entrée série et sortie parallèle.
Dans le code VHDL du listing 4.26, on a utilisé une boucle « LOOP » (de ligne 17 à ligne
19) pour éviter l’affectation de la valeur de la variable à celle de la sortie plusieurs fois.
87
4.5.2.2.c) Registre à entrée parallèle et sortie série :
Dans ce type de registre, les données sont chargées en parallèle, c’est-à-dire que toutes les
bascules qui constituent le registre reçoivent les données simultanément, et sont lues en
série (bit par bit) c’est-à-dire séquentiellement donc synchronisées avec une horloge.
Un tel registre, possède une entrée supplémentaire qui indique au registre ce qu’il doit faire ;
charger les données ou bien les décaler.
Nommons cette entrée par SH/LD (pour LOAD/SHIFT), car c’est l’appellation qu’on trouve le
plus souvent dans les circuits intégrés tels que le 74166N de chez TEXAS INSTRUMENTS.
L’entrée SH/LD peut être conçue pour fonctionner de façon asynchrone ou synchrone.
Si l’entrée SH/LD est asynchrone, le chargement des données agit sur les entrées
asynchrones de la bascule (SET et RESET).
Si par contre l’entrée SH/LD est synchrone, il faut appliquer une impulsion d’horloge (CLK)
pour chaque chargement d’une donnée dans la bascule.
Soit « DAT A_0, DATA_1, DAT A_2, DATA_3 »les données à charger dans le registre à
décalage, et « S » la sortie.
Les équations booléennes de ce registre pour le chargement et pour le décalage sont

données par :
D0  DATA _ 0 D0  DATA _ 0

D1  DATA _ 1 D1  Q1
 
 
D2  DATA _ 2 D2  Q2
D3  DATA _ 3 D3  Q3
Chargement Décalage
Pour :
0  Chargement
SH / LD  
1  Décalage
On aura les équations du registre :
D0  (SH / LD).(DATA _ 0)  (SH / LD).(DATA _ 0)


D1  (SH / LD).(DATA _1)  (SH / LD).(Q1)

D2  (SH / LD).(DATA _ 2)  (SH / LD).(Q2)

D3  (SH / LD).(DATA _ 3)  (SH / LD).(Q3)
Le schéma d’un tel registre est donné dans la figure 4.57.
88
Figure 4.57 Schéma d’un registre à décalage à entrée parallèle et sortie série.
Figure 4.58 Diagramme de temps du registre à décalage à entrée parallèle et à sortie série.
89
Ce type de registre est à la base du convertisseur de données parallèles en série, comme

par exemple le port série RS-232, ou bien l’UART (Universal Asynchronous Receiver
Transmitter).
Le listing 4.27 décrit un registre à décalage à entrée parallèle et à sortie série.
En pratique, il faut tenir compte du nombre de données à convertir (8 données en général),

pour les succéder d’un bit de START et les précéder d’un bit de STOP pour éviter les erreurs
de transmissions.
Listing 4.27 Description comportementale en VHDL du registre à décalage à entrée

parallèle et sortie série.
Simulation :
Figure 4.59 Simulation du registre à décalage à entrée parallèle et sortie série.
90
4.5.2.2.d) Registre à entrée parallèle et sortie parallèle :
Dans ce type de registre, les données sont chargées et lues en parallèle, c’est-à-dire
simultanément.
Ce type de registre a les mêmes caractéristiques que celui étudié auparavant (mode de
chargement de données, mode de décalage), mis à part que, dès que les données sont
chargées dans les bascules, elles apparaissent aussitôt dans les sorties parallèles.
Le schéma d’un tel registre est donné dans la figure 4.60.
Figure 4.60 Schéma d’un registre à décalage à entrée parallèle et sortie parallèle.
4.5.2.3 Registre universel :
C’est un registre qui a la capacité de charger des données en série ou en parallèle, de les
décaler à droite ou à gauche, et où on peut lire ces données en série ou en parallèle, pour
cela, il possède des entrées de commande qui permettent de choisir son mode de
fonctionnement.
Le 74HC194 de Philips Semiconductors est un exemple d’un registre universel, le symbole

du bloc logique du 74HC194 est montré dans la figure 4.61, et son diagramme du temps
dans la figure 4.62.
Figure 4.61 Symbole du bloc logique du registre universel 74HC194.
91
Figure 4.62 Diagramme de temps du registre universelle 74HC194.
Les entrées S0 et S1 sont les entrées de commande qui permettent de choisir le mode de
fonctionnement du registre (chargement, décalage…).
Le chargement parallèle des données est synchrone, actif sur front montant de l’horloge
(CLK), et est activé lorsque les deux entrées de commande S0 et S1 sont à l’état logique ‘1’.
Le décalage à droite est synchrone, actif sur front montant de l’horloge (CLK), et est activé
lorsque l’entrée de commande S0 est à l’état logique ‘1’ et l’entrée de commande S1 est à
l’état logique ‘0’.
Les données sérielles à décaler à droite sont prises par l’entrée SR_SER, et celles à décaler
à gauche sont prises par l’entrée SL_SER.
Le décalage à gauche est synchrone, actif sur front montant de l’horloge (CLK), et est activé
lorsque l’entrée de commande S0 est à l’état logique ‘0’ et l’entrée de commande S1 est à
l’état logique ‘1’.
Lorsque les entrées de commande S0 et S1 sont à l’état logique ‘0’, il y’ a inhibition de
l’horloge.
Modélisons le registre universel 74HC194 en VHDL.
92
Le datasheetdu registre universel 74HC194 nous renseigne sur ses caractéristiques.
La table de vérité du fonctionnement du 74HC194 est donnée ci-dessous.
Mode de Entrées Sortie

fonctionnement CLK MR S1 S0 SER_SR SER_SL Dn Q0 Q1 Q2 Q3
Reset (clear) X L X X X X X L L L L
Inhibition (Hold) X H L L X X X q0 q1 q2 q3
H L H L X X L q0 q1 q2
Décalage à droite
H L H H X X H q0 q1 q2
Décalage à H H L X L X q1 q2 q3 L
gauche H H L X H X q1 q2 q3 H
Chargement
H H H X X Dn d0 d1 d2 d3
parallèle
Où : CLK : Entrées d’horloge
MR : Master Reset.
S1, S0 : entrées de commande.
SER_SR, SER_SL : les entrées sérielles pour le décalage à droite ou à gauche.
Dn : Les entrées de données D0, D1, D2, D3.
Q0, Q1, Q2, Q3 : Les sorties.
93
V.Tourtchine et M.Izouine. Initiation au langage VHDL. Application pour la modélisation des systèmes
numériques.
Listing 4.28 Description VHDL du registre universel 74HC194.
Figure 4.63 Simulation du registre universel 74HC194.
94
Chapitre 5
Machine à états finis (FSM)
5.1 Introduction :
Une FSM (Finite State Machine), machine à états finis, est utilisée pour modéliser un
systeme qui transite entre un nombre fini d’état interne.Ces transitions dépendent de l’état
courant et des entrées.
Contrairement à un circuit séquentiel régulier qui est composé principalement de

composants structurés, tels que les compteurs et les registres, les transitions d’états d’une
FSM ne présentent pas une simple répétition de style, son prochain état logique est
généralement construit à partir de zéro et est parfois connu sous le nom de "logique
aléatoire".
Dans ce chapitre, nous donnons un aperçu des caractéristiques de base ainsi que la
représentation d’une FSM, nous aborderons aussi l’aspect VHDL des FSM.
5.1.1 types d’FSM :
Il existe deux types d’FSM ; FSM de Moore et FSM de Mealy.
Le diagramme de base d'un FSM est représenté par la figure 5.1.
Il se compose d'un registre d'état, d’un bloc logique du prochain état, et d’un bloc logique des
sorties.
Une FSM est une machine de Moore si la sortie est uniquement en fonction de l'état courant,
et est une machine de Mealy si la sortie est en fonction de l'état courant ainsi que les
entrées externes.
Les deux machines, FSM de Moore et FSM de Mealy sont similaires mais pas
identiques.L’exemple qui est présenté dans le paragraphe 5.3.1 illustre les comportements
et les constructions des deux types d’FSM.
Figure 5.1 Diagramme de base d’un FSM.
95
5.1.2 Représentation d’une FSM :
Une FSM est généralement représentée par un diagramme d'état abstrait ou d'un
diagrammeASM (Algorithmic State Machine), où il y’a les entrées de la FSM, les sorties,
les états, ainsi que les transitions.
Les deux représentations fournissent les mêmes informations.La représentation FSM est
plus compacte et mieux adaptée pour les applications simples, tandis que la représentation
en diagrammeASM est plus descriptive pour les applications où il y’a des transitions
complexes, des conditions, et des actions, c’est un peu comme un organigramme.
- Diagramme d’état :
Un diagramme d'état est composé de nœuds, qui représentent les états.Ces derniers sont
représentés par des cercles, ainsi que des arcs notés par des transitions.
Un nœud et ses arcs de transition sont illustrés à la figure 5.2 (a).
Une expression logique exprimée en termes de signaux d'entrée est associée à chaque arc
de transition et représente une condition spécifique.L’arc est pris lorsque l'expression
correspondante est évaluée comme vrai.
Les valeurs de sortie de Moore sont placées à l'intérieur du cercle, car elles ne dépendent
que de l’état courant, tandis que les valeurs de sortie de Mealy sont placées sur les arcs de
transition car elles dépendent de l'état courant ainsi que des entrées externes.Pour que le
diagramme soit clair, seules les valeurs de sorties sont représentées.
Un exemple d’un diagramme d’état de type Moore est donné à la figure 5.3 (a), et àla figure
5.3 (b) de type Mealy, c’est un détecteur de séquence ‘’11’’, le signal de sorti « y » est activé
lorsque le circuit détecte deux fois de suite l’état logique "1" du signal d’entrée A.
- Diagramme ASM :
Un diagramme ASM est composé d'un réseau de blocs ASM.Ce dernier est constitué d’un
bloc d'état relié à un réseau optionnel où il y’a des blocs de choix (bloc conditionnel) ainsi
que des blocs de sorties conditionnelles.
Une représentation d’un diagramme ASM de type Moore est montrée à la figure 5.3 (c),
etde type Mealy à la figure 5.3 (d).
Un bloc d’état représente un état dans un ASM, les valeurs de sortie de Moore sont
affichées à l’intérieur de ce bloc, notez qu'il n'a qu'un seul chemin de sortie.
Le bloc conditionnel teste la condition d'entrée et détermine le chemin de sortie à prendre.Il

dispose de deux chemins de sortie, étiquetésV et F, (ou généralement ‘1’ et ‘0’) qui
correspondent successivement aux valeurs vraies et fausses de la condition.
Le bloc de sortie conditionnelle est généralement placé après le bloc conditionnel.
Il indique que le signal de sortie ne peut être activé que lorsque la condition correspondante
dans le bloc conditionnel est rencontrée.
96
Figure 5.2 (a) Symbole d’état d’un nœud et ses arcs de transition.
Figure 5.2 (b) Structure d’état d’un bloc ASM.
97
Un diagramme d'état peut facilement être converti en un diagramme ASM, et vice-versa.
Les figures5.3 (a), 5.3(b), 5.3(c) et5.3(d) sont équivalentes.
Le « Reset » correspond à l’état initial dans le cas d’une réinitialisation du circuit.
Figure 5.3 (a) Diagramme d’état de type Moore du détecteur de séquence « 11 ».
Figure 5.3 (b) Diagramme d’état de type Mealy du détecteur de séquence « 11 ».
Remarque :
Le diagramme d’état de type Mealy contient moins d’état que le diagramme d’état de type
Moore, ce qui est avantageux économiquement.
98
Figure 5.3 (c) Diagramme ASM de type Moore du détecteur de séquence « 11 ».
Figure 5.3 (d) Diagramme ASM de type Mealy du détecteur de séquence « 11 ».
99
5.2 Développement de code VHDL d’FSM :
La procédure de développement de code VHDL pour une FSM est similaire à celle d’un
circuit séquentiel, car il n’y a pas un standard en VHDL pour la description d’une FSM.
Par conséquent, tout en respectant la syntaxe VHDL, il existe plusieurs façons de décrire
une FSM donnée.
Un exemple de code VHDL pour le FSM de la figure 5.3 (a) est donnée dans le listing
5.1(a), celui de la figure 5.3 (b) dans le listing 5.1 (b).
La ligne 10 dans le listing 5.1 introduit le mot-clé TYPE, qui est une caractéristique du
langage VHDL que nous n'avons pas utilisé auparavant.
Le mot-clé TYPE nous permet de créer un type de signal défini par l'utilisateur.
Le nouveau type de signal est nommé « ETAT », ainsi la ligne 10 spécifie qu'un signal de ce
type peutavoir trois valeurs possibles : S0, S1, ou S2.
La ligne 11 du listing 5.1 définitun signal nommé « SIG », qui est du type « ETAT ».
Le signal « SIG » est utilisé dans le corps « architecture » pour représenter les sorties des
bascules qui mettent en œuvre les états de la FSM, le code ne précise pas le nombre de bits
représentés par lesignal « SIG », mais précise qu’il peut avoir les trois valeurs d’état S0, S1
ou S2.
Cela signifie que nous n'avons pas à spécifier le nombre d'états des bascules qui devrait être
utilisé pour la FSM, comme nous allons le voir ci-dessous, c’est le compilateur qui choisit
automatiquement un nombre approprié d’états des bascules lors de la synthèse d'un circuit
pour mettre en œuvre cette FSM.
Après avoir défini un signal pour représenter l'état des bascules, la prochaine étape consiste
àspécifier les transitions entre ces états.
L’instruction CASE est bien adaptée à cette description.
Les signaux d'entrée qui déclenchent le PROCESS sont « CLOCK » et « RESET », ainsi ils
apparaissentdans la liste de sensibilité.
Notez que le signal « A » n'est pas inclus dans la liste de sensibilité du PROCESS, car un
changementdans la valeur de ce signal ne peut pas affecter le signal « SIG » jusqu'à ce
qu'un changement seproduise dans le signal d'horloge (CLOCK), (comme par exemple la
détection d’un front), ou dans le signalRESET qui est asynchrone et donc, indépendant de
l’horloge.
Les lignes 15 et 16 précisent que la FSM devrait être à l'état S0, dans le cas
d’uneréinitialisation (RESET = ‘0’).
Les lignes 37 et 38 précisent que si l’FSM est à l'état S2, la sortie « Y » prend l’état logique
‘1’, sinon, elle prend l’état logique ‘0’.
100
Listing 5.1 (a) Description VHDL du FSM de la figure 5.3 (a).

Simulation :
Figure 5.4 Résultat de simulation d’FSM de type Moore du détecteur de séquence « 11 ».
101
Listing 5.1 (b) Description VHDL du FSM de la figure 5.3 (b).
La description VHDL d’une FSM de type Mealy peut être faite de la même manière que celle
de Moore.
La principale différence dans le cas d’une description d’FSM de type Mealy, est la façon dont
le code de la sortie est écrit.
Remarque :
On a décrit un autre PROCESS pour la sortie, sa liste de sensibilité prend en compte les
entrées, car dans le cas d’une FSM de type Mealy, la sortie ne dépend pas que de l’état
courant mais dépend également des entrées.
102
Lors de la synthèse, le logiciel associe automatiquement les valeurs des types de données
énumérés en représentations binaires, ce processus est connu sous le nom de
« assignation des états ».
Toutefois il existe un mécanisme pour effectuer cette opération manuellement, mais il est
rarement nécessaire.
5.3 Exemple de conception :
5.3.1 Détecteur de front montant :
Un détecteur de front montant est un circuit qui génère une impulsion d’horloge courte qu’on
appelle « un tick » quand un signal d’entrée passe de l’état logique ‘0’ à l’état logique ‘1’, il
est généralement utilisé pour indiquer le début d’un signal d’entrée variable dans un temps
lent.
Nous allons concevoir un détecteur de front montant en utilisant les deux modèles ; Moore
et Mealy afin de les comparer.
- Conception du détecteur de front montant avec le modèle de Moore :
Le diagramme d’état et le diagramme ASM basé sur le modèle de Moore du circuit détecteur
de front montant sont donnés à la figure 5.5, l’état « S0 » indique que le signal d’entrée est à
l’état logique ‘0’, tandis que l’état « S1 » indique que le signal d’entrée est à l’état logique ‘1’.
Un front montant se produit lorsque l’état logique ‘0’ de l’état « S0 » change à l’état logique
‘1’, dans ce cas l’FSM passe de l’état « S0 » à l’état « F », et le signal de sortie « tick »
reçoit l’état logique ‘1’.
Figure 5.5 Diagramme d’état et diagramme ASM du détecteur de front montant, basé sur le
modèle de Moore.
103
Listing 5.2 Description VHDL du détecteur de front montant, basé sur le modèle de Moore.
La méthode de conception qu’on a utilisée dans le listing 5.2 est plus pratique que celle
utilisée dans le listing 5.1 (a).
Dans le listing 5.2, on a séparé le registre d’état de bloc logique du prochain état, et on a
décrit ce dernier ainsi que la logique de sortie (revoir la figure 5.1).
C’est pour éviter les confusions et les erreurs.
104
Simulation :
Figure 5.6 Résultat de simulation du détecteur de front montant, basé sur le modèle de
Moore.
- Conception du détecteur de front montant avec le modèle de Mealy :
Le diagramme d’état et le diagramme ASM basé sur le modèle de Mealy du circuit détecteur
de front montant sont donnés à la figure 5.7.
Les états « S0 » et « S1 » sont similaires à ceux du modèle de Moore.
Lorsque l’FSM se trouve à l’état « S0 » et que le signal d’entrée « A » change de l’état

logique ‘0’ à l’état logique ‘1’, la sortie « tick » prend l’état logique ‘1’ immédiatement, l’FSM
prend l’état « S1 » après un second front montant de l’horloge.
Figure 5.7 Diagramme d’état et diagramme ASM du détecteur de front montant, basés sur le
modèle de Mealy.
105
Listing 5.3 Description VHDL du détecteur de front montant, basé sur le modèle de Mealy.
Simulation :
Figure 5.8 Résultat de simulation du détecteur de front montant, basé sur le modèle de
Mealy.
106
Comparaison :
Bien que les deux types de machines ; Moore et Mealy soit similaires, c’est-à-dire qu’ils
produisent « un tick » lorsqu’ils détectent un front montant, il faut savoir qu’ils ne sont pas
identiques et qu’il y a plusieurs différences entre ces machines.
La machine de Mealy requiert moins d’état que la machine de Moore, et elle est plus rapide
que cette dernière, mais la largeur de ses sorties peut varier, et les « GLITCHS » peuvent
être transmises à la sortie.
Le choix entre les deux conceptions dépend de la façon dont on veut traiter les signaux de
sorties.
Par exemple, les applications qui utilisent des sous-systèmes synchrones contrôlés par une
unique horloge, les « GLITCHS » n’ont pas besoin d’être pris en considération tant que le
signal de sortie soit stable autour d’un front montant ou descendant, et par conséquent, dans
ce type de circuit on préférera la machine de type Mealy.
5.3.2 Circuit anti-rebond :
Les commutateurs ainsi que les boutons poussoirs qui se trouvent dans la carte de
prototypage d’FPGA sont des dispositifs mécaniques, lorsqu’on presse l’un d’eux, il peut
rebondir plusieurs fois (dans le voisinage de 20 ms) avant de se fixer, ces rebondissement
conduisent à des instabilités dans le signal comme le montre la figure 5.9 (le signal en
haut).
Pour y remédier, on utilise un circuit anti-rebond pour filtrer les instabilités (rebondissements)
présentes dans le signal après les transitions de commutation.
Le signal de sortie du circuit anti-rebond est montré dans la figure 5.9 (le signal en bas).
Figure 5.9 Signal de sortie avec et sans circuit anti-rebond.
L’FSM de type Moore du circuit anti-rebond est montrée dans la figure 5.10, elle utilise une
minuterie qui génère une impulsion d’horloge après chaque 10ms pour éviter de vérifier la
stabilité du signal d’entrée.
107
Figure 5.10 FSM de type Moore du circuit anti-rebond.
Les deux états de la FSM « S0 » et « S1 » indiquent que le signal d’entrée « BP » (Bouton

poussoir, ou le commutateur) est stabilisé à l’état logique ‘0’ (si il est à l’état « S0 »), ou à
l’état logique ‘1’ (si il est à l’état « S1 »).
Supposons que l’FSM est initialement à l’état « S0 », elle passe à l’état « T1 » lorsque le
signal « BP » passe à l’état logique ‘1’, et elle attend le « tick » (10ms) pour passer à l’état
« T2 », ce dernier processus se répète trois fois (c’est-à-dire de l’état « T1 » à l’état « T2 »,
de l’état « T2 » à l’état « T3 » et de l’état « T3 » à l’état « S1 ») pour que le signal de sortie
« Sout » passe à l’état logique ‘1’.
Le processus d’attente se déroule trois fois pour être sûr que le signal d’entrée « BP » est
stabilisé, et de revenir à l’état initiale dans le cas contraire.
Le code VHDL de cette FSM est donné dans le listing 5.4.
108
109
Listing 5.4 FSM du circuit anti-rebond de la figure 5.10.
110
Installation de Xilinx ISE 13.2

Outil de conception de circuit FPGA
Téléchargement de l’outil Xilinx ISE 13.2

- Aller au lien suivant : http://www.xilinx.com/support/download/index.htm
- Choisir la version 13.2 sous l’onglet version qui se trouve à gauche
- Cliquer sur Full Installer for Windows
PS : Pour le système d’exploitation Linux, il faut choisir Full Installer for Linux.
111
Installation de l’outil Xilinx ISE 13.2
- Aller dans le répertoire où se trouve l’outil Xilinx ISE 13.2 et cliquer sur l’icône
xsetup.exe (Si la fenêtre du Contrôle de compte d’utilisateur s’ouvre, cliquer
sur oui).
- Cliquer sur Next
- Cocher la case :I accept and agree to the terms and conditions aboveet
cliquer sur Next
112
113
- Cocher la case :I accept and agree to the terms and conditions aboveet
cliquer sur Next
114
- Choisir l’outil ISE WebPACK et cliquer sur Next
115
- Cliquer sur Next
- Cliquer sur Next
- Cliquer sur Install
116
- Vers les 89% de l’installation, une nouvelle fenêtre s’ouvrira, il s’agit de

l’installation du logiciel WinPcap. Cliquer sur Next
- Cliquer sur Next
117
- Cliquer sur : I Agree
- Décocher la case : Automatically start the WinPcap driver at boot time, et

cliquer sur Next
118
- Cliquer sur : Finish
- Si la fenêtre : Select MATLAB installation for System Generator

13.2s’ouvre, cliquer sur : Choose Later
119
- Cliquer sur : Finish
120
- Séléctionner : Locate Existing License(s), et cliquer sur Next
- Cliquer sur : Copy License…en haut à gauche
121
- Aller dans le répertoire M_License et choisir la license : xilinx_ise.lic
- Un message de succès apparaitra, cliquer sur OK :
- Aller dans le répertoire où Xilinx ISE 13.2 a été installé, suivre le chemin
suivant puis supprimer le fichier xilinx.lic :
C :\Xilinx\13.2\ISE_DS\EDK\data\core_licenses\Xilinx.lic
- Cliquer sur Refresh
L’outil Xilinx ISE 13.2 est prêt à être utilisé.
122
Guide pratique d’utilisation de Xilinx ISE 13.2
1 Introduction
1.1 Survol
Le logiciel Xilinx ISE 13.2 est un outil de synthèse et d’analyse de conception HDL, produit
par la société américaine Xilinx.
Il permet aux développeurs de faire la synthèse de leurs conceptions, effectuer une analyse
temporelle, examiner les diagrammes RTL, et de simuler des conceptions sous différents
stimuli.
1.2 Objectif de ce guide
- La création d’un nouveau projet dans Xilinx ISE 13.2.
- La description d’un circuit numérique à l’aide du langage de description VHDL.
- La simulation d’un circuit numérique décrit avec le langage de description VHDL.
1.3 Lancement de Xilinx ISE 13.2
Lancez Xilinx ISE 13.2 en cliquant deux fois sur l’icône correspondante sur le bureau.
Ou aller à : Démarrer  Tous les programmes  Xilinx ISE Design Suite 13.2 
ISEDesign Tools  Project Navigator
123
2 Création d’un nouveau projet :

Pour créer un nouveau projet, cliquez sur le bouton New Project qui se situe à gauche.
Ou bien : File  New Project
Une boite de dialogue apparaitra où vous devrez saisir le nom du projet (Name),
l’emplacement du projet (Location), la description de votre projet (Description), et spécifier le
type de source de la conception de haut niveau (Top-level source type).
Conservez le « Top-level source type » en HDL et cliquez sur Next.
124
Vous devez remplir certains champs correspondants aux différents outils et FPGA utilisés.
Reproduisez les choix de la figure suivante, puis cliquez sur Next, puis sur Finish.
Note :
- Evaluation Development Board : Spécifie la carte de développement utilisée avec
la conception.
- Synthesis Tool : Spécifie l’outil de synthèse utilisé pour la conception.

o XST (Xilinx Synthesis Technology) dans notre cas, ce dernier est fourni
avec l’outil ISE.
- Simulator : Spécifie l’outil utilisé pour la simulation.

o ISim (ISE Simulator) dans notre cas, ce dernier est fourni avec l’outil ISE.
- Preferred language : Contrôle le paramètre par défaut pour les propriétés de

processus qui génèrent une sortie HDL.
125
3 Description d’un circuit numérique en VHDL
Modélisons un circuit arithmétique de base ; un additionneur complet 1 bit.

Nous rappelons que ce circuit a trois entrées ; deux opérandes et une retenue d’entrée, ainsi
que deux sorties ; l’addition des trois bits d’entrées et une retenue de sortie.
Le tableau de ce circuit est donné ici :
A B Ci S Cout
0 0 0 0 0
0 0 1 1 0
0 1 0 1 0
0 1 1 0 1
1 0 0 1 0
1 0 1 0 1
1 1 0 0 1
1 1 1 1 1
Dans la fenêtre de Design, à gauche, cliquez avec le bouton droit sur le nom de votre projet,
et cliquez sur New Source…
Dans la boîte de dialogue qui apparait, choisissez comme type VHDL Module et donnez un
nom pour votre fichier source (ici additionneur), et cliquez sur Next.
126
Vous pouvez maintenant donner les entrées et sorties de votre module, pour l’instant,
cliquez sur Next, puis Finish.
Un nouveau fichier VHDL est automatiquement crée dans votre projet, ce dernier comporte
déjà un début de structurepour votre description matérielle.
Remplacez ce code par le code VHDL suivant :
Listing 1 Description VHDL d’un additionneur complet 1 bit.
Enregistrez votre code après l’avoir écrit : File  Save ou bien Ctrl + S.
Après avoir développé n’importe quel code VHDL, il faut vérifier les erreurs de syntaxe pour
une éventuelle correction.
127
Pour la vérification des erreurs de syntaxe, il faut utiliser la partie inférieure de l’onglet
Design :
Défilez le menu de « Synthesize – XST » en cliquant sur le « + » se trouvant à sa gauche.
Cliquez deux fois sur l’onglet Check Syntax.
Un message de succès devrait s’afficher dans la console.

Dans le cas contraire,il faut corriger les erreurs ou inspecter les avertissements (warnings)
pour vous assurer qu’ils ne proviennentpas d’erreurs dans votre code.
Idéalement, on devrait voir s’afficher le crochet vert illustré par la figure suivante :
128
4 Simulation d’un circuit numérique en VHDL
Simulons l’additionneur complet 1 bit modélisé auparavant.

Pour simuler notre additionneur, il faut créer un fichier de test appelé Test Bench, ce dernier
contient les signaux de tests.
Créez un nouveau fichier dans la fenêtre de Design, à gauche, cliquez avec le bouton droit
sur le nom de votre projet, et cliquez sur New Source…
Dans la boîte de dialogue qui apparait, choisissez comme type VHDL Test Benchet donnez
un nom pour votre fichier de test (ici test_additionneur), et cliquez sur Next.
Choisir le code VHDL associé à ce code de test (en général il est sélectionné par défaut) et
cliquez sur Next, puis Finish.
129
Un nouveau fichier de test VHDL est automatiquement crée dans votre projet, ce dernier
comporte déjà un début de structurepour test de votre description matérielle.
Remplacez ce code par le code VHDL suivant :
Listing 2 Test Bench de l’additionneur complet 1 bit.
Enregistrez votre code après l’avoir écrit : File  Save ou bien Ctrl + S.
Dans la fenêtre de Design, à gauche, cliquez sur Simulation, et sélectionnez le Test Bench
que vous avez créé.
Défilez le menu de « ISim Simulator » en cliquant sur le « + » se trouvant à sa gauche et

cliquez deux fois sur « Behavioral Check Syntax » pour vérifier la syntaxe du code de test.
Un message de succès devrait s’afficher dans la console.
Dans le cas contraire,il faut corriger les erreurs ou inspecter les avertissements (warnings)
pour vous assurer qu’ils ne proviennentpas d’erreurs dans votre code.
Idéalement, on devrait voir s’afficher le crochet vert illustrés par la figure suivante :
130
Cliquez deux fois sur « Simulate Behavioral Model » pour lancer la simulation :
L’outil de simulation ISim se lance, utilisez les options de ZOOM pour régler l’affichage des
résultats.
131
Liste des mots réservés
abs function of on signal

access generate open shared
across generic or sla
after group others sll
aliasall guarded out spectrum
and if package sra
architecture impure port srl
array assert in postponed subnature
attribute inertial procedural subtype
begin inout procedure terminal
block body is label process then
break library protected through
buffer bus limit pure to
case linkage quantity tolerance
component literal range transport
configuration loop record type
constant map reference unaffected
disconnect mod register units
downto nand reject until
else nature rem use
elsif new report variable
end next return wait
entity noise rol when
exit nor ror while
file not select with
for null severity xnor
xor
132

04 Modélisation Des Systèmes Numériques

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

04 Modélisation Des Systèmes Numériques

Transféré par

Droits d'auteur :

Formats disponibles

REPUBLIQUE ALGERIENNE DEMOCRATIQUE ET POPULAIRE

MINISTERE DE L’ENSEIGNEMENT SUPERIEUR ET DE LA

UNIVERCITE M’HAMED BUGARA DE BOUMERDES

Manuscrit élaboré selon le programme officiellement agréé et

Table des matières

Chapitre 1 : Les concepts de base du langage VHDL................................. 5

Chapitre 2 : Objets et types de données .......................................................... 14

Chapitre 3 : Les différentes descriptions d’une architecture ............... 24

Chapitre 4 : La modélisation des circuits séquentiels ............................. 37

4.5.1.4 Méthode de conception d’un compteur synchrone ................................... 68

Application : Registre avec mode de décalage à droite ou à gauche ..................... 79

4.5.2.2 Type de registres à décalage ....................................................................... 84

Chapitre 5 : Machine à états finis(FSM) ............................................................ 95

Annexe ............................................................................................................................... 111

Annexe 2. Guide pratique d’utilisation de Xilinx ISE 13.2 ................................................... 123

Annexe 3. Liste des mots réservés...................................................................................... 132

La première version du VHDL accessible au public a été publiée en 1985, et a fait

Avec un langage de description matérielle et un FPGA (Field Programmable Gate

Cette brochure est présentée en cinq chapitres, et trois annexes.

1.1 Description générale :

Listing 1.1 Description VHDL du circuit intégré 7400.

1.1.1 Les règles de base du VHDL :

1.1.2La déclaration de l’entité :

L’entité correspond au circuit vu de l’extérieur (Figure 1.1(a)), et comprend essentiellement

NOM_DU_PORT : MODE TYPE ;

Le mode d’un port peut être : - IN s’il s’agit d’une entrée

- OUT s’il s’agit d’une sortie

- INOUT s’il s’agit d’une entrée - sortie (port bidirectionnel)

- BUFFER s’il s’agit d’une sortie rebouclée en entrée

Si le type du signal utilisé est un bus de données, on utilise alors le type

Soit le signal d’entré A de 8 bits, on le déclarera en VHDL comme suit :

On peut utiliser le type bit à la place de std_logic, et le type bit_vector à la place de

1.1.3La déclaration de l’architecture :

L’architecture du circuit correspond au circuit vu de l’intérieur (Figure 1.1 (b)), et comprend

Architecture NOM_DE_L’ARCHITECTURE of NOM_DE_L’ENTITE is

Dans notre exemple, le nom de l’architecture est behavioral.

Exemple 1 : Comparateur 1 bit

Les entrées du comparateur sont : A, B

Les sorties du comparateur sont : EG (égale), PG (plus grand), PP (plus petit).

Table de vérité du et équations booléennes du comparateur :

Le schéma du circuit du comparateur :

Figure 1.2 Schéma du comparateur.

La description du comparateur en langage VHDL :

Listing 1.2 Description VHDL du comparateur.

Exemple 2 - Additionneur complet 1 bit :

Les entrées de l’additionneur sont : A, B, Ri.

Les sorties de l’additionneur sont : S (somme), Rout (retenue).

Table de vérité et équations booléennes de l’additionneur :

Le schéma du circuit du l’additionneur :

Le code VHDL de l’additionneur :

Figure 1.4 Schéma de l’additionneur complet 1 bit à partir de deux demi-additionneurs.

Listing 1.3 Description VHDL d’un additionneur complet 1 bit.

1.2. Les signaux intermédiaires :

Figure 1.4 Schéma de l’additionneur complet 1 bit à partir de deux demi-additionneurs.

Le code VHDL de la figure 1.7 :

1.3Assignation conditionnelle et assignation sélectionnée des signaux :

Les instructions d’assignation conditionnelles et d’assignation sélectionnées aux

1.3.1 Assignation conditionnelle des signaux :

Le format d’une assignation conditionnelle des signaux est le

suivant : Signal_1<= valeur_expression_1 WHEN

valeur_expression_2 WHEN choix_2 ELSE

Soit un multiplexeur 2 vers 1.

Il a comme entréesA, B, SEL, et comme sortie S (Figure 1.5).

Figure 1.5 Multiplexeur 2 vers 1.