Document ID: /fineweb-2-swissfilter-quality_10-filterrobots/filtered/06990.jsonl.gz/746

21H — Rasp-a-mole
Ce projet a été réalisé par EL OLMI, Mehdi.
1. Introduction
Il est souvent difficile de trouver des jeux amusants et simples à jouer durant un dîner de famille ou une soirée entre amis. Le jeu de la taupe, dont le principe consiste à taper le plus rapidement possible sur des taupes qui surgissent d’une plateforme, est un jeu amusant sans besoin de grande intelligence, qui permet de tester qui a la plus grande réactivité parmi les joueurs. Toutefois il est difficile d’en avoir un chez soi dû à sa taille et à son prix.
Mon but pour ce projet est de concevoir un jeu, partant du même principe que le jeu de la taupe, mais qui se joue différemment car le but n’est non pas de taper sur une taupe mais d’appuyer le plus rapidement possible sur un bouton qui correspond à la position et à la couleur d’une lumière qui s’allume. Le jeu se déroule de la manière suivante : Le plateau de jeu est consisté de deux platines d'expérimentations "breadboard" sur lesquels se trouvent 1 bouton "start" qui sert à commencer la partie, 4 leds de couleurs différentes et 4 boutons, qui chacun correspondent à la couleur d'une led. Le joueur après avoir débuté la partie en actionnant le bouton "start" devra, le plus rapidement possible, appuyer, dès qu'une led s'allume, sur l’interrupteur dont la couleur correspond à la led allumée. Les objectifs de ce projet sont donc de concevoir un circuit fermé sur les breadboards sur lesquels il est possible d'y jouer, d’utiliser les librairies GPIO, “time” et “random” sur python et de déterminer une manière de calculer la réactivité d’un joueur.
2. Matériel et méthodes
2.1 Matériel
- 2 breadboards
- 1 SparkFun Pi Wedge
- 4 leds (1 jaune, 1 vert, 1 rouge et 1 bleu)
- 5 interrupteurs
- 4 capuchons de couleur pour les interrupteurs (1 jaune, 1 vert, 1 rouge et 1 bleu)
- 25 fils conducteur
- 9 résistances 33Ω
2.2 Méthode
2.2.1 Mise en place du hardware Pour la mise en place des leds et des boutons j’ai pris exemple du circuit qui figure ci-dessous :
Premièrement, la structure du circuit de la led, qui est connectée à la fois au gnd et à un pin précis (par exemple le pin 20), fait en sorte que celle-ci s'allume seulement quand le programme déclenche un courant de 3.3V depuis le pin 20. Ensuite, pour l’interrupteur c’est un principe différent. En effet celui-ci est connecté à une alimentation de 3.3V et à un pin(par exemple le pin 18) ce qui engendre donc que quand l’interrupteur est appuyé il y’a un courant entre le 3.3V et le pin 18 donc son état est “HIGH” alors que si le bouton n’est pas appuyé il n’y a pas de courant qui provient de 3.3V et va jusqu’au pin 18, donc l’état de celui-ci sera “LOW”. En outre, dans les circuits il y a besoin d’une résistance qui permet d’éviter un court-circuit car celle-ci ralentit le courant électrique en s’opposant à celui-ci. Finalement pour la mise en place du jeu, il faut placer 2 leds aux extrémités des deux breadboards en suivant le schéma ci-dessus pour le circuit des leds. Le but est de créer une sorte de rectangle dont les leds sont les coins. Puis il faut placer les interrupteurs avec les capuchons colorés dessus en suivant le schéma pour les interrupteurs ci-dessus. Il faut créer un rectangle d’interrupteurs similaire à celui des leds en dessous du rectangle de leds et il faut que la position dans le rectangle des interrupteurs colorés correspondent à la position de la led de même couleur. Puis, finalement, il faut placer un interrupteur tout en bas, toujours en suivant le schéma pour le circuit, qui sert à débuter une partie.
2.2.2 Software Maintenant que le Hardware est mis en place, il faut maintenant créer un programme, à l'aide de python 3.5 sur le Raspberry Pi, pour faire fonctionner notre jeu. Tout d'abord, pour se faciliter la tâche il faut donner un nom à tous les pin utilisé, cela va servir pour plus tard pour coder plus facilement en sachant quelle led ou quel interrupteur on veut utiliser.
LED_J = 6 LED_V = 12 LED_R = 18 LED_B = 19
BOUTON_J = 4 BOUTON_J = 5 BOUTON_J = 26 BOUTON_J = 27 BOUTON_START = 17
Ensuite, il faut configurer toutes les leds comme sortie et tous les interrupteurs comme entrée.
GPIO.setup(LED, GPIO.OUT) GPIO.setup(BOUTON, GPIO.IN)
Après cette configuration nous pouvons commencer l’écriture du programme qui fera marcher le jeu. Tout d’abord nous allons créer un boucle “while True” dans laquelle nous ajoutons une condition “if” qui va, si l’on appuie sur l’interrupteur “BOUTON_START” allumer toutes les leds 3 fois pendant 1 seconde et démarrer un timer puis appeler une fonction que l’on va créer s'appelant “lights()” puis quand cette fonction se termine toute les leds s’allument pendant 1 seconde pour faire comprendre que la partie est terminé et va finalement afficher dans le shell la phrase “Vous avez réagi à l’allumage de 20 leds en” puis le temps entre l’activation de “BOUTON_START” jusqu’à l’affichage du message. Pour allumer les leds il faut simplement changer l’état des pins led à “HIGH” pour qu’il y ait une tension de 3.3V à partir de ces pin. while True: if GPIO.input(BOUTON_START): GPIO.output(LED_J, GPIO.HIGH) sleep(1)
Pour que les leds s’allument durant seulement une seconde, il faut d’abord importer la librairie “time” puis utiliser la fonction sleep(n) qui va pauser le programme au dessus pendant n secondes puis passer à la prochaine instruction. Ensuite, il faut définir la fonction “lights()” qui va nous permettre d’allumer aléatoirement les leds et les fait s'éteindre si l’interrupteur de la couleur correspondante est appuyé puis allume un autre led et cela 20 fois de suite. Pour créer une fonction il faut utiliser la commande “def” puis le nom de la fonction, dans notre cas “lights()”. Ensuite dans cette fonction nous allons créer une boucle “for i in range (20)” qui nous permettra d’allumer une led 20 fois. Dans cette boucle nous allons utiliser la fonction “random.randint()” de la librairie “random” qu’il faudra importer. La fonction random.randint(n,k) permet de choisir aléatoirement des nombres intégrales entre n et k. Nous allons donc mettre en place une variable “led” qui sera égal à cette fonction pour les chiffres entre 1 à 4.
def lights() : for i in range(20): led = random.randint(1, 4)
Dans la boucle “for” nous allons poser des conditions pour chaque valeur de la variable “led”. Pour chaque condition nous allons créer une boucle “while True” qui allume une seule led sur les quatres. Par exemple si “led” est égal à 1, toutes les leds sont éteintes à part la jaune. Ensuite dans cette boucle nous allons poser la condition que si le bouton jaune est appuyé, alors que l’on se trouve dans la boucle ou seulement la led jaune est allumée, cela va éteindre la led jaune, l’état de la varibable “led” va redevenir égal à zero et cela va ajouter + 1 à une varibale “score” qui va nous indiquer le nombre de leds allumée pendant la partie.
def lights() : score = 0 for i in range(20): led = random.randint(1, 4) sleep(0.25 if led == 1: while led == 1: GPIO.output(LED_J, GPIO.HIGH) GPIO.output(LED_V, GPIO.LOW) GPIO.output(LED_R, GPIO.LOW) GPIO.output(LED_B, GPIO.LOW) if GPIO.input(BOUTON_J) == True: GPIO.output(LED_J, GPIO.LOW) led = 0 score += 1 print(“nombre de LEDs”, score)
Revenons maintenant à notre boucle “while True” principal, à afficher la variable “temps” qui mesure le nombre de secondes écoulées entre le moment pendant lequel le “BOUTON_START” a été allumé jusqu’à la fin de la partie ou le “temps” est affiché dans le shell. Nous allons donc créer une variable “start_time” qui est égal à la fonction time.time(), qui donne le temps en seconde écoulé depuis la création d' Unix en 1970, juste en dessous de la condition du “BOUTON_START”. Ensuite à la fin de la condition nous allon créer la variable “temps” qui est égal à time.time() moins start_time, qui représente la durée depuis 1970 moins la durée depuis la création d’Unix jusqu’à l’activation du “BOUTON_START”.
while True:
If GPIO.INPUT(BOUTON_START): start_time = time.time() (...) temps = time.time() - start_time print("Vous avez réagit à l'allumage de 20 LEDs en", temps, "secondes")
Finalement il faut préciser, dans la boucle principale, que l'état des leds est "LOW" le reste du temps quand la condition "BOUTON_START" n'est pas en marche.
while True: If GPIO.INPUT(BOUTON_START): (...) else:
GPIO.output(LED, GPIO.LOW)
3. Résultats
Après avoir appuyé sur l'interrupteur start, toutes les lumières s'allument à 0.75 secondes d'intervalles pendant 1 seconde trois fois avant de s'allumer aléatoirement une par une à chaque fois que le joueur appuie sur l'interrupteur, dont la couleur correspond à la led allumée. Puis après vingt fois, toutes les leds s'allument pendant 1 secondes pour indiquer la fin de la partie. Finalement la phrase ("Vous avez réagit à l'allumage de 20 LEDs en, ( le temps que cela a pris depuis l'activation de l'interrupteur start), secondes") s'affiche sur l'écran dans le Shell python.
Ci-dessus se trouve le montage final du hardware.
4. Discussion
Mon but pour ce projet était de créer un jeu d’attention pour savoir qui parmi tous les participants réagit le plus vite. En m’inspirant du principe du jeu de la taupe, dont le but est de taper sur le taupes, qui surgissent de la terre, le plus rapidement possible, j’ai réussi à créer un jeu qui permet au joueur de savoir son temps de réaction à l’allumage de 20 Leds qui s'allument une par une et où le joueur doit appuyer sur le bouton dont la couleur correspond à celle de la led le plus rapidement possible. Le but est atteint, toutefois le chemin pour y arriver a été périlleux. Tout je devais revoir ma gestion du temps car la dernière semaine avant la date de soumission du projet a été rude, parce qu’il me restait encore beaucoup à faire. Aussi, je me suis peut - être trop surestimé au début du projet car même si l’allumage d’une led avec un interrupteur me paraissait simple dans ma tête, dans l’application c’était tout autre chose. Il m’a fallu plusieurs heures pour vraiment comprendre comment utiliser le python et le GPIO. La manière de calculer la réactivité du joueur m’a pris beaucoup de temps à trouver, avant que je décide de mesurer le temps que le joueur fait pour appuyer 20 fois sur les bons interrupteurs. Cette manière de calculer ne m’a pas permis d’afficher le score physiquement en binaire sur des leds, ce qui était mon idée de base, puisque le temps peut varier tellement cela rend difficile à savoir le nombre de leds à utiliser. Ce qui m’a aussi surpris pour sa difficulté et ce qui m’a pris le plus de temps, c’était de faire en sorte que quand j’appuie sur le bouton correspondant à la led allumée, celle-ci s’éteigne puis une autre led s’allume. Toutefois maintenant que j’ai réussi, ce code me parait finalement assez simple. Cela montre à quelle point ce projet m’a permis d’apprendre à coder et à comprendre les circuits électroniques, j’ai l’impression que mon niveau pour l’usage de python avec le GPIO, par exemple, s’est drastiquement amélioré. J’ai eu du plaisir à créer quelque chose moi-même et d’ arriver au but voulu.
5. Conclusion
Le but de ce projet est atteint, le projet final est un jeu dont le but est d’appuyer le plus rapidement possible sur les interrupteurs colorés dont la couleur de la led allumée aléatoirement est similaire. Ce jeu permet donc de savoir quel joueur est le plus réactif parmi tous les participants qui y jouent. Toutefois un objectif à atteindre reste un peu en suspens. L’objectif de la manière de calculer la réactivité d’un joueur a été atteint, néanmoins ce n’est, selon moi, pas la manière la plus optimale. Premièrement, pour afficher le temps que le joueur a fait durant une partie, il faut un écran. Ce serait plus idéal de l’afficher physiquement sur des leds en binaire, mais il faudrait donc changer la manière de calculer la réactivité car le temps peut beaucoup varier. Deuxièmement, le jeu ne réagit pas si le joueur presse sur le mauvais interrupteur, il peut alors appuyer sur tous les interrupteurs durant toute la partie et le finit donc en un temps record. En outre, le jeu ne mémorise pas le temps des parties précédentes, c’est les joueurs donc qui doivent s’en rappeler eux-mêmes. En conclusion pour améliorer ce projet je pourrais rajouter un support physique pour afficher le score, néanmoins je devrais changer la manière de calculer la réactivité du joueur, je pourrais aussi ajouter au code une fonction qui enlève des points ou arrête le jeu si le joueur presse sur un mauvais interrupteur et finalement je pourrais ajouter au code une fonction qui mémorise le score des parties précédentes.
Références
Circuit pour leds et boutons : https://learn.sparkfun.com/tutorials/python-programming-tutorial-getting-started-with-the-raspberry-pi/all https://cdn.sparkfun.com/assets/learn_tutorials/7/8/3/pi_fritzing_01b.png
Apprendre à programmer en python : https://www.youtube.com/watch?v=rfscVS0vtbwl
Apprendre à utiliser le GPIO avec python : https://gpiozero.readthedocs.io/en/stable/recipes.html https://gpiozero.readthedocs.io/en/stable/remote_gpio.html https://toptechboy.com/raspberry-pi-lesson-30-controlling-leds-from-push-buttons/
Utiliser random : https://stackoverflow.com/questions/31603263/why-wont-my-4-leds-turn-on-with-this-code-in-python https://docs.python.org/3/library/random.html
Créer un timer: https://www.youtube.com/watch?v=juSH7hmYUGA