Arduino - klaveriplaadid: 16 sammu (piltidega)

2024 Autor: John Day | [email protected]. Viimati modifitseeritud: 2024-01-30 08:49

Tere Interneti -inimesed, siin räägitakse sellest, kuidas teha seda, mis KINDLASTI pole arduino uno r3 mobiilimängu rippimine.

nii et alustamiseks vajate kõiki osi, mis on järgmised! 1x Arduino Uno r3 (42 dollarit)

2x LCD -klahvistiku kilp (igaüks 19 dollarit)

5x nupud

5x 220Ω takistid

28x juhtmed

Olgu, kui olete kõik osad kätte saanud, on aeg alustada!

Samm: juhtmestik

Alustuseks ühendage oma arduino ja sõbrad, nagu skeemil näidatud, Veenduge, et nupud on ühendatud õigesti, kusjuures nuppude rööbaste alumisel küljel on pilud A0-4, vastasel juhul arvab arduino, et nuppe hoitakse pidevalt all, mitte ainult vajutades.

2. etapp: deklaratsiooni avaldused

Kogu siin olev kood peaks minema enne tühimike seadistamist ja void -tsüklit, sest kõik need muutujad ja objektid on kasutusel mitmetes meie seadistatavates funktsioonides.

Alustuseks pange:

#kaasake

teie koodi ülaosas käsib see arduino kasutada teeki "LiquidCrystal.h" ja selle osi.

Järgmine samm on määratleda nööpnõelad, mida me oma nuppude jaoks kasutame, pannes selle koodi meie #clude alla:

#define btn Sisestage A0 #define btn1 15 #define btn2 16 #define btn3 17 #define btn4 18

Me määratleme terminid btnEnter ja btn1 kuni btn 4, et koodi oleks lihtsam lugeda või vajadusel muuta. See tähendab, et kui kirjutame btn1, teab arduino, et me tegelikult mõtleme nuppu 15. Kuigi me nimetame sadamaid portideks 15, 16, 17 ja 18, on need arduino -l märgistatud kui A1 A2 A3 ja A4, sest need on spetsiaalselt analoogsisendite jaoks kasutatavad pordid, kuigi me kasutame neid ainult digitaalsisendite jaoks.

Järgmisena loome objektid, mis juhivad vedelkristallekraane. Selleks pange see kood meie määratluste alla

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

See ütleb arduinole, et kui helistame lcdLeft või lcdRight, viitame LiquidCrystali objektile. Lisatud sulgudes olevad numbrid ütlevad arduinole, milliseid porte peaks objekt kasutama LCD -le sõnumite saatmiseks, kui kasutame nende funktsioone.

Nüüd peame muutujad deklareerima, pannes objekti deklaratsioonide alla järgmise koodibiti:

// need muutujad on valikud, mida saate muuta - suuremad numbrid = mängu kiirem kiirus upint intGameSpeedEasy = 10; int intGameSpeedMedium = 25; int intGameSpeedHard = 80;

// seadista muutujad mängulise bolPlay jaoks; // jälgib, kui mängija int intScore; // jälgib mängija tulemust int intDiff; // lihtsalt esteetiline asi, et öelda, mis raskustega mäng on // // muutujate seadistamine sisend int intEnter; // jälgib, kui kasutaja vajutab sisestusnuppu int intInput; // jälgib, milliseid nuppe kasutaja vajutab boolean bolTilePressed; // veenduge, et mängija ei vajuta kogemata nuppu 5x ja ei kaota // seadistage muutujad turn int intTick; // loeb millisid (silmuse kohta) kuni intDelay int intDelay; // aeg, mil programm ootab järgmist pööret millis int intGameSpeed; // silumisvalikute abit boolean bolSerialBoard; // kui tõene, prindib tahvli jadamonitoris

Muutuja deklareerime, nimetades andmetüübi ja seejärel muutuja nime, nt. int thisIsAnInteger

Loogilistel muutujatel, näiteks bolSerialBoard ja bolPlay, võib olla ainult üks kahest väärtusest - tõene või vale.

Täisarvuline muutuja (int), näiteks intScore ja intInput, võib võtta täisarvuna väärtusi, näiteks 1, 5 või 100.

Mõned muud märkimisväärsed andmetüübid, mida me siin ei kasuta, on string, mis on tekstiosa, ja ujuk, mis on kümnendarv.

