REPUBLIQUE ALGERIENNE DEMOCRATIQUE ET …dspace.univ-bouira.dz:8080/jspui/bitstream/123456789/455/1/04... · Chapitre 5 : Machine à états finis ... VHDL est ’ cronyme de VHSIC

- 0 -

REPUBLIQUE ALGERIENNE DEMOCRATIQUE ET POPULAIRE

MINISTERE DE L’ENSEIGNEMENT SUPERIEUR ET DE LARECHERCHE SCIENTIFIQUE

Spécialité : INFOTRONIQUE&

IMAGERIE ET APPARAILLAGE BIOMEDICALE

V.Tourtchine et M.IzouinMODELISATION DES SYSTEMES NUMERIQUESDANS L'ENVIRONNEMENT Xilinx ISE 13.2 (VHDL)

Manuscrit élaboré selon le programme officiellement agréé etconfirme par le Conseil Scientifique de la Faculté des Sciences

BOUMERDES - 2012

UNIVERCITE M’HAMED BUGARA DE BOUMERDES

FACULTE DES SCIENCES – DEPARTEMENT PHYSIQUE

1

V.Tourtchine et M.Izouine. Initiation au langage VHDL. Application pour la modélisation des systèmes numériques.

Table des matièresPAGE

Introduction Générale.............................................................................. 4

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

1.1Description générale ....................................................................................................... 51.1.1 Les règles de base du VHDL ................................................................................. 61.1.2 La déclaration de l’entité......................................................................................... 61.1.3 La déclaration de l’architecture ............................................................................. 7

1.2Les signaux intermédiaires .......................................................................................... 101.3Assignation conditionnelle et assignation sélectionnée des signaux .................... 111.3.1 Assignation conditionnelle des signaux ............................................................. 111.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 ................................................................................................................... 142.1.1 Déclaration d’un signal............................................................................................. 152.1.2 Initialisation des signaux .......................................................................................... 152.1.3 Utilisation des signaux ............................................................................................. 16

2.2 Les types et sous-types ............................................................................................... 162.2.1 Les types « scalaires » ......................................................................................... 162.2.2 Les types « composites »..................................................................................... 172.2.3 Les types « accès »............................................................................................... 212.2.4 Les types « fichiers » ............................................................................................ 21

2.3 Les opérations de base sur les objets....................................................................... 212.3.1 Les opérations logiques ........................................................................................... 212.3.2 Les opérations relationnelles ................................................................................... 212.3.3 Les opérations d’addition ......................................................................................... 222.3.4 Les opérations de multiplication............................................................................... 222.3.5 Les opérations de signe ........................................................................................... 222.3.6 Les opérations de décalage..................................................................................... 222.3.7 Autres opérations ..................................................................................................... 23

2.4 Les attributs ................................................................................................................... 23

2


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

3.1Description par flots de données................................................................................. 243.2Description comportementale ...................................................................................... 253.2.1 Le PROCESS ......................................................................................................... 253.2.2 Les variables et les constantes ........................................................................... 273.2.3 Description avec l’instruction IF........................................................................... 283.2.4 Description avec l’instruction CASE ................................................................... 303.2.5 Description avec les boucles (LOOP) ................................................................ 303.2.5.1 Répétitions itératives (FOR) ......................................................................... 313.2.5.2 Répétitions conditionnelles (WHILE) .......................................................... 32

3.3Description structurelle ................................................................................................. 333.3.1 Instanciation ........................................................................................................... 343.3.1.1 Instanciation par position .............................................................................. 353.3.1.2 Instanciation par nom .................................................................................... 353.3.1.3 Instanciation mixte ......................................................................................... 36

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

4.1 Introduction ..................................................................................................................... 374.2Les opérations synchrones et asynchrones .............................................................. 384.3Les LATCHS................................................................................................................... 384.3.1 LATCH R-S............................................................................................................. 394.3.2 LATCH RSH ........................................................................................................... 404.3.3 LATCH D................................................................................................................. 42

4.4Les FLIP-FLOPS ........................................................................................................... 434.4.1 Flip-Flop D .............................................................................................................. 444.4.2 Flip-Flop J-K ........................................................................................................... 464.4.3 Flip-Flop T ............................................................................................................... 48

