Arduino - Klavierfliesen - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:20

Hallo Internet-Leute, hier wird es darum gehen, was DEFINITIV keine Abzocke eines Handyspiels auf einem arduino uno r3 ist.

Um zu beginnen, benötigen Sie alle Teile, die wie folgt sind! 1x Arduino Uno r3 ($ 42)

2x LCD-Tastaturschild (jeweils 19 US-Dollar)

5x Tasten

5x 220Ω Widerstände

28x Drähte

Alles klar, sobald Sie alle Teile haben, können Sie loslegen!

Schritt 1: Verkabelung

Beginnen Sie damit, Ihr Arduino und Ihre Freunde wie in der Abbildung gezeigt zu verdrahten.

Stellen Sie sicher, dass die Tasten richtig herum verbunden sind, mit den A0-4-Slots auf der Bodenseite der Tastenschienen, oder das Arduino denkt stattdessen, dass die Tasten ständig gedrückt werden, anstatt nur beim Drücken.

Schritt 2: Erklärungserklärungen

Der gesamte Code hier sollte vor Ihrem void setup und void loop stehen, da all diese Variablen und Objekte in mehreren der Funktionen verwendet werden, die wir einrichten werden.

Beginnen Sie mit dem Setzen:

#enthalten

Am Anfang Ihres Codes weist das Arduino an, die Bibliothek "LiquidCrystal.h" und die Funktionen, die dazu gehören, zu verwenden.

Der nächste Schritt besteht darin, die Pins zu definieren, die wir für unsere Schaltflächen verwenden, indem Sie diesen Code unter unserem #include einfügen:

#define btnEnter A0#define btn1 15 #define btn2 16 #define btn3 17 #define btn4 18

Wir definieren die Begriffe btnEnter und btn1 bis btn 4, um den Code für uns leichter lesbar zu machen oder bei Bedarf zu ändern. Dies bedeutet, dass das Arduino, wenn wir btn1 eingeben, weiß, dass wir tatsächlich die Taste 15 meinen. Obwohl wir die Ports Port 15, 16, 17 und 18 nennen, sind sie auf dem Arduino als A1 A2 A3 und A4 gekennzeichnet, weil Dies sind Ports, die speziell für analoge Eingänge verwendet werden, obwohl wir sie nur für digitale Eingänge verwenden.

Als nächstes werden wir die Objekte erstellen, die die Flüssigkristallanzeigen steuern. Um dies zu tun, setzen Sie diesen Code unter unsere Definitionen

LiquidCrystal lcdLeft(8, 9, 12, 10, 11, 13);LiquidCrystal lcdRight(2, 3, 4, 5, 6, 7);

Dies sagt dem Arduino, dass wir beim Aufruf von lcdLeft oder lcdRight auf ein LiquidCrystal-Objekt verweisen. Die Zahlen in den angehängten Klammern teilen dem Arduino mit, welche Ports das Objekt verwenden soll, um Nachrichten an das LCD zu senden, wenn wir ihre Funktionen verwenden.

Jetzt müssen wir die Variablen deklarieren, indem wir den nächsten Code unter die Objektdeklarationen einfügen:

//Diese Variablen sind Optionen, die Sie ändern können - höhere Zahlen = schnellere Spielgeschwindigkeit upint intGameSpeedEasy = 10; int intGameSpeedMedium = 25; int intGameSpeedHard = 80;

// Variablen für das Gameboolean einrichten bolPlay; // verfolgt, ob der Spieler int intScore; // verfolgt die Punktzahl des Spielers int intDiff; //nur eine ästhetische Sache, um zu sagen, auf welchem Schwierigkeitsgrad das Spiel ist //setze Variablen für die Eingabe ein int intEnter; // verfolgt, ob der Benutzer die Eingabetaste drückt int intInput; // verfolgt, welche Tasten der Benutzer drückt boolean bolTilePressed; // Stellen Sie sicher, dass der Spieler nicht versehentlich 5x eine Taste drückt und verliert // Variablen für Turn einrichten int intTick; // zählt Millis hoch (pro Schleife) bis intDelay int intDelay; // die Zeit, die das Programm bis zur nächsten Runde wartet in Millisekunden int intGameSpeed; // einige Debug-Optionen boolean bolSerialBoard; // Wenn wahr, wird die Platine im seriellen Monitor gedruckt

Wir deklarieren eine Variable, indem wir den Datentyp und dann den Namen der Variablen angeben, z. int thisIsAnInteger

Boolesche Variablen wie bolSerialBoard und bolPlay können nur einen von zwei Werten haben, true oder false.

Integer-Variablen (int) wie intScore und intInput können ganze Zahlen als Werte annehmen, z. B. 1, 5 oder 100.

Einige andere bemerkenswerte Datentypen, die wir hier nicht verwenden, sind ein String, bei dem es sich um einen Textblock handelt, und ein Float, bei dem es sich um eine Dezimalzahl handelt.

Jede der Variablen hier wird an verschiedenen Stellen vom Programm verwendet, hier ist eine Zusammenfassung dessen, was jede einzelne macht