Programm kasutab siin kõiki muutujaid mitmes erinevas kohas, siin on kokkuvõte sellest, mida igaüks teeb

bolPlay ütleb programmile, kas menüüd tuleks kuvada või peaks tegelik mäng käima.

intScore jälgib mängija tulemust, kui see plaate tabab, intDiff kasutatakse peamenüüs, et öelda programmile, millist teksti teksti LCD -ekraanile printida, intEnterit kasutatakse programmi teavitamiseks, kui vajutatakse sisestusnuppu (kõige kaugemal vasakul), intInput abil öeldakse programmile, millist ülejäänud 4 nuppu vajutatakse.

bolTilePressed kasutatakse veendumaks, et programm loeb edasi ainult siis, kui nuppu vajutatakse, mitte siis, kui seda hoitakse.

intGameSpeed, intGameSpeedEasy, intGameSpeedMedium ja intGameSpeedHard kasutatakse selleks, et kontrollida, kui kiiresti mäng peaks kiirendama, lähtudes sellest, millise raskusastme valitakse.

IntTick ja intDelay kasutatakse selleks, et programm ei liigutaks tahvlit iga kord, kui see ringleb.

bolSerialBoardit kasutatakse selleks, et võimaldada programmil saata plaat arduino jadamonitorile numbriseeriana testimiseks.

Lõpuks on aeg kuulutada meie plaat massiivina, kasutades seda koodi:

// mängu massiivi seadistamine 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}};

Massiiv on maatriks, mille mis tahes punkti saab matemaatikaks kutsuda või muuta.

Teie kood peaks nüüd välja nägema umbes selline;

// kaasata teegid#include

// need muutujad on valikud, mida saate muuta - suuremad numbrid = kiirem mäng

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

// Määrake tihvtid

#define btn Sisestage A0 #define btn1 15 #define btn2 16 #define btn3 17 #define btn4 18

// LCD -objektide loomine (n, ~, n, ~, ~, n)

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

// seadistage mängumassiiv

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

// mängu muutujate seadistamine

boolean bolPlay; // jälgib, kui mängija int intScore; // jälgib mängija tulemust int intdiff; // lihtsalt esteetiline asi, et öelda, mis raskustega mäng on

// muutujate seadistamine sisendiks

int intEnter; // jälgib, kui kasutaja vajutab sisestusnuppu int intInput; // jälgib, milliseid nuppe kasutaja vajutab boolean bolTilePressed; // veenduge, et mängija ei vajuta kogemata 5x nuppu ja kaotab

// muutujate seadistamine pöördele

int intTick; // loeb millisid (silmuse kohta) kuni intDelay int intDelay; // aeg, mil programm ootab järgmist pööret millis int intGameSpeed;

// silumisvalikute abit

boolean bolSerialBoard; // kui tõene, prindib tahvli jadamonitoris

Samm: seadistusfunktsioon

Seadistusahel on funktsioon, mida arduino loeb algselt käivitamisel ainult üks kord.

Seadistusahelas määrame lihtsalt mõne meie muutuja väärtused, sest selle väärtuse määramise asemel nende deklareerimisel teeme seda siin.

Alustage selle koodi sisestamisega oma tühimike seadistusse.

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

Iga rida määrab lihtsalt muutuja väärtuseks.

et mäng ei hakkaks mängima, on bolPlay väärtuseks seatud vale.

intScore on seatud väärtusele 0, sest loomulikult algab teie tulemus 0 -st.

intTick algab nullist, kuna programm ei loe praegu midagi.

intDelay väärtuseks on määratud 1000, kuna see on plaatide alguskiirus.

intDiff on lihtsalt askeetlik asi, et programm teaks, mida mängu raskuste jaoks kirjutada.

intGameSpeed on seatud mis tahes intGameSpeedMedium on, see tähendab, et see on seatud keskmise raskusastmega.

Järgmisena pange see kood tühjusseadistusse just sisestatud koodi alla.

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

Seriaalne algus (9600);

See käsib arduino'l hakata arvutiga jadamonitori kaudu suhtlema (nähtav, klõpsates arduino IDE paremas ülanurgas asuvat nuppu).

Teie tühimike seadistus peaks nüüd välja nägema umbes selline!