4.5Compteurs et Registres ................................................................................................ 504.5.1 Compteurs .............................................................................................................. 504.5.1.1 Compteurs asynchrones ............................................................................... 504.5.1.1.1 Description d’un compteur asynchrone 2 bits ......................................... 514.5.1.1.2 Description d’un décompteur asynchrone 3 bits..................................... 534.5.1.1.3 Délai de propagation dans un compteur asynchrone ............................ 564.5.1.1.4 Compteur asynchrone modulo N .............................................................. 57

4.5.1.2 Compteurs synchrones ................................................................................. 584.5.1.2.1 Description d’un compteur synchrone 2 bits ........................................... 594.5.1.2.2 Description d’un décompteur synchrone 3 bits ....................................... 624.5.1.2.3 Délai de propagation dans un compteur synchrone .............................. 644.5.1.2.4 Compteur synchrone modulo N................................................................. 64

4.5.1.3 Compteurs avec choix pour le mode : comptage/décomptage .............. 67

3


4.5.1.4 Méthode de conception d’un compteur synchrone................................... 684.5.2 Les registres ........................................................................................................... 734.5.2.1 Registre à décalage....................................................................................... 734.5.2.1.1 Registre à décalage à droite ...................................................................... 734.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....................................................................... 844.5.2.2.1 Registre à entrée série et sortie série ...................................................... 844.5.2.2.2 Registre à entrée série et sortie parallèle ................................................ 864.5.2.2.3 Registre à entrée parallèle et sortie série ................................................ 884.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....................................................................................................................... 955.1.1 Types d’FSM .......................................................................................................... 955.1.2 Représentation d’FSM .......................................................................................... 96

- Diagramme d’état ................................................................................................ 96- Diagramme ASM ................................................................................................. 96

5.2 Développement de code VHDL d’FSM.......................................................................... 1005.3 Exemple de conception.................................................................................................. 103

5.3.1 Détecteur de front montant .................................................................................... 1035.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

4


Introduction généraleVHDL 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, lesobjets et types de données seront présentés dans le deuxième chapitre, ainsi queles opérations applicables sur ces derniers, on verra les différents styles dedescription d’une architecture dans le troisième chapitre, on modélisera des circuitssé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.

5


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.

6


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érateursdisponibles 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 paquetageSTD_LOGIC_1164, et possède neuf états :

Etat Définition0 Niveau logique 0, forçage fort1 Niveau logique 1, forçage fortZ Haute impédanceU Niveau non initialiséX Niveau inconnu, forçage fort- Niveau quelconque (Don’t care)L Niveau logique 0, forçage faibleH Niveau logique 1, forçage faibleW Niveau inconnu, forçage faible

7


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.

8


A B EG PG PP0 0 1 0 00 1 0 0 11 0 0 1 01 1 1 0 0

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 :

EG A.B A.BPG A.B 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.

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

10


A B Ri S Rout0 0 0 0 00 0 1 1 00 1 0 1 00 1 1 0 11 0 0 1 01 0 1 0 11 1 0 0 11 1 1 1 1

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 :

S A B RiRout A.B A.Ri B.Ri

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.

11


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).

12


Le code VHDL de la figure 1.7 :

Listing 1.4 Description VHDL d’un additionneur complet 1 bit en utilisant lessignaux

intermédiaires.

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

Les instructions d’assignation conditionnelles et d’assignation sélectionnées auxsignaux sont exécutées en concurrence. Leurs comportements sont similaires auxinstructions IF et CASE qu’on verra dans le chapitre 2, qui ont quant à eux, desinstructions 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_expression_n ;

13


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 lafigure 1.5 est la suivante :

Listing 1.5 Description VHDL d’un multiplexeur 2 vers 1 avec l’assignation conditionnelle.

Simulation :

14


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 lafigure 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.

15


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érationsbien 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).

16


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 conventionsd’é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, maisqu’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érenceentre 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.

17


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 typecomposé.

18


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 (Lesdiffé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.

19


- 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 typestd_logic.

On peut associer un objet de type « MON_TABLEAU » comme suit :

20


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 typestd_logic(figure 2.2).

Figure 2.2

21


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 typestd_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 :

22


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 dansl’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

23


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 exemplel’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ésultatAND Le ‘ET’ logique Tout type binaire ou booléen Même typeOR Le ‘OU’ logique Tout type binaire ou booléen Même typeNAND Le ‘NON ET’ logique Tout type binaire ou booléen Même typeNOR Le ‘NON OU’ logique Tout type binaire ou booléen Même typeXOR Le ‘XOR’ logique Tout type binaire ou booléen Même typeNXOR 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.

24


Opération Description Type d’opération Type de résultat= 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.

Opération Description Type d’opération Type de résultat+ 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.

Opération Description Type d’opération Type de résultat* 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 typeREM 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).

