Arduino - Klavirske ploščice: 16 korakov (s slikami)

2024 Avtor: John Day | [email protected]. Nazadnje spremenjeno: 2024-01-30 12:05

Pozdravljeni internetni ljudje, to bo govorilo o tem, kako narediti tisto, kar DEFINITYNO ni odtrganje mobilne igre na arduino uno r3.

Torej, za začetek boste potrebovali vse dele, ki so naslednji! 1x Arduino Uno r3 (42 USD)

2x ščit za tipkovnico LCD (19 USD vsak)

5x gumbi

5x 220Ω upori

28x žice

V redu, ko imate vse dele, je čas, da začnete!

1. korak: Ožičenje

Začnite tako, da povežete svoj arduino in prijatelje, kot je prikazano na diagramu, Prepričajte se, da so gumbi pravilno povezani, z režami A0-4 na tleh gumbov, sicer bo arduino mislil, da gumbe držite nenehno, namesto samo s pritiskom.

2. korak: Izjave o izjavah

Vsa koda bi morala iti pred vašo nastavitvijo void in void zanko, ker se vse te spremenljivke in predmeti uporabljajo v več funkcijah, ki jih bomo nastavili.

Začnite tako, da vnesete:

#vključi

na vrhu kode to sporoča arduinu, naj uporabi knjižnico "LiquidCrystal.h" in funkcije, ki so njen del.

Naslednji korak je določiti zatiče, ki jih uporabljamo za gumbe, tako da to kodo vstavimo pod naš #include:

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

Opredelimo izraza btnEnter in btn1 do btn 4, da kodo olajšamo pri branju ali po potrebi spremenimo. To pomeni, da bo pri vnosu btn1 arduino vedel, da v resnici mislimo na gumb 15. Čeprav vrata imenujemo vrata 15, 16, 17 in 18, so na arduinu označena kot A1 A2 A3 in A4, to je zato, ker so vrata, ki se uporabljajo posebej za analogne vhode, čeprav jih uporabljamo samo za digitalne vhode.

Nato bomo ustvarili predmete, ki bodo upravljali zaslone s tekočimi kristali. Če želite to narediti, postavite to kodo pod naše definicije

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

To naredi arduinu, da pri klicu lcdLeft ali lcdRight govorimo o objektu LiquidCrystal. Številke v priloženih oklepajih povedo arduinu, katera vrata naj objekt uporablja za pošiljanje sporočil na LCD, ko uporabljamo njihove funkcije.

Zdaj moramo spremenljivke razglasiti tako, da pod deklaracije objektov postavimo naslednji bit kode:

// te spremenljivke so možnosti, ki jih lahko spremenite - višje številke = hitrejša hitrost igre upint intGameSpeedEasy = 10; int intGameSpeedMedium = 25; int intGameSpeedHard = 80;

// nastavimo spremenljivke za gameboolean bolPlay; // sledi, če je igralec int intScore; // sledi rezultatom igralca int intDiff; // samo estetska stvar, ki pove, na kakšnih težavah je igra // nastavimo spremenljivke za vnos int intEnter; // sledi, če uporabnik pritisne gumb za vnos int intInput; // sledi, katere gumbe uporabnik pritisne boolean bolTilePressed; // zagotovimo, da igralec po nesreči ne pritisne gumba 5x in izgubi // nastavi spremenljivke za turn int intTick; // šteje miljone (na zanko) do intDelay int intDelay; // čas, ko program počaka do naslednjega obrata v milisah int intGameSpeed; // abit of debug options boolean bolSerialBoard; // ko je true, bo plošča natisnjena v serijskem monitorju

Spremenljivko razglasimo tako, da navedemo podatkovni tip in nato ime spremenljivke, npr. int thisIsAnInteger

Logične spremenljivke, kot sta bolSerialBoard in bolPlay, imajo lahko samo eno od dveh vrednosti, true ali false.

Celobrojna spremenljivka (int), kot sta intScore in intInput, lahko za vrednosti vzame cela števila, na primer 1, 5 ali 100.

Nekatere druge pomembne vrste podatkov, ki jih tukaj ne uporabljamo, so niz, ki je kos besedila, in plavajoči, ki je decimalno število.

