Arduino - Rajoles de piano: 16 passos (amb imatges)

2024 Autora: John Day | [email protected]. Última modificació: 2024-01-30 08:14

Hola gent d'Internet, es tractarà de com fer allò que DEFINITIVAMENT no és una estafa d'un joc per a mòbils en un arduino uno r3.

Així doncs, per començar, necessitareu totes les parts, que són les següents! 1x Arduino Uno r3 (42 dòlars)

Escut del teclat LCD 2x (19 dòlars cadascun)

Botons 5x

Resistències 5x 220Ω

28x cables

Molt bé, un cop teniu totes les parts, és hora de començar.

Pas 1: cablejat

Comenceu per connectar el vostre arduino i els vostres amics tal com es mostra al diagrama, Assegureu-vos que els botons estiguin enllaçats de la manera correcta, amb les ranures A0-4 a la part de terra dels rails del botó, o bé l’arduino pensarà que els botons es mantenen premuts constantment en lloc de fer-ho només en prémer.

Pas 2: declaracions de declaracions

Tot el codi aquí hauria d’anar abans de la configuració i el bucle de buit, ja que totes aquestes variables i objectes s’utilitzen en diverses de les funcions que configurarem.

Comenceu posant:

#incloure

a la part superior del codi, això indica a l'arduino que utilitzi la biblioteca "LiquidCrystal.h" i les funcions que en formen part.

El següent pas és definir els pins que estem utilitzant per als nostres botons posant aquest codi a sota del #include:

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

Definim els termes btnEnter i btn1 a btn 4 per facilitar-nos la lectura del codi o canviar-lo si cal. Vol dir que quan escrivim btn1, l'arduino sabrà que de fet volem dir el botó 15. Tot i que estem trucant als ports 15, 16, 17 i 18, els ports estan etiquetats a l'Arduino com a A1 A2 A3 i A4, això es deu al fet que són ports utilitzats específicament per a entrades analògiques, tot i que només els fem servir per a entrades digitals.

A continuació, crearem els objectes que controlaran les pantalles de cristall líquid. Per fer-ho, poseu aquest codi per sota de les nostres definicions

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

El que fa això és dir a l'arduino que quan anomenem lcdLeft o lcdRight ens referim a un objecte LiquidCrystal. Els números entre claudàtors adjunts indiquen a l'arduino quins ports hauria d'utilitzar l'objecte per enviar missatges a la pantalla LCD quan utilitzem les seves funcions.

Ara hem de declarar les variables posant el següent bit de codi a sota de les declaracions d'objecte:

// aquestes variables són opcions que podeu canviar: nombres més elevats = velocitat del joc més ràpida intGameSpeedEasy = 10; int intGameSpeedMedium = 25; int intGameSpeedHard = 80;

// configureu variables per al joc boloolic bolPlay; // fa un seguiment si el jugador int intScore; // fa un seguiment de la puntuació del jugador en intDiff; // només una cosa estètica per explicar quina dificultat té el joc // configurar variables per a l'entrada int intEnter; // fa un seguiment si l'usuari prem el botó d'intro int intInput; // fa un seguiment de quins botons prem l’usuari bolTilePressed booleà; // assegureu-vos que el jugador no prem accidentalment un botó 5x i perd // // configureu les variables per al gir int intTick; // compta milers (per bucle) fins a intDelay int intDelay; // l'hora en què el programa espera fins al següent torn en millis int intGameSpeed; // abit of debug options boolean bolSerialBoard; // quan true s'imprimirà la placa al monitor sèrie

Declarem una variable indicant el tipus de dades i el nom de la variable, per exemple. int thisIsAnInteger

Les variables booleanes, com ara bolSerialBoard i bolPlay, només poden tenir un dels dos valors, cert o fals.

La variable sencera (int) com intScore i intInput pot prendre nombres enters com a valors, com ara 1, 5 o 100.

Alguns altres tipus de dades notables que no fem servir aquí són una cadena, que és un tros de text, i un flotant, que és un nombre decimal.

Cadascuna de les variables aquí les utilitza el programa en diversos llocs, aquí teniu una sinopsi del que fan cadascuna

