.. note:: Bonjour et bienvenue dans la Communauté Facebook des passionnés de Raspberry Pi, Arduino et ESP32 de SunFounder ! Plongez plus profondément dans l'univers des Raspberry Pi, Arduino et ESP32 avec d'autres passionnés. **Pourquoi rejoindre ?** - **Support d'experts** : Résolvez les problèmes après-vente et les défis techniques avec l'aide de notre communauté et de notre équipe. - **Apprendre et partager** : Échangez des astuces et des tutoriels pour améliorer vos compétences. - **Aperçus exclusifs** : Accédez en avant-première aux annonces de nouveaux produits et aux aperçus. - **Réductions spéciales** : Profitez de réductions exclusives sur nos produits les plus récents. - **Promotions festives et cadeaux** : Participez à des cadeaux et des promotions de vacances. 👉 Prêt à explorer et à créer avec nous ? Cliquez [|link_sf_facebook|] et rejoignez-nous aujourd'hui ! .. _3.1.13_c_pi5: 3.1.13 JEU – NotNot =========================== Introduction ------------------- Dans ce projet, nous allons créer un dispositif de jeu intéressant, que nous appelons "Not Not". Pendant le jeu, la matrice de points affichera une flèche de manière aléatoire. Ce que vous devez faire, c'est appuyer sur le bouton dans la direction opposée à la flèche dans un temps limité. Si le temps est écoulé ou si vous appuyez sur le bouton dans la même direction que la flèche, vous perdez. Ce jeu est excellent pour exercer votre pensée inversée, alors, pourquoi ne pas essayer ? Composants nécessaires ------------------------------ Pour ce projet, nous avons besoin des composants suivants. .. image:: ../img/list_GAME_14_NotNot.png :align: center Il est très pratique d'acheter un kit complet, voici le lien : .. list-table:: :widths: 20 20 20 :header-rows: 1 * - Nom - ÉLÉMENTS DANS CE KIT - LIEN * - Kit Raphael - 337 - |link_Raphael_kit| Vous pouvez également les acheter séparément aux liens ci-dessous. .. list-table:: :widths: 30 20 :header-rows: 1 * - INTRODUCTION DES COMPOSANTS - LIEN D'ACHAT * - :ref:`cpn_gpio_extension_board` - |link_gpio_board_buy| * - :ref:`cpn_breadboard` - |link_breadboard_buy| * - :ref:`cpn_wires` - |link_wires_buy| * - :ref:`cpn_dot_matrix` - |link_led_matrix_buy| * - :ref:`cpn_button` - |link_button_buy| Schéma de câblage ------------------------ =============== ======== ======== ==== Nom de la carte Physique WiringPi BCM GPIO22 Pin 15 3 22 GPIO23 Pin 16 4 23 SPIMOSI Pin 19 12 MOSI SPICE0 Pin 24 10 CE0 SPISCLK Pin 23 14 SCLK =============== ======== ======== ==== .. image:: ../img/Schematic_notnot.png :align: center Procédures expérimentales --------------------------------- **Étape 1** : Construisez le circuit. .. image:: ../img/3.1.14game_notnot.png **Étape 2** : Activez le SPI avant de commencer l'expérience, consultez :ref:`spi_configuration` pour plus de détails. **Étape 3** : Accédez au dossier du code. .. raw:: html .. code-block:: cd ~/raphael-kit/c/3.1.13/ **Étape 4** : Compilez le code. .. raw:: html .. code-block:: make **Étape 5** : Exécutez le fichier exécutable. .. raw:: html .. code-block:: sudo ./3.1.13_GAME_NotNot Après le démarrage du programme, une flèche gauche ou droite sera affichée aléatoirement sur la matrice de points. Vous devez appuyer sur le bouton dans la direction opposée à la flèche, puis “√” apparaît sur la matrice de points. Si vous appuyez sur le bouton dans la même direction que la flèche, vous perdez et la matrice de points affiche “x”. Vous pouvez également ajouter 2 nouveaux boutons ou les remplacer par des touches de joystick pour les directions haut, bas, gauche et droite afin d'augmenter la difficulté du jeu. .. note:: Si cela ne fonctionne pas après l'exécution ou s'il y a un message d'erreur : "wiringPi.h: No such file or directory", veuillez consulter :ref:`install_wiringpi_pi5`. **Explication du code** Ce programme en C est conçu pour fonctionner sur un Raspberry Pi en utilisant la bibliothèque WiringPi. Il interagit avec un écran de matrice LED 8x8 contrôlé par le pilote MAX7219 et utilise deux boutons pour l’interaction avec l’utilisateur. Le programme affiche aléatoirement une flèche vers la gauche ou la droite sur la matrice LED, et l’utilisateur doit appuyer sur le bouton correspondant. Ensuite, il affiche une coche pour une réponse correcte ou une croix pour une réponse incorrecte. #. Fichiers d'en-tête : * ``wiringPi.h`` : Fournit des fonctions pour le contrôle GPIO via la bibliothèque WiringPi. * ``wiringPiSPI.h`` : Fournit des fonctions pour la communication SPI. * ``stdio.h`` : Fonctions standard d'entrée/sortie (``printf``, etc.). * ``stdlib.h`` : Fonctions de la bibliothèque standard (``rand``, ``srand``, ``exit``). * ``time.h`` : Fonctions pour manipuler la date et l'heure (``time``, ``NULL``). #. Définitions de types : * ``#define uchar unsigned char`` : Définit ``uchar`` comme un alias pour ``unsigned char``. * ``#define uint unsigned int`` : Définit ``uint`` comme un alias pour ``unsigned int``. #. Constantes et macros : * ``SPI_CHANNEL`` : Canal SPI utilisé pour la communication (0 ou 1). * ``SPI_SPEED`` : Vitesse de communication SPI fixée à 1 MHz. * ``AButtonPin`` : Numéro de broche WiringPi pour le Bouton A (GPIO 22). * ``BButtonPin`` : Numéro de broche WiringPi pour le Bouton B (GPIO 23). #. Variables globales : * ``int stage = 0;`` : Suit l’étape actuelle du jeu (affichage de la flèche ou du résultat). #. Tableaux de données : * ``uchar arrow[2][8]`` : Contient deux modèles de 8 octets représentant les flèches droite et gauche pour la matrice LED. * ``arrow[0]`` : Modèle de flèche droite. * ``arrow[1]`` : Modèle de flèche gauche. * ``uchar check[2][8]`` : Contient deux modèles de 8 octets représentant les symboles correct (coche) et incorrect (croix). * ``check[0]`` : Modèle de symbole correct. * ``check[1]`` : Modèle de symbole incorrect. #. Fonction ``void Delay_xms(uint x)`` : * Fonction enveloppe pour ``delay(x)`` fournie par WiringPi. * Retarde l'exécution du programme de ``x`` millisecondes. #. Fonction ``void Write_Max7219_byte(uchar DATA)`` : * Envoie un octet unique (``DATA``) au MAX7219 via SPI. * Utilise ``wiringPiSPIDataRW`` pour effectuer le transfert de données SPI. * ``DATA`` : L'octet de données à envoyer. #. Fonction ``void Write_Max7219(uchar address1, uchar dat1)`` : * Envoie une commande et des données au MAX7219. * Combine ``address1`` (adresse du registre) et ``dat1`` (données) dans un buffer et les envoie via SPI. * ``address1`` : Adresse du registre MAX7219. * ``dat1`` : Données à écrire dans le registre. #. Fonction ``void Init_MAX7219()`` : * Initialise le pilote d'affichage MAX7219 avec les configurations nécessaires. * Configure le mode de décodage, l’intensité, la limite de balayage, le mode veille et le test d'affichage. * Efface les données précédentes sur l'affichage. #. Fonction ``void Init_WiringPi()`` : * Initialise la bibliothèque WiringPi et l'interface SPI. * Configure les broches des boutons en entrée avec des résistances pull-up. * Vérifie la réussite de l'initialisation et quitte en cas d'échec. #. Fonction ``int get_index()`` : * Génère un index aléatoire (0 ou 1) pour choisir entre la flèche gauche et droite. * Retourne : ``0`` ou ``1``. #. Fonction ``int get_key(uint num)`` : * Attend que l’utilisateur appuie sur un bouton et détermine si l’entrée correspond à la flèche affichée. * Paramètres : * ``num`` : L'index de la flèche affichée (0 pour droite, 1 pour gauche). * Renvoie : * ``1`` si l'entrée de l'utilisateur est correcte. * ``0`` si l'entrée de l'utilisateur est incorrecte. * Fonctionnalité : * Entre dans une boucle infinie vérifiant l'état des boutons. * Utilise ``digitalRead`` pour détecter les appuis de boutons (actif en BAS). * Compare le bouton pressé avec l'entrée attendue en fonction de ``num``. #. Fonction ``void display(uint index)`` : * Affiche soit une flèche soit un symbole de résultat sur la matrice LED en fonction de ``stage``. * Paramètres : * ``index`` : Index pour sélectionner le modèle dans les tableaux ``arrow`` ou ``check``. * Fonctionnalité : * Si ``stage == 0``, affiche un modèle de flèche. * Si ``stage == 1``, affiche une coche ou une croix. #. Fonction principale : * **Initialisation :** * Initialise le générateur de nombres aléatoires avec ``srand((unsigned)time(NULL))``. * Appelle ``Init_WiringPi()`` pour configurer le GPIO et le SPI. * Appelle ``Init_MAX7219()`` pour initialiser l'affichage de la matrice LED. * Introduit un court délai avec ``Delay_xms(50)``. * **Boucle du jeu (``while (1)``) :** * **Étape 0 (Affichage de la flèche) :** * Appelle ``get_index()`` pour sélectionner aléatoirement une direction de flèche. * Appelle ``display(direction)`` pour afficher la flèche sur la matrice LED. * Définit ``stage = 1`` pour passer à l’étape suivante. * **Étape 1 (Obtenir l’entrée de l’utilisateur et afficher le résultat) :** * Appelle ``get_key(direction)`` pour attendre l'entrée de l’utilisateur et déterminer si elle est correcte. * Appelle ``display(key)`` pour afficher le symbole de résultat (coche ou croix). * Attend 1 seconde avec ``Delay_xms(1000)`` pour permettre à l’utilisateur de voir le résultat. * Définit ``stage = 0`` pour redémarrer la boucle. **Résumé du déroulement du programme :** 1. **Configuration :** * Initialiser WiringPi et SPI. * Configurer les broches des boutons et les paramètres du MAX7219. * Initialiser le générateur de nombres aléatoires. 2. **Affichage de la flèche :** * Sélectionner aléatoirement une direction de flèche (gauche ou droite). * Afficher la flèche correspondante sur la matrice LED. 3. **Interaction avec l'utilisateur :** * Attendre que l'utilisateur appuie sur le bouton A ou le bouton B. * Vérifier si le bouton pressé correspond à la direction de la flèche. 4. **Affichage du résultat :** * Afficher une coche si la réponse de l'utilisateur est correcte. * Afficher une croix si la réponse de l'utilisateur est incorrecte. * Attendre 1 seconde avant la prochaine manche. 5. **Répéter :** * Revenir en boucle pour afficher une nouvelle flèche et continuer le jeu.