Vsako od spremenljivk tukaj program uporablja na več različnih mestih, tukaj je povzetek, kaj vsaka od njih počne

bolPlay programu pove, ali naj se prikaže meni ali naj se izvaja dejanska igra.

intScore spremlja igralčev rezultat, ko zadene ploščice, intDiff se uporablja v glavnem meniju, da programu pove, kateri del besedila naj natisne na LCD -jih, intEnter se uporablja, da programu pove, če je pritisnjen gumb za vnos (skrajno levo), intInput se uporablja, da programu pove, kateri od preostalih 4 gumbov je pritisnjen.

bolTilePressed se uporablja za zagotovitev, da se program bere samo, ko pritisnete gumb, in ne, ko ga držite.

intGameSpeed, intGameSpeedEasy, intGameSpeedMedium in intGameSpeedHard se uporabljajo za nadzor, kako hitro naj se igra pospeši glede na izbrano težavnost.

intTick in intDelay se uporabljata za zaustavitev programa pri premikanju plošče vsakič, ko se zanka.

bolSerialBoard se uporablja za omogočanje, da program pošlje ploščo na arduinov serijski monitor kot vrsto številk za namene testiranja.

Končno je čas, da svojo ploščo razglasimo kot matriko s to kodo:

// nastavimo niz iger 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}};

Niz je matrika, katere koli točke, na katerih je mogoče poklicati za matematiko ali jih spremeniti.

Vaša koda bi morala izgledati nekako takole;

// vključi knjižnice#include

// te spremenljivke so možnosti, ki jih lahko spremenite - višje številke = hitrejše pospeševanje igre

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

// Določimo zatiče

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

// ustvarjanje objektov LCD (n, ~, n, ~, ~, n)

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

// nastavimo matriko iger

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

// nastavimo spremenljivke za igro

boolean bolPlay; // sledi, če igralec int intScore; // sledi rezultatom igralca int intDiff; // samo estetska stvar, ki pove, na kakšni težavnosti je igra

// nastavimo spremenljivke za vnos

int intEnter; // sledi, če uporabnik pritisne gumb za vnos int intInput; // sledi, katere gumbe uporabnik pritisne boolean bolTilePressed; // zagotovimo, da igralec po nesreči ne pritisne gumba 5x in izgubi

// nastavimo spremenljivke za turn

int intTick; // šteje miljone (na zanko) do intDelay int intDelay; // čas, ko program počaka do naslednjega obrata v milisah int intGameSpeed;

// abit možnosti odpravljanja napak

boolean bolSerialBoard; // ko je true, bo plošča natisnjena v serijskem monitorju

3. korak: Nastavitvena funkcija

Nastavitvena zanka je funkcija, ki jo arduino prebere le enkrat, ko se zažene.

V nastavitveni zanki samo nastavljamo vrednosti nekaj naših spremenljivk, ker namesto da jih določimo, ko jih razglasimo, to počnemo tukaj.

Začnite tako, da to kodo vnesete v nastavitev Void.

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

Vsaka vrstica samo nastavi spremenljivko na vrednost.

bolPlay je nastavljen na false, da se igra ne začne igrati.

intScore je nastavljen na 0, ker se seveda vaš rezultat začne pri 0.

intTick se začne pri 0, ker program trenutno ne šteje nič.

intDelay je nastavljen na 1000, ker je to hitrost, pri kateri se ploščice začnejo.

intDiff je samo asketska stvar, tako da program ve, kaj naj napiše za težave igre.

intGameSpeed je nastavljen na vse, kar je intGameSpeedMedium, kar pomeni, da je nastavljeno na srednji težavnosti.

Nato vnesite to kodo v nastavitev Void pod kodo, ki ste jo pravkar vnesli.

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

Serial.begin (9600);

To pove arduinu, naj začne komunicirati z računalnikom prek serijskega monitorja (vidno s klikom na gumb v zgornjem desnem kotu arduino IDE).

Vaša nastavitev Void bi morala izgledati nekako tako!