Opération Description Type d’opération Type de résultat+ 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 rotationsau niveau des bits ou d’objet de type booléens.

Opération Description Type d’opération Type de résultatSLL Décalage à gauche (logique) Entier, bit, ou booléen Même typeSRL Décalage à droite (logique) Entier, bit, ou booléen Même typeSLA Décalage à gauche (arithmétique) Entier, bit, ou booléen Même typeSRA Décalage à droite arithmétique Entier, bit, ou booléen Même typeROL Rotation à gauche (logique) Entier, bit, ou booléen Même typeROR Rotation à droite (logique) Entier, bit, ou booléen Même type

25


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.

Opération Description Type d’opération Type de résultat** Exponentiation Tout type entier ou flottant Même type

ABS Valeur absolue Tout type numérique Même typeNOT 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 informationssupplé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

Attribut POS(X)Il nous informe sur la position de l’élément X par un nombreentier.

Attribut VAL(X) Il nous informe sur la valeur contenue de la position X.

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

Attribut SUCC(X) Il nous informe sur la valeur contenue de l’élément qui succède la position X.

Attribut LEFT Il exprime la valeur la plus à gauche dans la déclaration du type.

Attribut RIGHT Il exprime la valeur la plus à droite dans la déclaration du type.

Attribut HIGH Il exprime la plus grande valeur dans la déclaration du type.

Attribut LOW Il exprime la plus petite valeur dans la déclaration du type.

Attribut LENGTH Il exprime le nombre d’éléments d’un indice.

Attribut RANGE Il exprime l’intervalle de variation de sa borne gauche à saborne droite

AttributREVERSE_RANGE

Il exprime l’intervalle de variation de sa borne droite à sa bornegauche.

26


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.

27


Listing 3.1 Description VHDL avec le style de description flot de données d’un multiplexeur4 vers 1.

Simulation :

3.2 Description comportementale :

Appelée aussi description procédurale, elle décrit le comportement d’un circuit selon desconditions (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.

28


On peut le considérer comme une boite noire où il y’a des instructions à l’intérieur quis’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.

29


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, ellene 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

Signal

<=Utilité Etendu Comportement Usage

Représente un fil de connexion

GlobaleMise à jour après un temps (cycle delta)

Dans les entités, les architectures, les packages.

Variable

:=Représente uneinformation locale

Locale Mise à jour immédiate

Dans des exécutions séquentielles.

30


3.2.3 Description avec l’instruction if :

La description avec l’instruction ifcommence avec le mot réservé

if et se termine avec les deux mots réservés end if ;(remarquer

l’espace entre end et if suivie d’un point-virgule ;)ensuite vient la

condition, suivie par le mot réservé then .

Exemple 1 :

if signal_x = ‘1’ then

y <= ‘0’ ;

end if ;

if condition_1 then

séquence_instructions_1 ;

elsif condition_2 then

séquence_instructions_2 ;

else

séquence_instruction_3 ;

end if ;

La condition est vraie quand la valeur du signal « signal_x » est à l’état logique ‘1’, et elleest 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

signal nommé « a ».

Les tests se font séquentiellement.

Le signal « s »recevra le niveau logique ‘1’ si la valeur du signal « a » sera

supérieure à 5, si cette dernière sera inférieure à 3, alors le signal « s »

if (a > 5) then

s <= ‘1’;

elsif (a < 3 then) then

s <= ‘0’;

recevra le niveau logique‘0’.

Si par contre, aucune des conditions précédentes ne seront satisfaites alors

lesignal « s » recevra l’état de la haute impédance.

Remarque :

else

end if;

s <= ‘z’;

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).

31


Exemple pratique :

On étudie les mêmes circuits vus précédemment, pour qu’on puisse faire la différence entreles 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 :

32


3.2.4 Description avec l’instruction CASE :

La description avec l’instruction case est utilisée lorsque la

valeur d’un signal peut être utilisée pour choisir entre un certain

nombre d’actions.

Cette description débute avec le mot réservé « case » suivi

par une instruction, et le mot-clé « is ».

L’instruction entre « case » et « is », renvoie une valeur qui

case instruction is

when choix_1 => instruction_1 ;

when choix_2 => instruction_2;

when choix_3 => instruction_3;

…

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, sitoutes 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étitionspeuvent être itératives (for), conditionnelles (while), et infinie (loop). On étudie dans ce chapitre les 2 premières boucles.

