LCD-Animation und -Spiele

Apps und Onlinedienste

Arduino-IDE

Über dieses Projekt

Dieses Projekt konzentriert sich auf die Grundlagen der Animation mit Arduino und einem 16 x 2 LCD. Dieses Projekt kann jedoch auch auf LCDs anderer Abmessungen erweitert werden.

Zuerst beginnen wir mit der Verkabelung des LCDs mit dem Arduino, dann mit dem einfachen Drucken einer Nachricht auf dem LCD. Dann gehen wir zur Animation über.

LCD-Verkabelung

Dies ist die Schaltung wie oben schematisch dargestellt.

LCD-PIN

1:VSS:an die positive Schiene des Steckbretts (befestige auch 5 V von Arduino an der positiven Schiene)

2:VDD:an die negative Schiene des Steckbretts (befestige auch hier GND von Arduino)

3:VO (Kontrast):zum Schleifer des Potentiometers (befestigen Sie die seitlichen Klemmen des Potentiometers an positive und negative Schienen)

4:RS (Registerauswahl):zum Arduino-Pin 12

5:R/W(read-write):zu negativer Schiene

6:E (aktivieren):zum Arduino-Pin 11

15:A (Anode):an positive Schiene mit 220 Ohm Widerstand

16:K(Kathode):zu negativer Schiene

Wir werden derzeit keinen Daten-Pin anhängen.

Schalten Sie den Strom ein und wenn die untere Reihe aufleuchtet, funktioniert Ihr LCD. Sie müssen dies testen, bevor Sie etwas anderes tun.

Wenn das LCD nicht aufleuchtet, überprüfen Sie Ihre Lötung, Verkabelung (erneut überprüfen) und wenn es immer noch nicht aufleuchtet, ist es sehr wahrscheinlich, dass Ihr LCD beschädigt ist, also müssen Sie es ersetzen.

Wenn Ihr LCD funktioniert, Bravo! Sie haben den ersten Teil dieses Tutorials abgeschlossen.

Verbinden Sie danach die Daten-Pins:

11:D4 (Daten-Pin 4):zum Arduino-Pin 4

12:D5:an Arduino-Pin 5

13:D6:zum Arduino-Pin 6

14:D7:an Arduino-Pin 7

Nach diesem Beispielcode hochladen

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

Wenn Sie nach dem Hochladen zufällige Zeichen oder gar nichts sehen, überprüfen Sie Ihren Kontrast (Drehen Sie das Potentiometer nach oben und unten), überprüfen Sie Ihr Stiftlöten (Datenstifte sollten NICHT auch nur geringfügig miteinander verbunden sein) und schließlich Ihre Schaltung und Leitung 2 in den Beispielcode (stellen Sie sicher, dass die für LiquidCrystal bereitgestellten Pin-Nummern mit denen in Ihrer Schaltung übereinstimmen.

Wenn immer noch nichts passiert, verlieren Sie nicht die Hoffnung, wenn Sie im ersten Teil die untere Reihe aufleuchten sehen, bedeutet dies, dass Ihr LCD-Bildschirm in Ordnung ist. Spielen Sie mit der Schaltung und dem Löten herum, bis es funktioniert.

Wenn Sie die Meldung "Working" sehen, haben Sie Ihr LCD erfolgreich verkabelt und den zweiten Teil dieses Tutorials abgeschlossen. Lassen Sie Ihre Schaltung so, wie sie ist, wir werden uns nicht mehr damit anlegen, alles, was wir jetzt tun müssen, ist die Software.

Erklärung des Codes in Teil2

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

Diese Zeile deklariert ein LCD-Objekt mit Schnittstellenpins, wie in den Argumenten angegeben. Jetzt werden alle Ihre LCD-Schnittstellen über dieses 'lcd'-Objekt ausgeführt. (Beachten Sie, dass Sie dies beliebig benennen können, aber diesen Namen durchgehend beibehalten).

lcd.begin(16,2);

Diese Zeile erklärt, dass unser LCD-Bildschirm die Abmessungen von 16 Spalten und 2 Zeilen hat. Beachten Sie, dass Ihr LCD möglicherweise nicht 16 x 2 groß ist, passen Sie die Zahlen entsprechend an.

lcd.setCursor(0,1);

Diese Zeile setzt den Cursor auf die erste Spalte und die zweite Zeile (da das Zählen in C++ mit 0 und nicht mit 1 beginnt!). Beachten Sie, dass Sie den Cursor nicht sehen können, aber der Cursor ist immer da, er fixiert die Stelle, an der das nächste Zeichen erscheint.

lcd.print("Willkommen");

In dieser Zeile wird die Nachricht Willkommen an der Stelle gedruckt, auf die der Cursor zeigt, dh 0 Spalten 1 Zeilen.

Scrollender Text

Nun, wir haben eine Nachricht auf den Bildschirm gedruckt, aber es ist nicht sehr attraktiv, auf dieselbe Nachricht zu starren, außerdem erfüllt sie keinen Zweck. Daher werden wir in diesem Abschnitt eine Nachricht drucken, die wie in den Werbetafeln von rechts nach links scrollt. Nur die Funktionen setup() und loop() werden sich unterscheiden, daher zeige ich nur diese Funktionen, der Rest bleibt gleich.

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); wenn (n<0) {ptr++; } lcd.print (ptr); n--;verzögerung(250);}} 

