Arduino - zongoracsempe: 16 lépés (képekkel)

2024 Szerző: John Day | [email protected]. Utoljára módosítva: 2024-01-30 09:42

Sziasztok internetes emberek! Ez arról fog szólni, hogy miként tehetjük meg azt, ami VISZONYAN nem egy mobil játék letörlése egy arduino uno r3 -on.

így a kezdéshez szüksége lesz az összes alkatrészre, amelyek a következők: 1x Arduino Uno r3 ($ 42)

2x LCD billentyűpajzs (egyenként 19 USD)

5x gombok

5x 220Ω ellenállás

28x vezeték

Rendben, ha megvan az összes alkatrész, ideje elkezdeni!

1. lépés: Kábelezés

Kezdje az arduino és barátai bekötésével, ahogy az ábra mutatja, Győződjön meg arról, hogy a gombok a megfelelő irányban vannak összekapcsolva, az A0-4 nyílásokkal a gombok síneinek földi oldalán, különben az arduino azt gondolja, hogy a gombokat folyamatosan lenyomva tartja, nem pedig csak megnyomásra.

2. lépés: Nyilatkozat

Itt minden kódnak a void setup és void loop előtt kell lennie, mert mindezeket a változókat és objektumokat számos általunk beállított funkcióban használják.

Kezdje azzal, hogy felteszi:

#befoglalni

a kód tetején ez azt jelzi az arduino -nak, hogy használja a "LiquidCrystal.h" könyvtárat és annak funkcióit.

A következő lépés az, hogy meghatározzuk a gombjainkhoz használt csapokat úgy, hogy ezt a kódot beírjuk a #include alá:

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

Meghatározzuk a btnEnter és a btn1 -btn 4 kifejezéseket, hogy megkönnyítsük a kód olvasását, vagy szükség esetén módosítsuk. Ez azt jelenti, hogy a btn1 beírásakor az arduino tudni fogja, hogy valójában a 15 gombot értjük. Bár a portokat 15, 16, 17 és 18 portnak hívjuk, az arduino -n A1 A2 A3 és A4 címkével vannak ellátva, ez azért van, mert ezek kifejezetten analóg bemenetekhez használt portok, bár ezeket csak digitális bemenetekhez használjuk.

Ezután létrehozzuk azokat az objektumokat, amelyek a folyadékkristályos kijelzőket irányítják. Ehhez tegye ezt a kódot a definícióink alá

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

Ez azt mondja az arduino -nak, hogy amikor az lcdLeft vagy az lcdRight parancsot hívjuk, egy LiquidCrystal objektumra hivatkozunk. A csatolt zárójelben lévő számok jelzik az arduino számára, hogy az objektum mely portokat használja üzenetek küldésére az LCD -re, amikor a funkcióikat használjuk.

Most deklarálnunk kell a változókat úgy, hogy a következő kódrészletet az objektum deklarációk alá tesszük:

// ezek a változók változtatható lehetőségek - magasabb számok = gyorsabb játéksebesség upint intGameSpeedEasy = 10; int intGameSpeedMedium = 25; int intGameSpeedHard = 80;

// változók beállítása a gameboolean bolPlay; // nyomon követi, ha a játékos int intScore; // követi a játékos pontszámát int intiff; // csak egy esztétikai dolog a játék nehézségeinek megmondására // változók beállítása az int intEnter bemenetére; // nyomon követi, ha a felhasználó megnyomja az enter gombot int intInput; // nyomon követi, hogy mely gombokat nyomja meg a felhasználó a boolean bolTilePressed; // biztosítsuk, hogy a játékos véletlenül ne nyomjon meg egy gombot 5x és ne veszítsen // állítson be változókat a turn int intTick; // milliókat számlál (ciklusonként), amíg intDelay int intDelay; // az az idő, amikor a program vár a következő fordulóig millis int intGameSpeed; // abit of debug options boolean bolSerialBoard; // amikor true, akkor kinyomtatja a táblát a soros monitoron

Változót deklarálunk az adattípus, majd a változó nevének megadásával, pl. int thisIsAnInteger

A logikai változók, például a bolSerialBoard és a bolPlay két érték közül csak egyet tartalmazhatnak, igaz vagy hamis.

Az egész változó (int), például az intScore és az intInput egész számokat vehet fel értékként, például 1, 5 vagy 100.

Néhány más figyelemre méltó adattípus, amelyet itt nem használunk, egy karakterlánc, amely egy szövegdarab, és egy úszó, amely egy tizedes szám.