33


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 nombrefixe d’itérations (intervalle_boucle).

Exemple :

L’utilisation de la boucle for est montré par un exemple simple : description d’un circuit xorde 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.

34


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’indicede 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 à diretant que la variable I sera strictement inférieure à 5).

35


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 (figure3.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’architectureassociée) (listing 3.6 et listing 3.7).

Listing 3.6 Description VHDL d’une porte logique OR.

36


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 instancesutilisé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

37


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 del’instance et le signal auquel elle est connectée.

38


Listing 3.10 Description structurelle d’un additionneur complet 1 bit avec instanciation parnom.

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

39


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 etd’un élément de mémoire (bascules).

Le circuit combinatoire reçoit deux signaux d’entrées ; un signal primaire (régi parl’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 typede la bascule utilisée.

Figure 4.1 Modèle général d’un circuit séquentiel.

40


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 sortiese 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 sortiepeuvent 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.

41


R S Q(t) Q (t+1)0 0 Q Q0 1 1 01 0 0 11 1 Etat indéterminé Etat indéterminé

R S Q(t) Q (t+1)0 0 Etat indéterminé Etat indéterminé0 1 1 01 0 0 11 1 Q Q

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 etQ .

(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’étatindéterminé arrive quand les entrées R et S sont à ‘0’.

Table de vérité d’un LATCH R-S (à base de NOR) :

Table de vérité d’un LATCH R-S (à base de NOR) :

Figure 3.4Symbole logique d’un LATCH R-S

(à base de NOR).

Figure 3.5Symbole logique d’un LATCH R-S

(à base de NAND).

42


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.

43


Table de vérité :

H R S Q(t) Q (t+1)0 0 0 Q Q0 0 1 Q Q0 1 0 Q Q0 1 1 Q Q1 0 0 Q Q1 0 1 1 01 1 0 0 11 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’.

44


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 Q1 0 0 11 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 sil’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 combinaisonqui produira un état indéterminé.

La description en VHDL du LATCH D est donnée par le listing 4.3.

45


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.

46


Set Reset Clk D Q(t+1) Q (t+1)0 0 - - 0 10 1 - - 1 01 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.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é :

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 ».

47


Listing 4.4 Description en VHDL d’un Flip-Flop D.

Figure 4.11 Résultat de la simulation du Flip-Flop D.

48


Set Reset Clk J K Q(t+1) Q (t+1)

0 0 - - - 0 10 1 - - - 1 01 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

1 1 1 1 Q Q

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éequi 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é :

Figure 4.12 Symbole logique d’un Flip-Flop J-K.

Remarque :

Si les entrées J et K sont à ‘1’, la sortie prend l’inverse de l’état précédent.

J 1K 1

Q Q

La description en VHDL du Flip-Flop J-K est donnée par le listing 4.5.

49


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.

50


Clk T Q(t+1) Q (t+1)

0 - Q Q1 - Q Q

- Q Q0 Q Q1 Q Q

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é :

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.

51


Figure 4.13 Résultat de la simulation du Flip-Flop T.

52


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’unFlip-Flop pilote l’entrée d’horloge de la bascule suivante.

Dans un compteur asynchrone, l’horloge (CLK) est appliquée uniquement à la premièrebascule, (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.

53


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êmetemps.

Figure 4.15 Compteur asynchrone 2 bits.

Diagramme de temps :

Examinons le fonctionnement de base du compteur asynchrone de la figure 4.15 enappliquant 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.

54


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 11 0 1 1 02 1 0 1 13 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

55


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.

56


CLK Valeur Q2(t) Q1(t) Q0(t) Q2(t+1) Q1(t+1) Q0(t+1)7 1 1 1 1 1 06 1 1 0 1 0 15 1 0 1 1 0 04 1 0 0 0 1 13 0 1 1 0 1 02 0 1 0 0 0 11 0 0 1 0 0 00 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 enappliquant des impulsions d’horloge (CLK) et en observant les sorties de chaque Flip-Flop.


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’.


57


On voit dans la figure 4.18 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 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.

58


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 ladeuxième bascule doit attendre par l’intermédiaire de la première bascule l’effet de l’horlogeet 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’ (TPHL), correspond autemps de propagation de l’horloge (CLK) à Q0.

2 : Le temps de la transition de l’état logique ‘0’ à l’état logique ‘1’ (TPLH), correspond au

temps de propagation de Q0 à Q1.

3 : Le temps de la transition de l’état logique ‘0’ à l’état logique ‘1’ (TPLH), 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ériodede l’horloge.

59


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èdeN é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 JKactivent 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.

60



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.

61


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 appliquant des impulsions d’horloge (CLK) et en observant les sorties de chaque Flip-Flop.


62




On voit dans la figure 4.25 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.

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.

61


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.

Listing 4.12 Description VHDL d’un compteur synchrone 3 bits avec une description comportementale.

Figure 4.26 Simulation du compteur synchrone 2 bits.

62


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 sessé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 11 0 0 1 0 1 02 0 1 0 0 1 13 0 1 1 1 0 04 1 0 0 1 0 15 1 0 1 1 1 06 1 1 0 1 1 17 1 1 1 0 0 0

63



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 :

Listing 4.13 Description VHDL d’un compteur synchrone 3 bits avec une description structurelle.

64


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.

65


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’estdé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.Q2K0=1

K1=Q0.Q3K2=Q0.Q1

K3=Q0.Q1

66


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 11 0 0 0 1 0 0 1 02 0 0 1 0 0 0 1 13 0 0 1 1 0 1 0 04 0 1 0 0 0 1 0 15 0 1 0 1 0 1 1 06 0 1 1 0 0 1 1 17 0 1 1 1 1 0 0 08 1 0 0 0 1 0 0 19 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.

67


Listing 4.15 Description VHDL d’un compteur décade synchrone une descriptionstructurelle.

Figure 4.33 Simulation du compteur synchrone décade modélisé avec le style de descriptionstructurelle.

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 quelleséquence.

68


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 comptageComptage 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 11 0 0 1 0 1 0 0 0 02 0 1 0 0 1 1 0 0 13 0 1 1 1 0 0 0 1 04 1 0 0 1 0 1 0 1 15 1 0 1 1 1 0 1 0 06 1 1 0 1 1 1 1 0 17 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.


69


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.

70


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

Avec n log x

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 xDans le cas où le résultat de n n’est pas un nombre entier, le ramener à un nombre

log2entier à 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 : 3B) Table des transitions du compteur :

71


Q2(t)Q1(t)\Q0(t) 0 100 1 X01 0 X11 1 X10 0 X

Q2(t)Q1(t)\Q0(t) 0 100 X 001 X 111 X 010 X 1

Q2(t)Q1(t)\Q0(t) 0 100 0 101 X X11 X X10 0 0

Q2(t)Q1(t)\Q0(t) 0 100 X X01 0 011 0 110 X X

Etat présent Etats suivantQ2(t) Q1(t) Q0(t) Q2(t+1) Q1(t+1) Q0(t+1)

0 0 0 0 0 10 0 1 0 1 10 1 1 0 1 00 1 0 1 1 01 1 0 1 1 11 1 1 1 0 11 0 1 1 0 01 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 K0 0 0 X0 1 1 X1 0 X 11 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 K00 0 0 0 0 1 0 X 0 X 1 X0 0 1 0 1 1 0 X 1 X X 00 1 1 0 1 0 0 X X 0 X 10 1 0 1 1 0 1 X X 0 0 X1 1 0 1 1 1 X 0 X 0 1 X1 1 1 1 0 1 X 0 X 1 X 01 0 1 1 0 0 X 0 0 X X 11 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 équationsd’entrées des bascules en fonction des états présents du compteur :

J0 : K0 :

J1 : K1 :

72


Q2(t)Q1(t)\Q0(t) 0 100 0 001 1 011 X X10 X X

Q2(t)Q1(t)\Q0(t) 0 100 X X01 X X11 0 010 1 0

J2 : K2 :

On obtient les expressions des entrées des bascules JK suivantes :

J0 Q2.Q1Q2.Q1Q2Q1K0 Q2.Q1Q2.Q1Q2Q1J1Q2.Q0K1Q2.Q0J2 Q1.Q0

K2 Q1.Q0

E) Implémentation du compteur :

Figure 4.37 Schéma d’un compteur GRAY 3 bits.

73


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 desbascules 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 frontmontant 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) estappliqué à 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 quis’activent sur front montant.