Beachten Sie, dass Sie zum Verständnis dieses Codes ziemlich gute Kenntnisse der Zeiger in C und C++ benötigen, da die Arduino-Sprache wirklich nur AVR-C++ ist, nur leicht verarbeitet.

In der Schleifenfunktion definieren wir Ihre Nachricht als konstanten String.

lcd.clear() wird verwendet, um den Bildschirm für jede Iteration zu leeren.

Dann setzen wir einen Zeiger ptr auf die Adresse der Nachricht. Dieser Zeigerwert wird inkrementiert, damit die Nachricht auch dann in das LCD-Fenster passt, wenn die Zeichen nach links aus dem Blickfeld geraten. Wir tun dies für die linke Extremität und nicht für die rechte, da die LiquidCrystal-Bibliothek dies für die rechte Extremität (Text-Scrollen) verarbeiten kann, jedoch keine negativen Spaltenadressen verarbeiten kann, wie es für unser Programm erforderlich ist.

Dann haben wir eine while-Schleife, die die Nachricht an verschiedenen Stellen von links nach rechts anzeigt und so die Illusion vermittelt, dass sich der Text bewegt. Beachten Sie, dass das delay() am Ende sicherstellen soll, dass wir den Text lesen können und er nicht mit unleserlicher Geschwindigkeit von rechts nach links saust. Wenn die Animation zu langsam oder zu schnell erscheint, können Sie den Verzögerungswert ändern.

Benutzerdefinierte Charaktere

Bei allen Verwendungen der Funktion lcd.print() können wir beispielsweise keinen Dinosaurier auf dem LCD-Bildschirm anzeigen. Wir können dies jedoch mit einer Funktion der LiquidCrystal-Bibliothek namens Custom Characters tun.

Dazu definieren wir ein Datenbyte, das 1s für alle eingeschalteten Pixel und 0s für alle ausgeschalteten Pixel enthält, wie folgt:

Byte-Dino[]={B01110, B01110, B01100, B01111, B11101, B01010, B01010, B01010} 

Dies ist ein benutzerdefinierter Charakter, der einen Dinosaurier auf dem LCD-Bildschirm anzeigt. Hier kannst du deine eigenen Charaktere erstellen:https://maxpromer.github.io/LCD-Character-Creator/

Danach müssen wir sie anzeigen. Diese Zeichen können jedoch nicht mit der normalen lcd.print-Methode angezeigt werden; Wir müssen dies verwenden:

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