void setup () {Serial.begin (9600); // seeriamonitori käivitamine // muutujate seadistamine bolPlay = false; intScore = 0; intTick = 0; intDelay = 1000; intDiff = 1; intGameSpeed = intGameSpeedMedium; // alusta lcd lcdLeft.begin (16, 2); lcdRight.begin (16, 2); }

4. samm: silmuse funktsioon

Silmusfunktsiooni juhib arduino igal arduino iteratsioonil.

Kopeerige järgmine kood oma tühjusse.

void loop () {input (); // kontrollige mängimissisendit, kui (bolPlay == true) {if (intTick> = intDelay) {// kontrollige, kas mäng peaks mängima kordi või ootama Serial.println ("~~~~~~~ ~~ "); // print, mis tähistab tahvli liikumist // writeSerial (); // kui suvand on lubatud, kirjuta plaat jadanuppudesseGame (); // kontrollige mängija sisendeid playBoard (); // liiguta tahvlit ja lisa uus plaat clearLcd (); // puhasta LCD enne joonistamist drawBoard (); // joonista tahvel lcd põhjaleCheck (); intTick = 0; // intTick lähtestamine} else {buttonsGame (); // kontrollige mängija sisendeid clearLcd (); // puhasta LCD enne joonistamist drawBoard (); // joonista tahvel lcd -le intTick = intTick + intGameSpeed; // lisa linnukesse}} else {clearLcd (); // LCD puhastamine enne pealkirja joonistamist (); // kuva pealkirja ja tulemuste info nupudMenüü (); // mängija sisendi lugemine clearBoard (); // taga kogu laud = 0} viivitus (10); // viivitage arduino lühikese hetkega}

kui bolPlay võrdub tõesega, tähendab see, et mängu mängitakse ja kogu mängu esitamise kood tuleks käivitada, kuid me tahame, et laud lisaks uue plaadi ja liiguks allapoole, kui intTick on suurem kui meie intDelay, vastasel juhul tahame ikkagi lubada kasutajal plaadile vajutamiseks nuppu vajutada ja intTick kiirust suurendada.

Enamik sellest koodist kasutab funktsioone, mida me veel ei tee, ja teeme need järgmistes sammudes. Nende funktsioonide eesmärk on järgmine.

Sisend loeb, milliseid nuppe kasutaja on vajutanud.

nupudGame kontrollib, mida nupud mängu ajal teevad, mitte menüüs

playBoard lisab tahvlile uue plaadi ja liigutab seejärel kõik plaadil olevad kohad allapoole

clearLCD puhastab LCD -d, veendumaks, et plaatide taha ei jää kummitusi

drawBoard läbib arrGame'i ja prindib selle LCD -ekraanile

clearBoard kustutab kogu arrGame'i, kui mäng pole mängus

bottomCheck kontrollib arrGame'i põhja ebaõnnestumist

pealkiri kuvab menüüs mängu pealkirja ja skooriteabe

nuppude menüü juhib seda, mida kasutaja sisendid menüüs olles teevad.

gameOver on veel üks funktsioon, kuigi seda siin ei kutsuta, nagu seda nimetatakse allosas Kontrollige ja nupud Mäng.

Samm: ClearLCD funktsioon

funktsiooni loomiseks alustame selle lisamisega koodile

void functionName () {

}

"functionName" võib olla ükskõik milline, kui seda juba pole.

Kopeerige see kood oma programmi:

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

see läbib kogu massiivi, kasutades 2 loendatud silmust, et läbida iga LCD -ekraanipunkt ja kirjutada tühik.

Ilma millegi lähtestamiseta säilitavad LCD -ekraanid kõik, mis varem kirjutati

6. samm: joonistuslaua funktsioon

kopeerige see kood oma programmi

void drawBoard () {for (int i = 1; i <= 15; i ++) {// joonista kollumid 1 ja 2 vasakul LCD -ekraanil // kui paan = 0 ei kirjuta midagi, = 1 kirjutab "#", = 2 kirjuta "@" lcdLeft.setCursor (i, 1); // seadistatakse esimeseks veeruks (kõige kaugemal vasakul) if (arrGame [0] == 1) {lcdLeft.write ("#");} if (arrGame [0] == 2) {lcdLeft.write ("@");} lcdLeft.setCursor (i, 0); // seadke teisele veerule (keskel vasakul), kui (arrGame [1] == 1) {lcdLeft.write ("#");} if (arrGame [1] == 2) {lcdLeft.write ("@");} lcdRight.setCursor (i, 1); // seada kolmandasse veergu (paremal keskel) if (arrGame [2] == 1) {lcdRight.write ("#");} if (arrGame [2] == 2) {lcdRight.write ("@");} lcdRight.setCursor (i, 0); // seatud neljandale veerule (kõige kaugemal paremal) if (arrGame [3] == 1) {lcdRight.write ("#");} if (arrGame [3] == 2) {lcdRight.write ("@");}}}

see kasutab tahvli iga rea läbimiseks silmust, seejärel kontrollib, kas rea üks veerg on võrdne 1 või 2, selle põhjal prindib see seejärel LCD -le kas hashtagi tabamust või @ plahvatusplaadi jaoks.

Samm 7: PlayBoardi funktsioon

kopeerige see kood oma programmi.

void playBoard () {for (int i = 0; i <= 3; i ++) {arrGame [0] = 0;} // tühjendage ülemine rida arrGame [0] [juhuslik (0, 4)] = 1; // määrake ülemisele reale juhuslik punkt, et olla paan (int i = 15; i> = 1; i-) {// tahvli alt ülespoole töötamiseks (int ii = 0; ii <= 3; ii ++) {// iga kollumi kohta arrGame [ii] = arrGame [i - 1] [ii]; }}}

see kood algab kogu ülemise rea tühjendamisega väärtuseks 0 või üldse mitte ja seab seejärel ühe juhusliku paani väärtuseks 1 ja tühi paan.

Seejärel läbib see loendatud silmuse tagurpidi, vahemikus 15 kuni 1, seades rea võrdseks, olenemata selle kohal olevast reast, mis muudab plaadi LCD -ekraanil allapoole

8. samm: ClearBoardi funktsioon

kopeerige see kood oma programmi.

void clearBoard () {// lähtesta puugi ja viivituse väärtused intTick = 0; intDelay = 1000; // minge tahvlist läbi ja seadke kõik väärtusele 0 (int i = 0; i <= 15; i ++) {jaoks (int ii = 0; ii <= 3; ii ++) {arrGame [ii] = 0; }}}

Seda koodi käitatakse siis, kui mängu ei mängita, veendumaks, et kogu arrGame on seatud väärtusele 0 või pole plaate, kasutades massiivi läbimiseks loendatud silmuseid.

Samuti lähtestab kood intDelay ja intTick väärtused.

9. samm: pealkirja funktsioon

kopeerige järgmine kood oma programmi

void title () {// kirjutage pealkiri LCD -le ja tühik skoori jaoks lcdRight.setCursor (0, 0); lcdRight.write ("Klaveriplaadid"); lcdRight.setCursor (0, 1); lcdRight.write ("Skoor:"); // teisendada skoor stringiks char strScore [3]; sprintf (strScore, "%d", intScore); // kuva skoor LCD -le lcdRight.write (strScore); // lisage raskesti lcdRight.setCursor (10, 1); if (intDiff == 0) {lcdRight.write ("Lihtne"); } if (intDiff == 1) {lcdRight.write ("Keskmine"); } if (intDiff == 2) {lcdRight.write ("Raske"); } // Vajutage natuke käsku lcdLeft.setCursor (0, 0); lcdLeft.write ("Vajutage sisestusklahvi"); lcdLeft.setCursor (0, 1); lcdLeft.write ("alustada!"); }

See kood kirjutab mängu pealkirja ja partituuri LCD -ekraanile, teatades LCD -le, kust alustada tippimist, kasutades LCD.setCursor ja kirjutades seejärel stringi LCD.write.

Siia luuakse ka uus muutuja strScore, mida kasutatakse intScore teisendamiseks string- või char -andmetüübiks, kasutades funktsiooni sprintf.

Siin kasutatakse ka intDiff, mis trükib selle väärtuste põhjal erinevaid raskusvõimalusi.

10. samm: nuppude menüü funktsioon

sisestage oma programmi järgmine kood

void nupudMenüü () {// kui sisestusklahvi vajutatakse, käivitage mäng ja nullige skoori väärtus, kui (intEnter == 1) {bolPlay = true; intScore = 0; playBoard (); drawBoard (); } // nupu 3 vajutamisel lülitage sisse silumisvõimalus trükkida tahvlit järjestikku, kui (intInput == 3) {if (bolSerialBoard == false) {Serial.println ("Serial Board Active"); bolSerialBoard = tõsi; } else {Serial.println ("Serial Board Disabled"); bolSerialBoard = vale; }} // seadke mängu kiirus kergeks raskuseks, kui (intInput == 0) {Serial.print ("Mäng on seatud lihtsaks ("); Serial.print (intGameSpeedEasy); Serial.println ("ms kiirendus)"); intDiff = 0; intGameSpeed = intGameSpeedEasy; } // seadke mängu kiirus keskmise raskusastmega, kui (intInput == 1) {Serial.print ("Mäng on määratud keskmisele ("); Serial.print (intGameSpeedMedium); Serial.println ("ms kiirendus)"); intDiff = 1; intGameSpeed = intGameSpeedMedium; } // seadke mängu kiirus raskeks, kui (intInput == 2) {Serial.print ("Mäng on määratud raskeks ("); Serial.print (intGameSpeedHard); Serial.println ("ms kiirendus)"); intDiff = 2; intGameSpeed = intGameSpeedHard; }}

seda koodi käitatakse ainult siis, kui bolPlay on tühises silmus võrdne valega

kui intEnter on seatud väärtusele 1, tähendab see, et sisestusnuppu on vajutatud, kui seda vajutatakse, määrab programm bolPlay väärtuseks true ja mäng algab.

Seejärel loeb programm, millega intInput võrdub. kui see on 0, siis vajutatakse vasakult esimest nuppu, paremale ülespoole kuni 3. Kui intInput on võrdne 4, ei vajutata ühtegi nuppu.

kui vajutada nuppe 0-2, muudab mäng raskusi, reguleerides ka mängu kiiruse väärtust, mis tähendab, et see kiireneb kiiremini.

Kui vajutate nuppu 3, aktiveerib või deaktiveerib mäng silumisrežiimi, kus kogu plaat on seeriamonitoris trükitud, et aidata programmis probleeme leida.

11. samm: funktsioon ButtonsGame

kopeerige järgmine kood oma programmi

void buttonsGame () {if (intInput! = 4) {// kui nuppu vajutatakse, kui (bolTilePressed == false) {// ainult juhul, kui bolTilePressed on vale käivitustoiming nupuvajutuse kontrollimiseks bolTilePressed = true; // seejärel määrake bolTilePressed väärtusele true, et veenduda, et see ei käivitu juhuslikult uuesti int intLowestTile = 0; // seadistatakse madalaima paaniga plaadile int intCheckedTile = 15; // jälgida, milliseid paane on kontrollitud (intLowestTile == 0) {// seni, kuni see pole midagi määratud, kontrollige plaate (int i = 0; i 100) {// seni, kuni int viivitus ei ole väiksem kui 100 intDelay = intDelay - 20; // võta sealt väärtus}} else {Serial.println ("Vale nupp vajutatud"); mäng läbi(); // muidu mäng läbi}}}}}

Kood käivitatakse ainult siis, kui bolPlay võrdub tõesega tühjas silmus.

Sarnaselt nuppudega Menüü intInput väärtuse põhjal kontrollib, kas mängija on paani tabanud või selle vahele jätnud.

Selleks minge altGM alla alt üles, kasutades while -tsüklit, et otsida, milline rida on unhi plaadiga madalaim. Seejärel kontrollib see, kas selle rea punkt, mis vastab vajutatud nupule, on unhi plaat või mitte, kui see on unhit, määrab selle väärtuseks 1 asemel 2, mis tähendab, et see kuvatakse @-na, vastasel juhul käivitab mängu funktsioon, mida me veel loome.

See funktsioon kasutab ka muutujat bolTilePressed, seades selle nupule vajutamisel väärtuseks tõene ja nupule mittevajutamisel vale. Selle eesmärk on tagada, et kasutaja ei kaotaks mängu kogemata lahti, kuna programm arvas, et nad vajutasid seda nuppu all hoides mitu korda.

12. samm: funktsioon GameOver

Kopeerige järgmine kood oma programmi

void gameOver () {Serial.println ("Mäng läbi!"); Serial.print ("Teie tulemus oli:"); Serial.println (intScore); Serial.print ("Teie kiirus oli:"); Serial.println (intDelay); bolPlay = vale; }

Selle käivitab kas funktsioonid checkBottom või nupudGame ja käivitab mängu lõpu, määrates bolPlay väärtuseks vale.

Samuti prindib see kasutajate skoori jada monitorile sõnumi ja kiirusplaadid lisati millisekundites.

Samm 13: sisendfunktsioon

Kopeerige järgmine kood oma programmi.

tühi sisend () {intEnter = digitalRead (btnEnter); // read enter // lugege, milline teistest sisenditest või kui ükski pole seatud väärtusele 4, kui (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; }}}} // seeriaprindib sisendid if (intEnter == 1) {Serial.println ("Enter Pressed!");} if (intInput! = 4) {Serial.print ("Button Press:"); Serial.println (intInput); } else {// kui ühtegi nuppu ei vajutata lähtestamine bolTilePressed bolTilePressed = false; }}

Seda koodi kasutatakse nuppudega Mäng ja nupud Menüü. kasutaja poolt vajutatud nuppude põhjal määrab intInput väärtuse või kui ühtegi nuppu ei vajutata, seab intInput väärtuseks 4.

Kui ühtegi nuppu ei vajutata, lähtestatakse nuppudeGame funktsioon BolTilePressed.

See prindib ka teate jadamonitorile, millel nuppu vajutatakse.

14. samm: funktsioon BottomCheck

kopeerige järgmine kood oma programmi.

void bottomCheck () {for (int i = 0; i <= 3; i ++) {// 4 veeru jaoks, kui (arrGame [15] == 1) {// kui plaat on all Serial.println ("Plaat allosas"); arrGame [15] = 2; drawBoard (); viivitus (400); arrGame [15] = 1; drawBoard (); viivitus (400); arrGame [15] = 2; drawBoard (); viivitus (400); arrGame [15] = 1; drawBoard (); viivitus (400); mäng läbi(); }}}

kasutades seda tsüklit, kontrollib see kood arrGame alumist rida kõikide unhit -plaatide osas (plaadid võrdsed 1 -ga), kui ekraani allosas on unhi -plaat, vilgutab see plaati ja käivitab seejärel mängu üle funktsiooni.

Samm 15: WriteSerial funktsioon

kopeerige järgmine kood oma programmi

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

See on funktsioon, millele järgneb silumisvalik, mida saab nuppude menüü funktsioonis lubada. Kui bolSerialBoard on selles funktsioonis seatud väärtusele true, läbib see arrGame ja prindib massiivi abil testimiseks kogu plaadi jadamonitori.

16. samm: lõpetamine

Kogu teie kood ei peaks olema täielik ja välja nägema midagi sellist!

/ * * Nimi - klaveriplaadid; Arduino * Autor - Domenic Marulli * Kuupäev - 11/ *

/ sisaldavad raamatukogusid

#kaasake

// need muutujad on valikud, mida saate muuta - suuremad numbrid = kiirem mäng

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

// Määrake tihvtid

#define btn Sisestage A0 #define btn1 15 #define btn2 16 #define btn3 17 #define btn4 18

// LCD -objektide loomine (n, ~, n, ~, ~, n)

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

// seadistage mängumassiiv

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

// mängu muutujate seadistamine

boolean bolPlay; // jälgib, kui mängija int intScore; // jälgib mängija tulemust int intdiff; // lihtsalt esteetiline asi, et öelda, mis raskustega mäng on

// muutujate seadistamine sisendiks

int intEnter; // jälgib, kui kasutaja vajutab sisestusnuppu int intInput; // jälgib, milliseid nuppe kasutaja vajutab boolean bolTilePressed; // veenduge, et mängija ei vajuta kogemata 5x nuppu ja kaotab

// muutujate seadistamine pöördele

int intTick; // loeb millisid (silmuse kohta) kuni intDelay int intDelay; // aeg, mil programm ootab järgmist pööret millis int intGameSpeed;

// silumisvalikute abit

boolean bolSerialBoard; // kui tõene, prindib tahvli jadamonitoris

// seadistus, mis käivitatakse üks kord

void setup () {Serial.begin (9600); // seeriamonitori käivitamine // muutujate seadistamine bolPlay = false; intScore = 0; intTick = 0; intDelay = 1000; intDiff = 1; intGameSpeed = intGameSpeedMedium; // alusta lcd lcdLeft.begin (16, 2); lcdRight.begin (16, 2); }

// tsükkel, mida käivitatakse iga 10 millisekundi järel

void loop () {input (); // kontrollige mängimissisendit, kui (bolPlay == true) {if (intTick> = intDelay) {// kontrollige, kas mäng peaks mängima kordi või ootama Serial.println ("~~~~~~~ ~~ "); // print, mis tähistab tahvli liikumist // writeSerial (); // kui suvand on lubatud, kirjuta plaat jadanuppudesseGame (); // kontrollige mängija sisendeid playBoard (); // liiguta tahvlit ja lisa uus plaat clearLcd (); // puhasta LCD enne joonistamist drawBoard (); // joonista tahvel lcd põhjaleCheck (); intTick = 0; // intTick lähtestamine} else {buttonsGame (); // kontrollige mängija sisendeid clearLcd (); // puhasta LCD enne joonistamist drawBoard (); // joonista tahvel lcd -le intTick = intTick + intGameSpeed; // lisa linnukesse}} else {clearLcd (); // LCD puhastamine enne pealkirja joonistamist (); // kuva pealkirja ja tulemuste info nupudMenüü (); // mängija sisendi lugemine clearBoard (); // taga kogu laud = 0} viivitus (10); // viivitage arduino lühikese hetkega}

// puhastab lcd, nii et kõik sisestamata lahtrid ei jää sinna

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

// tõmbab tahvli lcd -le

void drawBoard () {for (int i = 1; i <= 15; i ++) {// joonista kollumid 1 ja 2 vasakul LCD -ekraanil // kui paan = 0 ei kirjuta midagi, = 1 kirjutab "#", = 2 kirjuta "@" lcdLeft.setCursor (i, 1); // seadistatakse esimeseks veeruks (kõige kaugemal vasakul) if (arrGame [0] == 1) {lcdLeft.write ("#");} if (arrGame [0] == 2) {lcdLeft.write ("@");} lcdLeft.setCursor (i, 0); // seadke teisele veerule (keskel vasakul), kui (arrGame [1] == 1) {lcdLeft.write ("#");} if (arrGame [1] == 2) {lcdLeft.write ("@");} lcdRight.setCursor (i, 1); // seada kolmandasse veergu (paremal keskel) if (arrGame [2] == 1) {lcdRight.write ("#");} if (arrGame [2] == 2) {lcdRight.write ("@");} lcdRight.setCursor (i, 0); // seatud neljandale veerule (kõige kaugemal paremal) if (arrGame [3] == 1) {lcdRight.write ("#");} if (arrGame [3] == 2) {lcdRight.write ("@");}}}

// liigutab tahvlit allapoole ja paneb juhusliku väärtuse plaadiks

void playBoard () {for (int i = 0; i <= 3; i ++) {arrGame [0] = 0;} // tühjendage ülemine rida arrGame [0] [juhuslik (0, 4)] = 1; // määrake ülemisele reale juhuslik punkt, et olla paan (int i = 15; i> = 1; i-) {// tahvli alt ülespoole töötamiseks (int ii = 0; ii <= 3; ii ++) {// iga kollumi kohta arrGame [ii] = arrGame [i - 1] [ii]; }}}

// seab kogu plaadi väärtuseks 0 ja lähtestab muutujad eelmängule

void clearBoard () {// lähtesta puugi ja viivituse väärtused intTick = 0; intDelay = 1000; // minge tahvlist läbi ja seadke kõik väärtusele 0 (int i = 0; i <= 15; i ++) {jaoks (int ii = 0; ii <= 3; ii ++) {arrGame [ii] = 0; }}}

// kuvab LCD -ekraanil peamenüü

void title () {// kirjutage pealkiri LCD -le ja tühik skoori jaoks lcdRight.setCursor (0, 0); lcdRight.write ("Klaveriplaadid"); lcdRight.setCursor (0, 1); lcdRight.write ("Skoor:"); // teisendada skoor stringiks char strScore [3]; sprintf (strScore, "%d", intScore); // kuva skoor LCD -le lcdRight.write (strScore); // lisage raskesti lcdRight.setCursor (10, 1); if (intDiff == 0) {lcdRight.write ("Lihtne"); } if (intDiff == 1) {lcdRight.write ("Keskmine"); } if (intDiff == 2) {lcdRight.write ("Raske"); } // Vajutage natuke käsku lcdLeft.setCursor (0, 0); lcdLeft.write ("Vajutage sisestusklahvi"); lcdLeft.setCursor (0, 1); lcdLeft.write ("alustada!"); }

// kontrollib nuppe ja mida nende jaoks mängust väljas olles teha

void nupudMenüü () {// kui sisestusklahvi vajutatakse, käivitage mäng ja nullige skoori väärtus, kui (intEnter == 1) {bolPlay = true; intScore = 0; playBoard (); drawBoard (); } // nupu 3 vajutamisel lülitage sisse silumisvõimalus trükkida tahvlit järjestikku, kui (intInput == 3) {if (bolSerialBoard == false) {Serial.println ("Serial Board Active"); bolSerialBoard = tõsi; } else {Serial.println ("Serial Board Disabled"); bolSerialBoard = vale; }} // seadke mängu kiirus kergeks raskuseks, kui (intInput == 0) {Serial.print ("Mäng on seatud lihtsaks ("); Serial.print (intGameSpeedEasy); Serial.println ("ms kiirendus)"); intDiff = 0; intGameSpeed = intGameSpeedEasy; } // seadke mängu kiirus keskmise raskusastmega, kui (intInput == 1) {Serial.print ("Mäng on määratud keskmisele ("); Serial.print (intGameSpeedMedium); Serial.println ("ms kiirendus)"); intDiff = 1; intGameSpeed = intGameSpeedMedium; } // seadke mängu kiirus raskeks, kui (intInput == 2) {Serial.print ("Mäng on määratud raskeks ("); Serial.print (intGameSpeedHard); Serial.println ("ms kiirendus)"); intDiff = 2; intGameSpeed = intGameSpeedHard; }}

// kontrollib nuppe ja mida nende jaoks mängu ajal teha

void buttonsGame () {if (intInput! = 4) {// kui nuppu vajutatakse, kui (bolTilePressed == false) {// ainult juhul, kui bolTilePressed on vale käivitustoiming nupuvajutuse kontrollimiseks bolTilePressed = true; // seejärel määrake bolTilePressed väärtusele true, et veenduda, et see ei käivitu juhuslikult uuesti int intLowestTile = 0; // seadistatakse madalaima paaniga plaadile int intCheckedTile = 15; // jälgida, milliseid paane on kontrollitud (intLowestTile == 0) {// seni, kuni see pole midagi määratud, kontrollige plaate (int i = 0; i 100) {// seni, kuni int viivitus ei ole väiksem kui 100 intDelay = intDelay - 20; // võta sealt väärtus}} else {Serial.println ("Vale nupp vajutatud"); mäng läbi(); // muidu mäng läbi}}}}}

void gameOver () {

Serial.println ("Mäng läbi!"); Serial.print ("Teie tulemus oli:"); Serial.println (intScore); Serial.print ("Teie kiirus oli:"); Serial.println (intDelay); bolPlay = vale; }

// kontrollib mängija sisendit

tühine sisend () {intEnter = digitalRead (btnEnter); // loe sisestamine // loe, milline teistest sisenditest või kui ükski pole seatud väärtusele 4, kui (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; }}}} // seeriaprindib sisendid if (intEnter == 1) {Serial.println ("Enter Pressed!");} if (intInput! = 4) {Serial.print ("Button Press:"); Serial.println (intInput); } else {// kui ühtegi nuppu ei vajutata lähtestamine bolTilePressed bolTilePressed = false; }}

// kontrollib tahvli põhja ebaõnnestumist

void bottomCheck () {for (int i = 0; i <= 3; i ++) {// 4 veeru jaoks, kui (arrGame [15] == 1) {// kui plaat on all Serial.println ("Plaat allosas"); arrGame [15] = 2; drawBoard (); viivitus (400); arrGame [15] = 1; drawBoard (); viivitus (400); arrGame [15] = 2; drawBoard (); viivitus (400); arrGame [15] = 1; drawBoard (); viivitus (400); mäng läbi(); }}}

// prindib tahvli jadamonitori, kui bolSerialBoard on tõene

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

Kui kogu kood on sisestatud, laadige üles oma arduino ja nautige!