Vous êtes sur la page 1sur 7

TP Cir. Prog. VHDL 2ème Ing. Mécat.

TP3 : Compteur Hexadécimal


Introduction : En logique séquentielle, les sorties ne dépendent pas seulement des entrées, mais également des
séquences des entrées passées. Pour ce faire, le circuit utilise une partie mémoire qui va lui permettre de retrouver
l’état induit par les entrées passées. La sortie est par conséquent calculée en fonction de l’état présent et des entrées
qui arrivent au système. Le langage VHDL possède un jeu d’instructions séquentielles très complet, mais uniquement
utilisable au sein d’un processus. Comme instructions séquentielles il y a l’instruction wait, la structure de boucle, la
structure conditionnelle (if…then…else…) et l’instruction case. Notons qu’en structure conditionnelle, une
description incomplète (absence de : else…) crée l’effet mémoire, un effet propre au système séquentiel. En hardware,
cela se traduit par la présence d’une bascule.

Objectif du TP :

L’objectif de ce TP est de décrire en VHDL puis implémenter sur une carte FPGA un compteur Hexadécimal
(Figure 1). Un compteur Hexadécimal est un circuit basé sur un « Compteur binaire 4-bit » à cycle complet (compte
de 0 jusqu’à 15) et qui affiche les valeurs de sortie en format hexadécimal sur un afficheur 7-segments à travers un
«Décodeur». Le circuit contient aussi un module «Diviseur de Fréquence» dont le rôle est de générer l’horloge
nécessaire au fonctionnement du compteur 4-bit à partir de l’horloge principale de la carte FPGA. La figure ci-dessous
présente le travail à réaliser
Horloge 50Hz de la carte FPGA

Diviseur de Fréquence

Horloge du
compteur

4 Decodeur 12
Clear Compteur 4-bit d'afficheur
7-segments

Programme VHDL à réaliser

Figure 1 : Schéma du compteur Hexadécimal

Remarque: Il est important de comprendre que cette figure vous donne l'architecture de votre programme VHDL : on
utilisera la programmation structurelle. Ce style consiste à assembler des composants créés séparément.

Plan du TP :
1. Le compteur 4-bit
2. Le diviseur de fréquence
3. Le décodeur de l’afficheur 7-segments
4. Programme principal : Compteur hexadécimal

Remarque importante : Vous allez compléter chacune des 3 premières parties du TP dans son propre dossier. Pour
la 4ème partie, c.à.d. le programme principal, vous allez rassembler les fichiers.vhd développés précédemment
(copier/coller les de leurs sources vers le dossier « Principal »). Tous les fichiers nécessaires au TP se trouvent dans
le dossier TP3_work.

ENICAR (2015/2016) 1
TP Cir. Prog. VHDL 2ème Ing. Mécat.

1. Le compteur 4-bit

Un compteur est un circuit intégré numérique destiné à compter le nombre d'impulsions d’horloge appliquées à
son entrée. En VHDL, les compteurs sont des éléments très utiles qui permettent de gérer tout ce qui est
temporisation et bien sur le comptage.

Clock
Q(3..0)
Compteur 4-bit
Clear

Figure 2 : Schéma représentatif d’un compteur 4-bit

