projet vhdl

IUT GEII de Neuville sur Oise – TP FPGA – 2015
PROJET VHDL
Jeux du Simon
Simon est un jeu de société des années 70-80 de forme circulaire divisé en quatre quarts de couleur différentes,
rouge, vert, bleu et jaune. A chaque couleur est associé un son caractéristique. Le principe du jeu consiste à
répéter une séquence aléatoire des quatre couleurs qui s’affiche. Le jeu affiche une couleur et le joueur répète
cette couleur. Si la couleur est fausse, le joueur a perdu et le jeu recommence depuis le début. Si la couleur est
bonne, le jeu ajoute une nouvelle couleur à la suite de la précédente et le joueur doit reproduire l’intégralité de la
séquence. Plus le joueur reproduit fidèlement la séquence et plus l’affichage de la séquence est rapide et longue.
L’objectif du jeu est de réaliser la plus longue séquence produite. Les joueurs jouent à tour de rôle.
Une illustration du jeu est donnée ci-dessous et une vidéo est disponible à l’adresse suivante
http://olivieromain.free.fr/simon.avi
Figure 1 : Jeu du simon
L’objectif de ce projet est de réaliser ce jeu à partir d’une carte FPGA. L’affichage des séquences lumineuses
sera réalisé à partir d’un écran. Le son sera reproduit à partir du codec audio disponible sur la carte (partie
optionnelle).
Le projet comporte trois parties :
• Génération des séquences aléatoires
• Contrôleur VGA pour l’affichage des couleurs
• Machine à états pour le contrôle du jeu
Pr. Olivier ROMAIN
1
IUT GEII de Neuville sur Oise – TP FPGA – 2015
Partie I. Générateur Pseudo Aléatoire : Automate Cellulaire
Il existe différentes méthodes pour générer des séquences pseudo-aléatoire de nombre. La plus connue est la
méthode basée sur une boucle fermée d’un registre à décalage sur lui même suivant un polynôme générateur. Ici,
nous allons utiliser une seconde technique basée sur les automates cellulaires. Avant de coder en VHDL cet
automate, une brève introduction est donnée ci-dessous.
Le nom d’automate cellulaire peut sonner comme une oxymore. D’un côté le mot ‘automate’ suggère l’artificiel,
la mécanique, le logique, le déterminisme et de l’autre côté le mot ‘cellulaire’ renvoie au naturel, à la biologie et
au vivant et donc à l’imprévisible. Comment deux concepts aussi opposés peuvent-ils s’associer au sein d’un
même nom pour désigner un objet ?
Dans les années quarante, le mathématicien Stanislas Ulam donna naissance aux
automates cellulaires en modélisant la croissance des cristaux sur une grille. Son
point de départ était un quadrillage, soit un espace à deux dimensions définissant
un nombre fini de cases ou de cellules. Chacune des cellules était booléenne :
allumé ou éteint. A l’état de départ, t0, certaines cellules de façon arbitraire étaient
allumées. A partir de cette configuration initiale, les états des cellules évoluaient
en fonction de règles de voisinage entre cellules. Par exemple, si une cellule
donnée était en contact avec deux cellules allumées, alors elle s'allumait, sinon elle
s'éteignait. Ces mécanismes simples permettaient de générer des figures
complexes qui, dans certains cas, pouvaient se répliquer.
Dans les mêmes années, John Von Neumann, un collègue de Ulam, travaillait sur les mécanismes
mathématiques de machines auto-réplicatives, c'est-à-dire des machines capables de produire une copie d’ellemême.
"... living organisms are very complicated aggregations of elementary parts, and by any reasonable theory of
probability or thermodynamics highly improbable. That they should occur in the world at all is a miracle of the
first magnitude; the only thing which removes, or mitigates, this miracle is that they reproduce themselves.
Therefore, if by any peculiar accident there should ever be one of them, from there on the rules of probability do
not apply, and there will be many of them, at least if the milieu is reasonable."
John Von Neumann, Theory of Self-Reproducing Automata.
source : The artificial Self-replication page by Moshe Sipper.
A partir des travaux de Ulam, John von Neumann construisit une première implémentation de l’auto
reproduction. Ulam avait conçu des programmes intégrant des règles simples qui permettait la génération de
motif auto-reproductif et John Von Neumann inventa alors le Kinématon. Le ‘Kinématon est un automate
cellulaire bidimensionnel intégrant environ 200.000 cellules à 29 états, avec un voisinage de 5 cellules (1 cellule
cible + 4 voisines). L’objectif de Von Neumann au travers le Kinématon était de réaliser un constructeur
universel, capable de répliquer à l’identique toute structure dont on lui a donné le plan.
Un automate cellulaire se caractérise par 4 paramètres :
•
Sa dimension : un automate cellulaire est le plus généralement 1D (ligne), 2D (matrice), ou de
dimension N. Toutes les cellules qui constituent l’automate sont mises à jours de manière synchrone.
•
Le voisinage d’une cellule : celui-ci détermine le nombre de cellules qui participeront à la détermination
de l’état futur de la cellule en cours d’étude. Dans le cas d’une ligne, une cellule possède un voisinage
de deux. Ces deux cellules détermineront l’état de cellule centrale à l’instant t+1. Toutes les cellules
utilisent les mêmes règles pour déterminer leur état suivant.
• Son Alphabet ou espace d’état : Cet alphabet correspond à l’ensemble de tous
les états qu’une cellule peut prendre. Le plus souvent ils sont Booléen (2 états) mais il
existe des exemples d’automates cellulaires ou l’alphabet est supérieur à 2, comme dans
le cas du Kinématon.
•
Sa fonction de transition : elle correspond aux règles de passage d’un état présent à un état futur d’une
cellule en fonction de son voisinage. Le nombre de fonction de transition correspond au nombre de
voisinage à la puissance nombre de configuration de voisinage.
Pr. Olivier ROMAIN
2
IUT GEII de Neuville sur Oise – TP FPGA – 2015
Il existe de nombreuse réalisation d’automates cellulaires dont les plus connus sont :
• L’automate élémentaire de Wolfram
• La boucle auto réplicante de Langton
• Le jeu de la vie de Conway
Les automates cellulaires trouvent de nombreuses applications dans des domaines très divers, de la conception
d’ordinateurs massivement parallèles à la simulation de la propagation des deux de forêts en passant par la
conception de générateur de séquences pseudo aléatoires utiles en télécommunication.
Automate cellulaire simple générateur de séquencse pseudo-aléatoires
Un automate cellulaire simple ou automate de Wolfram consiste en une grille unidimensionnelle de cellules ne
pouvant prendre que deux états (0 ou 1), avec un voisinage constitué, pour chaque cellule, d'elle-même et des
deux cellules qui lui sont adjacentes, une cellule voisine de gauche et une cellule voisine de droite.
Cellule 0
Cellule 1
Cellule 2
Cellule N
1
0
0
1
Fonction de
transition
Fonction de
transition
Voisinage
Fonction de
transition
Fonction de
transition
Chacune des cellules pouvant prendre deux états, il existe 23=8 configurations possibles d'un tel voisinage.
Pour que l'automate cellulaire fonctionne, il faut définir quel doit être l'état, à la génération suivante, d'une
cellule pour chacun de ces motifs. Il y a 28 = 256 façons différentes de s'y prendre, soit donc 256 automates
cellulaires différents pouvant être simulés sur une telle grille.
Ces automates sont bouclés, c'est à dire que si l'automate a une taille n, la cellule 0 à comme voisin de gauche la
cellule n − 1, et la cellule n − 1 a comme voisin de droite la cellule 0. Considérons l'automate cellulaire défini
par la table suivante qui donne la valeur de la cellule centrale à l'instant t + 1 en fonction de la valeur de la
cellule et de ses cellules adjacentes à l'instant t :
Valeur de la cellule i-1 à l’instant t
1
1
1
1
0
0
0
0
Valeur de la cellule i à l’instant t
1
1
0
0
1
1
0
0
Valeur de la cellule i+1 à l’instant t
1
0
1
0
1
0
1
0
Valeur de la cellule i à l’instant t+1
0
0
0
1
1
1
1
0
Cela signifie que si par exemple, à un temps t donné, une cellule est à l'état 1 , sa voisine de gauche à l'état 1 et
sa voisine de droite à l'état 0, au temps t + 1 elle sera à l'état 0.
L’équation de la fonction de transition régit complètement le séquencement de l’automate cellulaire. Il existe des
équations qui permettent de d’obtenir un comportement pseudo-aléatoire comme par exemple en
prenant l’équation ci-dessous et en initialisant l’automate à 1.
c(i) t +1 = (c(i −1) t + c(i) t ) ⊕ c(i + 1) t
Pr. Olivier ROMAIN
€
3
IUT GEII de Neuville sur Oise – TP FPGA – 2015
En prenant l’une des sorties de l’automate c(i) on récupère alors une séquence pseudo aléatoire comparable aux
générateur obtenus à l’aide de bascules D et dont certaines sont une porte Xor suivant un polynôme
caractéristique comme ci-dessous :
Figure 2 : Exemple de générateur pseudo-aléatoire à 3 bascules D
Remarque
Des informations supplémentaires sont disponibles : https://fr.wikipedia.org/wiki/Automate_cellulaire
Travail à réaliser
1.
2.
3.
4.
5.
6.
Créer un projet sous Quartus et nommer le simon
Créer un fichier bdf simon.bdf
Créer un fichier VHDL automate.
Ecrire le code VHDL d’un automate cellulaire générique sur 8 cellules.
a. L’entité de l’automate prendra une horloge dont la fréquence
b. Un signal de reset
c. Un signal de start
d. Un signal de sortie correspondant à la séquence aléatoire
Simuler le fonctionnement.
Déterminer la longueur de la séquence en fonction de l’état initial.
La principale limitation de ce générateur est la périodicité de la longueur de la séquence. Elle a pour
conséquence de rendre déterministe le générateur. Pour palier à ce problème, on va pré-positionner les entrées
des bascules D avant le démarrage de la séquence.
7.
Modifier l’entité pour prendre en entrée un bus de 8 bits. Chaque bit du bus pré-positionnera l’entrée de
la bascule correspondante. Par exemple, le 3ème bit pré-positionnera l’entrée de la 3ème bascule. Si le 3ème
bit est à ‘1’, la 3ème bascule D prendra un 1 en entrée avant le démarrage du générateur (signal de start).
Le pré-positionnement sera réalisé au moyen des 8 switchs SW0 … SW7.
8. Simuler le fonctionnement et déterminer la longueur L de la séquence en fonction de la valeur V des
switchs.
9. Programmer la carte et observer la séquence générée. La sortie sera affectée à la broche 2 de J4
(PIN_AB16) (cf. reference manual DE1)
10. Tracez la courbe L en fonction de V.
11. Déterminer la valeur de V permettant d’obtenir la plus grande longueur.
12. Conclusion
Pour augmenter la longueur de la séquence, une autre solution consiste à modifier le rebouclage. Sur la figure 2,
il existe deux possibilités ; injecter sur la première bascule le résultat de Q2 xor Q1 ou d’injecter Q2 xor Q0.
13. Modifier le design de votre automate afin de tester les 7 configurations suivantes :
a. Injecter sur D0 le résultat de Q7 xor Q6
Pr. Olivier ROMAIN
4
IUT GEII de Neuville sur Oise – TP FPGA – 2015
b. Injecter sur D0 le résultat de Q7 xor Q5
c. Injecter sur D0 le résultat de Q7 xor Q4
d. Injecter sur D0 le résultat de Q7 xor Q3
e. Injecter sur D0 le résultat de Q7 xor Q2
f. Injecter sur D0 le résultat de Q7 xor Q1
g. Injecter sur D0 le résultat de Q7 xor Q0
14. Pour chaque configuration déterminer la longueur maximale L en fonction de la valeur V. Reporter
dans le graphe de la question 7
15. Remplir le tableau ci-dessous et le reporter dans votre rapport.
Configuration
a
b
c
d
e
f
g
Valeur V en décimal donnant Lmax
Longueur Maxi - Lmax
16. Consigner tous les développements et résultats dans votre rapport.
17. Réaliser un bloc graphique que vous intégrer dans votre fichier structurel simon.bdf.
18. Fin contrôler l’ensemble des résultats par l’enseignant avant de passer à l’étape 2 du projet.
Pr. Olivier ROMAIN
5
IUT GEII de Neuville sur Oise – TP FPGA – 2015
Partie II. Affichage des séquences lumineuses
2.1 Contrôleur VGA
La séquence lumineuse va être affiché sur un écran VGA. Cet écran va être divisé en quatre parties égales qui
sont :
• HG : pour la partie Haute à Gauche
• HD : pour la partie Haute à Droite
• BG : pour la partie Basse à Gauche
• BD : pour la partie Basse à Droite
HG
HD
BG
BD
Figure 3 : Zones de couleur de l’écran
La partie HG sera rouge, la partie HD sera verte, la partie BG sera bleue et la partie BD sera jaune.
L’objectif final étant d’obtenir à l’écran une alternance des couleurs choisies par le générateur pseudo- aléatoire,
comme représentée par la figure ci-dessous. Sur cette figure durant les alternances i, i+1, i+2 et i+3 seule les
couleurs choisies par le générateur pseudo-aléatoire sont affichées. Toutes les alternances ont la même durée.
HG
HD
HG
HD
HG
HD
HG
HD
BG
BD
BG
BD
BG
BD
BG
BD
Figure 4 : Exemple de 4 séquences affichées à i, i+1, i+2 et i+3
Afin d’arriver à afficher, vous allez décomposer le problème en trois étapes;
• la première étant d’arriver à afficher une couleur sur tout l’écran,
• la seconde étant d’arriver à afficher les 4 couleurs sur l’écran en même temps dans les 4 zones BG, BD,
HG et HD.
• la troisième consiste à arriver à afficher alternativement les 4 couleurs puis une seule parmi 4. Pour cela
vous devrez préalablement avoir décrit un générateur de nombre pseudo-aléatoire.
La première des étapes à réaliser pour pouvoir afficher un motif à l’écran, c’est de générer les signaux de
synchronisation de l’écran VGA. L’affichage sur un écran VGA est réalisé via le balayage d’un spot lumineux
sur l’écran. Il est nécessaire ici d’avoir deux signaux de synchronisation, un signal HS de synchronisation
horizontale qui va permettre au spot de passer d’une ligne à l’autre (retour à gauche de l’écran). Un signal de
synchronisation verticale qui va permettre un retour du coin en bas à droite de l’écran au coin en haut à gauche
de l’écran.
Pr. Olivier ROMAIN
6
IUT GEII de Neuville sur Oise – TP FPGA – 2015
Figure 5 : principe d'affichage d'une image sur un écran au format VGA
Les valeurs des temps de synchronisation et d’affichage sont données dans la table ci- dessous.
Figure 6 : Timing
Figure 7 : Table timing
Ces valeurs correspondent à un signal de synchronisation, qui a la même forme pour la synchronisation
horizontale et verticale.
Pr. Olivier ROMAIN
7
IUT GEII de Neuville sur Oise – TP FPGA – 2015
Travail à réaliser
2.1. Quel est le composant qui va permettre de mesurer le temps ?
2.2. En utilisant ce composant, déterminer un système capable de générer les signaux de synchronisation HS
et VS. Vous ferez une représentation graphique de votre système.
2.3. Sachant que les temps indiqués dans le tableau ci-dessus sont donnés pour une horloge de 25 MHz et
que l’horloge globale de la carte est une horloge à 50 MHz, décrivez en VHDL un système capable de
générer une horloge à 25 MHz en fonction de l’horloge système.
2.4. Décrire de manière structurelle le circuit qui permet de générer les signaux HS et VS.
2.5. Compiler et simuler.
2.6. Consigner les résultats dans votre rapport
2.7. Faites contrôler par l’enseignant
Pour afficher des couleurs sur l’écran, il est nécessaire d’avoir des signaux permettant de définir une couleur par
pixel. Les signaux R, G et B jouent ce rôle. Le contrôleur VGA de la carte Cyclone III (cf. reference manual) et
un codec de 4 bits. Les entrées (R, G et B) sont codées sur 4 bits. Le tableau ci-dessous donne une
correspondance entre les couleurs générées et les valeurs des entrées.
R
0000
1111
0000
1111
0000
1111
G
0000
0000
1111
1111
0000
1111
B
1111
0000
0000
0000
0000
1111
Couleur
Bleu
Rouge
Vert
Jaune
Noir
Blanc
Afin que l’affichage soit bien synchronisé, il faut absolument que les signaux R, G et B soit à l’état bas quand le
spot lumineux est en dehors de l’écran (période de retour du spot).
2.8. Modifier le système de synchronisation afin d’afficher une couleur uniforme sur l’écran.
2.9. Compiler et simuler le système
2.10. A l’aide de la documentation de la carte, modifier ce système pour que les signaux soient affectés aux
broches du FPGA
2.11. Synthétiser et programmer la carte. Vous connecterez un écran VGA sur la sortie vidéo de la carte.
2.12. Consigner les résultats dans votre rapport.
2.13. Faites contrôler par l’enseignant.
2.2 Partitionnement de l’écran en zone
Maintenant que vous savez synchroniser votre écran et afficher une couleur, il faut maintenant le partitionner en
4 zones tel le modèle de la figure 3. Pour cela, il suffit de repérer le milieu horizontal et vertical de l’écran. Il
faut alors modifier le système de synchronisation pour qu’il repère ces deux milieux.
2.14. Calculez la valeur du milieu vertical et du milieu horizontal pour la résolution VGA de l’écran.
2.15. Modifiez votre système de synchronisation afin qu’il indique ces deux milieux. On pourra définir
deux signaux de sortie MH et MV qui passent à ‘1’ lorsqu’on se situe respectivement dans la zone HD
pour MH et les zones BG et BD pour MV.
2.16. Décrire en VHDL un système capable d’afficher 4 couleurs sur l’écran comme sur la figure 3.
2.17. Compilez, simulez et programmez la carte. Vous aurez au préalable vérifiez à l’aide de la
documentation de la carte que l’affectation des broches du FPGA a été correctement réalisée.
2.3 Modulateur temporel
Dans le jeu du Simon la séquence aléatoire accélère au fur et à mesure du temps. Pour cela, il est nécessaire de
développer un modulateur temporel qui permet d’alterner aléatoirement les couleurs et d’accélérer leurs
affichages.
Il faut interconnecter le générateur de nombre pseudo-aléatoires et le contrôleur VGA afin de réaliser l'alternance
des couleurs.
Pr. Olivier ROMAIN
8
IUT GEII de Neuville sur Oise – TP FPGA – 2015
Pour éviter tout phénomène d'affichage hasardeux, il est nécessaire de synchroniser le générateur pseudoaléatoire à l'aide d'une horloge qui ait une fréquence multiple de celle de l'affichage d'une image 640x480.
Il faut ensuite déterminer un signal périodique, dont la fréquence est aussi une fréquence multiple de celle de
l'affichage d'une image 640x480. Ce signal commandera l'alternance des couleurs déterminées par le générateur
pseudo-aléatoire.
2.18.
2.19.
2.20.
2.21.
2.22.
Décrire en VHDL un circuit qui permet cet affichage alterné.
Compiler et simulez votre système.
Affectez les bonnes broches à votre système.
Faite la synthèse de votre système.
Programmez votre système sur la carte et vérifiez son bon fonctionnement.
2.4 Accélération de l’affichage
On souhaite accélérer l’affichage au fur et à mesure que le joueur gagne.
2.23. Proposer un système (contrôleur d’accélération) pour que périodiquement l’alternance de l’affichage
s’accélère. On supposera qu’une fois arrivée à l’alternance la plus rapide, l’alternance suivante sera la
plus longue pour former ainsi un cycle. On pourra dans un premier temps utiliser un des interrupteurs
de la carte pour passer d’une fréquence d’alternance à une autre.
2.24. Faite valider par l’enseignant l’architecture du contrôleur d’accélération
2.25. Ecrire en VHDL le contrôleur d’accélération
2.26. Compiler et simulez votre système.
2.27. Créer un symbole et connecter le au reste du système (simon.bdf)
2.28. Affectez les bonnes broches à votre système.
2.29. Compiler.
2.30. Tester sur la carte FPGA.
2.31. Faite valider par l’enseignant.
2.32. Consigner dans votre rapport tous les développement.
Pr. Olivier ROMAIN
9
IUT GEII de Neuville sur Oise – TP FPGA – 2015
Partie III. Contrôleur du jeu
Maintenant que tous les composants nécessaires à l’affichage, à la génération d’une séquence, au réglage de la
vitesse, nous allons nous intéresser à la partie contrôle du jeu. Une machine à états finis est un séquenceur
possédant un nombre d’état définis par le concepteur. Il existe plusieurs types de machine à états – MAE et nous
allons en concevoir une du type de MOORE.
La MAE que nous souhaitons construire devra suivra le déroulement ci-dessous des différentes séquences.
Figure 8 : Organigramme du déroulement des états
3.1 Le jeu de Simon
Lorsque les paramètres de fréquence d’affichage et de longueur de la séquence initialisé, Simon créé la séquence
de longueur L des couleurs à afficher.
3.1. A l’aide d’un compteur, d’un comparateur, de bloc combinatoire et d’une machine à états de Moore,
déterminer une architecture capable de réaliser cette séquence.
3.2. Déterminer le graph de transition de la MAE
3.3. Décrire en VHDL la MAE
3.4. Compiler et simulez votre système.
3.5. Intégrer ce bloc dans Simon.bdf
3.6. Faite vérifier par l’enseignant.
3.7. Tester sur la carte FPGA
3.8. Consigner dans votre rapport les développements et les résultats
Pr. Olivier ROMAIN
10
IUT GEII de Neuville sur Oise – TP FPGA – 2015
3.2 Répétition par le joueur
Une fois la séquence jouée par Simon, le joueur doit-être capable de la reproduire.
3.9. A l’aide d’un compteur, d’un comparateur, de bloc combinatoire et d’une machine à états de Moore,
déterminez un montage capable d'acquérir la séquence que joue le joueur et de la comparer avec la
séquence initiale. On pourra s'aider du fait que le générateur pseudo-aléatoire si il est initialisé à la
même valeur créé toujours la même séquence de nombres pseudo-aléatoires.
3.10. Déterminer le graph de transition de la MAE
3.11. Décrire en VHDL la MAE
3.12. Compiler et simulez votre système.
3.13. Intégrer ce bloc dans Simon.bdf
3.14. Faite vérifier par l’enseignant.
3.15. Tester sur la carte FPGA
3.16. Consigner dans votre rapport les développements et les résultats
3.3 Le jeu
3.17. A l'aide du chronogramme et des parties précédentes, décrivez en VHDL un contrôle des composants
de la première partie qui permette de jouer.
3.18. Compiler et simulez votre système.
3.19. Intégrer ce bloc dans Simon.bdf
3.20. Faite vérifier par l’enseignant.
3.21. Tester sur la carte FPGA
3.22. Consigner dans votre rapport les développements et les résultats.
Tester votre jeu J
Pr. Olivier ROMAIN
11