4 connecter avec AZ Touch Mod

Comme vous l'avez peut-être déjà remarqué, je ne suis pas seulement un blogueur, mais aussi un père de famille. Pour cela, vous devez combiner votre hobby et votre vie de famille d'une manière ou d'une autre et programmer de petits gadgets pour les enfants. Dans ce cas, il s'agit du jeu populaire "4 Wins", qui existe déjà sous différentes formes et conceptions. Dans ce cas, nous apportons le jeu à l'AZ-Touch Mod avec un écran de 2,4" ou 2,8" et en même temps vous devriez apprendre quelque chose sur les tableaux multidimensionnels et les fonctions récursives.

Le matériel et les Software de ce blog

Pour recréer ce blog, vous aurez besoin des composants du tableau 1 :

Tableau 1 : Composants pour 4 Wins

Vous aurez besoin des logiciels suivants :

• Arduino Ide (https://www.arduino.cc/en/Main/Software), Téléchargez la dernière version ici
• La bibliothèque TFT_eSPI avec toutes les dépendances. Comment cela fonctionne, nous montrons entre autres ici.

L'essentiel

Le tableau multidimensionnel

Si vous n'avez pas de formation en informatique, mais que la programmation est l'un de vos passe-temps, vous commencerez probablement par vous hérisser devant le terme "tableau multidimensionnel". Dans l'un de mes derniers articles de blog sur le jeu TicTacToe, j'ai utilisé un tableau normal de type integer,
voir le code 1 :

int IsetMark[] = {0, 0, 0, 0, 0, 0, 0, 0, 0};

Code 1: Tableau du type de données Integer

Il s'agit d'un tableau dit unidimensionnel, où il n'existe qu'une seule série de données. À la ligne 29 du jeu "4 Wins", un tableau à deux dimensions est créé,
voir le code 2 :

byte bmatrix[Numrov][Numcolumn];

Code 2 : Tableau à deux dimensions

En principe, vous pouvez imaginer un tableau à deux dimensions comme une liste Excel. Vous saisissez une valeur dans chaque colonne et chaque ligne, qui peut ensuite être lue ou écrite. En fait, cela peut être poussé si loin que vous pouvez créer un tableau à n dimensions,
voir le code 3 :

Datatype array [first level] [second level] [third level] .... [N-1 level] [nth level];

Code 3 : tableau à n dimensions

La lecture et l'écriture de tels tableaux peuvent être assez difficiles, selon la complexité du tableau. Pour réinitialiser le tableau bidimensionnel de "4 victoires", deux boucles for imbriquées sont suffisantes,
voir le code 4 :

 /*
 * =================================================================
 * FUNCTION: ResetMatrix 
 * RETURNS: Void
 * Description: Reset the Matrix
 * =================================================================
 */
 void resetmatrix()
 {
   Serial.Println("----- Reset Matrix -----");
   for(int icolum = 0; icolum < int(Numcolumn); icolum++)
     for(int Irov = 0; Irov < int(Numrov); Irov++)
       bmatrix[Irov][icolum] = 0;
   showmatrix();
   Serial.Println("------------------------");
 }

Code 4 : Réinitialisation du tableau bidimensionnel de "4 Wins

Pour mieux comprendre la boucle for imbriquée, nous pouvons la dérouler. Au centre, nous trouvons le commandement :

BMATRIX [IROW] [ICOLUM] = 0;

Les emplacements de stockage d'un tableau sont spécifiés entre crochets. Plus il y a de crochets, plus il y a de niveaux (comme décrit ci-dessus). Deux niveaux représentent une table, comme mentionné ci-dessus. Vous parcourez ensuite les lignes et les colonnes avec les valeurs entre parenthèses en commençant par 0 :
Bmatrix [0] [0] = 0;

Bmatrix [0] [1] = 0;

…

Bmatrix [1] [0] = 0;

BMATRIX [1] [1] = 0;

…

etc.

L'une des deux boucles for peut maintenant être utilisée pour itérer dans une ligne. L'autre boucle for compte ensuite les colonnes. Dans ce cas, la boucle interne est responsable des lignes, la boucle externe des colonnes.

Vous pouvez maintenant considérer un tableau tridimensionnel comme une deuxième table qui se trouve derrière la première. En tête de la boucle for, on spécifie la valeur de départ, la valeur de fin, puis la taille du pas. Pour définir toutes les valeurs d'un tableau avec 0, vous devez procéder de cette manière en C ou C++.

Il suffit de jeter un coup d'œil à la fonction checkForWinner(), qui lit le tableau bidimensionnel pour déterminer un éventuel gagnant.

L'appel de fonction récursif

Si la fonction checkForWinner() a déjà été mentionnée, le sujet des appels de fonction récursifs doit être expliqué plus en détail. Dans beaucoup de nos articles de blog, vous trouverez quelque chose comme le code 5.

boot checkvertical(int Irov, int icolum)

Code 5 : Exemple d'une fonction

Tout d'abord, la valeur de retour de la fonction est définie, dans l'exemple ci-dessus un bool (c'est-à-dire vrai ou faux, ou HIGH ou LOW, ou 0 ou 1). Juste après, suit le nom de la fonction, qui est utilisé pour appeler la fonction dans le code source. Suivent ensuite entre parenthèses les données qui sont utilisées comme copie, comme référence ou comme pointeur. Avec cela, vous avez d'abord clarifié le principe d'une fonction "normale". Un appel de fonction récursif est appelé ainsi parce que la fonction s'appelle elle-même à nouveau. Le Code 6 en est la meilleure illustration :

 /*
 * =================================================================
 * FUNCTION: CHECKVERTICAL 
 * RETURNS: TRUE IF There is a Winner Else False
 * INPUT IROW: CURRENT ROW
 * INPUT ICOLUMN: CURRENT COLUMN
 * Ref Isum: Sum of Current Equal position
 * Description: RECURSIVE FUNCTION TO CHECK VERTICAL WIN
 * =================================================================
 */
 boot checkvertical(int Irov, int icolum, int &isum)
 {
   IF(bmatrix[Irov][icolum] != Bplayermove || bmatrix[Irov][icolum] == 0)
     return false;
   Else
  {
     isum++;
     IF(isum == 4)
       return true;
     Else
       return checkvertical(Irov, icolum+1, isum);
  }
 }

Code 6 : Exemple d'une fonction récursive

Le danger de ce type d'appel est que les erreurs sont difficiles à trouver et que vous pouvez programmer une boucle infinie non désirée. Par conséquent, la condition de terminaison doit être programmée proprement, voir la requête if interne du code 6, qui renvoie un vrai et met fin à l'appel récursif. À ce stade, la référence iSum est vérifiée pour voir si iSum a atteint la valeur 4.

Soyez donc prudent lorsque vous programmez des fonctions récursives.

Transférer le jeu vers le microcontrôleur

Pour jouer à "4 Wins", veuillez télécharger le paquet zip depuis ma page GitHub. Décompressez ce fichier zip et ouvrez le dossier directement après. Vous y trouverez deux fichiers :

• Ino: le programme pour l'IDE Arduino
• H: le fichier de configuration de l'affichage

Veuillez remplacer le fichier User_setup.h dans le dossier C:\User\IHR-Name\Documents\Arduino\libraries\TFT_eSPI, voir figure 1. Il est préférable de renommer le fichier avec le même nom qu'auparavant, par exemple en User_Setup_old.h.

Figure 1: User_Setup.h écraser

Après cela, ouvrez le code source dans Arduino IDE et sélectionnez le micro-contrôleur approprié selon les instructions de l'E-Book. Transférez le programme vers le micro-contrôleur et après le redémarrage, vous devriez voir l'invite de calibration, voir Figure 2.

Figure 2 : Invitation à l'étalonnage sur l'affichage

Si une erreur se produit lors de la compilation, par exemple que TFT_eSPI ne connaît pas la fonction calibrateTouch(), c'est que vous n'avez pas remplacé le fichier User_Setup.h correctement, ou que le fichier User_Setup.h se trouve dans le même répertoire que le fichier *.ino, ce qui ne doit pas être le cas.

Une fois cette étape terminée, cherchez la flèche verte à côté des cases rouges dans le coin et vous verrez l'écran de démarrage immédiatement après, voir la Figure 3 :

                                        Figure 3 : écran de démarrage de "4 Wins

En appuyant sur le bouton "Start", le champ de jeu se construit directement, voir figure 4 :

Figure 4 : Le terrain de jeu

En haut, vous voyez des cibles pour placer votre pièce, à droite, vous voyez quel est le tour du joueur. Vous et votre adversaire pouvez voir à tout moment à qui c'est le tour et, bien sûr, quelles pièces ont été placées, voir la figure 5 :

Figure 5 : Jeu avancé avec toutes les informations nécessaires

Ne vous souciez pas de trouver la bonne case dans le jeu, selon la colonne que vous ou votre adversaire sélectionnez, la position correcte du jeton est automatiquement déterminée. Si une colonne est pleine, un autre coup dans cette colonne n'est également plus possible, comme dans le jeu réel.

Si l'un des deux joueurs a gagné ou si le terrain de jeu est rempli et que personne ne peut gagner, un écran de fin correspondant s'affiche, voir figure 6 :

Figure 6 : La partie est terminée, le joueur 2 a gagné.

On espère que vous vous amuserez en jouant le jeu et une petite information importante à la fin :

Comme l'écran de 2,4" et celui de 2,8" ont la même résolution, il n'est pas nécessaire de modifier quoi que ce soit dans le code source. En calibrant au début, vous pouvez utiliser l'Az-Touch avec un écran de 2.4" ou 2.8".

Pour découvrir d'autres projets réalisés par mes soins pour AZ-Delivery, rendez-vous sur https://github.com/M3taKn1ght/Blog-Repo.