Le compteur asynchrone est basé sur le diviseur de fréquence. Il s'agit d'une bascule D dont la sortie inverseuse (/Q)
est envoyée sur son entrée D (figure 3).. Ainsi, à chaque front montant de l'entrée d'horloge, la donnée transférée sur la
sortie est complémentée (change d'état). La fréquence du signal
signal est donc divisée par deux (figure 4).

D Q

Clk
Clk

/Q
Clr

Clr

Figure 3 : Diviseur de fréquence Figure 4 : Chronogramme du diviseur


d de fréquence

Un compteur est constitué de plusieurs diviseurs de fréquences (autant que de bits requis) monté en cascade (la
sortie (Q0 à QN-1) permet de compter au maximum (2N -
sortie de l'un pilotant la CLK du suivant). Un compteur à N sorties
1) impulsions d'entrées. L’architecture d’un compteur 4-bit (compte de 0 à 15) est présentée sur la figure 5.

Q0 Q1 Q2 Q3

D Q D Q D Q D Q

Clock CLK /Q CLK /Q CLK /Q CLK /Q

CLR CLR CLR CLR

Clear

Figure 5 : Architecture d’un compteur binaire 4 bits

Figure 6 : Chronogrammes du compteur 4-bit

Comme on peut observer sur la figure 6, les


l sorties Q0 Q1 Q2 Q3 sont successivement égales à 0000, 0001, 0010, ...,
1111, puis à nouveau 0000, 0001, 0010, ... c'est-à-dire
c'est dire 0, 1, 2, ..., 15, 0, 1, 2, ... Ce cycle continue indéfiniment, aussi
longtemps que le signal d'horloge est présent.

ENICAR (2015/2016) 2
TP Cir. Prog. VHDL 2ème Ing. Mécat.

A faire :
1.1) Décrire en VHDL une bascule D active sur front montant avec un reset active à l’état haut (Dff.vhd).
1.2) Maintenant, décrire en VHDL le compteur binaire 4-bit de la figure 5, basé sur 4 bascules D (counter4.vhd).
Indice : utiliser l’instruction concurrente for … generate.
1.3) Compléter le testbench du compteur (counter4_tb.vhd) et simuler le avec ModelSim de la façon suivante :
- Créer une horloge (Clock) de période T = 20 ns.
- Mettre clear à ‘1’ pendant 10 ns.
- Mettre clear à ‘0’.
- Dans ModelSim, Spécifier 350 ns comme durée totale de simulation.
Lancer la simulation, observer les chronogrammes et vérifier que le compteur fonctionne comme prévu.

2. Le diviseur de fréquence

Un circuit qui divise une fréquence de signal est appelé un diviseur de fréquence. Diviser indique une conversion
de la fréquence d'un signal numérique, tel qu'une horloge, en le réduisant à 1/N. Comme on a vu dans la première
partie du TP, un compteur est un diviseur de 1/2n (où n est le nombre de bits).

Figure 7 : Compteur/Diviseur de Fréquence


En effet, si on observe les chronogrammes des signaux de sortie d’un compteur 4-bits (Figure 7), on peut voir
que la sortie O1, le bit de poids le plus faible, a une fréquence égale à la moitié de la fréquence du signal d’horloge
commandant le compteur (CLK). De même pour la sortie O2 qui a une fréquence égale à la moitié de celle du signal
qui la précède et ¼ de la fréquence d’horloge, et ainsi de suite. Ainsi, étant donnée la fréquence f de l’horloge, la
fréquence d’une sortie Oi peut s’écrire : f = f / 2i+1
Par exemple un simple compteur 26-bits peut être utilisé comme diviseur de fréquence qui produit un large
choix de fréquences, allant de 25Mhz à moins d’ 1Hz, à partir de l'horloge 50Mhz de la carte, comme le montre le
Tableau 1, q(i) étant le bit d’indice i de la sortie q du compteur.
Tableau 1 – Fréquences produites par un compteur 26-bit
Fréquence Période Période Fréquence Période
q(i) q(i) Fréquence (Hz) q(i)
(Hz) (ms) (ms) (Hz) (ms)
i 50000000.00 0.00002 8 97656.25 0.01024 17 190.73 5.24288
0 25000000.00 0.00004 9 48828.13 0.02048 18 95.37 10.48576
1 12500000.00 0.00008 10 24414.06 0.04096 19 47.68 20.97152
2 6250000.00 0.00016 11 12207.03 0.08192 20 23.84 41.94304
3 3250000.00 0.00032 12 6103.52 0.16384 21 11.92 83.88608
4 1562500.00 0.00064 13 3051.76 0.32768 22 5.96 167.7721
5 781250.00 0.00128 14 1525.88 0.65536 23 2.98 335.5443
6 390625.00 0.00256 15 762.94 1.31072 24 1.49 671.0886
7 195312.50 0.00512 16 381.47 2.62144 25 0.74 1 342.177

ENICAR (2015/2016) 3
TP Cir. Prog. VHDL 2ème Ing. Mécat.

Pour notre compteur binaire 4--bits,