A program minden változóját több helyen is használja a program, itt van egy összefoglaló arról, hogy mindegyik mit tesz

A bolPlay megmondja a programnak, hogy meg kell -e jeleníteni a menüt, vagy a tényleges játéknak kell futnia.

Az intScore nyomon követi a játékos pontszámát a lapkák ütésekor, Az intDiff a főmenüben jelzi a programnak, hogy milyen szöveget kell kinyomtatni az LCD -ken, Az intEnter jelzi a programnak, ha az Enter gombot (balra legtávolabb) nyomja meg, Az intInput segítségével meg lehet mondani a programnak, hogy a másik 4 gomb közül melyiket nyomja meg.

A bolTilePressed segítségével biztosítható, hogy a program csak a gomb megnyomásakor olvasson, és ne tartsa lenyomva.

Az intGameSpeed, intGameSpeedEasy, intGameSpeedMedium és intGameSpeedHard segítségével szabályozható, hogy a játék milyen gyorsan gyorsuljon fel a kiválasztott nehézség alapján.

Az intTick és az intDelay segítségével megakadályozható, hogy a program minden ciklusban mozgassa a táblát.

A bolSerialBoard lehetővé teszi, hogy a program tesztelési célból számlapokként küldje el a táblát az arduino soros monitorára.

Végül itt az ideje, hogy a táblánkat tömbként nyilvánítsuk a következő kód használatával:

// játék tömb beállítása 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}};

A tömb olyan mátrix, amely bármely pontja, amelyen matematika hívható vagy módosítható.

A kódnak most valahogy így kell kinéznie;

// include libraries#include

// ezek a változók olyan lehetőségek, amelyeket meg lehet változtatni - magasabb számok = gyorsabb játék

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

// Definiálja a csapokat

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

// LCD objektumok létrehozása (n, ~, n, ~, ~, n)

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

// játék tömb beállítása

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

// változók beállítása a játékhoz

logikai bolPlay; // nyomon követi, ha a játékos int intScore; // követi a játékos pontszámát int intiff; // csak egy esztétikai dolog, hogy megmondja, milyen nehézséggel jár a játék

// változók beállítása bemenetre

int intEnter; // nyomon követi, ha a felhasználó megnyomja az enter gombot int intInput; // nyomon követi, hogy mely gombokat nyomja meg a felhasználó a boolean bolTilePressed; // ügyeljen arra, hogy a játékos véletlenül ne nyomjon meg 5x egy gombot, és ne veszítsen

// változók beállítása a fordulóhoz

int intTick; // milliókat számlál (ciklusonként), amíg intDelay int intDelay; // az az idő, amikor a program vár a következő fordulóig millis int intGameSpeed;

// a hibakeresési lehetőségek abit

logikai bolSerialBoard; // amikor true, akkor kinyomtatja a táblát a soros monitoron

3. lépés: A beállítási funkció

A beállítási ciklus egy olyan funkció, amelyet az arduino csak egyszer olvas el az első indításkor.

A beállítási ciklusban csak néhány változónk értékét állítjuk be, mert ahelyett, hogy értéket adnánk meg azok deklarálásakor, itt ezt tesszük.

Kezdje azzal, hogy beilleszti ezt a kódot a Void Setupba.

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

Minden sor csak egy változót állít be értékre.

A bolPlay hamisra van állítva, hogy a játék ne induljon el.

Az intScore értéke 0, mert természetesen a pontszám 0 -tól kezdődik.

Az intTick 0 -ról indul, mert a program jelenleg nem számít semmit.

Az intDelay 1000 -re van állítva, mert a csempe ezzel kezdődik.

Az intDiff csak egy aszketikus dolog, hogy a program tudja, mit írjon a játék nehézségeire.

Az intGameSpeed bármilyen intGameSpeedMedium értékre van állítva, vagyis közepes nehézségű.

Ezután helyezze be ezt a kódot az Üres beállításokba az imént megadott kód alá.

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

Sorozat.kezdet (9600);

Ez azt mondja az arduino -nak, hogy kezdje el a kommunikációt a számítógéppel a soros monitoron keresztül (ez látható az arduino IDE jobb felső sarkában található gombra kattintva).

A Void Setup most valahogy így néz ki!