bolPlay indica al programa si s'ha de mostrar el menú o si s'hauria d'executar el joc real.

intScore fa un seguiment de la puntuació del jugador a mesura que toca fitxes, intDiff s'utilitza al menú principal per indicar al programa quina part de text s'ha d'imprimir a la pantalla LCD, intEnter s'utilitza per indicar al programa si es prem el botó d'inici (més a l'esquerra), intInput s'utilitza per indicar al programa quin dels altres 4 botons es prem.

bolTilePressed s’utilitza per assegurar-se que el programa només es llegeix quan es prem el botó i no quan es manté premut.

intGameSpeed, intGameSpeedEasy, intGameSpeedMedium i intGameSpeedHard s’utilitzen per controlar la rapidesa amb què el joc s’ha d’accelerar en funció de la dificultat seleccionada.

intTick i intDelay s'utilitzen per evitar que el programa mogui la placa cada cop que fa bucles.

bolSerialBoard s’utilitza per permetre que el programa enviï la placa al monitor serial de l’arduino com una sèrie de números amb finalitats de prova.

Finalment, és hora de declarar el nostre tauler com a matriu mitjançant aquest codi:

// configure game 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}};

Una matriu és una matriu que es pot demanar o canviar qualsevol punt sobre el qual es pugui fer matemàtiques.

El vostre codi ara hauria de ser semblant a això;

// inclou biblioteques # include

// aquestes variables són opcions que podeu canviar: números més alts = velocitat del joc més ràpida

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

// Definiu pins

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

// crear objectes LCD (n, ~, n, ~, ~, n)

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

// configura una matriu de jocs

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}};

// configureu variables per al joc

boolean bolPlay; // fa un seguiment si el jugador int intScore; // fa un seguiment de la puntuació del jugador a intDiff; // només una cosa estètica per dir a quina dificultat té el joc

// configurar variables per a l'entrada

int intEnter; // fa un seguiment si l'usuari prem el botó d'intro int intInput; // fa un seguiment de quins botons prem l’usuari bolTilePressed booleà; // assegureu-vos que el jugador no prem accidentalment un botó 5 vegades i perd

// configurar variables per torn

int intick; // compta milers (per bucle) fins a intDelay int intDelay; // l'hora en què el programa espera fins al següent torn en millis int intGameSpeed;

// àmbit d'opcions de depuració

bolSerialBoard booleà; // quan true s'imprimirà la placa al monitor sèrie

Pas 3: la funció de configuració

El bucle de configuració és una funció que llegeix l'arduino només una vegada quan s'inicia inicialment.

Al bucle de configuració només estem establint els valors d'algunes de les nostres variables perquè en lloc de definir-los un valor en declarar-les, ho fem aquí.

Comenceu introduint aquest codi a la configuració del buit.

bolPlay = false; intScore = 0; intTick = 0; intDelay = 1000; intDiff = 1; intGameSpeed = intGameSpeedMedium;

Cada línia només estableix una variable en un valor.

bolPlay es defineix com a fals perquè el joc no comenci a jugar.

intScore s'estableix a 0, perquè naturalment la vostra puntuació comença a 0.

intTick comença a 0 perquè el programa actualment no compta res.

intDelay s'estableix en 1000 perquè és la velocitat en què comencen les fitxes.

intDiff és només una cosa ascètica perquè el programa sàpiga què escriure per a la dificultat del joc.

intGameSpeed es defineix com sigui intGameSpeedMedium, és a dir, es defineix a la dificultat mitjana.

A continuació, poseu aquest codi a la configuració del buit, a sota del codi que acabeu d'introduir.

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

Serial.begin (9600);