bits, on a besoin d’un signal d’horloge ayant une fréquence suffisamment
faible. Sans cela, il ne sera pas possible d’observer le changement de la sortie du compteur à l’œil humain. On aura
donc besoin de transformer la fréquence de l’horloge très élevé de la carte FPGA (50 Mhz) en une fréquence de
quelques Hertz. Pour générer cette fréquence, on va avoir besoin d’un circuit diviseur de fréquence (Figure 8).

50 Mhz mclk

clr Diviseur de Fréquence


(Compteur 26-bit)

clk_ctr
Figure 8 : Diviseur de fréquence

mclk : C’est l’entrée d’horloge du diviseur de fréquence. Elle est de 50 Mhz.


clr : Cette entrée sert à remettre à zéro le diviseur de fréquence.
Clk_ctr : La fréquence de sortie.

A faire :
2.1) On désire créer une horloge ayant une fréquence égale à 0.74 Hz (T ( ≈ 1.34 seconde). Dans le fichier
freq_div.vhd,, modifier le code du
d compteur 4-bit (counter4.vhd) pour créer un compteur générant cette
fréquence.
2.2) Compléter le testbench (freq_div
freq_div_tb.vhd) et simuler le avec ModelSim de la façon suivante :
- Créer une horloge (mclk) de période T = 20 ns (Ceci correspond à une fréquence
f de 50Mhz).
- Mettre clr à ‘1’ pendant 10 ns.
- Mettre clr à ‘0’.
- Dans ModelSim, spécifier 1400
1 ms comme durée totale de simulation.

3. Le décodeur de l’afficheur 7-segments


7

À la sortie du compteur 4-bit,, les signaux doivent être décodés pour pouvoir commander l’afficheur 7-segments.
7
Pour cela, on utilisera un « décodeur » (Figure 9).

Figure 9 : Le Décodeur et l'afficheur 7-segments


7

Figure 10 : Entrées Décodeur/ Sorties Afficheur

ENICAR (2015/2016) 4
TP Cir. Prog. VHDL 2ème Ing. Mécat.

Le décodeur doit transformer le nombre reçu en entrée sur 4 bits en 7 bits afin de l’afficher en écriture hexadécimal
(0 jusqu’à F) sur un afficheur 7-segment, comme le montre la figure 10.
La carte FPGA « Spartan-3™ Starter Kit » possède 4 afficheurs 7-segments à LEDs commandables par
l’utilisateur via les broches de l’FPGA, comme indiqué dans la Figure 11. Chaque afficheur partage huit signaux de
commandes avec les 3 autres afficheurs qui servent à allumer les segments LEDs. Chaque afficheur a également une
entrée de commande d'anode distincte (ANx). L’indice des broches de l’FPGA connectées aux afficheurs apparaît
entre parenthèses devant ANx. Pour allumer individuellement un segment LED d’un afficheur, il faut mettre au
niveau logique bas l’entrée de contrôle de ce segment aussi bien que le signal de commande de l’anode associée à cet
afficheur.

Figure 11 : Contrôles des afficheurs de la carte FPGA


Par exemple, Dans la figure 11 le premier afficheur en partant de gauche affiche le chiffre '2'. Les valeurs
numériques contrôlant l'affichage dans cet exemple sont indiquées en bleu. Le signal de commande de l’anode AN3
est au niveau logique bas, ce qui permet à ces valeurs de cibler l’afficheur en question. Ainsi, les entrées de commande
des segments, A à G et DP, contrôlent les segments de l’afficheur. Un niveau logique bas allume un segment
individuel, un niveau haut l’éteint. Par exemple, en mettant un 0 sur le signal d'entrée A, on allume le segment «a».
Les contrôleurs d'anode pour les afficheurs restants, AN [2:0] sont tous maintenus à 1. Ainsi, ces 3 afficheurs ignorent
les valeurs présentées sur les entrées A à G et DP.
En VHDL on pourra utiliser un std_logic_vector(3 downto 0) pour le sélecteur de l’afficheur (AN). La
variable correspondante sera dénommée "sel_aff".
A faire :
3.1) Compléter la description VHDL du décodeur de la figure 12 qui permettra d'afficher le contenu de 4 bits en
écriture Hexadécimal sur l’afficheur d’indice AN3. Consultez le Tableau 2 pour avoir les valeurs des entrées
nécessaires pour afficher des caractères hexadécimaux sur les 7 segments de l’afficheur.