Mit diesem Code erstellen wir ein benutzerdefiniertes adressierbares Zeichen aus unserem früher definierten Dino[]-Byte. Die Adresse unseres benutzerdefinierten Charakters wird von der Methode lcd.createChar() angegeben, die den Charakter 0 als Dino[] definiert. Wir bezeichnen dieses Zeichen dann als byte(0), das die Adresse unseres benutzerdefinierten Zeichens zurückgibt, und drucken es schließlich mit der Methode lcd.Write() auf dem Bildschirm aus.

Pfeile schießen

Dieses Programm wird Ihnen schließlich beibringen, wie Sie mit LCD-Bildschirmen animieren. Lesen Sie dies sorgfältig.

#include LiquidCrystal lcd(12,11,4,5,6,7);byte Pfeilspitze[]={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);}} 

Hier verwenden wir drei benutzerdefinierte Zeichen, um einen Pfeil zu simulieren. Der Rest ist dir bekannt. Während Sie dies auf Ihrem LCD ausführen, bemerken Sie möglicherweise eine Spur hinter dem Pfeilschwanz, die ihn länger aussehen lässt, als er ist. Keine Sorge, es ist nur der Rest der früheren Pfeilposition.

Das ist es! Sie haben Ihre erste Animation mit Arduino und LCDs abgeschlossen! Spielen Sie mit dem Code herum und kombinieren Sie ihn mit Tasteneingaben, um daraus ein vollwertiges Spiel zu machen!

LCD-Spiel

Endlich können wir ein Spiel machen! In diesem Tutorial werde ich jedoch nicht mit einem sehr komplizierten Spiel beginnen, sondern einem sehr einfachen Spiel, das den frühen Arcade-Spielen sehr ähnlich ist.

Ziel dieses Spiels

Bevor wir das Spiel starten, müssen wir uns ein Ziel für das Gameplay überlegen.

In diesem Spiel ist das Ziel wie folgt:

Da ist der Held, eine Person in Reihe 1 (beachten Sie, dass die erste Reihe Reihe 0) ist (normalerweise), auf die eine Reihe von Pfeilen abgefeuert wird. Wird der Held getroffen, ist das Spiel vorbei. Der Held wird den Pfeilen ausweichen, indem er zu Reihe 0 springt, die wir mit einem Knopf manipulieren werden. (Knopf drücken=Reihe 0 nicht=Reihe1). Die Punktzahl wird pro Schleife erhöht und in der rechten Ecke angezeigt.

Dies ist eigentlich eine Erweiterung der Animation der Eariler-Pfeile, daher werde ich nur die Teile aufnehmen, die sich geändert haben.