Le schéma de ce registre est donné par la figure 4.39.

74


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 impulsiond’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 (listing4.18) et part une description comportementale (listing 4.19).

75


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 (SETet 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.

76


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.

77


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) estappliqué à 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 quis’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 impulsionsd’horloge (CLK).

78


Modélisons en VHDL, le registre de la figure 4.42, par une description structurelle (listing4.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.

79


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 dumode 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 telque :

0Décalage à droiteMODE

1Décalage à gauche

Le schéma de la figure 4.45 montre un exemple d’un registre à décalage avec mode dedé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éeDATA_L représente la donnée à décaler à gauche.

80


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 dedescriptions, 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).

81


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éesdans 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 enVHDL 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.

82


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.

83


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.

84


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 cesdonné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 quatrebascules 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.

85


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.

86


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 quatrebascules 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.

87


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 à ligne19) pour éviter l’affectation de la valeur de la variable à celle de la sortie plusieurs fois.

88


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 leplus 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 « DATA_0, DATA_1, DATA_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

D1 DATA _ 1D2 DATA _ 2D3 DATA _ 3

D0 DATA _ 0

D1Q1D2Q2D3Q3

Chargement Décalage

Pour :

0ChargementSH / LD

1Dé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.

89


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.

90


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.

91


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.

92


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.

