Le jeu Arduino le plus simple avec un écran 1602 - Partie # 1


C'est ce que nous devons obtenir, eh bien, il sait toujours sauter, marcher et battre les mauvais cactus qui l'attaquent, mais nous y arriverons pas à pas :)

PARTIE # 1 notions de base


Je me suis commandé un arduino, "un jouet moyen", ai-je pensé, un petit kit (à tester), ce que j'ai regretté par la suite. Je voulais libérer le potentiel, mais en raison du manque de modules supplémentaires, cela n'a pas fonctionné, j'ai dû expérimenter, couper l'arduino au système de sécurité et regarder comment les capteurs faisaient leur travail, puis j'ai décidé de faire une alarme sonore (en utilisant le sifflet pratique du kit), alors j'ai sevré les chiens à haute voix ou aboyant soudain :) puis mes mains atteignirent l'écran 1602. "Hmm ... c'est un véritable écran", pensai-je, mais je fus déçu de découvrir qu'il mange presque la moitié de tous les contacts sur l'arduino lui-même. J'ai fouillé et trouvé une étrange carte dans le bundle «i2C» et c'était très méfiant! Que le nombre de trous coïncidait avec le nombre de proxénète sur l'écran. "Hmm, pas facile ..." J'ai pensé, et j'ai décidé de les souder. Un peu plus tard, j'ai réalisé que j'avais fait la bonne chose et maintenant mon écran ne mange que deux canaux. Il a commencé à étudier de quel type d'exposition il s'agissait et ce qu'il pouvait faire. Après avoir étudié suffisamment de matériel, j'ai découvert que l'affichage est purement textuel, mais voilà! Il peut gérer 8 nouveaux personnages avec des dimensions de 5x8 pixels. Eh bien, commençons à écrire un jeu! Tout d'abord, vous devez déterminer de quel type de jeu il s'agit, j'ai décidé de le faire ressembler à un dinosaure gugl chrome, mais avec quelques jetons, pour ainsi dire, pour commencer, je pense que cela fonctionnera :) mais vous devez encore gérer quelque chose, et multi-bouton, n'a pas eu à réfléchir longtemps. J'ai pris la télécommande IR du kit.

image

"C'est le joystick," marmonnai-je soupçonneusement dans mon souffle, pensant au retard de la télécommande, à la clarté du capteur IR, et généralement à l'adéquation de cette idée, mais il n'y avait rien à faire, je pouvais entraîner Arduino à travailler avec le clavier de l'ordinateur, mais c'était vraiment de la paresse pour le faire. J'ai donc commencé à écrire les codes de la télécommande, afin de pouvoir travailler avec eux à l'avenir. Le code du microcontrôleur est le plus simple ici:

"--------------------------------------------------------------------------" //   IRremote #include <IRremote.h> decode_results results; IRrecv irrecv (A0); //      void setup () { Serial.begin(9600); //   com  irrecv.enableIRIn(); //    } void loop () { if (irrecv.decode( &results )) //      ,    { Serial.println( results.value, HEX ); //          irrecv.resume(); //            } } "--------------------------------------------------------------------------" 

Le code du signal de la télécommande ressemble à ceci: "FF18E7" vos codes seront différents, bien sûr, mais vous devez comprendre l'essence, et lorsque vous faites appel à ce code, nous ajoutons "0x" au début et nous obtenons (0xFF18E7).

Après avoir rempli cela dans arduino et l'avoir connecté comme il se doit, nous pouvons commencer l'enregistrement à partir du port de connexion du tsiforka, après avoir cliqué sur les boutons de l'appareil IR. Mais ici, je veux juste vous expliquer comment connecter le capteur infrarouge.

Si nous regardons le capteur, nous voyons trois pattes, gauche (signal analogique), moyenne (sol), droite (plus 5V).

image

Comme je ne savais toujours pas comment cela pourrait fonctionner, j'ai commencé des expériences. Au début, j'ai fait le code de croquis étape par étape, à travers (délai (temps)) au début, je ne pensais pas que c'était une mauvaise idée :)
Quel est le montant principal. Ce microcontrôleur n'est pas capable de faire du multitâche. Il considère le code de haut en bas, en passant par toutes les branches et fonctions, et après avoir terminé, il recommence. Et maintenant, quand nous avons beaucoup de ces «retards» dans le code, nous commençons à remarquer des retards évidents. Soit dit en passant, oui, pourquoi avons-nous besoin de beaucoup de «retard»? Lorsque nous faisons un jeu, le nombre de contrôles et d'interactions commence à augmenter. Par exemple, un ennemi se déplace vers nous et je veux sauter dessus, j'appuie sur le «saut» et selon le plan, je dois accrocher en l'air par exemple 0,8f seconde en l'air, et c'est tout le jeu et se fige pendant ces 0,8f seconde. "Je ne peux pas" J'ai pensé et j'ai commencé à penser à une solution. La solution a été trouvée rapidement. Le microcontrôleur lui-même est capable de lire rapidement le code du début à la fin (si cela ne le dérange pas) et il sait aussi compter le temps depuis le début de son inclusion. Voilà ce dont nous avons besoin. Maintenant, nous créons simplement des variables qui stockeront le temps pour telle ou telle action et une variable qui compare la différence entre l'heure actuelle et le temps nécessaire pour activer le code. Arduino par seconde, prend 1000 millisecondes, assez pratique. Voici un extrait quand il devient plus clair:

 "--------------------------------------------------------------------------" //    ,  ,        //  long ClearTime = 150; // 150 = 0.15f   ~6    long ClearTimeCheck = 0; // ,       long currentMillis = 0; //   void loop () { currentMillis = millis(); //   =    } void clearscreen () //   { // if (currentMillis - ClearTimeCheck >= ClearTime) //  (  -     0.15f    { ClearTimeCheck = currentMillis; //       lcd.clear(); //   ,     } } "--------------------------------------------------------------------------" 