Tableau 2
Caractère
Seg(0) Héxadécimal a b c d e f g
Seg(1) 0 0 0 0 0 0 0 1
1 1 0 0 1 1 1 1
Seg(2)
2 0 0 1 0 0 1 0
Decodeur Seg(3) 3 0 0 0 0 1 1 0
de Seg(4) 4 1 0 0 1 1 0 0
Q(3..0)
l'afficheur 5 0 1 0 0 1 0 0
Seg(5)
6 0 1 0 0 0 0 0
Seg(6) 7 0 0 0 1 1 1 1
8 0 0 0 0 0 0 0
DP
9 0 0 0 0 1 0 0
sel_aff A 0 0 0 1 0 0 0
B 1 1 0 0 0 0 0
Figure 12 : Décodeur 4-bit vers 7 segments C 0 1 1 0 0 0 1
D 1 0 0 0 0 1 0
E 0 1 1 0 0 0 0
F 0 1 1 1 0 0 0

3.2) Compléter le testbench du décodeur et simuler le avec ModelSim.

ENICAR (2015/2016) 5
TP Cir. Prog. VHDL 2ème Ing. Mécat.

4. Programme principal : Compteur hexadécimal


Maintenant que les différents modules du compteur hexadécimal sont prêts, vous allez les assembler dans un seul
programme principal.
A faire :
4.1) Dans le dossier nommé « Principal», transférer tous les fichiers des modules complétés précédemment :
counter4.vhd, freq_div.vhd ET decoder.vhd.
4.2) Faire la description structurelle du compteur hexadécimal « hex_counter.vhd » en y instanciant et en y reliant
les 3 modules comme le montre le schéma ci-dessous:

50 Mhz mclk

Diviseur de Fréquence

Seg(0)
clk_ctr
Seg(1)

Q(0) Seg(2)

Seg(3)
Q(1) Decodeur
Clear de Seg(4)
Compteur 4-bit Q(2)
l'afficheur Seg(5)
Q(3) Seg(6)

DP
sel_aff

Figure 13 : Schéma complet du compteur Hexadécimal

4.3) Compléter le testbench du compteur Hexadécimal (« hex_counter_tb.vhd ) et simuler le avec ModelSim.

Remarque : Penser à utiliser un indice i faible pour la sortie du Diviseur de fréquence (q(i)) pour pouvoir visualiser
les sorties sur le simulateur. Après la simulation, ne pas oublier de restaurer l’ancienne valeur de i.

4.4) Avec Xilinx ISE, implémenter le « compteur hexadécimal » sur la carte Spartan-3 (Suivre les étapes du Tutorial).
Lors de l’étape d’assignation des broches (Assign Package Pins), connecter les ports du compteur hexadécimal aux
broches de la carte comme suit:
 L’entrée «clear» au bouton poussoir BTN0.
 L’horloge d’entrée du diviseur de fréquence (mclk) à l’horloge de la carte FPGA *.
 Les sorties du décodeur aux broches du bloc des afficheurs 7-segments * et choisir l’afficheur d’indice AN3.

Pour résumer :

ENICAR (2015/2016) 6
TP Cir. Prog. VHDL 2ème Ing. Mécat.

Compteur_Hex (VHDL) Carte FPGA


Entrées :
mclk Clock
Oscillator(50Mhz)
Clr BTN0
Sorties :
sel_aff AN0,AN1,AN2,AN3
Seg(6) A
Seg(5) B
Seg(4) C
Seg(3) D
Seg(2) E
Seg(1) F
Seg(0) G
dp DP BTN0 Afficheur AN3

(*) : Vous trouverez les indices des broches de l’FPGA qui contrôlent les segments LED d’un afficheur 7-segments
dans les Tableaux 3-1 et 3-2 de la page 16 du document «Spartan-3 Starter Kit Board User Guide.pdf». L’indice de
l’horloge de l’FPGA est dans le chapitre 8 du même document.

4.5) Vérifier que votre compteur fonctionne correctement.

ENICAR (2015/2016) 7