Animation LCD et jeux

Applications et services en ligne

Arduino IDE

À propos de ce projet

Ce projet se concentre sur les bases de l'animation à l'aide d'arduino et d'un écran lcd 16 par 2. Cependant, ce projet peut également être étendu à des écrans lcd d'autres dimensions.

Nous commencerons d'abord par le câblage de l'écran lcd à l'arduino, puis par la simple impression d'un message à l'écran lcd. Ensuite, nous allons passer à l'animation.

Câblage LCD

C'est le circuit tel qu'il est schématisé ci-dessus.

NIP LCD

1 : VSS :au rail positif de la planche à pain (attachez également 5 v d'arduino au rail positif)

2:VDD:au rail négatif de la maquette (attachez GND de l'arduino ici aussi)

3:VO (contraste):pour essuyer le potentiomètre (fixer les bornes latérales du potentiomètre aux rails positifs et négatifs)

4:RS (sélection du registre):vers la broche Arduino 12

5:R/W(lecture-écriture):vers rail négatif

6 : E (activer) :vers la broche Arduino 11

15 : A (anode) :vers le rail positif avec une résistance de 220 ohms

16 : K (cathode) :vers le rail négatif

Nous n'attacherons pas de broche de données pour le moment.

Mettez sous tension et si la rangée du bas s'allume, votre écran LCD fonctionne. Vous devez tester ceci avant de commencer à faire autre chose.

Si l'écran LCD ne s'allume pas, vérifiez vos soudures, votre câblage (vérifiez à nouveau) et s'il ne s'allume toujours pas, il est fort probable que votre écran LCD soit corrompu, vous devez donc le remplacer.

Si votre écran LCD fonctionne, Bravo ! vous avez terminé la première partie de ce tutoriel.

Après cela, connectez les broches de données :

11 : D4 (broche de données 4) :vers la broche Arduino 4

12 : D5 :vers la broche 5 de l'Arduino

13 : D6 :vers la broche 6 d'Arduino

14 : D7 :vers la broche 7 d'Arduino

Après cet exemple de code de téléchargement

#include LiquidCrystal lcd(12,11,4,5,6,7);//rs,e,d4,d5,d6,d7 respectivementvoid setup(){lcd.begin (16,2);lcd.setCursor(0,1);lcd.print("Working");}boucle vide(){} 

Après le téléchargement si vous voyez des caractères aléatoires ou rien du tout, vérifiez votre contraste (tournez le cadran du potentiomètre vers le haut et vers le bas), vérifiez votre soudure des broches (les broches de données ne doivent PAS être connectées les unes aux autres, même légèrement), et enfin votre circuit et la ligne 2 dans l'exemple de code (assurez-vous que les numéros de broche fournis à LiquidCrystal correspondent à ceux de votre circuit.

Si toujours rien ne se passe, ne perdez pas espoir, si vous avez vu la rangée du bas s'allumer dans la première partie, cela signifie que votre écran lcd est OK. jouer avec le circuit et la soudure jusqu'à ce que cela fonctionne.

Si vous voyez le message "Working", c'est que vous avez câblé avec succès votre écran LCD et terminé la deuxième partie de ce tutoriel. Laissez votre circuit tel quel, nous n'y toucherons plus, il ne nous reste plus qu'à faire dans le logiciel.

Explication du code dans la partie 2

LiquideCristallcd(12,11,4,5,6,7);

Cette ligne déclare un objet lcd avec les broches d'interface fournies dans les arguments. Maintenant, tout votre interfaçage lcd se fera via cet objet 'lcd'. (notez que vous pouvez le nommer comme vous le souhaitez, mais conservez ce nom tout au long).

lcd.begin(16,2) ;

Cette ligne déclare que notre écran LCD est de dimensions 16 colonnes et 2 lignes, notez que votre écran LCD peut ne pas être 16 par 2, ajustez les nombres en conséquence.

lcd.setCursor(0,1) ;

Cette ligne positionnera le curseur sur la première colonne et la deuxième ligne (car le comptage en C++ commence par 0 et non par 1 !). Notez que vous ne pouvez pas voir le curseur, mais le curseur est toujours là, il fixe l'endroit où le prochain caractère apparaîtra.

lcd.print("Bienvenue");

Cette ligne imprimera le message Bienvenue à l'endroit où pointe le curseur, c'est-à-dire 0 colonnes 1 lignes.

Texte défilant

Eh bien, nous avons imprimé un message à l'écran, mais ce n'est pas très attrayant de rester assis à regarder ce même message, de plus cela ne sert à rien. Ainsi nous imprimerons dans cette rubrique un message qui défilera de droite à gauche comme dans les panneaux publicitaires. Seules les fonctions setup() et loop() seront différentes, donc je ne montre que ces fonctions, le reste reste le même.

void setup(){lcd.begin(16,2);}void loop(){int n;char message[]="scrolling text!";n=15;char* ptr=message; while(n!=-14){lcd.clear(); lcd.setCursor(n,1) ; if(n<0){ ptr++; } lcd.print(ptr); n--;delay(250);}} 

Notez que pour comprendre ce code, vous avez besoin d'une assez bonne connaissance des pointeurs en C et C++, car le langage Arduino n'est en fait qu'AVR-C++ légèrement traité.

Dans la fonction de boucle, nous définissons votre message comme une chaîne constante.

lcd.clear() est utilisé pour effacer l'écran à chaque itération.

Ensuite, nous définissons un pointeur ptr pour contenir l'adresse du message. Cette valeur de pointeur sera incrémentée afin de tenir le message dans la fenêtre lcd même après que les caractères glissent hors de vue vers la gauche. Nous le faisons pour l'extrémité gauche et non pour la droite car la bibliothèque LiquidCrystal peut le gérer pour l'extrémité droite (texte défilant) mais ne peut pas gérer les adresses de colonne négatives comme cela est requis pour notre programme.

Ensuite, nous avons une boucle while qui affichera le message à divers endroits de gauche à droite donnant ainsi l'illusion que le texte bouge. Notez que le delay() à la fin est de s'assurer que nous pouvons lire le texte et qu'il ne siffle pas de droite à gauche à des vitesses illisibles. Si l'animation semble trop lente ou trop rapide, vous pouvez modifier la valeur du délai.

Caractères personnalisés

Pour toutes les utilisations de la fonction lcd.print(), nous ne pouvons pas afficher, disons un dinosaure, sur l'écran lcd. Cependant, nous pouvons le faire en utilisant une fonctionnalité de la bibliothèque LiquidCrystal appelée Caractères personnalisés.

Pour cela, nous définissons un octet de données, qui contient des 1 pour tous les pixels activés et des 0 pour tous les pixels désactivés, comme ceci :

octet dino[]={B01110, B01110, B01100, B01111, B11101, B01010, B01010, B01010} 

Il s'agit d'un personnage personnalisé qui affichera un dinosaure sur l'écran LCD. Vous pouvez créer vos propres personnages ici :https://maxpromer.github.io/LCD-Character-Creator/

Après cela, nous devons les afficher. Cependant, ces caractères ne peuvent pas être affichés à l'aide de la méthode lcd.print normale; nous devons utiliser ceci :

void setup(){lcd.createChar(0,dino);lcd.begin(16,2);lcd.setCursor(0,1);lcd.write(byte(0));} 

Avec ce code, nous créons un caractère adressable personnalisé à partir de notre octet dino[] défini précédemment. L'adresse de notre personnage personnalisé est donnée par la méthode lcd.createChar() qui définit le caractère 0 comme dino[]. Nous appellerons ensuite ce caractère byte(0) qui renvoie l'adresse de notre caractère personnalisé, et enfin l'imprimerons à l'écran en utilisant la méthode lcd.Write().

Tirer des flèches

Ce programme va enfin vous apprendre à animer à l'aide d'écrans LCD, lisez ceci attentivement.

#include LiquidCrystal lcd(12,11,4,5,6,7);byte arrowhead[]={B00001, B00011, B00111, B01111, B00111, B00011, B00001, B00000 }byte arrowbody[]={B00000, B00000, B00000, B11111, B11111, B00000, B00000, B00000}byteB00011, B00111, B01111, B11111, B11111, B01111, B00111, B00011}voidlcd.createChar(0,arrowhead);lcd. createChar(1,arrowbody);lcd.createChar(2,arrowtail);lcd.begin(16,2);}voidintwhile(n!=-1){lcd.clear();lcd.setCursor(0,1) ; lcd.write(byte(0));lcd.write(byte(1));lcd.write(byte(2));n--;delay(50);}} 

Ici, nous utilisons trois caractères personnalisés pour simuler une flèche. Le reste vous est familier. Lors de l'exécution de cette opération sur votre écran LCD, vous remarquerez peut-être une traînée derrière la pointe de la flèche, la faisant paraître plus longue qu'elle ne l'est, ne vous inquiétez pas, ce n'est que le résidu de la position de la flèche précédente.

C'est ça! Vous avez terminé votre première animation avec Arduino et LCD ! Jouez avec le code et combinez-le avec des entrées de bouton pour le transformer en un jeu à part entière !

Jeu LCD

Enfin on peut faire un jeu ! Cependant pendant ce tutoriel je ne vais pas commencer avec un jeu très compliqué, mais un jeu très simple assez similaire aux premiers jeux d'arcade.

Objectif de ce jeu

Avant de commencer le jeu, nous devons déterminer un objectif pour le gameplay.

Dans ce jeu, l'objectif est le suivant :

Il y a le héros, une personne sur la rangée 1 (notez que la première rangée est la rangée 0) (normalement) sur laquelle une série de flèches va être tirée. Si le héros est touché, le jeu est terminé. Le héros va éviter les flèches en sautant à la ligne 0, que nous allons manipuler par un bouton. (appuyez sur le bouton =ligne 0 pas =ligne 1). Le score est incrémenté par boucle et affiché dans le coin droit.

C'est en fait une extension de l'animation des flèches d'eariler, donc je vais inclure uniquement les parties qui ont changé.

byte man[] ={ B01110, B01110, B00100, B01110, B10101, B00100, B01010, B10001};void setup() { // configure le nombre de colonnes et de lignes de l'écran LCD :lcd.createChar( 0, pointe de flèche) ; lcd.createChar(1, corps de flèche); lcd.createChar(2,arrowtail); lcd.createChar(3,man); lcd.begin (16, 2); attachInterrupt(0,bouton,CHANGE); randomSeed(analogRead(A0)); // Imprime un message sur l'écran LCD. //lcd.print("hello, world!");} int n;void loop() { // place le curseur sur la colonne 0, ligne 1 // (remarque :la ligne 1 est la deuxième ligne, car le comptage commence par 0)://lcd.setCursor(0, 1); // affiche le nombre de secondes depuis la réinitialisation ://lcd.print(millis() / 1000); n=15 ; int rnd; rnd=aléatoire(15,25); while(n!=-1){ lcd.clear(); retard(10) ; dessinateur(); lcd.setCursor(n,1) ; if(n==1){ if(level==1){ stopgame(); Continuez; } } lcd.write(byte(0)); lcd.write(octet(1)); lcd.write(byte(2)); lcd.setCursor(10,0); lcd.print(score); retard (100-rnd); n--; note++ ; si(niveau==0) score--; }}void drawman(){ lcd.setCursor(1,level); lcd.write(byte(3));}void buttonin(){ if(digitalRead(2)==LOW){ level=0; } else{ niveau=1; }}jeu d'arrêt nul(){ lcd.clear(); lcd.setCursor(0,0); lcd.print("Game over"); lcd.setCursor(10,0); lcd.print(score); niveau=1 ; note=0 ; n=15 ; retard (3000); retour;} 

Tout ce code ne concerne pas l'écran LCD, mais TOUT est important pour le développement du jeu.

Nous commençons par la définition du caractère de man[] qui stockera l'octet pour le caractère man (notre héros). Ensuite, nous avons la fonction de configuration, où seules deux lignes ont changé. Les deux lignes ne sont représentatives que d'une partie du vaste groupe auquel elles appartiennent, à savoir les interruptions et les nombres aléatoires. Les deux sont des équipements très utiles, vous trouverez plus d'informations sur le site Web arduino.cc.

Nous avons d'abord la fonction attachInterrupt. Notez que la définition que je vais donner n'est pas très complète, mais une courte est nécessaire pour comprendre ce qui se passe ici.

Les interruptions sont des fonctions qui peuvent être appelées lors de la survenance d'un événement, PEU IMPORTE O L'EXÉCUTION a lieu. C'est un fait important utile pour la mise en œuvre des fonctions d'entrée en temps réel. Ici, nous l'utilisons pour nous assurer que peu importe à quel moment de l'exécution le bouton est enfoncé, nous prendrons l'action appropriée (au moins le programme le fera).

Syntaxe pour attachInterrupt :

attachInterrupt(pin_number-2,function_to_call_without_parenthesis,condition_for_calling);

CHANGE est une valeur #define utilisée pour signifier que pour tout changement d'état dans l'entrée pin_number, la fonction attachée sera appelée.

Ensuite, nous avons un nombre aléatoire. Une qualité exceptionnelle que possèdent les processeurs physiques comme l'Arduino, contrairement aux processeurs normaux, c'est qu'un nombre aléatoire généré par l'Arduino est vraiment aléatoire comme le bruit analogique présent sur la broche A0 if la broche A0 est flottante (c'est-à-dire non connectée) est aléatoire comme prédit par la physique quantique (plus ou moins).

randomSeed est utilisé pour définir la graine du processus aléatoire. random() est une fonction avec les paramètres MIN,MAX ou MAX uniquement pour obtenir le prochain nombre aléatoire dans la séquence.

Ensuite, nous avons la fonction Interruption buttonin() qui vérifie si le bouton est enfoncé (BAS) ou non (HIGH) et modifie le niveau (rangée) de notre héros en conséquence.

Ça y est, nous avons un jeu entièrement fonctionnel !!

Code

• code pour l'animation
• code pour le jeu

code d'animationArduino

// inclure le code de la bibliothèque :#include // initialiser la bibliothèque en associant toute broche d'interface LCD nécessaire // avec le numéro de broche arduino auquel elle est connectée const int rs =12, en =11, d4 =4, d5 =5, d6 =6, d7 =7;LiquidCrystal lcd(rs, en, d4, d5, d6, d7);byte arrowhead[]={ B00001, B00011, B00111, B01111, B00111, B00011, B00001 , B00000};byte arrowbody[]={ B00000, B00000, B00000, B11111, B11111, B00000, B00000, B00000};byte arrowtail[]={ B00011, B00111, B11111, B11111, B11111, B00111, B00011, B00000} ; byte man[] ={ B01110, B01110, B00100, B01110, B10101, B00100, B01010, B10001};void setup() { // configure le nombre de colonnes et de lignes de l'écran LCD :lcd.createChar(0,arrowhead); lcd.createChar(1, corps de flèche); lcd.createChar(2,arrowtail); lcd.createChar(3,man); lcd.begin (16, 2); // Imprime un message sur l'écran LCD. //lcd.print("hello, world!");}void loop() { // place le curseur sur la colonne 0, ligne 1 // (remarque :la ligne 1 est la deuxième ligne, car le comptage commence par 0) ://lcd.setCursor(0, 1); // affiche le nombre de secondes depuis la réinitialisation ://lcd.print(millis() / 1000); entier n; n=15 ; while(n!=-1){ lcd.clear(); retard(10) ; lcd.setCursor(0,0); lcd.print("par Debanshu Das"); /* lcd.setCursor(1,1) ; lcd.write(byte(3)); lcd.setCursor(n,1) ; lcd.write(byte(0)); lcd.write(octet(1)); lcd.write(byte(2));*/ delay(65); n--; }}

code pour le jeuArduino

// inclure le code de la bibliothèque :#include // initialiser la bibliothèque en associant toute broche d'interface LCD nécessaire // avec le numéro de broche arduino auquel elle est connectée const int rs =12, en =11, d4 =4, d5 =5, d6 =6, d7 =7;LiquidCrystal lcd(rs, en, d4, d5, d6, d7);int level=1;int score=0;byte arrowhead[]={ B00001, B00011 , B00111, B01111, B00111, B00011, B00001, B00000};octet flèche[]={ B00000, B00000, B00000, B11111, B11111, B00000, B00000, B00000};octet flèche[]={ B00011, B00111, B11111, B11111 , B11111, B00111, B00011, B00000};byte man[] ={ B01110, B01110, B00100, B01110, B10101, B00100, B01010, B10001};void setup() { // configurer le nombre de colonnes et de lignes de l'écran LCD :lcd.createChar(0, pointe de flèche); lcd.createChar(1, corps de flèche); lcd.createChar(2,arrowtail); lcd.createChar(3,man); lcd.begin (16, 2); attachInterrupt(0,bouton,CHANGE); randomSeed(analogRead(A0)); // Imprime un message sur l'écran LCD. //lcd.print("hello, world!");} int n;void loop() { // place le curseur sur la colonne 0, ligne 1 // (remarque :la ligne 1 est la deuxième ligne, car le comptage commence par 0)://lcd.setCursor(0, 1); // affiche le nombre de secondes depuis la réinitialisation ://lcd.print(millis() / 1000); n=15 ; int rnd; rnd=aléatoire(15,25); while(n!=-1){ lcd.clear(); retard(10) ; dessinateur(); lcd.setCursor(n,1) ; if(n==1){ if(level==1){ stopgame(); Continuez; } } lcd.write(byte(0)); lcd.write(octet(1)); lcd.write(byte(2)); lcd.setCursor(10,0); lcd.print(score); retard (100-rnd); n--; note++ ; si(niveau==0) score--; }}void drawman(){ lcd.setCursor(1,level); lcd.write(byte(3));}void buttonin(){ if(digitalRead(2)==LOW){ level=0; } else{ niveau=1; }}jeu d'arrêt nul(){ lcd.clear(); lcd.setCursor(0,0); lcd.print("Game over"); lcd.setCursor(10,0); lcd.print(score); niveau=1 ; note=0 ; n=15 ; retard (3000); retour ;}

Schémas