byte man[] ={ B01110, B01110, B00100, B01110, B10101, B00100, B01010, B10001};void setup() { // die Anzahl der Spalten und Zeilen des LCDs einstellen:lcd.createChar( 0, Pfeilspitze); lcd.createChar(1,Pfeilkörper); lcd.createChar(2,Pfeilschwanz); lcd.createChar(3,mann); lcd.begin(16, 2); attachInterrupt(0,buttonin,CHANGE); randomSeed (analogRead (A0)); // Eine Nachricht auf dem LCD ausgeben. //lcd.print("hallo, world!");} int n;void loop() { // setze den Cursor auf Spalte 0, Zeile 1 // (Hinweis:Zeile 1 ist die zweite Zeile, da das Zählen mit beginnt 0)://lcd.setCursor(0, 1); // die Anzahl der Sekunden seit dem Zurücksetzen ausgeben://lcd.print(millis() / 1000); n =15; int rnd; rnd=zufällig(15,25); while(n!=-1){lcd.clear(); Verzögerung(10); Zeichner(); lcd.setCursor(n,1); if(n==1){ if(level==1){ stopgame(); Fortfahren; } } lcd.write (byte (0)); lcd.write(byte(1)); lcd.write (byte (2)); lcd.setCursor(10,0); lcd.print (Score); Verzögerung (100-Rnd); n--; Punktzahl++; if(level==0) punktzahl--; }}void drawman () {lcd.setCursor (1, Level); lcd.write (byte (3));}void buttonin () { if (digitalRead (2) ==LOW) { level =0; aufrechtzuerhalten. Sonst { Ebene =1; }} Stoppspiel ungültig () {lcd.clear (); lcd.setCursor(0,0); lcd.print("Spiel vorbei"); lcd.setCursor(10,0); lcd.print (Score); Stufe=1; Punktzahl =0; n =15; Verzögerung (3000); zurück;} 

Nicht der gesamte Code dreht sich um das LCD, aber ALLES ist wichtig für die Spieleentwicklung.

Wir beginnen mit der Charakterdefinition von man[], die das Byte für das Man-Charakter (unseren Helden) speichert. Dann haben wir die Setup-Funktion, bei der sich nur zwei Zeilen geändert haben. Beide Linien repräsentieren nur einen Teil der riesigen Gruppe, unter die sie fallen, nämlich Interrupts und Zufallszahlen. Beides sind sehr nützliche Annehmlichkeiten, weitere Informationen dazu finden Sie auf der Website arduino.cc.

Zuerst haben wir die Funktion attachInterrupt. Beachten Sie, dass die Definition, die ich geben werde, nicht sehr umfassend ist, aber eine kurze ist notwendig, um zu verstehen, was hier vor sich geht.

Interrupts sind Funktionen, die beim Eintreten eines Ereignisses aufgerufen werden können, EGAL, WO DIE AUSFÜHRUNG stattfindet. Dies ist eine wichtige Tatsache, die für die Implementierung von Echtzeit-Eingabefunktionen nützlich ist. Hier verwenden wir es, um sicherzustellen, dass wir unabhängig davon, an welcher Stelle der Ausführung die Schaltfläche gedrückt wird, die entsprechende Aktion ausführen (zumindest das Programm).

Syntax für attachInterrupt:

attachInterrupt(pin_number-2,function_to_call_ohne_parenthesis,condition_for_calling);

CHANGE ist ein #define-Wert, der verwendet wird, um anzuzeigen, dass bei jeder Zustandsänderung in der pin_number-Eingabe die angehängte Funktion aufgerufen wird.

Dann haben wir eine Zufallszahl. Eine herausragende Eigenschaft, die physische Prozessoren wie der Arduino besitzen, die normale Prozessoren nicht haben, ist, dass eine vom Arduino generierte Zufallszahl wirklich ist zufällig als analoges Rauschen an Pin A0 wenn Pin A0 ist schwebend (d. h. nicht verbunden) ist zufällig, wie von der Quantenphysik vorhergesagt (mehr oder weniger).

randomSeed wird verwendet, um den Seed für den Zufallsprozess zu setzen. random() ist eine Funktion mit den Parametern MIN,MAX oder MAX nur um die nächste Zufallszahl in der Sequenz zu erhalten.

Dann haben wir die Interrupt-Funktion buttonin(), die überprüft, ob die Taste gedrückt (LOW) oder nicht gedrückt (HIGH) ist und die Stufe (Reihe) unseres Helden entsprechend ändert.

Das war's, wir haben ein voll funktionsfähiges Spiel!!

Code

• Code für Animation
• Code für das Spiel

Code für AnimationArduino

// fügen Sie den Bibliothekscode ein:#include // Initialisieren Sie die Bibliothek, indem Sie alle benötigten LCD-Schnittstellenpins// mit der Arduino-Pinnummer verknüpfen, mit der sie verbunden ist const int rs =12, en =11, d4 =4, d5 =5, d6 =6, d7 =7;LiquidCrystal lcd(rs, en, d4, d5, d6, d7);byte Pfeilspitze[]={ B00001, B00011, B00111, B01111, B00111, B00011, B00001 , B00000};Byte Pfeilkörper[]={ B00000, B00000, B00000, B11111, B11111, B00000, B00000, B00000};Byte Pfeilschwanz[]={ B00011, B00111, B11111, B11111, B11111, B00111, B00011, B00000}; byte man[] ={ B01110, B01110, B00100, B01110, B10101, B00100, B01010, B10001};void setup () { // die Anzahl der Spalten und Zeilen des LCDs einstellen:lcd.createChar (0,arrowhead); lcd.createChar(1,Pfeilkörper); lcd.createChar(2,Pfeilschwanz); lcd.createChar(3,mann); lcd.begin(16, 2); // Eine Nachricht auf dem LCD ausgeben. //lcd.print("hallo, world!");}void loop() { // setze den Cursor auf Spalte 0, Zeile 1 // (Hinweis:Zeile 1 ist die zweite Zeile, da das Zählen bei 0 beginnt)://lcd.setCursor (0, 1); // die Anzahl der Sekunden seit dem Zurücksetzen ausgeben://lcd.print(millis() / 1000); int n; n =15; while(n!=-1){lcd.clear(); Verzögerung(10); lcd.setCursor(0,0); lcd.print("von Debanshu Das"); /* lcd.setCursor(1,1); lcd.write (byte (3)); lcd.setCursor(n,1); lcd.write (byte (0)); lcd.write(byte(1)); lcd.write(byte(2));*/ delay(65); n--; }}

Code für SpielArduino

// fügen Sie den Bibliothekscode ein:#include // Initialisieren Sie die Bibliothek, indem Sie alle benötigten LCD-Schnittstellenpins// mit der Arduino-Pinnummer verknüpfen, mit der sie verbunden ist 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};Byte Pfeilkörper[]={ B00000, B00000, B00000, B11111, B11111, B00000, B00000, B00000};Byte Pfeilschwanz[]={ B00011, B00111, B11111, B11111 , B11111, B00111, B00011, B00000};byte man[] ={ B01110, B01110, B00100, B01110, B10101, B00100, B01010, B10001};void setup() { // die Anzahl der Spalten und Zeilen des LCD einstellen:lcd.createChar(0,Pfeilspitze); lcd.createChar(1,Pfeilkörper); lcd.createChar(2,Pfeilschwanz); lcd.createChar(3,mann); lcd.begin(16, 2); attachInterrupt(0,buttonin,CHANGE); randomSeed (analogRead (A0)); // Eine Nachricht auf dem LCD ausgeben. //lcd.print("hallo, world!");} int n;void loop() { // setze den Cursor auf Spalte 0, Zeile 1 // (Hinweis:Zeile 1 ist die zweite Zeile, da das Zählen mit beginnt 0)://lcd.setCursor(0, 1); // die Anzahl der Sekunden seit dem Zurücksetzen ausgeben://lcd.print(millis() / 1000); n =15; int rnd; rnd=zufällig(15,25); while(n!=-1){lcd.clear(); Verzögerung(10); Zeichner(); lcd.setCursor(n,1); if(n==1){ if(level==1){ stopgame(); Fortfahren; } } lcd.write (byte (0)); lcd.write(byte(1)); lcd.write (byte (2)); lcd.setCursor(10,0); lcd.print (Score); Verzögerung (100-Rnd); n--; Punktzahl++; if(level==0) punktzahl--; }}void drawman () {lcd.setCursor (1, Level); lcd.write (byte (3));}void buttonin () { if (digitalRead (2) ==LOW) { level =0; aufrechtzuerhalten. Sonst { Ebene =1; }} Stoppspiel ungültig () {lcd.clear (); lcd.setCursor(0,0); lcd.print("Spiel vorbei"); lcd.setCursor(10,0); lcd.print (Score); Stufe=1; Punktzahl =0; n =15; Verzögerung (3000); zurück;}

Schaltpläne