bolPlay teilt dem Programm mit, ob das Menü angezeigt werden soll oder das eigentliche Spiel laufen soll.

intScore verfolgt die Punktzahl des Spielers, wenn er Kacheln trifft, intDiff wird im Hauptmenü verwendet, um dem Programm mitzuteilen, welcher Text auf den LCDs gedruckt werden soll.

intEnter wird verwendet, um dem Programm mitzuteilen, ob die Eingabetaste (ganz links) gedrückt wird, IntInput wird verwendet, um dem Programm mitzuteilen, welche der anderen 4 Tasten gedrückt wird.

bolTilePressed wird verwendet, um sicherzustellen, dass das Programm nur dann weiterliest, wenn die Taste gedrückt wird und nicht, wenn sie gedrückt gehalten wird.

IntGameSpeed, intGameSpeedEasy, intGameSpeedMedium und intGameSpeedHard werden verwendet, um zu steuern, wie schnell das Spiel je nach gewähltem Schwierigkeitsgrad beschleunigt werden soll.

intTick und intDelay werden verwendet, um das Programm daran zu hindern, das Board bei jeder Schleife zu verschieben.

bolSerialBoard wird verwendet, damit das Programm das Board zu Testzwecken als eine Reihe von Zahlen an den seriellen Monitor des Arduino senden kann.

Schließlich ist es an der Zeit, unser Board mit diesem Code als Array zu deklarieren:

// Spiel einrichten arrayint arrGame[16][4] = { {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0} };

Ein Array ist eine Matrix, bei der jeder Punkt, an dem mathematisch aufgerufen oder geändert werden kann, aufgerufen werden kann.

Ihr Code sollte jetzt ungefähr so aussehen;

// Bibliotheken einbinden#include

//Diese Variablen sind Optionen, die Sie ändern können - höhere Zahlen = schnellere Spielgeschwindigkeit

int intGameSpeedEasy = 10; int intGameSpeedMedium = 25; int intGameSpeedHard = 80;

// Pins definieren

#define btnEnter A0 #define btn1 15 #define btn2 16 #define btn3 17 #define btn4 18

// LCD-Objekte erstellen (n, ~, n, ~, ~, n)

LiquidCrystal lcdLeft(8, 9, 12, 10, 11, 13); Flüssigkristallanzeige rechts (2, 3, 4, 5, 6, 7);

// Spiel-Array einrichten

int arrGame[16][4] = { {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0} };

// Variablen für das Spiel einrichten

boolesches bolPlay; // verfolgt, ob der Spieler int intScore; // verfolgt die Punktzahl des Spielers int intDiff; //nur eine ästhetische Sache, um zu sagen, auf welchem Schwierigkeitsgrad das Spiel ist

// Variablen für die Eingabe einrichten

int intEnter; // verfolgt, ob der Benutzer die Eingabetaste drückt int intInput; // verfolgt, welche Tasten der Benutzer drückt boolean bolTilePressed; // Stellen Sie sicher, dass der Spieler nicht aus Versehen eine Taste 5x drückt und verliert

// Variablen für Turn einrichten

int intTick; // zählt Millis hoch (pro Schleife) bis intDelay int intDelay; // die Zeit, die das Programm bis zur nächsten Runde wartet in Millisekunden int intGameSpeed;

//ein bisschen Debug-Optionen

boolescher Wert bolSerialBoard; // Wenn wahr, wird die Platine im seriellen Monitor gedruckt

Schritt 3: Die Setup-Funktion

Die Setup-Schleife ist eine Funktion, die vom Arduino nur einmal beim ersten Start gelesen wird.

In der Setup-Schleife setzen wir nur die Werte einiger unserer Variablen, denn anstatt ihnen bei der Deklaration einen Wert zu setzen, tun wir dies hier.

Beginnen Sie damit, diesen Code in Ihr Void-Setup einzugeben.

bolPlay = false;intScore = 0; intTick = 0; intVerzögerung = 1000; intDiff = 1; intGameSpeed = intGameSpeedMedium;

Jede Zeile setzt nur eine Variable auf einen Wert.

bolPlay ist auf false gesetzt, damit das Spiel nicht gestartet wird.

intScore wird auf 0 gesetzt, da Ihre Punktzahl natürlich bei 0 beginnt.

intTick beginnt bei 0, da das Programm derzeit nichts zählt.

intDelay ist auf 1000 gesetzt, da dies die Rate ist, mit der die Kacheln beginnen.

intDiff ist nur eine asketische Sache, damit das Programm weiß, was es für den Schwierigkeitsgrad des Spiels schreiben soll.

intGameSpeed ist auf intGameSpeedMedium eingestellt, d.h. es ist auf mittlerer Schwierigkeitsgrad eingestellt.

Als nächstes fügen Sie diesen Code in das Void-Setup unter dem Code ein, den Sie gerade eingegeben haben.

lcdLeft.begin(16, 2);lcdRight.begin(16, 2);

Serial.begin (9600);