void setup () {Serial.begin (9600); // indítsa el a soros monitort // állítsa be a változókat bolPlay = false; intScore = 0; intTick = 0; intDelay = 1000; intDiff = 1; intGameSpeed = intGameSpeedMedium; // start lcd's lcdLeft.begin (16, 2); lcdRight.begin (16, 2); }

4. lépés: A hurok funkció

A ciklus funkciót az arduino futtatja az arduino minden iterációja során.

Másolja a következő kódot a Void Loop -ba.

void loop () {input (); // ellenőrizze a lejátszási bemenetet, ha (bolPlay == true) {if (intTick> = intDelay) {// ellenőrizze, hogy a játéknak játszania kell -e, vagy várnia kell -e a Serial.println ("~~~~~~~ ~~ "); // nyomtatás a tábla továbbhaladásának jelezésére // writeSerial (); // ha az opció engedélyezve van, írja be a táblát a soros gombokbaGame (); // a lejátszó bemeneteinek ellenőrzése playBoard (); // mozgassa a táblát és adjon hozzá egy új lapkát clearLcd (); // tisztítsa meg az LCD -ket rajzolás előtt drawBoard (); // rajzoljuk a táblát az lcd aljáraCheck (); intTick = 0; // intTick visszaállítása} else {buttonsGame (); // a játékos bemeneteinek ellenőrzése clearLcd (); // tisztítsa meg az LCD -ket rajzolás előtt drawBoard (); // rajzoljuk a táblát az lcd intTick = intTick + intGameSpeed; // hozzáadás a kullancshoz}} else {clearLcd (); // tisztítsa meg az LCD -ket a cím () rajzolása előtt; // cím és pontszám információ gombok megjelenítéseMenu (); // a lejátszó bemenetének olvasása clearBoard (); // az egész tábla biztosítása = 0} delay (10); // késleltesse az arduino -t egy rövid pillanattal}

ha a bolPlay egyenlő az igaz értékkel, az azt jelenti, hogy a játék zajlik, és a játék során használt összes kódot futtatni kell, de csak azt szeretnénk, ha a tábla új lapkát adna hozzá, és lefelé lépne, ha az intTick nagyobb, mint az intDelay, ellenkező esetben továbbra is engedélyezni szeretnénk, hogy a felhasználó megnyomjon egy gombot egy lapka eléréséhez, és az intTick növelje a sebességet.

Ennek a kódnak a nagy része olyan funkciókat használ, amelyeket még el kell készítenünk, és a következő lépésekben elkészítjük őket. E funkciók célja a következő.

A bemenet olvassa, hogy a felhasználó mely gombokat nyomta meg.

buttonGame szabályozza, hogy a gombok mit csinálnak a játékban, és nem a menüben

A playBoard új lapkát ad hozzá a táblához, majd a táblán lévő összes elemet egy mezővel lefelé mozgatja

A clearLCD tisztítja az LCD -ket, hogy megbizonyosodjon arról, hogy a lapok mögött nem marad szellem

A drawBoard átmegy az arrGame -en, és kinyomtatja az LCD -ken

A clearBoard törli az egész arrGame -et, ha a játék nincs játékban

bottomCheck ellenőrzi az arrGame alját hibaállapotban

title megjeleníti a játék címét és pontszámadatait, amikor a menüben van

gombok menü vezérli, hogy a felhasználó bemenetei mit csinálnak a menüben.

A gameOver egy másik funkció, bár itt nem úgy hívják, mint ahogyan az alsóCheck és gombokGame funkciókban.

5. lépés: A ClearLCD funkció

egy függvény létrehozásához először ezt adjuk hozzá a kódhoz

void functionName () {

}

a "functionName" bármi lehet, ha még nem létezik.

Másolja ezt a kódot a programba:

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

ez végigfut a teljes tömbön 2 számlált hurok használatával, hogy végigmegy az LCD -k minden pontján, és szóközt ír.

A semmire való visszaállítás nélkül az LCD -k megtartják a korábban leírtakat

6. lépés: A DrawBoard funkció

másolja ezt a kódot a programjába

void drawBoard () {for (int i = 1; i <= 15; i ++) {// rajzoljon 1 -es és 2 -es collumokat a bal oldali LCD -n // ha a csempe = 0 semmit nem ír, = 1 írja "#", = 2 írjon "@" lcdLeft.setCursor (i, 1); // az első oszlopra állítva (balra legtávolabb), ha (arrGame [0] == 1) {lcdLeft.write ("#");} if (arrGame [0] == 2) {lcdLeft.write ("@");} lcdLeft.setCursor (i, 0); // állítsa a második oszlopra (bal középen), ha (arrGame [1] == 1) {lcdLeft.write ("#");} if (arrGame [1] == 2) {lcdLeft.write ("@");} lcdRight.setCursor (i, 1); // állítsa a harmadik oszlopra (jobbra középre), ha (arrGame [2] == 1) {lcdRight.write ("#");} if (arrGame [2] == 2) {lcdRight.write ("@");} lcdRight.setCursor (i, 0); // állítsa a negyedik oszlopra (a legtávolabbi jobbra), ha (arrGame [3] == 1) {lcdRight.write ("#");} if (arrGame [3] == 2) {lcdRight.ír("@");} } }

ez egy hurkot használ a tábla minden sorában, majd ellenőrzi, hogy a sor bármely oszlopa egyenlő -e 1 -vel vagy 2 -vel, ez alapján ezután kinyomtatja az LCD -n egy hashtaget, hogy egy csempe még nem lesz találat, vagy egy @ egy találati lapkához.

7. lépés: A PlayBoard funkció

másolja ezt a kódot a programjába.

void playBoard () {for (int i = 0; i <= 3; i ++) {arrGame [0] = 0;} // törölje a felső sort arrGame [0] [random (0, 4)] = 1; // állítson be egy véletlenszerű pontot a felső sorban, hogy legyen csempéje (int i = 15; i> = 1; i-) {// a tábla aljától a tetejéig dolgozik (int ii = 0; ii <= 3; ii ++) {// minden kollum esetében arrGame [ii] = arrGame [i - 1] [ii]; }}}

ez a kód azzal kezdődik, hogy az egész felső sort 0 -ra törli, vagy nincs csempét, majd egy véletlenszerű csempét 1 -es és unhit csempének állít be.

Ezután egy visszaszámlált cikluson megy keresztül fordítva, 15 -ről 1 -re, és a sort egyenlővé teszi a fölötte lévő sorral, és a panel lefelé mozog az LCD -n

8. lépés: A ClearBoard funkció

másolja ezt a kódot a programjába.

void clearBoard () {// a kullancs és késleltetés értékeinek visszaállítása intTick = 0; intDelay = 1000; // menjen át a táblán, és állítson be mindent 0 -ra (int i = 0; i <= 15; i ++) {for (int ii = 0; ii <= 3; ii ++) {arrGame [ii] = 0; }}}

Ez a kód akkor fut, amikor a játék nem játszódik le, hogy megbizonyosodjon arról, hogy az arrGame egésze 0 -ra van állítva, vagy nincsenek lapkák.

A kód visszaállítja az intDelay és az intTick értékeit is.

9. lépés: A cím funkció

másolja a programba a következő kódot

void title () {// írjon címet az LCD -re és szóközt lcdRight.setCursor (0, 0); lcdRight.write ("Zongoracsempe"); lcdRight.setCursor (0, 1); lcdRight.write ("Pontszám:"); // konvertálja a pontszámot karakterlánccá char strScore [3]; sprintf (strScore, "%d", intScore); // a pontszám megjelenítése LCD -n lcdRight.write (strScore); // add hozzá a nehéz lcdRight.setCursor (10, 1); if (intDiff == 0) {lcdRight.write ("Egyszerű"); } if (intDiff == 1) {lcdRight.write ("Közepes"); } if (intDiff == 2) {lcdRight.write ("Kemény"); } // Nyomjon egy kis utasítást lcdLeft.setCursor (0, 0); lcdLeft.write ("Nyomja le az Enter billentyűt"); lcdLeft.setCursor (0, 1); lcdLeft.write ("kezdeni!"); }

Ez a kód felírja a játék címét és a pontszámot az LCD -kre, ezt úgy teszi meg, hogy megmondja az LCD -nek, hol kezdje el a gépelést az LCD.setCursor használatával, majd írja be a karakterláncot az LCD.write -be.

Itt is létrejön egy új változó, az strScore, amellyel az intScore -t karakterlánccá vagy char adattípusgá alakítják a sprintf függvény használatával.

Az intDiff itt is használatos, értékei alapján kinyomtatja a különböző nehézségi lehetőségeket.

10. lépés: A ButtonsMenu funkció

illessze be a programba a következő kódot

void buttonsMenu () {// az Enter megnyomásakor indítsa el a játékot és állítsa vissza a pontszámot, ha (intEnter == 1) {bolPlay = true; intScore = 0; playBoard (); drawBoard (); } // ha megnyomja a 3 gombot, kapcsolja be a hibakeresési lehetőséget, ha sorban nyomtatja a táblát, ha (intInput == 3) {if (bolSerialBoard == false) {Serial.println ("Serial Board Active"); bolSerialBoard = igaz; } else {Serial.println ("Serial Board Disabled"); bolSerialBoard = hamis; }} // állítsa a játék sebességét könnyű nehézségre, ha (intInput == 0) {Serial.print ("A játék könnyű ("); Serial.print (intGameSpeedEasy); Serial.println ("ms gyorsítás)"); intDiff = 0; intGameSpeed = intGameSpeedEasy; } // állítsa a játék sebességét közepes nehézségűre, ha (intInput == 1) {Serial.print ("A játék közepes ("); Serial.print (intGameSpeedMedium); Serial.println ("ms gyorsítás)"); intDiff = 1; intGameSpeed = intGameSpeedMedium; } // állítsa a játék sebességét nehéz nehézségre, ha (intInput == 2) {Serial.print ("A játék keményre van állítva ("); Serial.print (intGameSpeedHard); Serial.println ("ms gyorsítás)"); intDiff = 2; intGameSpeed = intGameSpeedHard; }}

ez a kód csak akkor fut, ha a bolPlay értéke hamis a void hurokban

ha az intEnter 1 -re van állítva, az azt jelenti, hogy az enter gombot megnyomták, ha megnyomja, a program a bolPlay -t igazra állítja, és a játék elindul.

A program ekkor beolvassa, hogy az intInput egyenlő -e. ha 0, akkor a bal oldali első gombot kell megnyomni, jobbra felfelé felfelé 3 -ig. Ha az intInput értéke 4, akkor nincs gomb megnyomva.

ha megnyomja a 0-2 gombokat, a játék megváltoztatja a nehézséget, és módosítja a játék sebességét is, vagyis gyorsabban fog gyorsulni.

ha megnyomja a 3 gombot, a játék aktiválja vagy deaktiválja a hibakeresési módot, ahol a teljes táblát kinyomtatják a soros monitoron, hogy segítsenek megtalálni a program problémáit.

11. lépés: A ButtonsGame funkció

másolja a programba a következő kódot

void buttonsGame () {if (intInput! = 4) {// ha megnyom egy gombot, ha (bolTilePressed == false) {// csak akkor, ha a bolTilePressed hamis trigger művelet a gomb megnyomásának ellenőrzésére bolTilePressed = true; // majd állítsa a bolTilePressed -t true -ra, hogy megbizonyosodjon arról, hogy nem véletlenül vált ki újra int intLowestTile = 0; // a legalacsonyabb csempével rendelkező csempére kell beállítani int intCheckedTile = 15; // nyomon követni, hogy mely csempéket ellenőrizték (intLowestTile == 0) {// amíg nincs beállítva semmi, ellenőrizze a csempéket (int i = 0; i 100) {// mindaddig, amíg int késleltetés nem kevesebb, mint 100 intDelay = intDelay - 20; // értéket vesz belőle}} else {Serial.println ("Rossz gomb lenyomva"); játék vége(); // különben vége a játéknak}}}}}

A kód csak akkor fut, ha a bolPlay egyenlő a true értékkel a void Loop -ban.

A gombokhoz hasonlóan Menü az intInput értéke alapján ellenőrzi, hogy a játékos eltalált -e egy lapkát, vagy nem.

Ez úgy történik, hogy végigmegy az arrGame -en alulról felfelé egy while ciklus segítségével, hogy megkeresse, melyik sor a legalacsonyabb egy unhit csempével. Ezután ellenőrzi, hogy az adott sorban lévő gomb, amely megfelel a megnyomott gombnak, unhit csempe, vagy sem, ha unhit, akkor 2 helyett 2 helyett állítja be, azaz @-ként jelenik meg, különben elindítja a játékot funkciót, amelyet még létre kell hoznunk.

Ez a funkció a bolTilePressed változót is felhasználja, ha egy gomb megnyomásakor igaz értékre állítja, ha nincs gomb, akkor hamis. Ennek célja annak biztosítása, hogy a felhasználó ne veszítse el véletlenül a játékot, mert a program azt gondolta, hogy többször megnyomta a gombot, amikor lenyomta.

12. lépés: A GameOver funkció

Másolja a programba a következő kódot

void gameOver () {Serial.println ("A játéknak vége!"); Serial.print ("A pontszámod:"); Serial.println (intScore); Serial.print ("A sebessége:"); Serial.println (intDelay); bolPlay = hamis; }

Ezt a checkBottom vagy a buttonsGame funkciók váltják ki, és a játék végét a bolPlay hamis értékre állításával váltják ki.

Ezenkívül üzenetet nyomtat a soros monitorba a felhasználók pontszámához, és a sebességlapokat ezredmásodpercben adták hozzá.

13. lépés: A bemeneti funkció

Másolja a programba a következő kódot.

void input () {intEnter = digitalRead (btnEnter); // read enter // más bemenetek közül melyik olvasható, vagy ha egyik sem 4 -re van állítva, ha (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; }}}}} // soros nyomtatás a bemenetekre, ha (intEnter == 1) {Serial.println ("Enter Pressed!");} if (intInput! = 4) {Serial.print ("Button Press:"); Serial.println (intInput); } else {// ha egyetlen gombot sem nyom meg reset bolTilePressed bolTilePressed = false; }}

Ezt a kódot a „Játék” és a „Menü” gombokkal kell használni. a felhasználó által megnyomott gombok alapján az intInput értékét állítja be, vagy ha egyetlen gombot sem nyom meg, akkor az intInput értéke 4 lesz.

Ha egyetlen gombot sem nyom meg, akkor a bolTilePressed visszaáll a gombokGame funkcióra.

Ezenkívül üzenetet nyomtat a soros monitorra, amelyen megnyomja a gombot.

14. lépés: A BottomCheck funkció

másolja a programba a következő kódot.

void bottomCheck () {for (int i = 0; i <= 3; i ++) {// a 4 oszlophoz, ha (arrGame [15] == 1) {// ha egy csempe az alsó soros.println ("Csempe alul"); arrGame [15] = 2; drawBoard (); késleltetés (400); arrGame [15] = 1; drawBoard (); késleltetés (400); arrGame [15] = 2; drawBoard (); késleltetés (400); arrGame [15] = 1; drawBoard (); késleltetés (400); játék vége(); }}}

ciklus segítségével ez a kód ellenőrzi az arrGame alsó sorát, hogy nincs -e unhit csempe (1 -es csempe), ha van egy unhit csempe a képernyő alján, akkor villogni fogja a lapkát, majd elindítja a játék funkciót.

15. lépés: Az WriteSerial függvény

másolja a programba a következő kódot

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 (","); } Soros.println (""); }}}

Ezt a funkciót követi a hibakeresési opció, amelyet a gombok menüben lehet engedélyezni. Ha a bolSerialBoard igazra van állítva ebben a funkcióban, akkor átmegy az arrGame -en, és tömb segítségével tesztelés céljából kinyomtatja a teljes kártyát a soros monitorba.

16. lépés: Befejezés

Az összes kód nem lehet teljes, és valahogy így néz ki!

/ * * Név - Zongoracsempe; Arduino * By - Domenic Marulli * Dátum - 11/ *

/ tartalmazza a könyvtárakat

#befoglalni

// ezek a változók olyan lehetőségek, amelyeket meg lehet változtatni - magasabb számok = gyorsabb játék

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

// Definiálja a csapokat

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

// LCD objektumok létrehozása (n, ~, n, ~, ~, n)

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

// játék tömb beállítása

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

// változók beállítása a játékhoz

logikai bolPlay; // nyomon követi, ha a játékos int intScore; // követi a játékos pontszámát int intiff; // csak egy esztétikai dolog, hogy megmondja, milyen nehézséggel jár a játék

// változók beállítása bemenetre

int intEnter; // nyomon követi, ha a felhasználó megnyomja az enter gombot int intInput; // nyomon követi, hogy mely gombokat nyomja meg a felhasználó a boolean bolTilePressed; // ügyeljen arra, hogy a játékos véletlenül ne nyomjon meg 5x egy gombot, és ne veszítsen

// változók beállítása a fordulóhoz

int intTick; // milliókat számlál (ciklusonként), amíg intDelay int intDelay; // az az idő, amikor a program vár a következő fordulóig millis int intGameSpeed;

// a hibakeresési lehetőségek abit

logikai bolSerialBoard; // amikor true, akkor kinyomtatja a táblát a soros monitoron

// az egyszer futtatandó beállítás

void setup () {Serial.begin (9600); // indítsa el a soros monitort // állítsa be a változókat bolPlay = false; intScore = 0; intTick = 0; intDelay = 1000; intDiff = 1; intGameSpeed = intGameSpeedMedium; // start lcd's lcdLeft.begin (16, 2); lcdRight.begin (16, 2); }

// a ciklus, amely 10 ezredmásodpercenként fog futni

void loop () {input (); // ellenőrizze a lejátszási bemenetet, ha (bolPlay == true) {if (intTick> = intDelay) {// ellenőrizze, hogy a játéknak játszania kell -e, vagy várnia kell -e a Serial.println ("~~~~~~~ ~~ "); // nyomtatás a tábla továbbhaladásának jelezésére // writeSerial (); // ha az opció engedélyezve van, írja be a táblát a soros gombokbaGame (); // a lejátszó bemeneteinek ellenőrzése playBoard (); // mozgassa a táblát és adjon hozzá egy új lapkát clearLcd (); // tisztítsa meg az LCD -ket rajzolás előtt drawBoard (); // rajzoljuk a táblát az lcd aljáraCheck (); intTick = 0; // intTick visszaállítása} else {buttonsGame (); // a játékos bemeneteinek ellenőrzése clearLcd (); // tisztítsa meg az LCD -ket rajzolás előtt drawBoard (); // rajzoljuk a táblát az lcd intTick = intTick + intGameSpeed; // hozzáadás a kullancshoz}} else {clearLcd (); // tisztítsa meg az LCD -ket a cím () rajzolása előtt; // cím és pontszám információ gombok megjelenítéseMenu (); // a lejátszó bemenetének olvasása clearBoard (); // az egész tábla biztosítása = 0} delay (10); // késleltesse az arduino -t egy rövid pillanattal}

// megtisztítja az LCD -t, így a nem bevitt cellák nem maradtak ott

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

// ráhúzza a táblát az LCD -re

void drawBoard () {for (int i = 1; i <= 15; i ++) {// rajzoljon 1 -es és 2 -es collumokat a bal oldali LCD -n // ha a csempe = 0 semmit nem ír, = 1 írja "#", = 2 írjon "@" lcdLeft.setCursor (i, 1); // az első oszlopra állítva (balra legtávolabb), ha (arrGame [0] == 1) {lcdLeft.write ("#");} if (arrGame [0] == 2) {lcdLeft.write ("@");} lcdLeft.setCursor (i, 0); // állítsa a második oszlopra (bal középen), ha (arrGame [1] == 1) {lcdLeft.write ("#");} if (arrGame [1] == 2) {lcdLeft.write ("@");} lcdRight.setCursor (i, 1); // állítsa a harmadik oszlopra (jobbra középre), ha (arrGame [2] == 1) {lcdRight.write ("#");} if (arrGame [2] == 2) {lcdRight.write ("@");} lcdRight.setCursor (i, 0); // állítsa a negyedik oszlopra (a legtávolabbi jobbra), ha (arrGame [3] == 1) {lcdRight.write ("#");} if (arrGame [3] == 2) {lcdRight.ír("@");} } }

// lefelé mozgatja a táblát, és egy véletlenszerű értéket helyez egy csempévé

void playBoard () {for (int i = 0; i <= 3; i ++) {arrGame [0] = 0;} // törölje a felső sort arrGame [0] [random (0, 4)] = 1; // állítson be egy véletlenszerű pontot a felső sorban, hogy legyen csempéje (int i = 15; i> = 1; i-) {// a tábla aljától a tetejéig dolgozik (int ii = 0; ii <= 3; ii ++) {// minden kollum esetében arrGame [ii] = arrGame [i - 1] [ii]; }}}

// az egész táblát 0 -ra állítja, és a változókat visszaállítja az előjátékra

void clearBoard () {// a kullancs és késleltetés értékeinek visszaállítása intTick = 0; intDelay = 1000; // menjen át a táblán, és állítson be mindent 0 -ra (int i = 0; i <= 15; i ++) {for (int ii = 0; ii <= 3; ii ++) {arrGame [ii] = 0; }}}

// a főmenüt jeleníti meg az LCD -n

void title () {// írjon címet az LCD -re és szóközt lcdRight.setCursor (0, 0); lcdRight.write ("Zongoracsempe"); lcdRight.setCursor (0, 1); lcdRight.write ("Pontszám:"); // konvertálja a pontszámot karakterlánccá char strScore [3]; sprintf (strScore, "%d", intScore); // a pontszám megjelenítése LCD -n lcdRight.write (strScore); // add hozzá a nehéz lcdRight.setCursor (10, 1); if (intDiff == 0) {lcdRight.write ("Egyszerű"); } if (intDiff == 1) {lcdRight.write ("Közepes"); } if (intDiff == 2) {lcdRight.write ("Kemény"); } // Nyomjon egy kis utasítást lcdLeft.setCursor (0, 0); lcdLeft.write ("Nyomja le az Enter billentyűt"); lcdLeft.setCursor (0, 1); lcdLeft.write ("kezdeni!"); }

// ellenőrzi a gombokat, és mit tegyen velük játékon kívül

void buttonsMenu () {// az Enter megnyomásakor indítsa el a játékot és állítsa vissza a pontszámot, ha (intEnter == 1) {bolPlay = true; intScore = 0; playBoard (); drawBoard (); } // ha megnyomja a 3 gombot, kapcsolja be a hibakeresési lehetőséget, ha sorban nyomtatja a táblát, ha (intInput == 3) {if (bolSerialBoard == false) {Serial.println ("Serial Board Active"); bolSerialBoard = igaz; } else {Serial.println ("Serial Board Disabled"); bolSerialBoard = hamis; }} // állítsa a játék sebességét könnyű nehézségre, ha (intInput == 0) {Serial.print ("A játék könnyű ("); Serial.print (intGameSpeedEasy); Serial.println ("ms gyorsítás)"); intDiff = 0; intGameSpeed = intGameSpeedEasy; } // állítsa a játék sebességét közepes nehézségűre, ha (intInput == 1) {Serial.print ("A játék közepes ("); Serial.print (intGameSpeedMedium); Serial.println ("ms gyorsítás)"); intDiff = 1; intGameSpeed = intGameSpeedMedium; } // állítsa a játék sebességét nehéz nehézségre, ha (intInput == 2) {Serial.print ("A játék keményre van állítva ("); Serial.print (intGameSpeedHard); Serial.println ("ms gyorsítás)"); intDiff = 2; intGameSpeed = intGameSpeedHard; }}

// ellenőrzi a gombokat, és mit tegyen velük játék közben

void buttonsGame () {if (intInput! = 4) {// ha megnyom egy gombot, ha (bolTilePressed == false) {// csak akkor, ha a bolTilePressed hamis trigger művelet a gomb megnyomásának ellenőrzésére bolTilePressed = true; // majd állítsa a bolTilePressed -t true -ra, hogy megbizonyosodjon arról, hogy nem véletlenül vált ki újra int intLowestTile = 0; // a legalacsonyabb csempével rendelkező csempére kell beállítani int intCheckedTile = 15; // nyomon követni, hogy mely csempéket ellenőrizték (intLowestTile == 0) {// amíg nincs beállítva semmi, ellenőrizze a csempéket (int i = 0; i 100) {// mindaddig, amíg int késleltetés nem kevesebb, mint 100 intDelay = intDelay - 20; // értéket vesz belőle}} else {Serial.println ("Rossz gomb lenyomva"); játék vége(); // különben vége a játéknak}}}}}

void gameOver () {

Serial.println ("A játéknak vége!"); Serial.print ("A pontszámod:"); Serial.println (intScore); Serial.print ("Az Ön sebessége:"); Serial.println (intDelay); bolPlay = hamis; }

// ellenőrzi a játékos bemenetét

void input () {intEnter = digitalRead (btnEnter); // read enter // más bemenetek közül melyik olvasható, vagy ha egyik sem 4 -re van állítva, ha (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; }}}}} // soros nyomtatás a bemenetekre, ha (intEnter == 1) {Serial.println ("Enter Pressed!");} if (intInput! = 4) {Serial.print ("Button Press:"); Serial.println (intInput); } else {// ha egyetlen gombot sem nyom meg reset bolTilePressed bolTilePressed = false; }}

// ellenőrzi a tábla alját, hogy nincs -e hiba

void bottomCheck () {for (int i = 0; i <= 3; i ++) {// a 4 oszlophoz, ha (arrGame [15] == 1) {// ha egy csempe az alsó soros.println ("Csempe alul"); arrGame [15] = 2; drawBoard (); késleltetés (400); arrGame [15] = 1; drawBoard (); késleltetés (400); arrGame [15] = 2; drawBoard (); késleltetés (400); arrGame [15] = 1; drawBoard (); késleltetés (400); játék vége(); }}}

// kinyomtatja a táblát a soros monitorba, ha a bolSerialBoard igaz

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 (","); } Soros.println (""); }}}

Miután megadta az összes kódot, töltse fel az arduino -jába, és élvezze!