93


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 fonctionnement

Entrées SortieCLK MR S1 S0 SER_SR SER_SL Dn Q0 Q1 Q2 Q3

Reset (clear) X L X X X X X L L L LInhibition (Hold) X H L L X X X q0 q1 q2 q3

Décalage à droiteH L H L X X L q0 q1 q2H L H H X X H q0 q1 q2

Décalage à gauche

H H L X L X q1 q2 q3 LH H L X H X q1 q2 q3 H

Chargement parallèle H H H X X Dn d0 d1 d2 d3

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.

94


Listing 4.28 Description VHDL du registre universel 74HC194.

Figure 4.63 Simulation du registre universel 74HC194.

95


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 dessorties.

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 lesentré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.

96


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 figure5.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.

97


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.

98


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 typeMoore, ce qui est avantageux économiquement.

99


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 ».

100


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 listing5.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 casd’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’.

101


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 ».

102


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.

103


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 ; Mooreet 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 lemodèle de Moore.

104


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.

105


Simulation :

Figure 5.6 Résultat de simulation du détecteur de front montant, basé sur le modèle deMoore.

- 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.

106


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 deMealy.

107


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.

108


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.

109


110


Listing 5.4 FSM du circuit anti-rebond de la figure 5.10.

111


Installation de Xilinx ISE 13.2Outil 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.

http://www.xilinx.com/support/download/index.htm

http://www.xilinx.com/support/download/index.htm

112


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

113


114


- Cocher la case :I accept and agree to the terms and conditions aboveet cliquer sur Next

115


- Choisir l’outil ISE WebPACK et cliquer sur Next

116


- Cliquer sur Next

- Cliquer sur Next

- Cliquer sur Install

117


- 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

cliquer sur Next

118


- Cliquer sur : I Agree

- Décocher la case : Automatically start the WinPcap driver at boot time, et

119


- Cliquer sur : Finish

- Si la fenêtre : Select MATLAB installation for System Generator13.2s’ouvre, cliquer sur : Choose Later

120


- Cliquer sur : Finish

121


- Séléctionner : Locate Existing License(s), et cliquer sur Next

- Cliquer sur : Copy License…en haut à gauche

122


- 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é.

123


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, produitpar 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

124


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.

125


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.

126


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, ainsique 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 Cout0 0 0 0 00 0 1 1 00 1 0 1 00 1 1 0 11 0 0 1 01 0 1 0 11 1 0 0 11 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.

127


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 pourune éventuelle correction.

128


Pour la vérification des erreurs de syntaxe, il faut utiliser la partie inférieure de l’ongletDesign :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 :

129


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.

130


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 :

131


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 desrésultats.

132


Liste des mots réservés

abs access across after

aliasall and

architecture

array assert attribute

beginblock body

break buffer bus

case

component configuration

constant disconnect

downtoelse elsif end

entity exit filefor

function generate generic group

guarded if

impure

in inertial inout

is label

library limit

linkage literal loop map mod nand

nature new next noise nornot

null

of on open

or others

out

package port

postponed

procedural procedure process

protected pure

quantity range record

reference register rejectrem

report return

rolror

select severity

signal shared

slasll

spectrum sra

srl subnature subtype terminal

then through

to tolerance transport

type unaffected

units

until

use variable

wait when while with xnorxor

Documents

REPUBLIQUE ALGERIENNE DEMOCRATIQUE ET …dspace.univ-bouira.dz:8080/jspui/bitstream/123456789/455/1/04... · Chapitre 5 : Machine à états finis ... VHDL est ’ cronyme de VHSIC