Això indica a l'arduino que comenci a comunicar-se amb l'ordinador a través del monitor sèrie (visible fent clic al botó situat a la part superior dreta de l'IDE arduino).

La configuració del buit ara hauria de ser semblant a aquesta.

configuració nul·la () {Serial.begin (9600); // iniciar el monitor de sèrie // configurar les variables bolPlay = false; intScore = 0; intTick = 0; intDelay = 1000; intDiff = 1; intGameSpeed = intGameSpeedMedium; // comença lcdLeft.begin de lcd (16, 2); lcdRight.begin (16, 2); }

Pas 4: la funció de bucle

La funció de bucle és executada per l'arduino cada iteració de l'arduino.

Copieu el següent codi al vostre bucle de buit.

bucle buit () {entrada (); // comproveu si hi ha l'entrada de joc si (bolPlay == true) {if (intTick> = intDelay) {// comproveu si el joc hauria de fer un torn o continuar esperant Serial.println ("~~~~~~~ ~~ "); // imprimeix per significar que el tauler es mou en // writeSerial (); // si l'opció està habilitada escriviu el tauler als botons de sèrie Game (); // comprova si hi ha entrades del reproductor playBoard (); // mou el tauler i afegeix un nou mosaic clearLcd (); // netejar les pantalles LCD abans de dibuixar drawBoard (); // dibuixa el tauler a la part inferior del lcdCheck (); intTick = 0; // restableix intTick} else {botonsGame (); // comproveu les entrades del jugador clearLcd (); // netejar les pantalles LCD abans de dibuixar drawBoard (); // dibuixeu el tauler a l’intTick de lcd = intTick + intGameSpeed; // afegir a la marca}} else {clearLcd (); // netejar les pantalles LCD abans de dibuixar el títol (); // mostra els botons d'informació sobre el títol i la puntuació Menú (); // llegir l'entrada del reproductor clearBoard (); // assegureu-vos que tota la junta = 0} demora (10); // retardar l’arduino un breu moment}

quan bolPlay és igual a true significa que el joc està jugant i que s'hauria d'executar tot el codi per al moment en què es juga el joc, però només volem que el tauler afegeixi una nova fitxa i baixi quan intTick sigui superior al nostre intDelay, en cas contrari, volem permetre a l'usuari prémer un botó per colpejar un mosaic i que intTick augmenti la velocitat.

La majoria d’aquest codi utilitza funcions que encara hem de fer i les farem en els passos següents. L’objectiu d’aquestes funcions és el següent.

L’entrada llegeix quins botons ha premut l’usuari.

buttonsGame controla el que fan els botons quan es troba al joc i no al menú

playBoard afegeix una nova fitxa al tauler i, a continuació, mou tot el que hi ha al tauler per un espai

clearLCD neteja les pantalles LCD per assegurar-se que no quedi cap fantasma darrere de les rajoles

drawBoard passa per arrGame i l’imprimeix a les pantalles LCD

clearBoard esborra tot l'arrGame quan el joc no està en joc

bottomCheck comprova si hi ha cap condició d'error a la part inferior d'arrGame

title mostra la informació del títol i la puntuació del joc quan es troba al menú

El menú de botons controla el que fan les entrades de l'usuari quan es troba al menú.

gameOver és una altra funció, tot i que no s’anomena aquí, ja que es diu a les funcions bottomCheck i botonsGame.

Pas 5: la funció ClearLCD

per crear una funció, comencem afegint-la al codi

void functionName () {

}

el "nomFunció" pot ser qualsevol cosa, sempre que no existeixi.

Copieu aquest codi al programa:

void clearLcd () {for (int i = 0; i <= 15; i ++) {for (int ii = 0; ii <= 1; ii ++) {lcdLeft.setCursor (i, ii); lcdLeft.write (""); lcdRight.setCursor (i, ii); lcdRight.write (""); }}}

això passa per tota la matriu mitjançant l'ús de 2 bucles comptats per passar per cada punt de les pantalles LCD i escriure un espai.

Sense restablir-se a res, els LCD mantindran tot el que s'havia escrit anteriorment

Pas 6: la funció DrawBoard

copieu aquest codi al vostre programa

void drawBoard () {for (int i = 1; i <= 15; i ++) {// dibuixa collums 1 i 2 a la pantalla LCD esquerra // si el mosaic = 0 no escriu res, = 1 escriu "#", = 2 escriviu "@" lcdLeft.setCursor (i, 1); // estableix la primera columna (més a l'esquerra) if (arrGame [0] == 1) {lcdLeft.write ("#");} if (arrGame [0] == 2) {lcdLeft.write ("@");} lcdLeft.setCursor (i, 0); // estableix la segona columna (centre esquerra) if (arrGame [1] == 1) {lcdLeft.write ("#");} if (arrGame [1] == 2) {lcdLeft.write ("@");} lcdRight.setCursor (i, 1); // estableix la tercera columna (centre dreta) if (arrGame [2] == 1) {lcdRight.write ("#");} if (arrGame [2] == 2) {lcdRight.write ("@");} lcdRight.setCursor (i, 0); // estableix la quarta columna (més a la dreta) if (arrGame [3] == 1) {lcdRight.write ("#");} if (arrGame [3] == 2) {lcdRight.write ("@");}}}

això utilitza un bucle per recórrer cada fila del tauler, i després comprova si alguna columna de la fila és igual a 1 o 2, basant-se en que després imprimeix a la pantalla LCD un hashtag, perquè un mosaic encara no sigui hit o un @ per a un mosaic de hit.

Pas 7: la funció PlayBoard

copieu aquest codi al vostre programa.

void playBoard () {for (int i = 0; i <= 3; i ++) {arrGame [0] = 0;} // esborra la fila superior arrGame [0] [random (0, 4)] = 1; // definiu un punt aleatori a la fila superior perquè sigui un mosaic per a (int i = 15; i> = 1; i -) {// treballant des de la part inferior del tauler fins a la part superior per a (int ii = 0; ii <= 3; ii ++) {// per a cada coll arrGame [ii] = arrGame [i - 1] [ii]; }}}

aquest codi comença esborrant tota la fila superior a 0, o sense cap mosaic, i després defineix un mosaic aleatori com a 1 i sense mosaic.

A continuació, passa per un bucle comptat a la inversa, de 15 a 1, establint la fila igual a la fila que hi ha a sobre, fent que el tauler baixi per la pantalla LCD

Pas 8: la funció ClearBoard

copieu aquest codi al vostre programa.

void clearBoard () {// restableix els valors de tick i retard intTick = 0; intDelay = 1000; // passar pel tauler i establir-ho tot a 0 per (int i = 0; i <= 15; i ++) {per (int ii = 0; ii <= 3; ii ++) {arrGame [ii] = 0; }}}

Aquest codi s’executa quan el joc no s’està jugant per assegurar-se que tot arrGame estigui establert a 0, o que no hi hagi fitxes, mitjançant l’ús de bucles comptats per passar per la matriu.

El codi també restableix els valors d’intDelay i intTick.

Pas 9: la funció de títol

copieu el codi següent al vostre programa

void title () {// escriu el títol a la pantalla LCD i espai per a la puntuació lcdRight.setCursor (0, 0); lcdRight.write ("Rajoles de piano"); lcdRight.setCursor (0, 1); lcdRight.write ("Puntuació:"); // converteix la partitura en una cadena de caràcters strScore [3]; sprintf (strScore, "% d", intScore); // mostra la puntuació a LCD lcdRight.write (strScore); // afegiu el lcdRight.setCursor (10, 1); if (intDiff == 0) {lcdRight.write ("Fàcil"); } if (intDiff == 1) {lcdRight.write ("Mitjà"); } if (intDiff == 2) {lcdRight.write ("Difícil"); } // Premeu una mica la instrucció lcdLeft.setCursor (0, 0); lcdLeft.write ("Premeu Retorn"); lcdLeft.setCursor (0, 1); lcdLeft.write ("per començar!"); }

Aquest codi escriu el títol del joc i la puntuació a les pantalles LCD, ho fa indicant a la pantalla LCD on començar a escriure mitjançant LCD.setCursor i després escrivint la cadena a LCD.write.

Aquí també es crea una nova variable, strScore, que s’utilitza per convertir intScore en una cadena o tipus de dades char mitjançant la funció sprintf.

aquí també s'utilitza intDiff, basat en els seus valors, imprimeix les diferents opcions de dificultat.

Pas 10: la funció ButtonsMenu

inseriu el codi següent al programa

void buttonsMenu () {// quan es prem Inicia, inicia el joc i restableix el valor de la puntuació si (intEnter == 1) {bolPlay = true; intScore = 0; playBoard (); drawBoard (); } // quan es prem el botó 3 activeu l'opció de depuració d'imprimir la placa en sèrie if (intInput == 3) {if (bolSerialBoard == false) {Serial.println ("Serial Board Active"); bolSerialBoard = cert; } else {Serial.println ("Serial Board Disabled"); bolSerialBoard = fals; }} // estableix la velocitat del joc a dificultats fàcils si (intInput == 0) {Serial.print ("Joc definit a fàcil ("); Serial.print (intGameSpeedEasy); Serial.println ("ms acceleració)"); intDiff = 0; intGameSpeed = intGameSpeedEasy; } // estableix la velocitat del joc a dificultat mitjana si (intInput == 1) {Serial.print ("Joc definit a mig ("); Serial.print (intGameSpeedMedium); Serial.println ("ms acceleració)"); intDiff = 1; intGameSpeed = intGameSpeedMedium; } // estableix la velocitat del joc a dificultat dura si (intInput == 2) {Serial.print ("Joc definit a hard ("); Serial.print (intGameSpeedHard); Serial.println ("ms acceleració)"); intDiff = 2; intGameSpeed = intGameSpeedHard; }}

aquest codi només s'executa quan bolPlay és igual a fals al bucle buit

si intEnter està establert en 1 significa que s'ha premut el botó d'inici, si s'està pressionant, el programa estableix bolPlay a true i el joc comença.

A continuació, el programa llegeix a què és igual a intInput. si és igual a 0, es prem el primer botó de l'esquerra, pujant a la dreta fins a 3. Si intInput és igual a 4, no es prem cap botó.

si es premen els botons 0-2, el joc canvia la dificultat i també ajusta el valor de la velocitat del joc, cosa que significa que accelerarà més ràpidament.

si es prem el botó 3, el joc activarà o desactivarà un mode de depuració on s'imprimeix tot el tauler al monitor sèrie per ajudar a trobar problemes al programa.

Pas 11: la funció ButtonsGame

copieu el codi següent al programa

void buttonsGame () {if (intInput! = 4) {// si es prem un botó si (bolTilePressed == false) {// només si bolTilePressed és una acció de desencadenament falsa per comprovar un botó, premeu bolTilePressed = true; //, a continuació, configureu bolTilePressed a true per assegurar-vos que no es torne a activar int intLowestTile = 0; // per definir el mosaic amb el mosaic més baix int intCheckedTile = 15; // per fer un seguiment de quines rajoles s'han comprovat mentre (intLowestTile == 0) {// sempre que no estigui configurat per res, reviseu les rajoles (int i = 0; i 100) {// sempre que int retard no és inferior a 100 intDelay = intDelay - 20; // agafeu-ne un valor}} else {Serial.println ("Botó incorrecte premut"); fi del joc(); // en cas contrari, joc acabat}}}}}

El codi només s’executa quan bolPlay és igual a true al bucle buit.

Com els botons Menú basat en el valor d’intInput, comprova si el jugador ha colpejat una fitxa o n’ha perdut una.

Ho fa passant per arrGame de baix a dalt mitjançant un bucle while per buscar quina fila és la més baixa amb un mosaic sense cops. A continuació, comprova si l’espot d’aquesta fila corresponent al botó premut és o no un mosaic sense cops, si és unhit l’estableix a 2 en lloc d’1, és a dir, es mostrarà com a @, en cas contrari, activarà el joc funció que encara hem de crear.

Aquesta funció també utilitza la variable bolTilePressed establint-la en true quan es prem un botó i falseja quan no es prem cap botó. Això és per garantir que l'usuari no perdi accidentalment el joc perquè el programa va pensar que va prémer el botó diverses vegades quan el va mantenir premut.

Pas 12: la funció GameOver

Copieu el codi següent al programa

void gameOver () {Serial.println ("Game Over!"); Serial.print ("La vostra puntuació va ser:"); Serial.println (intScore); Serial.print ("La vostra velocitat era:"); Serial.println (intDelay); bolPlay = fals; }

Això s’activa mitjançant les funcions checkBottom o botonsGame i activa el final del joc establint bolPlay com a fals.

També imprimeix un missatge al monitor sèrie per a la puntuació dels usuaris i les rajoles de velocitat es van afegir en mil·lisegons.

Pas 13: la funció d'entrada

Copieu el codi següent al programa.

void input () {intEnter = digitalRead (btnEnter); // read enter // read which of the other inputs, or if none set to 4 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; }}}} // sèrie imprimeix les entrades if (intEnter == 1) {Serial.println ("Enter Pressed!");} if (intInput! = 4) {Serial.print ("Press Button:"); Serial.println (intInput); } else {// si no es prem cap botó restableix bolTilePressed bolTilePressed = false; }}

Aquest codi s’utilitza amb les funcions botons Joc i botons Menú. basat en els botons que ha premut l'usuari, estableix el valor de intInput o, si no es prem cap botó, estableix intInput a 4.

Si no es prem cap botó, aquí es restableix bolTilePressed per a la funció de botons Joc.

També imprimeix un missatge al monitor sèrie en què es prem el botó.

Pas 14: la funció BottomCheck

copieu el codi següent al vostre programa.

void bottomCheck () {for (int i = 0; i <= 3; i ++) {// per a les 4 columnes if (arrGame [15] == 1) {// si hi ha un mosaic a la part inferior.println ("Rajola a la part inferior"); arrGame [15] = 2; drawBoard (); retard (400); arrGame [15] = 1; drawBoard (); retard (400); arrGame [15] = 2; drawBoard (); retard (400); arrGame [15] = 1; drawBoard (); retard (400); fi del joc(); }}}

mitjançant un bucle, aquest codi comprova la fila inferior d'arrGame si hi ha cap fitxa sense cops (fitxes iguals a 1), si hi ha una fitxa sense cop a la part inferior de la pantalla, parpellejarà la fitxa i activarà la funció de joc.

Pas 15: la funció WriteSerial

copieu el codi següent al programa

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 (""); }}}

Aquesta és la funció que segueix l'opció de depuració que es pot activar a la funció de botons Menú. Si bolSerialBoard s'estableix en true en aquesta funció, passarà per arrGame i imprimirà tota la placa al monitor sèrie per fer proves mitjançant un array.

Pas 16: finalització

Tot el vostre codi no hauria d'estar complet i tenir un aspecte semblant.

/ * * Nom: rajoles de piano; Arduino * Per - Domenic Marulli * Data - 11 / *

/ inclou biblioteques

#incloure

// aquestes variables són opcions que podeu canviar: números més alts = velocitat del joc més ràpida

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

// Definiu pins

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

// crear objectes LCD (n, ~, n, ~, ~, n)

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

// configura una matriu de jocs

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}};

// configureu variables per al joc

boolean bolPlay; // fa un seguiment si el jugador int intScore; // fa un seguiment de la puntuació del jugador a intDiff; // només una cosa estètica per dir a quina dificultat té el joc

// configurar variables per a l'entrada

int intEnter; // fa un seguiment si l'usuari prem el botó d'intro int intInput; // fa un seguiment de quins botons prem l’usuari bolTilePressed booleà; // assegureu-vos que el jugador no prem accidentalment un botó 5 vegades i perd

// configurar variables per torn

int intick; // compta milers (per bucle) fins a intDelay int intDelay; // l'hora en què el programa espera fins al següent torn en millis int intGameSpeed;

// àmbit d'opcions de depuració

bolSerialBoard booleà; // quan true s'imprimirà la placa al monitor sèrie

// la configuració que s'executarà una vegada

configuració nul·la () {Serial.begin (9600); // iniciar el monitor de sèrie // configurar les variables bolPlay = false; intScore = 0; intTick = 0; intDelay = 1000; intDiff = 1; intGameSpeed = intGameSpeedMedium; // comença lcdLeft.begin de lcd (16, 2); lcdRight.begin (16, 2); }

// el bucle que s'executarà cada 10 mil·lisegons

bucle buit () {entrada (); // comproveu si hi ha l'entrada de joc si (bolPlay == true) {if (intTick> = intDelay) {// comproveu si el joc hauria de fer un torn o continuar esperant Serial.println ("~~~~~~~ ~~ "); // imprimeix per significar que el tauler es mou en // writeSerial (); // si l'opció està habilitada escriviu el tauler als botons de sèrie Game (); // comprova si hi ha entrades del reproductor playBoard (); // mou el tauler i afegeix un nou mosaic clearLcd (); // netejar les pantalles LCD abans de dibuixar drawBoard (); // dibuixa el tauler a la part inferior del lcdCheck (); intTick = 0; // restableix intTick} else {botonsGame (); // comproveu les entrades del jugador clearLcd (); // netejar les pantalles LCD abans de dibuixar drawBoard (); // dibuixeu el tauler a l’intTick de lcd = intTick + intGameSpeed; // afegir a la marca}} else {clearLcd (); // netejar les pantalles LCD abans de dibuixar el títol (); // mostra els botons d'informació sobre el títol i la puntuació Menú (); // llegir l'entrada del reproductor clearBoard (); // assegureu-vos que tota la junta = 0} demora (10); // retardar l’arduino un breu moment}

// neteja el lcd, de manera que les cel·les sense entrar no queden allà

void clearLcd () {for (int i = 0; i <= 15; i ++) {for (int ii = 0; ii <= 1; ii ++) {lcdLeft.setCursor (i, ii); lcdLeft.write (""); lcdRight.setCursor (i, ii); lcdRight.write (""); }}}

// dibuixa el tauler a la pantalla LCD

void drawBoard () {for (int i = 1; i <= 15; i ++) {// dibuixa collums 1 i 2 a la pantalla LCD esquerra // si el mosaic = 0 no escriu res, = 1 escriu "#", = 2 escriviu "@" lcdLeft.setCursor (i, 1); // estableix la primera columna (més a l'esquerra) if (arrGame [0] == 1) {lcdLeft.write ("#");} if (arrGame [0] == 2) {lcdLeft.write ("@");} lcdLeft.setCursor (i, 0); // estableix la segona columna (centre esquerra) if (arrGame [1] == 1) {lcdLeft.write ("#");} if (arrGame [1] == 2) {lcdLeft.write ("@");} lcdRight.setCursor (i, 1); // estableix la tercera columna (centre dreta) if (arrGame [2] == 1) {lcdRight.write ("#");} if (arrGame [2] == 2) {lcdRight.write ("@");} lcdRight.setCursor (i, 0); // estableix la quarta columna (més a la dreta) if (arrGame [3] == 1) {lcdRight.write ("#");} if (arrGame [3] == 2) {lcdRight.write ("@");}}}

// mou el tauler cap avall i posa un valor aleatori com a mosaic

void playBoard () {for (int i = 0; i <= 3; i ++) {arrGame [0] = 0;} // esborra la fila superior arrGame [0] [random (0, 4)] = 1; // definiu un punt aleatori a la fila superior perquè sigui un mosaic per a (int i = 15; i> = 1; i -) {// treballant des de la part inferior del tauler fins a la part superior per a (int ii = 0; ii <= 3; ii ++) {// per a cada coll arrGame [ii] = arrGame [i - 1] [ii]; }}}

// estableix el tauler sencer a 0 i restableix les variables al joc previ

void clearBoard () {// restableix els valors de tick i retard intTick = 0; intDelay = 1000; // passar pel tauler i establir-ho tot a 0 per (int i = 0; i <= 15; i ++) {per (int ii = 0; ii <= 3; ii ++) {arrGame [ii] = 0; }}}

// mostra el menú principal a la pantalla LCD

void title () {// escriu el títol a la pantalla LCD i espai per a la puntuació lcdRight.setCursor (0, 0); lcdRight.write ("Rajoles de piano"); lcdRight.setCursor (0, 1); lcdRight.write ("Puntuació:"); // converteix la partitura en una cadena de caràcters strScore [3]; sprintf (strScore, "% d", intScore); // mostra la puntuació a LCD lcdRight.write (strScore); // afegiu el lcdRight.setCursor (10, 1); if (intDiff == 0) {lcdRight.write ("Fàcil"); } if (intDiff == 1) {lcdRight.write ("Mitjà"); } if (intDiff == 2) {lcdRight.write ("Difícil"); } // Premeu una mica la instrucció lcdLeft.setCursor (0, 0); lcdLeft.write ("Premeu Retorn"); lcdLeft.setCursor (0, 1); lcdLeft.write ("per començar!"); }

// comprova els botons i què cal fer per ells fora de joc

void buttonsMenu () {// quan es prem Inicia, inicia el joc i restableix el valor de la puntuació si (intEnter == 1) {bolPlay = true; intScore = 0; playBoard (); drawBoard (); } // quan es prem el botó 3 activeu l'opció de depuració d'imprimir la placa en sèrie if (intInput == 3) {if (bolSerialBoard == false) {Serial.println ("Serial Board Active"); bolSerialBoard = cert; } else {Serial.println ("Serial Board Disabled"); bolSerialBoard = fals; }} // estableix la velocitat del joc a dificultats fàcils si (intInput == 0) {Serial.print ("Joc definit a fàcil ("); Serial.print (intGameSpeedEasy); Serial.println ("ms acceleració)"); intDiff = 0; intGameSpeed = intGameSpeedEasy; } // estableix la velocitat del joc a dificultat mitjana si (intInput == 1) {Serial.print ("Joc definit a mig ("); Serial.print (intGameSpeedMedium); Serial.println ("ms acceleració)"); intDiff = 1; intGameSpeed = intGameSpeedMedium; } // estableix la velocitat del joc a dificultat dura si (intInput == 2) {Serial.print ("Joc definit a hard ("); Serial.print (intGameSpeedHard); Serial.println ("ms acceleració)"); intDiff = 2; intGameSpeed = intGameSpeedHard; }}

// comprova els botons i què fer per ells mentre es troba al joc

void buttonsGame () {if (intInput! = 4) {// si es prem un botó si (bolTilePressed == false) {// només si bolTilePressed és una acció de desencadenament falsa per comprovar un botó, premeu bolTilePressed = true; //, a continuació, configureu bolTilePressed a true per assegurar-vos que no es torne a activar int intLowestTile = 0; // per definir el mosaic amb el mosaic més baix int intCheckedTile = 15; // per fer un seguiment de quines rajoles s'han comprovat mentre (intLowestTile == 0) {// sempre que no estigui configurat per res, reviseu les rajoles (int i = 0; i 100) {// sempre que int retard no és inferior a 100 intDelay = intDelay - 20; // agafeu-ne un valor}} else {Serial.println ("Botó incorrecte premut"); fi del joc(); // en cas contrari, joc acabat}}}}}

void gameOver () {

Serial.println ("Joc acabat!"); Serial.print ("La vostra puntuació va ser:"); Serial.println (intScore); Serial.print ("La vostra velocitat era:"); Serial.println (intDelay); bolPlay = fals; }

// comprova si hi ha entrada del jugador

void input () {intEnter = digitalRead (btnEnter); // read enter // read which of the other inputs, or if none set to 4 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; }}}} // sèrie imprimeix les entrades if (intEnter == 1) {Serial.println ("Enter Pressed!");} if (intInput! = 4) {Serial.print ("Press Button:"); Serial.println (intInput); } else {// si no es prem cap botó restableix bolTilePressed bolTilePressed = false; }}

// comprova que la part inferior del tauler no tingui cap error

void bottomCheck () {for (int i = 0; i <= 3; i ++) {// per a les 4 columnes if (arrGame [15] == 1) {// si hi ha un mosaic a la part inferior.println ("Rajola a la part inferior"); arrGame [15] = 2; drawBoard (); retard (400); arrGame [15] = 1; drawBoard (); retard (400); arrGame [15] = 2; drawBoard (); retard (400); arrGame [15] = 1; drawBoard (); retard (400); fi del joc(); }}}

// imprimeix la placa al monitor sèrie si bolSerialBoard és cert

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 (""); }}}

Un cop introduït tot el codi, pengeu-lo al vostre arduino i gaudiu-ne.