Pas difficile, non?

Après avoir réécrit le code entier d'une manière nouvelle, le jeu a commencé à fonctionner rapidement et clairement, pour simuler des actions multitâches :) J'ai fait un long chemin. Après tout, nous devons encore créer un personnage, une sorte d'interface et d'animation. Comme nous ne pouvons créer que huit nouveaux personnages, nous devons en quelque sorte tout gâcher intelligemment. Je n'ai pas l'intention de faire beaucoup d'objets sur l'écran jusqu'à présent, donc cela peut être fait de manière à ce que je n'aie que huit objets actifs à l'écran en un seul traitement de code. Qu'est-ce que ce sera? Eh bien, naturellement, le personnage principal, un coup, un méchant, un cœur et un indicateur de santé. Pour commencer, cela suffit. Oui, et j'ai trois autres objets uniques en stock.

Le personnage principal ressemblera à ceci:



Le processus de saisie d'un nouveau personnage, je le produis en code binaire (je me sens tellement à l'aise)
cela ressemblera à ceci:

01110
01110
00100
01110
10101
00100
01110
01010

Si vous regardez attentivement, alors d'un côté, nous verrons notre personnage, mais pour qu'il ne reste pas inactif, faisons-en une animation.



Maintenant, dans notre code, un autre ensemble de nombres binaires est ajouté, à savoir celui-ci:

00000
01110
01110
00100
11111
00100
01110
01010

Comment faire une animation sur cet affichage, j'ai indiqué la logique ci-dessus, et maintenant nous allons nous entraîner, pour le moment, la placer au centre de l'écran et la faire rester immobile, et rappelez-vous, notre tâche est d'utiliser une seule cellule mémoire pour deux sprites d'animation. C'est plus simple qu'il n'y paraît:

 "--------------------------------------------------------------------------" #include <Wire.h> #include <LiquidCrystal_I2C.h> LiquidCrystal_I2C lcd(0x3F,16,2); //   long AnimatedTime = 300; //     long AnimatedTimeCheck = 0; //   (    ) int AnimPlayer = 1; //    int GGpozX = 8; //   int GGpozY = 1; //   1  2   0    long currentMillis = 0; //   //   ,     ,    :) enum { SYMBOL_HEIGHT = 8 }; byte Player_1[SYMBOL_HEIGHT] = {B01110,B01110,B00100,B01110,B10101,B00100,B01110,B01010,}; //  1 byte Player_2[SYMBOL_HEIGHT] = {B00000,B01110,B01110,B00100,B11111,B00100,B01110,B01010,}; //  2 void setup() { lcd.init(); lcd.backlight();//    loop(); PlAn(); } void loop() { if (AnimPlayer != 50) { //    ,       :) // --------------------------- Animated -> // -------------------- Player -> if (AnimPlayer == 1){lcd.createChar(0, Player_1);} //  1   1 //(lcd.createChar(    0  7,   )) if (AnimPlayer == 2){lcd.createChar(0, Player_2);} //  2   2 } // --------------------------- <- Animated currentMillis = millis(); //   =    PlAn(); } void PlAn () { if (AnimPlayer == 1) //   1  { lcd.setCursor(GGpozX, GGpozY); //  ""      lcd.write(0); //          "" } if (AnimPlayer == 2) //  №1 { lcd.setCursor(GGpozX, GGpozY); lcd.write(0); } if (currentMillis - AnimatedTimeCheck >= AnimatedTime) //       { AnimatedTimeCheck = currentMillis; //     if (AnimPlayer == 2){AnimPlayer = 1; return;} //  2   1      if (AnimPlayer == 1){AnimPlayer = 2;} // 1  2           ,         } } "--------------------------------------------------------------------------" 

Après avoir commencé, nous voyons le petit homme, qui est au centre de l'écran, sur la 2e ligne et se balance, pour ainsi dire.

Conclusion: aujourd'hui, j'ai expliqué comment trouver des données via le port infrarouge, comment contourner le retard du code du microcontrôleur et comment réaliser l'animation initiale.

Le reste arrive bientôt :) J'ai encore beaucoup à écrire, donc je vais voir comment ça va être intéressant pour vous, et si oui, demain je commencerai à écrire une suite.

Merci à tous pour votre attention, ciao cacao!

La deuxième partie de l'article -> habr.com/post/425367

Source: https://habr.com/ru/post/fr424859/


All Articles