void setup () {Serial.begin (9600); // zaženite serijski monitor // nastavite spremenljivke bolPlay = false; intScore = 0; intTick = 0; intDelay = 1000; intDiff = 1; intGameSpeed = intGameSpeedMedium; // začnite lcd's lcdLeft.begin (16, 2); lcdRight.begin (16, 2); }

4. korak: Funkcija zanke

Funkcijo zanke izvaja arduino vsako ponovitev arduina.

Kopirajte naslednjo kodo v svojo Void Loop.

void loop () {input (); // preverite, ali se igra vnos if (bolPlay == true) {if (intTick> = intDelay) {// preverite, ali bi morala igra odigrati potezo ali še naprej čakati Serial.println ("~~~~~~~ ~~ "); // tiskanje za označevanje premikanja plošče // writeSerial (); // če je možnost omogočena, ploščo zapišite v serijske gumbeGame (); // preveri vnose predvajalnika playBoard (); // premaknemo ploščo in dodamo novo ploščico clearLcd (); // očistimo LCD -je pred risanjem drawBoard (); // potegnemo ploščo na sprednjo stran lcdCheck (); intTick = 0; // ponastavi intTick} else {buttonsGame (); // preveri vnose igralcev clearLcd (); // očistimo LCD -je pred risanjem drawBoard (); // narišemo ploščo na lcd's intTick = intTick + intGameSpeed; // dodaj kljukico}} else {clearLcd (); // očistimo LCD -je, preden narišemo naslov (); // Prikaz gumbov za naslov in rezultatMenu (); // prebere vnos predvajalnika clearBoard (); // zagotovimo, da celotna plošča = 0} zamuda (10); // za kratek trenutek odložimo arduino}

ko je bolPlay enako true, to pomeni, da se igra in je treba zagnati vso kodo za igro, vendar želimo le, da deska doda novo ploščico in se premakne navzdol, ko je intTick večji od našega intDelay, sicer želimo še vedno dovoliti uporabniku, da pritisne gumb, da zadene ploščico, in intTick poveča hitrost.

Večina te kode uporablja funkcije, ki jih še moramo izvesti, in jih bomo naredili v naslednjih korakih. Namen teh funkcij je naslednji.

Vnos bere, katere gumbe je uporabnik pritisnil.

buttonGame nadzoruje, kaj gumbi počnejo v igri in ne v meniju

playBoard doda novo ploščico na ploščo in nato premakne vse na plošči za en prostor navzdol

clearLCD očisti LCD -je, da se prepriča, da za ploščicami ne ostanejo duhovi

drawBoard gre skozi arrGame in ga natisne na LCD -je

clearBoard počisti celotno arrGame, ko igra ni v igri

bottomCheck na dnu arrGame preveri stanje okvare

naslov prikazuje naslov igre in podatke o rezultatih, ko ste na meniju

Meni gumbov nadzoruje, kaj uporabniški vnosi počnejo v meniju.

gameOver je še ena funkcija, čeprav se tukaj ne kliče, temveč se kliče v spodnjih funkcijah Check and ButtonsGame.

5. korak: funkcija ClearLCD

če želite ustvariti funkcijo, začnemo z dodajanjem te kode

void functionName () {

}

"functionName" je lahko karkoli, če že ne obstaja.

Kopirajte to kodo v svoj program:

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

ta poteka skozi celotno matriko z uporabo 2 preštetih zank, da greste skozi vsako točko na LCD -jih in napišete presledek.

Brez ponastavitve na nič, bodo LCD -ji ohranili vse, kar je bilo prej napisano

6. korak: funkcija DrawBoard

kopirajte to kodo v svoj program

void drawBoard () {for (int i = 1; i <= 15; i ++) {// na levi LCD narišemo dogovore 1 in 2 // če ploščica = 0 ne napiše nič, = 1 napiše "#", = 2 napišite "@" lcdLeft.setCursor (i, 1); // nastavljeno na prvi stolpec (najbolj skrajno levo) if (arrGame [0] == 1) {lcdLeft.write ("#");} if (arrGame [0] == 2) {lcdLeft.write ("@");} lcdLeft.setCursor (i, 0); // nastavljeno na drugi stolpec (levo v sredini) if (arrGame [1] == 1) {lcdLeft.write ("#");} if (arrGame [1] == 2) {lcdLeft.write ("@");} lcdRight.setCursor (i, 1); // nastavljeno na tretji stolpec (desno desno) if (arrGame [2] == 1) {lcdRight.write ("#");} if (arrGame [2] == 2) {lcdRight.write ("@");} lcdRight.setCursor (i, 0); // nastavljeno na četrti stolpec (najbolj skrajno desno) if (arrGame [3] == 1) {lcdRight.write ("#");} if (arrGame [3] == 2) {lcdRight.write ("@");}}}

ta uporablja zanko za prehod skozi vsako vrstico plošče, nato pa preveri, ali je kateri koli stolpec v vrstici enak 1 ali 2, na podlagi tega nato na LCD natisne bodisi hashtag, za ploščico, ki še ni hit ali @ za zadetkovno ploščico.

7. korak: Funkcija PlayBoard

kopirajte to kodo v svoj program.

void playBoard () {for (int i = 0; i <= 3; i ++) {arrGame [0] = 0;} // počisti zgornjo vrstico arrGame [0] [naključno (0, 4)] = 1; // nastavimo naključno točko v zgornji vrstici za ploščico (int i = 15; i> = 1; i-) {//, ki deluje od dna plošče do vrha za (int ii = 0; ii <= 3; ii ++) {// za vsak collum arrGame [ii] = arrGame [i - 1] [ii]; }}}

ta koda se začne z brisanjem celotne zgornje vrstice na 0 ali brez ploščice, nato pa nastavi eno naključno ploščico na 1 in razkrije ploščico.

Nato gre skozi štetje zanke v obratni smeri, od 15 do 1, pri čemer je vrstica enaka ne glede na to, kako je vrstica nad njo enaka, zato se plošča premakne navzdol po LCD -jih

8. korak: funkcija ClearBoard

kopirajte to kodo v svoj program.

void clearBoard () {// ponastavi vrednosti klopov in zakasnitev intTick = 0; intDelay = 1000; // pojdite skozi ploščo in nastavite vse na 0 za (int i = 0; i <= 15; i ++) {for (int ii = 0; ii <= 3; ii ++) {arrGame [ii] = 0; }}}

Ta koda se zažene, ko se igra ne igra, da se prepričate, da je celotna arrGame nastavljena na 0 ali brez ploščic, z uporabo štetenih zank za prehod skozi matriko.

Koda ponastavi tudi vrednosti intDelay in intTick.

9. korak: Naslovna funkcija

kopirajte naslednjo kodo v svoj program

void title () {// zapišite naslov na LCD in prostor za rezultat lcdRight.setCursor (0, 0); lcdRight.write ("Klavirske ploščice"); lcdRight.setCursor (0, 1); lcdRight.write ("Ocena:"); // pretvorimo rezultat v niz char strScore [3]; sprintf (strScore, "%d", intScore); // prikaz rezultatov na LCD lcdRight.write (strScore); // dodamo težavno lcdRight.setCursor (10, 1); if (intDiff == 0) {lcdRight.write ("Enostavno"); } if (intDiff == 1) {lcdRight.write ("Medium"); } if (intDiff == 2) {lcdRight.write ("Hard"); } // Pritisnite malo ukaza lcdLeft.setCursor (0, 0); lcdLeft.write ("Pritisnite Enter"); lcdLeft.setCursor (0, 1); lcdLeft.write ("za začetek!"); }

Ta koda zapiše naslov igre in rezultat na LCD -prikazovalnike. To naredi tako, da LCD -ju pove, kje naj začne tipkati z uporabo LCD.setCursor in nato napiše niz v LCD.write.

Tu je ustvarjena tudi nova spremenljivka, strScore, ki se uporablja za pretvorbo intScore v podatkovni tip niza ali char s funkcijo sprintf.

tu se uporablja tudi intDiff, ki na podlagi svojih vrednosti natisne različne težavnostne možnosti.

10. korak: Funkcija ButtonsMenu

v svoj program vstavite naslednjo kodo

void buttonsMenu () {// ko pritisnete enter, začnite igro in ponastavite vrednost rezultata, če (intEnter == 1) {bolPlay = true; intScore = 0; playBoard (); drawBoard (); } // ko pritisnete gumb 3, vklopite možnost odpravljanja napak za tiskanje plošče v zaporedju if (intInput == 3) {if (bolSerialBoard == false) {Serial.println ("Serial Board Active"); bolSerialBoard = res; } else {Serial.println ("Serijska plošča onemogočena"); bolSerialBoard = false; }} // nastavite hitrost igre na lažje težave if (intInput == 0) {Serial.print ("Igra nastavljena na easy ("); Serial.print (intGameSpeedEasy); Serial.println ("ms pospešek)"); intDiff = 0; intGameSpeed = intGameSpeedEasy; } // nastavite hitrost igre na srednje težavnost if (intInput == 1) {Serial.print ("Igra nastavljena na medij ("); Serial.print (intGameSpeedMedium); Serial.println ("ms pospešek)"); intDiff = 1; intGameSpeed = intGameSpeedMedium; } // nastavite hitrost igre na težko težavnost, če (intInput == 2) {Serial.print ("Igra je nastavljena na trdo ("); Serial.print (intGameSpeedHard); Serial.println ("ms pospešek)"); intDiff = 2; intGameSpeed = intGameSpeedHard; }}

ta koda se zažene le, če je bolPlay v void Loop enak false

če je intEnter nastavljen na 1, to pomeni, da je bil pritisnjen gumb za vnos, če je pritisnjen, program nastavi bolPlay na true in igra se začne.

Program nato prebere, kaj je intInput enako. če je enako 0, se pritisne prvi gumb z leve strani, dvigne se v desno do 3. Če je intInput enak 4, se ne pritisne nobena tipka.

če pritisnete gumbe 0-2, igra spremeni težavnost in prilagodi tudi vrednost hitrosti igre, kar pomeni, da se bo pospešilo hitreje.

če pritisnete gumb 3, bo igra aktivirala ali deaktivirala način odpravljanja napak, pri katerem je celotna plošča natisnjena v serijskem monitorju, da pomaga pri iskanju težav v programu.

11. korak: Funkcija ButtonsGame

kopirajte naslednjo kodo v svoj program

void buttonsGame () {if (intInput! = 4) {// če je pritisnjen gumb if (bolTilePressed == false) {// samo, če je bolTilePressed napačno dejanje sprožilca za preverjanje gumba pritisnite bolTilePressed = true; // nato nastavite bolTilePressed na true, da se prepričate, da ni akidentilno znova sprožen int intLowestTile = 0; // nastavimo na ploščico z najnižjo ploščico int intCheckedTile = 15; // za sledenje, katere ploščice so bile preverjene medtem ko (intLowestTile == 0) {// dokler ni nastavljeno na nič, preverite ploščice (int i = 0; i 100) {// dokler je int zakasnitev ni nižja od 100 intDelay = intDelay - 20; // iz nje vzamemo vrednost}} else {Serial.println ("Napačen gumb pritisnjen"); konec igre(); // drugače je igre konec}}}}}

Koda se zažene le, če je bolPlay v void Loop enak true.

Podobno gumbom Meni na podlagi vrednosti intInput preveri, ali je igralec zadel ploščico ali jo zgrešil.

To naredi tako, da gre skozi arrGame od spodaj navzgor z uporabo zanke while, da poišče, katera vrstica je najnižja z razkrito ploščico. Nato preveri, ali je mesto v tej vrstici, ki ustreza pritisnjenemu gumbu, nepokrita ploščica ali ne, če je nehit, ga nastavi na 2 namesto na 1, kar pomeni, da se prikaže kot @, sicer sproži igro Over funkcijo, ki jo šele ustvarjamo.

Ta funkcija uporablja tudi spremenljivko bolTilePressed tako, da jo nastavi na true, ko pritisnete gumb, in false, če ne pritisnete nobenega gumba. To je zato, da uporabnik slučajno ne izgubi igre, ker je program menil, da so pritisnili gumb večkrat, ko so ga držali pritisnjenega.

12. korak: Funkcija GameOver

Kopirajte naslednjo kodo v svoj program

void gameOver () {Serial.println ("Igra je končana!"); Serial.print ("Vaša ocena je bila:"); Serial.println (intScore); Serial.print ("Vaša hitrost je bila:"); Serial.println (intDelay); bolPlay = napačno; }

To sprožijo funkcije checkBottom ali buttonGame in sproži konec igre z nastavitvijo bolPlay na false.

Natisne tudi sporočilo na serijski monitor za oceno uporabnikov, hitrostne ploščice pa so bile dodane v milisekundah.

Korak: Vhodna funkcija

Kopirajte naslednjo kodo v svoj program.

void input () {intEnter = digitalRead (btnEnter); // beri enter // preberi kateri od drugih vhodov ali če noben ni nastavljen na 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; }}}} // serijsko natisne vnose if (intEnter == 1) {Serial.println ("Enter Presssed!");} if (intInput! = 4) {Serial.print ("Button Press:"); Serial.println (intInput); } else {// če ni pritisnjen noben gumb reset bolTilePressed bolTilePressed = false; }}

Ta koda se uporablja s funkcijami gumbovIgra in gumbiMeni. na podlagi gumbov, ki jih je uporabnik pritisnil, nastavi vrednost intInput, če pa ni pritisnjen noben gumb, nastavi intInput na 4.

Če ne pritisnete nobenega gumba, se tukaj funkcija bolTilePressed ponastavi za funkcijo buttonGame.

Natisne tudi sporočilo na serijski monitor, na katerem je pritisnjen gumb.

Korak 14: Funkcija BottomCheck

kopirajte naslednjo kodo v svoj program.

void bottomCheck () {for (int i = 0; i <= 3; i ++) {// za 4 stolpce if (arrGame [15] == 1) {// če je ploščica na dnu Serijsko.println ("Ploščica na dnu"); arrGame [15] = 2; drawBoard (); zamuda (400); arrGame [15] = 1; drawBoard (); zamuda (400); arrGame [15] = 2; drawBoard (); zamuda (400); arrGame [15] = 1; drawBoard (); zamuda (400); konec igre(); }}}

ta koda z zanko preveri, ali je v spodnji vrstici arrGame nepokritih ploščic (ploščice enake 1), če je na dnu zaslona razkrita ploščica, bo ploščico utripala in nato sprožila funkcijo igre.

15. korak: funkcija WriteSerial

kopirajte naslednjo kodo v svoj program

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

To je funkcija, ki ji sledi možnost odpravljanja napak, ki jo lahko omogočite v funkciji gumbiMeni. Če je bolSerialBoard v tej funkciji nastavljen na true, bo šel skozi arrGame in natisnil celotno ploščo v serijski monitor za namene testiranja z uporabo matrike.

Korak 16: Dokončanje

Vsa vaša koda ne sme biti popolna in videti nekako tako!

/ * * Ime - Klavirske ploščice; Arduino * Avtor - Domenic Marulli * Datum - 11/ *

/ vključi knjižnice

#vključi

// te spremenljivke so možnosti, ki jih lahko spremenite - višje številke = hitrejše pospeševanje igre

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

// Določimo zatiče

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

// ustvarjanje objektov LCD (n, ~, n, ~, ~, n)

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

// nastavimo matriko iger

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

// nastavimo spremenljivke za igro

boolean bolPlay; // sledi, če igralec int intScore; // sledi rezultatom igralca int intDiff; // samo estetska stvar, ki pove, na kakšni težavnosti je igra

// nastavimo spremenljivke za vnos

int intEnter; // sledi, če uporabnik pritisne gumb za vnos int intInput; // sledi, katere gumbe uporabnik pritisne boolean bolTilePressed; // zagotovimo, da igralec po nesreči ne pritisne gumba 5x in izgubi

// nastavimo spremenljivke za turn

int intTick; // šteje miljone (na zanko) do intDelay int intDelay; // čas, ko program počaka do naslednjega obrata v milisah int intGameSpeed;

// abit možnosti odpravljanja napak

boolean bolSerialBoard; // ko je true, bo plošča natisnjena v serijskem monitorju

// nastavitev, ki se bo enkrat zagnala

void setup () {Serial.begin (9600); // zaženite serijski monitor // nastavite spremenljivke bolPlay = false; intScore = 0; intTick = 0; intDelay = 1000; intDiff = 1; intGameSpeed = intGameSpeedMedium; // začnite lcd's lcdLeft.begin (16, 2); lcdRight.begin (16, 2); }

// zanka, ki se bo izvajala vsakih 10 milisekonov

void loop () {input (); // preverite, ali se igra vnos if (bolPlay == true) {if (intTick> = intDelay) {// preverite, ali bi morala igra odigrati potezo ali še naprej čakati Serial.println ("~~~~~~~ ~~ "); // tiskanje za označevanje premikanja plošče // writeSerial (); // če je možnost omogočena, ploščo zapišite v serijske gumbeGame (); // preveri vnose predvajalnika playBoard (); // premaknemo ploščo in dodamo novo ploščico clearLcd (); // očistimo LCD -je pred risanjem drawBoard (); // potegnemo ploščo na sprednjo stran lcdCheck (); intTick = 0; // ponastavi intTick} else {buttonsGame (); // preveri vnose igralcev clearLcd (); // očistimo LCD -je pred risanjem drawBoard (); // narišemo ploščo na lcd's intTick = intTick + intGameSpeed; // dodaj kljukico}} else {clearLcd (); // očistimo LCD -je, preden narišemo naslov (); // Prikaz gumbov za naslov in rezultatMenu (); // prebere vnos predvajalnika clearBoard (); // zagotovimo, da celotna plošča = 0} zamuda (10); // za kratek trenutek odložimo arduino}

// očisti lcd, tako da neobdelane celice tam ne ostanejo

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

// potegne ploščo na lcd

void drawBoard () {for (int i = 1; i <= 15; i ++) {// na levi LCD narišemo dogovore 1 in 2 // če ploščica = 0 ne napiše nič, = 1 napiše "#", = 2 napišite "@" lcdLeft.setCursor (i, 1); // nastavljeno na prvi stolpec (najbolj skrajno levo) if (arrGame [0] == 1) {lcdLeft.write ("#");} if (arrGame [0] == 2) {lcdLeft.write ("@");} lcdLeft.setCursor (i, 0); // nastavljeno na drugi stolpec (levo v sredini) if (arrGame [1] == 1) {lcdLeft.write ("#");} if (arrGame [1] == 2) {lcdLeft.write ("@");} lcdRight.setCursor (i, 1); // nastavljeno na tretji stolpec (desno desno) if (arrGame [2] == 1) {lcdRight.write ("#");} if (arrGame [2] == 2) {lcdRight.write ("@");} lcdRight.setCursor (i, 0); // nastavljeno na četrti stolpec (najbolj skrajno desno) if (arrGame [3] == 1) {lcdRight.write ("#");} if (arrGame [3] == 2) {lcdRight.write ("@");}}}

// premakne ploščo navzdol in postavi naključno vrednost kot ploščico

void playBoard () {for (int i = 0; i <= 3; i ++) {arrGame [0] = 0;} // počisti zgornjo vrstico arrGame [0] [naključno (0, 4)] = 1; // nastavimo naključno točko v zgornji vrstici za ploščico (int i = 15; i> = 1; i-) {//, ki deluje od dna plošče do vrha za (int ii = 0; ii <= 3; ii ++) {// za vsak collum arrGame [ii] = arrGame [i - 1] [ii]; }}}

// celotno ploščo nastavi na 0 in spremenljivke ponastavi na predigro

void clearBoard () {// ponastavi vrednosti klopov in zakasnitev intTick = 0; intDelay = 1000; // pojdite skozi ploščo in nastavite vse na 0 za (int i = 0; i <= 15; i ++) {for (int ii = 0; ii <= 3; ii ++) {arrGame [ii] = 0; }}}

// prikaže glavni meni na LCD -jih

void title () {// zapišite naslov na LCD in prostor za rezultat lcdRight.setCursor (0, 0); lcdRight.write ("Klavirske ploščice"); lcdRight.setCursor (0, 1); lcdRight.write ("Ocena:"); // pretvorimo rezultat v niz char strScore [3]; sprintf (strScore, "%d", intScore); // prikaz rezultatov na LCD lcdRight.write (strScore); // dodamo težavno lcdRight.setCursor (10, 1); if (intDiff == 0) {lcdRight.write ("Enostavno"); } if (intDiff == 1) {lcdRight.write ("Medium"); } if (intDiff == 2) {lcdRight.write ("Hard"); } // Pritisnite malo ukaza lcdLeft.setCursor (0, 0); lcdLeft.write ("Pritisnite Enter"); lcdLeft.setCursor (0, 1); lcdLeft.write ("za začetek!"); }

// preveri gumbe in kaj storiti z njimi, ko ni igre

void buttonsMenu () {// ko pritisnete enter, začnite igro in ponastavite vrednost rezultata, če (intEnter == 1) {bolPlay = true; intScore = 0; playBoard (); drawBoard (); } // ko pritisnete gumb 3, vklopite možnost odpravljanja napak za tiskanje plošče v zaporedju if (intInput == 3) {if (bolSerialBoard == false) {Serial.println ("Serial Board Active"); bolSerialBoard = res; } else {Serial.println ("Serijska plošča onemogočena"); bolSerialBoard = false; }} // nastavite hitrost igre na lažje težave if (intInput == 0) {Serial.print ("Igra nastavljena na easy ("); Serial.print (intGameSpeedEasy); Serial.println ("ms pospešek)"); intDiff = 0; intGameSpeed = intGameSpeedEasy; } // nastavite hitrost igre na srednje težavnost if (intInput == 1) {Serial.print ("Igra nastavljena na medij ("); Serial.print (intGameSpeedMedium); Serial.println ("ms pospešek)"); intDiff = 1; intGameSpeed = intGameSpeedMedium; } // nastavite hitrost igre na težko težavnost, če (intInput == 2) {Serial.print ("Igra je nastavljena na trdo ("); Serial.print (intGameSpeedHard); Serial.println ("ms pospešek)"); intDiff = 2; intGameSpeed = intGameSpeedHard; }}

// preveri gumbe in kaj z njimi narediti med igro

void buttonsGame () {if (intInput! = 4) {// če je pritisnjen gumb if (bolTilePressed == false) {// samo, če je bolTilePressed lažno sprožilno dejanje za preverjanje pritiska na gumb bolTilePressed = true; // nato nastavite bolTilePressed na true, da se prepričate, da se ne sproži znova akidentilno int intLowestTile = 0; // nastavimo na ploščico z najnižjo ploščico int intCheckedTile = 15; // za sledenje, katere ploščice so bile preverjene medtem ko (intLowestTile == 0) {// dokler ni nastavljeno na nič, preverite ploščice (int i = 0; i 100) {// dokler je int zakasnitev ni nižja od 100 intDelay = intDelay - 20; // iz nje vzamemo vrednost}} else {Serial.println ("Napačen gumb pritisnjen"); konec igre(); // drugače je igre konec}}}}}

void gameOver () {

Serial.println ("Igra je končana!"); Serial.print ("Vaša ocena je bila:"); Serial.println (intScore); Serial.print ("Vaša hitrost je bila:"); Serial.println (intDelay); bolPlay = napačno; }

// preveri vnos predvajalnika

void input () {intEnter = digitalRead (btnEnter); // beri enter // preberi kateri od drugih vhodov ali če noben ni nastavljen na 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; }}}} // serijsko natisne vnose if (intEnter == 1) {Serial.println ("Enter Presssed!");} if (intInput! = 4) {Serial.print ("Button Press:"); Serial.println (intInput); } else {// če ni pritisnjen noben gumb reset bolTilePressed bolTilePressed = false; }}

// preveri, ali je spodnji del plošče okvarjen

void bottomCheck () {for (int i = 0; i <= 3; i ++) {// za 4 stolpce if (arrGame [15] == 1) {// če je ploščica na dnu Serijsko.println ("Ploščica na dnu"); arrGame [15] = 2; drawBoard (); zamuda (400); arrGame [15] = 1; drawBoard (); zamuda (400); arrGame [15] = 2; drawBoard (); zamuda (400); arrGame [15] = 1; drawBoard (); zamuda (400); konec igre(); }}}

// natisne ploščo v serijski monitor, če je bolSerialBoard res

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

Ko vnesete vso kodo, jo naložite na svoj arduino in uživajte!