Dies weist das Arduino an, über den seriellen Monitor mit dem Computer zu kommunizieren (sichtbar durch Klicken auf die Schaltfläche oben rechts in der Arduino-IDE).

Ihr Void-Setup sollte jetzt ungefähr so aussehen!

Void setup () { Serial.begin (9600); // den seriellen Monitor starten // die Variablen einrichten bolPlay = false; intScore = 0; intTick = 0; intVerzögerung = 1000; intDiff = 1; intGameSpeed = intGameSpeedMedium; // lcds lcdLeft.begin (16, 2) beginnen; lcdRight.begin(16, 2); }

Schritt 4: Die Loop-Funktion

Die Schleifenfunktion wird vom Arduino bei jeder Iteration des Arduino ausgeführt.

Kopieren Sie den folgenden Code in Ihre Void-Schleife.

Void Schleife () { Eingabe (); // auf Spieleingabe prüfen if (bolPlay == true) { if (intTick >= intDelay) {// prüfen, ob das Spiel eine Runde spielen oder weiter warten soll Serial.println("~~~~~~~ ~~"); // print, um anzuzeigen, dass das Board weitergeht //writeSerial(); // Wenn die Option aktiviert ist, schreibe das Board in serielle buttonsGame (); // Auf Spielereingaben prüfen playBoard (); // Verschiebe das Brett und füge eine neue Kachel hinzu clearLcd (); // Reinigen Sie die LCDs, bevor Sie drawBoard () zeichnen; // Zeichnen Sie die Platine auf den bottomCheck () des LCDs; intTick = 0; // IntTick zurücksetzen} else {buttonsGame(); // Auf Spielereingaben prüfen clearLcd (); // Reinigen Sie die LCDs, bevor Sie drawBoard () zeichnen; // Zeichnen Sie das Board auf den LCD-Bildschirm intTick = intTick + intGameSpeed; // zum Tick hinzufügen}} else { clearLcd(); // Reinigen Sie die LCDs vor dem Zeichnen von title (); // Titel- und Partiturinfo-Buttons anzeigenMenu (); // Spielereingabe lesen clearBoard (); // sicherstellen, dass das gesamte Board = 0} Verzögerung (10); // das Arduino um einen kurzen Moment verzögern}

Wenn bolPlay gleich true ist, bedeutet dies, dass das Spiel läuft und der gesamte Code für das Spiel ausgeführt werden sollte, aber wir möchten nur, dass das Board eine neue Kachel hinzufügt und nach unten bewegt, wenn intTick größer als unser intDelay ist. andernfalls möchten wir dem Benutzer weiterhin erlauben, eine Taste zu drücken, um eine Kachel zu treffen und intTick die Geschwindigkeit zu erhöhen.

Der größte Teil dieses Codes verwendet Funktionen, die wir noch erstellen müssen, und wir werden sie in den nächsten Schritten erstellen. Der Zweck dieser Funktionen ist wie folgt.

Input liest, welche Tasten der Benutzer gedrückt hat.

buttonsGame steuert, was die Tasten im Spiel und nicht im Menü tun

playBoard fügt dem Spielbrett eine neue Kachel hinzu und verschiebt dann alles auf dem Spielbrett um ein Feld nach unten

clearLCD reinigt die LCDs, um sicherzustellen, dass keine Geister hinter den Kacheln zurückbleiben

drawBoard durchläuft arrGame und druckt es auf die LCDs

clearBoard löscht das gesamte arrGame, wenn das Spiel nicht im Spiel ist

bottomCheck überprüft die Unterseite von arrGame auf eine Fehlerbedingung

title zeigt den Titel des Spiels und Informationen zum Spielstand an, wenn das Menü geöffnet ist

Das Schaltflächenmenü steuert, was die Benutzereingaben im Menü tun.

gameOver ist eine weitere Funktion, die hier jedoch nicht aufgerufen wird, da sie stattdessen in den Funktionen bottomCheck und buttonsGame aufgerufen wird.

Schritt 5: Die ClearLCD-Funktion

Um eine Funktion zu erstellen, fügen wir dies zunächst dem Code hinzu

Void Funktionsname () {

}

der "functionName" kann alles sein, solange er noch nicht existiert.

Kopieren Sie diesen Code in Ihr Programm:

Void clearLcd () { für (int i = 0; i <= 15; i++) { für (int ii = 0; ii <= 1; ii++) {lcdLeft.setCursor (i, ii); lcdLeft.write(" "); lcdRight.setCursor(i, ii); lcdRight.write(" "); } } }

Dies läuft durch das gesamte Array, indem 2 gezählte Schleifen verwendet werden, um jeden Punkt auf den LCDs zu durchlaufen und ein Leerzeichen zu schreiben.

Ohne auf nichts zurückgesetzt zu werden, behalten die LCDs alles, was zuvor geschrieben wurde

Schritt 6: Die DrawBoard-Funktion

kopiere diesen Code in dein Programm

Void drawBoard () { for (int i = 1; i <= 15; i++) {//Spalten 1 und 2 auf dem linken LCD zeichnen // wenn die Kachel = 0 nichts schreiben, = 1 "#" schreiben = 2 schreibe "@" lcdLeft.setCursor(i, 1); // auf die erste Spalte setzen (ganz links) if (arrGame[0] == 1) {lcdLeft.write("#");} if (arrGame[0] == 2) {lcdLeft.write("@");} lcdLeft.setCursor(i, 0); // auf die zweite Spalte setzen (Mitte links) if (arrGame[1] == 1) {lcdLeft.write("#");} if (arrGame[1] == 2) {lcdLeft.write("@");} lcdRight.setCursor(i, 1); //auf die dritte Spalte setzen (Mitte rechts) if (arrGame[2] == 1) {lcdRight.write("#");} if (arrGame[2] == 2) {lcdRight.write("@");} lcdRight.setCursor(i, 0); // auf die vierte Spalte setzen (ganz rechts) if (arrGame[3] == 1) {lcdRight.write("#");} if (arrGame[3] == 2) {lcdRight.schreiben("@");} } }

Dies verwendet eine Schleife, um durch jede Reihe des Boards zu gehen, es prüft dann, ob eine Spalte in der Reihe gleich 1 oder 2 ist, basierend darauf, dass es dann auf dem LCD entweder ein Hashtag für eine noch zu seinde Kachel druckt Hit oder ein @ für eine Hit-Kachel.

Schritt 7: Die PlayBoard-Funktion

Kopieren Sie diesen Code in Ihr Programm.

void playBoard() { for (int i = 0; i <= 3; i++){arrGame[0] = 0;} // lösche die oberste Zeile arrGame[0][random(0, 4)] = 1; // setze einen zufälligen Punkt in der oberen Reihe als Kachel für (int i = 15; i> = 1; i--) {// von der Unterseite des Boards nach oben arbeiten für (int ii = 0; ii <= 3; ii ++) {//für jede Spalte arrGame[ii] = arrGame[i - 1][ii]; } } }

Dieser Code beginnt damit, die gesamte obere Reihe auf 0 oder keine Kachel zu löschen, und setzt dann eine zufällige Kachel als 1 und nicht getroffene Kachel.

Es durchläuft dann eine gezählte Schleife in umgekehrter Reihenfolge, von 15 bis 1, wobei die Reihe gleich der Reihe darüber ist, wodurch sich das Board auf den LCDs nach unten bewegt

Schritt 8: Die ClearBoard-Funktion

Kopieren Sie diesen Code in Ihr Programm.

Void clearBoard () { // Tick- und Verzögerungswerte zurücksetzen IntTick = 0; intVerzögerung = 1000; // gehe durch das Brett und setze alles auf 0 für (int i = 0; i <= 15; i++){ for (int ii = 0; ii <= 3; ii++){ arrGame[ii] = 0; } } }

Dieser Code wird ausgeführt, wenn das Spiel nicht spielt, um sicherzustellen, dass das gesamte arrGame auf 0 oder keine Kacheln gesetzt ist, indem gezählte Schleifen verwendet werden, um das Array zu durchlaufen.

Der Code setzt auch die Werte von intDelay und intTick zurück.

Schritt 9: Die Titelfunktion

kopiere den folgenden Code in dein Programm

Void title () { // Titel auf LCD schreiben und Platz für Partitur lcdRight.setCursor (0, 0); lcdRight.write("Klavierkacheln"); lcdRight.setCursor(0, 1); lcdRight.write("Ergebnis: "); //konvertieren Sie die Partitur in einen String char strScore[3]; sprintf(strScore, "%d", intScore); // Punktzahl auf LCD anzeigen lcdRight.write (strScore); // füge den schwierigen lcdRight.setCursor (10, 1) hinzu; if (intDiff == 0) {lcdRight.write ("Einfach"); } if (intDiff == 1) {lcdRight.write ("Mittel"); aufrechtzuerhalten. Wenn (intDiff == 2) {lcdRight.write ("Hard"); } // Drücken Sie ein wenig Anweisung lcdLeft.setCursor (0, 0); lcdLeft.write("Drücken Sie die Eingabetaste"); lcdLeft.setCursor(0, 1); lcdLeft.write("zu Beginn!"); }

Dieser Code schreibt den Titel des Spiels und die Punktzahl auf die LCDs, indem er dem LCD mitteilt, wo er mit der Eingabe beginnen soll, mit LCD.setCursor und dann den String in LCD.write schreibt.

Hier wird auch eine neue Variable erstellt, strScore, die verwendet wird, um intScore mithilfe der sprintf-Funktion in einen string- oder char-Datentyp zu konvertieren.

IntDiff wird auch hier verwendet, basierend auf seinen Werten gibt es die verschiedenen Schwierigkeitsoptionen aus.

Schritt 10: Die ButtonsMenu-Funktion

füge den folgenden Code in dein Programm ein

Void buttonsMenu () {// Wenn die Eingabetaste gedrückt wird, starten Sie das Spiel und setzen Sie den Punktewert zurück if (intEnter == 1) {bolPlay = true; intScore = 0; playBoard(); drawBoard(); } // Wenn Taste 3 gedrückt wird, Debug-Option zum seriellen Drucken der Platine einschalten if (intInput == 3) { if (bolSerialBoard == false) { Serial.println ("Serial Board Active"); bolSerialBoard = true; } Else {Serial.println ("Serial Board Disabled"); bolSerialBoard = false; } } // Spielgeschwindigkeit auf leichte Schwierigkeit setzen, wenn (intInput == 0) {Serial.print ("Spiel auf einfach eingestellt ("); Serial.print (intGameSpeedEasy); Serial.println ("ms Beschleunigung)"); intDiff = 0; intGameSpeed = intGameSpeedEasy; } // Spielgeschwindigkeit auf mittlere Schwierigkeit einstellen, wenn (intInput == 1) {Serial.print ("Spiel auf Mittel gesetzt ("); Serial.print (intGameSpeedMedium); Serial.println ("ms Beschleunigung)"); intDiff = 1; intGameSpeed = intGameSpeedMedium; } // Spielgeschwindigkeit auf harte Schwierigkeit setzen, wenn (intInput == 2) {Serial.print ("Spiel auf hart gesetzt ("); Serial.print (intGameSpeedHard); Serial.println ("ms Beschleunigung)"); intDiff = 2; intGameSpeed = intGameSpeedHard; } }

Dieser Code wird nur ausgeführt, wenn bolPlay in der void-Schleife gleich false ist

Wenn intEnter auf 1 gesetzt ist, bedeutet dies, dass die Eingabetaste gedrückt wurde, wenn sie gedrückt wird, setzt das Programm bolPlay auf true und das Spiel beginnt.

Das Programm liest dann, was intInput gleich ist. wenn es gleich 0 ist, wird die erste Taste von links gedrückt, nach rechts bis 3. Wenn intInput gleich 4 ist, wird keine Taste gedrückt.

Wenn die Tasten 0-2 gedrückt werden, ändert das Spiel den Schwierigkeitsgrad und passt auch die Spielgeschwindigkeit an, was bedeutet, dass es schneller beschleunigt wird.

Wenn Taste 3 gedrückt wird, aktiviert oder deaktiviert das Spiel einen Debug-Modus, bei dem das gesamte Board im seriellen Monitor gedruckt wird, um beim Auffinden von Problemen im Programm zu helfen.

Schritt 11: Die ButtonsGame-Funktion

kopiere den folgenden Code in dein Programm

void buttonsGame(){ if (intInput != 4) { //wenn eine Taste gedrückt wird if (bolTilePressed == false){ //nur wenn bolTilePressed false ist Triggeraktion zum Prüfen einer Schaltfläche drücken bolTilePressed = true; // dann setze bolTilePressed auf true, um sicherzustellen, dass es nicht erneut fälschlicherweise ausgelöst wird int intLowestTile = 0; // auf die Kachel mit der niedrigsten Kachel gesetzt werden int intCheckedTile = 15; //um zu verfolgen, welche Kacheln überprüft wurden while (intLowestTile == 0) { //solange es auf nichts gesetzt ist, checke die Kacheln auf (int i = 0; i 100){ //solange wie int Verzögerung ist nicht kleiner als 100 intDelay = intDelay - 20; // einen Wert daraus nehmen}} else {Serial.println ("Falsche Taste gedrückt"); Spiel ist aus(); //sonst Spiel vorbei } } } } }

Der Code wird nur ausgeführt, wenn bolPlay in der void-Schleife gleich true ist.

Wie buttonMenu basierend auf dem Wert von intInput überprüft es, ob der Spieler eine Kachel getroffen oder verpasst hat.

Es tut dies, indem es arrGame von unten nach oben durchläuft, wobei eine while-Schleife verwendet wird, um zu suchen, welche Zeile mit einer nicht getroffenen Kachel die niedrigste ist. Es prüft dann, ob die Stelle in dieser Reihe, die der gedrückten Taste entspricht, ein nicht getroffenes Plättchen ist oder nicht Funktion, die wir noch erstellen müssen.

Diese Funktion verwendet auch die Variable bolTilePressed, indem sie auf true gesetzt wird, wenn eine Schaltfläche gedrückt wird, und auf false, wenn keine Schaltfläche gedrückt wird. Dies soll sicherstellen, dass der Benutzer das Spiel nicht versehentlich verliert, weil das Programm dachte, dass er den Knopf mehrmals gedrückt hat, als er ihn gedrückt hält.

Schritt 12: Die GameOver-Funktion

Kopieren Sie den folgenden Code in Ihr Programm

Void gameOver () { Serial.println ("Game Over!"); Serial.print ("Ihre Punktzahl war: "); Serial.println (intScore); Serial.print ("Ihre Geschwindigkeit war: "); Serial.println (intDelay); bolPlay = falsch; }

Dies wird entweder durch die Funktionen checkBottom oder buttonsGame ausgelöst und löst das Ende des Spiels aus, indem bolPlay auf false gesetzt wird.

Es druckt auch eine Nachricht in den seriellen Monitor für die Benutzerbewertung und die Geschwindigkeitskacheln wurden in Millisekunden hinzugefügt.

Schritt 13: Die Eingabefunktion

Kopieren Sie den folgenden Code in Ihr Programm.

Void input () { intEnter = digitalRead (btnEnter); // Eingabe lesen // lesen, welcher der anderen Eingänge oder wenn keiner auf 4 gesetzt ist if (digitalRead (btn1) == HIGH) {intInput = 0;} else { if (digitalRead (btn2) == HIGH) {intInput = 1;} else { if (digitalRead (btn3) == HIGH) {intInput = 2;} else { if (digitalRead (btn4) == HIGH) {intInput = 3;} else { intInput = 4; aufrechtzuerhalten. Serial.println (intInput); aufrechtzuerhalten. aufrechtzuerhalten. Else {// wenn keine Taste gedrückt wird Reset bolTilePressed bolTilePressed = false; } }

Dieser Code wird mit den Funktionen buttonsGame und buttonsMenu verwendet. basierend auf den Tasten, die der Benutzer gedrückt hat, setzt es den Wert von intInput, oder wenn keine Taste gedrückt wird, setzt es intInput gleich 4.

Wenn keine Taste gedrückt wird, wird hier bolTilePressed für die Funktion buttonsGame zurückgesetzt.

Es druckt auch eine Nachricht an den seriellen Monitor, auf dem die Taste gedrückt wird.

Schritt 14: Die BottomCheck-Funktion

Kopieren Sie den folgenden Code in Ihr Programm.

void bottomCheck() { for (int i = 0; i <= 3; i++) {//für die 4 Spalten if (arrGame[15] == 1){//wenn eine Kachel unten ist Serial.println("Kachel unten"); arrGame[15] = 2; drawBoard(); Verzögerung (400); arrGame[15] = 1; drawBoard(); Verzögerung (400); arrGame[15] = 2; drawBoard(); Verzögerung (400); arrGame[15] = 1; drawBoard(); Verzögerung (400); Spiel ist aus(); } } }

Mit einer Schleife überprüft dieser Code die untere Reihe von arrGame auf alle nicht getroffenen Kacheln (Kacheln gleich 1), wenn es eine nicht getroffene Kachel am unteren Bildschirmrand gibt, wird die Kachel blinken und dann die Game-Over-Funktion ausgelöst.

Schritt 15: Die WriteSerial-Funktion

kopiere den folgenden Code in dein Programm

Void writeSerial () { if (bolSerialBoard == true) { for (int i = 0; i <= 15; i ++) { for (int ii = 0; ii <= 3; ii++) {Serial.print (arrGame [ii]); Serial.print (", "); } Serial.println(""); } } }

Dies ist die Funktion, gefolgt von der Debug-Option, die in der Funktion buttonsMenu aktiviert werden kann. Wenn bolSerialBoard in dieser Funktion auf true gesetzt ist, durchläuft es arrGame und druckt das gesamte Board zu Testzwecken mithilfe eines Arrays in den seriellen Monitor.

Schritt 16: Abschluss

Ihr gesamter Code sollte nicht vollständig sein und etwa so aussehen!

/* * Name - Klavierkacheln; Arduino * Von - Domenic Marulli * Datum - 11/*

/ Bibliotheken einbinden

#enthalten

//Diese Variablen sind Optionen, die Sie ändern können - höhere Zahlen = schnellere Spielgeschwindigkeit

int intGameSpeedEasy = 10; int intGameSpeedMedium = 25; int intGameSpeedHard = 80;

// Pins definieren

#define btnEnter A0 #define btn1 15 #define btn2 16 #define btn3 17 #define btn4 18

// LCD-Objekte erstellen (n, ~, n, ~, ~, n)

LiquidCrystal lcdLeft(8, 9, 12, 10, 11, 13); Flüssigkristallanzeige rechts (2, 3, 4, 5, 6, 7);

// Spiel-Array einrichten

int arrGame[16][4] = { {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0} };

// Variablen für das Spiel einrichten

boolesches bolPlay; // verfolgt, ob der Spieler int intScore; // verfolgt die Punktzahl des Spielers int intDiff; //nur eine ästhetische Sache, um zu sagen, auf welchem Schwierigkeitsgrad das Spiel ist

// Variablen für die Eingabe einrichten

int intEnter; // verfolgt, ob der Benutzer die Eingabetaste drückt int intInput; // verfolgt, welche Tasten der Benutzer drückt boolean bolTilePressed; // Stellen Sie sicher, dass der Spieler nicht aus Versehen eine Taste 5x drückt und verliert

// Variablen für Turn einrichten

int intTick; // zählt Millis hoch (pro Schleife) bis intDelay int intDelay; // die Zeit, die das Programm bis zur nächsten Runde wartet in Millisekunden int intGameSpeed;

//ein bisschen Debug-Optionen

boolescher Wert bolSerialBoard; // Wenn wahr, wird die Platine im seriellen Monitor gedruckt

//das Setup, das einmal ausgeführt wird

Void setup () { Serial.begin (9600); // den seriellen Monitor starten // die Variablen einrichten bolPlay = false; intScore = 0; intTick = 0; intVerzögerung = 1000; intDiff = 1; intGameSpeed = intGameSpeedMedium; // lcds lcdLeft.begin (16, 2) beginnen; lcdRight.begin(16, 2); }

//die Schleife, die alle 10 Millisekunden ausgeführt wird

Void Schleife () { Eingabe (); // auf Spieleingabe prüfen if (bolPlay == true) { if (intTick >= intDelay) {// prüfen, ob das Spiel eine Runde spielen oder weiter warten soll Serial.println("~~~~~~~ ~~"); // print, um anzuzeigen, dass das Board weitergeht //writeSerial(); // Wenn die Option aktiviert ist, schreibe das Board in serielle buttonsGame (); // Auf Spielereingaben prüfen playBoard (); // Verschiebe das Brett und füge eine neue Kachel hinzu clearLcd (); // Reinigen Sie die LCDs, bevor Sie drawBoard () zeichnen; // Zeichnen Sie die Platine auf den bottomCheck () des LCDs; intTick = 0; // IntTick zurücksetzen} else {buttonsGame(); // Auf Spielereingaben prüfen clearLcd (); // Reinigen Sie die LCDs, bevor Sie drawBoard () zeichnen; // Zeichnen Sie das Board auf den LCD-Bildschirm intTick = intTick + intGameSpeed; // zum Tick hinzufügen}} else { clearLcd(); // Reinigen Sie die LCDs vor dem Zeichnen von title (); // Titel- und Partiturinfo-Buttons anzeigenMenu (); // Spielereingabe lesen clearBoard (); // sicherstellen, dass das gesamte Board = 0} Verzögerung (10); // das Arduino um einen kurzen Moment verzögern}

// reinigt das LCD, damit keine nicht eingegebenen Zellen dort bleiben

Void clearLcd () { für (int i = 0; i <= 15; i++) { für (int ii = 0; ii <= 1; ii++) {lcdLeft.setCursor (i, ii); lcdLeft.write(" "); lcdRight.setCursor(i, ii); lcdRight.write(" "); } } }

// zeichnet die Platine auf die LCDs

Void drawBoard () { for (int i = 1; i <= 15; i++) {//Spalten 1 und 2 auf dem linken LCD zeichnen // wenn die Kachel = 0 nichts schreiben, = 1 "#" schreiben = 2 schreibe "@" lcdLeft.setCursor(i, 1); // auf die erste Spalte setzen (ganz links) if (arrGame[0] == 1) {lcdLeft.write("#");} if (arrGame[0] == 2) {lcdLeft.write("@");} lcdLeft.setCursor(i, 0); // auf die zweite Spalte setzen (Mitte links) if (arrGame[1] == 1) {lcdLeft.write("#");} if (arrGame[1] == 2) {lcdLeft.write("@");} lcdRight.setCursor(i, 1); //auf die dritte Spalte setzen (Mitte rechts) if (arrGame[2] == 1) {lcdRight.write("#");} if (arrGame[2] == 2) {lcdRight.write("@");} lcdRight.setCursor(i, 0); // auf die vierte Spalte setzen (ganz rechts) if (arrGame[3] == 1) {lcdRight.write("#");} if (arrGame[3] == 2) {lcdRight.schreiben("@");} } }

//bewegt das Brett nach unten und platziert einen zufälligen Wert als Kachel

void playBoard() { for (int i = 0; i <= 3; i++){arrGame[0] = 0;} // lösche die oberste Zeile arrGame[0][random(0, 4)] = 1; // setze einen zufälligen Punkt in der oberen Reihe als Kachel für (int i = 15; i> = 1; i--) {// von der Unterseite des Boards nach oben arbeiten für (int ii = 0; ii <= 3; ii ++) {//für jede Spalte arrGame[ii] = arrGame[i - 1][ii]; } } }

// setzt das gesamte Board auf 0 und setzt die Variablen auf Pregame zurück

Void clearBoard () { // Tick- und Verzögerungswerte zurücksetzen IntTick = 0; intVerzögerung = 1000; // gehe durch das Brett und setze alles auf 0 für (int i = 0; i <= 15; i++){ for (int ii = 0; ii <= 3; ii++){ arrGame[ii] = 0; } } }

// zeigt das Hauptmenü auf den LCDs an

Void title () { // Titel auf LCD schreiben und Platz für Partitur lcdRight.setCursor (0, 0); lcdRight.write("Klavierkacheln"); lcdRight.setCursor(0, 1); lcdRight.write("Ergebnis: "); //konvertieren Sie die Partitur in einen String char strScore[3]; sprintf(strScore, "%d", intScore); // Punktzahl auf LCD anzeigen lcdRight.write (strScore); // füge den schwierigen lcdRight.setCursor (10, 1) hinzu; if (intDiff == 0) {lcdRight.write ("Einfach"); } if (intDiff == 1) {lcdRight.write ("Mittel"); aufrechtzuerhalten. Wenn (intDiff == 2) {lcdRight.write ("Hard"); } // Drücken Sie ein wenig Anweisung lcdLeft.setCursor (0, 0); lcdLeft.write("Drücken Sie die Eingabetaste"); lcdLeft.setCursor(0, 1); lcdLeft.write("zu Beginn!"); }

// überprüft die Schaltflächen und was für sie zu tun ist, wenn Sie nicht im Spiel sind

Void buttonsMenu () {// Wenn die Eingabetaste gedrückt wird, starten Sie das Spiel und setzen Sie den Punktewert zurück if (intEnter == 1) {bolPlay = true; intScore = 0; playBoard(); drawBoard(); } // Wenn Taste 3 gedrückt wird, Debug-Option zum seriellen Drucken der Platine einschalten if (intInput == 3) { if (bolSerialBoard == false) { Serial.println ("Serial Board Active"); bolSerialBoard = true; } Else {Serial.println ("Serial Board Disabled"); bolSerialBoard = false; } } // Spielgeschwindigkeit auf leichte Schwierigkeit setzen, wenn (intInput == 0) {Serial.print ("Spiel auf einfach eingestellt ("); Serial.print (intGameSpeedEasy); Serial.println ("ms Beschleunigung)"); intDiff = 0; intGameSpeed = intGameSpeedEasy; } // Spielgeschwindigkeit auf mittlere Schwierigkeit einstellen, wenn (intInput == 1) {Serial.print ("Spiel auf Mittel gesetzt ("); Serial.print (intGameSpeedMedium); Serial.println ("ms Beschleunigung)"); intDiff = 1; intGameSpeed = intGameSpeedMedium; } // Spielgeschwindigkeit auf harte Schwierigkeit setzen, wenn (intInput == 2) {Serial.print ("Spiel auf hart gesetzt ("); Serial.print (intGameSpeedHard); Serial.println ("ms Beschleunigung)"); intDiff = 2; intGameSpeed = intGameSpeedHard; } }

// überprüft die Tasten und was für sie im Spiel zu tun ist

void buttonsGame(){ if (intInput != 4) { //wenn eine Taste gedrückt wird if (bolTilePressed == false){ //nur wenn bolTilePressed false ist Triggeraktion zum Prüfen einer Schaltfläche drücken bolTilePressed = true; // dann setze bolTilePressed auf true, um sicherzustellen, dass es nicht erneut fälschlicherweise ausgelöst wird int intLowestTile = 0; // auf die Kachel mit der niedrigsten Kachel gesetzt werden int intCheckedTile = 15; //um zu verfolgen, welche Kacheln überprüft wurden while (intLowestTile == 0) { //solange es auf nichts gesetzt ist, checke die Kacheln auf (int i = 0; i 100){ //solange wie int Verzögerung ist nicht kleiner als 100 intDelay = intDelay - 20; // einen Wert daraus nehmen}} else {Serial.println ("Falsche Taste gedrückt"); Spiel ist aus(); //sonst Spiel vorbei } } } } }

void gameOver() {

Serial.println ("Spiel vorbei!"); Serial.print ("Ihre Punktzahl war: "); Serial.println (intScore); Serial.print ("Ihre Geschwindigkeit war: "); Serial.println (intDelay); bolPlay = falsch; }

// prüft auf Spielereingaben

Void input () { intEnter = digitalRead (btnEnter); // Eingabe lesen // lesen, welcher der anderen Eingänge oder wenn keiner auf 4 gesetzt ist if (digitalRead (btn1) == HIGH) {intInput = 0;} else { if (digitalRead (btn2) == HIGH) {intInput = 1;} else { if (digitalRead (btn3) == HIGH) {intInput = 2;} else { if (digitalRead (btn4) == HIGH) {intInput = 3;} else { intInput = 4; }}}} // serielle Ausgabe der Eingaben if (intEnter == 1) {Serial.println ("Enter Pressed!");} if (intInput!= 4) { Serial.print ("Button Press: "); Serial.println (intInput); aufrechtzuerhalten. aufrechtzuerhalten. Else {// wenn keine Taste gedrückt wird Reset bolTilePressed bolTilePressed = false; } }

// überprüft die Unterseite der Platine auf Fehler

void bottomCheck() { for (int i = 0; i <= 3; i++) {//für die 4 Spalten if (arrGame[15] == 1){//wenn eine Kachel unten ist Serial.println("Kachel unten"); arrSpiel[15] = 2; drawBoard(); Verzögerung (400); arrGame[15] = 1; drawBoard(); Verzögerung (400); arrGame[15] = 2; drawBoard(); Verzögerung (400); arrGame[15] = 1; drawBoard(); Verzögerung (400); Spiel ist aus(); } } }

// druckt das Board in den seriellen Monitor, wenn bolSerialBoard wahr ist

Void writeSerial () { if (bolSerialBoard == true) { for (int i = 0; i <= 15; i ++) { for (int ii = 0; ii <= 3; ii++) {Serial.print (arrGame [ii]); Serial.print (", "); } Serial.println(""); } } }

Sobald der gesamte Code eingegeben wurde, laden Sie ihn auf Ihr Arduino hoch und genießen Sie!