MINI-PROJET

Compteur Hexadécimal

Objectif:

L’objectif de ce projet est de modéliser un compteur Hexadécimal en VHDL.

Un compteur Hexadécimal est un circuit basé sur un « Compteur binaire 4-bit » à cycle
complet 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 figure1 présente l’architecture interne d’un compteur hexadécimale:

Pour votre programme principal: on utilisera la programmation structurelle en VHDL.

Ce style consiste à assembler des composants créés séparément afin de décrire la structure
interne du compteur hexadécimale.

Les différentes parties de votre projet :

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

1
 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 la temporisation et la quantification des grandeurs discrètes (numérique).

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 est donc divisée par deux (figure 4).

2
Un compteur est constitué de plusieurs diviseurs de fréquences (autant que de bits requis)
monté en cascade (la sortie de l'un pilote la CLK du suivant). Un compteur à N sorties (Q0 à
QN-1) permet de compter au maximum (2 1) impulsions d'entrées. L’architecture d’un
N

compteur 4-bit (compte de 0 à 15) est représentée sur la figure 5.

Comme on peut observer sur la figure 6, les sorties Q0 Q1 Q2 Q3 sont successivement égales à
0000, 0001, 0010, ...,1111, puis à nouveau 0000, 0001, 0010, ... 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.

Travail demandé

1.1- Décrire en VHDL le fonctionnement d’une bascule D active sur front montant avec un
reset active à l’état haut, dans un fichier (Dff.vhd).

1.2- Décrire en VHDL le compteur binaire 4-bit, basé sur 4 bascules D, dans (counter4.vhd).
Indice : utiliser l’instruction concurrente for … generate.

1.3- Décrire le testbench du compteur dans un fichier (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’.
 Spécifier 350 ns comme durée totale de simulation (dans ModelSim).
Lancer la simulation, observer les chronogrammes et vérifier que le compteur fonctionne
comme prévu.

3
 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, un compteur est un diviseur de 1/2N
(où N est le nombre de bits).

En effet, si on observe les chronogrammes des signaux de sortie d’un compteur 4-bits
(Figure7), 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 ci-dessous.
q(i) étant le bit d’indice i de la sortie q du compteur.

4
Pour le compteur binaire 4-bit que nous avons réalisé, 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).

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.

Travail demandé

2.1- On désire créer une horloge ayant une fréquence égale à 0.74 Hz (T ≈ 1.34 seconde).
Dans un fichier (freq_div.vhd), modifier le code du compteur 4-bit (counter4.vhd) pour
créer un compteur générant cette fréquence.

2.2- Décrire le testbench dans un fichier (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 (Fréquence de 50Mhz)
 Mettre clr à ‘1’ pendant 10ns.
 Mettre clr à ‘0’.
 Spécifier 1400 ms comme durée totale de simulation (dans ModelSim)

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

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

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

6
Dans la figure 11 le premier afficheur 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, de A à G et DP, contrôlent les segments de
l’afficheur.
Un niveau logique bas allume un segment individuel, un niveau haut l’éteint. C’est
afficheur 7-segments à anode commune.

Les contrôleurs d'anode pour les afficheurs restants, AN2, AN1, AN0 sont tous maintenus à 1,
ils seront donc éteints. Ainsi, ces 3 afficheurs ignorent les valeurs présentées sur les entrées de
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".

Travail demandé
3.1- Ecrire la description VHDL du décodeur de la figure 12 dans un fichier (decoder.vhd)
qui permettra d'afficher le contenu de 4 bits en écriture Hexadécimal sur l’afficheur d’indice
AN3. Consultez le Tableau ci-dessus, pour avoir les valeurs des entrées nécessaires pour
afficher des caractères hexadécimaux sur les 7 segments de l’afficheur.

3.2- Ecrire le testbench du décodeur dans un fichier (decoder_tb.vhd) et simuler le avec

ModelSim.

7
 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.
On rappelle le schéma de la structure étudiée :

Travail demandé

4.1- Dans un dossier nommé « Programme Principal», transférer tous les fichiers des modules
faits précédemment : counter4.vhd, freq_div.vhd et decoder.vhd.
4.2- Ecrire la description structurelle du compteur hexadécimal dans un fichier
hex_counter.vhd, en y instanciant et en y reliant les 3 modules comme le montre le
schéma ci-dessus (figure 13).
4.3- Compléter le testbench du compteur Hexadécimal (hex_counter_tb.vhd) et simuler
le avec ModelSim.