Arduino - klavírní dlaždice: 16 kroků (s obrázky)

2024 Autor: John Day | [email protected]. Naposledy změněno: 2024-01-30 08:22

Ahoj internetoví lidé, toto bude o tom, jak DEFINITIVNĚ vytvořit to, co není odtržením od mobilní hry na arduino uno r3.

takže pro začátek budete potřebovat všechny díly, které jsou následující! 1x Arduino Uno r3 (42 $)

2x štít klávesnice LCD (19 $ každý)

5x tlačítka

5x 220Ω odpory

28x dráty

Dobře, až budete mít všechny části, je čas začít!

Krok 1: Zapojení

Začněte zapojením arduina a přátel podle schématu, Ujistěte se, že jsou tlačítka propojena správným směrem, pomocí slotů A0-4 na zemní straně kolejnic pro tlačítka, nebo si arduino bude místo toho myslet, že jsou tlačítka stále držena, místo pouze při stisknutí.

Krok 2: Prohlášení

Veškerý kód zde by měl jít před vaše neplatné nastavení a prázdnou smyčku, protože všechny tyto proměnné a objekty se používají v několika funkcích, které nastavíme.

Začněte uvedením:

#zahrnout

v horní části kódu to znamená, že arduino má používat knihovnu „LiquidCrystal.h“a funkce, které jsou její součástí.

Dalším krokem je definovat piny, které používáme pro naše tlačítka, vložením tohoto kódu pod naše #include:

#define btnZadejte A0 #definujte btn1 15 #define btn2 16 #define btn3 17 #define btn4 18

Pojmy btnEnter a btn1 až btn 4 definujeme, aby byl kód pro nás čitelnější, nebo v případě potřeby změňte. To znamená, že když napíšeme btn1, arduino bude vědět, že ve skutečnosti máme na mysli tlačítko 15. Ačkoli voláme porty porty 15, 16, 17 a 18, jsou na arduinu označeny jako A1 A2 A3 a A4, je to proto, jsou to porty používané speciálně pro analogové vstupy, i když je používáme pouze pro digitální vstupy.

Dále vytvoříme objekty, které budou ovládat displeje z tekutých krystalů. Chcete -li to provést, vložte tento kód pod naše definice

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

Co to dělá, je arduino, že když voláme lcdLeft nebo lcdRight, odkazujeme na objekt LiquidCrystal. Čísla v přiložených závorkách informují arduino, jaké porty by měl objekt používat k odesílání zpráv na LCD, když používáme jejich funkce.

Nyní musíme deklarovat proměnné vložením dalšího bitu kódu pod deklarace objektů:

// tyto proměnné jsou možnosti, které můžete změnit - vyšší čísla = rychlejší zrychlení hry intGameSpeedEasy = 10; int intGameSpeedMedium = 25; int intGameSpeedHard = 80;

// nastavení proměnných pro gameboolean bolPlay; // sleduje, pokud hráč int intScore; // sleduje skóre hráče int intDiff; // jen estetická věc pro zjištění, na jaké obtížnosti je hra // nastavení proměnných pro vstup int intEnter; // sleduje, pokud uživatel stiskne tlačítko Enter int intInput; // sleduje, která tlačítka uživatel stiskne boolean bolTilePressed; // zajistěte, aby hráč neúmyslně nestiskl tlačítko 5x a neztratil // nastavení proměnných pro turn int intTick; // počítá míle (na smyčku) do intDelay int intDelay; // doba, po kterou program čeká do dalšího kola v milis int intGameSpeed; // ukončení možností ladění boolean bolSerialBoard; // when true vytiskne desku v sériovém monitoru

Proměnnou deklarujeme uvedením datového typu a poté názvu proměnné, např. int thisIsAnInteger

Booleovské proměnné, například bolSerialBoard a bolPlay, mohou mít pouze jednu ze dvou hodnot, true nebo false.

Celočíselná proměnná (int), například intScore a intInput, může nabývat celých čísel jako hodnot, například 1, 5 nebo 100.

Některé další pozoruhodné datové typy, které zde nepoužíváme, jsou řetězec, což je kus textu, a plovák, což je desetinné číslo.

Každá z proměnných zde program používá na několika různých místech, zde je souhrn toho, co každá z nich dělá

bolPlay řekne programu, zda se má zobrazit nabídka nebo zda má být spuštěna skutečná hra.

intScore sleduje skóre hráče, když narazí na dlaždice, intDiff se používá v hlavní nabídce k informování programu, jaký bit textu vytisknout na LCD, intEnter slouží k informování programu, zda je stisknuto tlačítko Enter (nejvíce vlevo), intInput slouží k informování programu, které z dalších 4 tlačítek je stisknuto.

bolTilePressed se používá k zajištění toho, aby program četl pouze při stisknutí tlačítka a ne při jeho podržení.

intGameSpeed, intGameSpeedEasy, intGameSpeedMedium a intGameSpeedHard slouží k ovládání toho, jak rychle se má hra zrychlit podle toho, která obtížnost je vybrána.

intTick a intDelay se používají k zastavení programu v pohybu desky vždy, když se smyčky.

BolSerialBoard se používá k tomu, aby vám program umožnil odeslat desku na sériový monitor arduina jako sérii čísel pro účely testování.

Nakonec je čas deklarovat naši desku jako pole pomocí tohoto kódu:

// nastavení herního pole 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}};

Pole je matice, kterou lze libovolně nazývat pro matematiku nebo měnit.

Váš kód by nyní měl vypadat nějak takto;

// zahrnout knihovny#zahrnout

// tyto proměnné jsou možnosti, které můžete změnit - vyšší čísla = rychlejší zrychlení hry

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

// Definujte piny

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

// vytváření objektů LCD (n, ~, n, ~, ~, n)

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

// nastavení pole hry

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

// nastavení proměnných pro hru

boolean bolPlay; // sleduje, pokud hráč int intScore; // sleduje skóre hráče int intDiff; // jen estetická věc pro zjištění, na jaké obtížnosti je hra

// nastavení proměnných pro vstup

int intEnter; // sleduje, pokud uživatel stiskne tlačítko Enter int intInput; // sleduje, která tlačítka uživatel stiskne boolean bolTilePressed; // zajistěte, aby hráč neúmyslně nestiskl tlačítko 5x a neprohrál

// nastavení proměnných pro turn

int intTick; // počítá míle (na smyčku) do intDelay int intDelay; // doba, po kterou program čeká do dalšího kola v milis int intGameSpeed;

// ukončení možností ladění

boolean bolSerialBoard; // when true vytiskne desku v sériovém monitoru

Krok 3: Funkce nastavení

Nastavovací smyčka je funkce, kterou čte arduino pouze jednou, když se zpočátku spustí.

V instalační smyčce právě nastavujeme hodnoty několika našich proměnných, protože místo jejich nastavení při jejich deklaraci to děláme zde.

Začněte vložením tohoto kódu do Nastavení prázdnoty.

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

Každý řádek právě nastavuje proměnnou na hodnotu.

BolPlay je nastaven na hodnotu false, aby se hra nezačala hrát.

intScore je nastaven na 0, protože vaše skóre přirozeně začíná na 0.

intTick začíná na 0, protože program aktuálně nic nepočítá.

intDelay je nastaven na 1000, protože to je rychlost, na které dlaždice začínají.

intDiff je jen asketická věc, aby program podle obtížnosti hry věděl, co napsat.

intGameSpeed je nastavena na jakoukoli hodnotu intGameSpeedMedium, což znamená, že je nastavena na střední obtížnost.

Dále vložte tento kód do Nastavení prázdnoty pod kód, který jste právě vložili.

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

Serial.begin (9600);

To sděluje arduinu, aby zahájilo komunikaci s počítačem prostřednictvím sériového monitoru (viditelné kliknutím na tlačítko v pravém horním rohu arduino IDE).

Vaše nastavení prázdnoty by nyní mělo vypadat nějak takto!

neplatné nastavení () {Serial.begin (9600); // spusťte sériový monitor // nastavte proměnné bolPlay = false; intScore = 0; intTick = 0; intDelay = 1000; intDiff = 1; intGameSpeed = intGameSpeedMedium; // begin lcd's lcdLeft.begin (16, 2); lcdRight.begin (16, 2); }

Krok 4: Funkce smyčky

Funkci smyčky spouští arduino při každé iteraci arduina.

Zkopírujte následující kód do prázdné smyčky.

void loop () {vstup (); // zkontroluje přehrávání vstupu if (bolPlay == true) {if (intTick> = intDelay) {// zkontroluje, zda má hra hrát tah nebo pokračovat v čekání Serial.println ("~~~~~~~ ~~ "); // tisk k označení desky pohybující se na // writeSerial (); // pokud je volba povolena, zapište desku do sériového tlačítkaGame (); // kontrola vstupů hráče playBoard (); // přesuňte desku a přidejte novou dlaždici clearLcd (); // vyčistit LCD před kreslením drawBoard (); // nakreslete desku na lcd's bottomCheck (); intTick = 0; // reset intTick} else {buttonsGame (); // kontrola vstupů hráče clearLcd (); // vyčistit LCD před kreslením drawBoard (); // nakreslete desku na lcd's intTick = intTick + intGameSpeed; // přidat do zaškrtnutí}} else {clearLcd (); // vyčistit LCD před kreslením title (); // zobrazení informací o názvu a skóre skóreMenu (); // číst vstup hráče clearBoard (); // zajištění celé desky = 0} zpoždění (10); // odložte arduino o krátký okamžik}

když se bolPlay rovná true, znamená to, že hra hraje a měl by být spuštěn veškerý kód, když hra hraje, ale chceme, aby deska přidala novou dlaždici a přesunula se dolů, když je intTick větší než naše intDelay, v opačném případě chceme uživateli umožnit stisknutím tlačítka zasáhnout dlaždici a intTick zvýšit rychlost.

Většina tohoto kódu používá funkce, které ještě musíme provést, a my je provedeme v dalších krocích. Účel těchto funkcí je následující.

Vstup čte, která tlačítka uživatel stiskl.

buttonsGame určuje, co tlačítka dělají ve hře, a ne v nabídce

PlayBoard přidá na hrací plochu novou dlaždici a poté přesune vše o desku o jedno místo níže

clearLCD čistí LCD a zajišťuje, aby za dlaždicemi nezůstali žádní duchové

drawBoard projde arrGame a vytiskne ho na LCD

clearBoard vymaže celý arrGame, když hra není ve hře

bottomCheck zkontroluje spodní část arrGame, zda neobsahuje poruchový stav

název zobrazuje v nabídce název hry a skóre

nabídka tlačítek ovládá, co dělají vstupy uživatele, když jsou v nabídce.

gameOver je další funkce, i když zde není volána, protože je místo toho nazývána ve funkcích bottomCheck a buttonsGame.

Krok 5: Funkce ClearLCD

pro vytvoření funkce začneme přidáním této do kódu

void functionName () {

}

„název funkce“může být cokoli, pokud již neexistuje.

Zkopírujte tento kód do svého programu:

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

toto prochází celým polem pomocí 2 počítaných smyček, které procházejí každým bodem na LCD a zapisují mezeru.

LCD displeje budou udržovat vše, co bylo napsáno dříve, aniž by byly resetovány na nic

Krok 6: Funkce DrawBoard

zkopírujte tento kód do svého programu

void drawBoard () {for (int i = 1; i <= 15; i ++) {// nakreslete na levém displeji LCD sloupce 1 a 2 // pokud dlaždice = 0 nic nepíše, = 1 napište „#“, = 2 napište "@" lcdLeft.setCursor (i, 1); // nastaveno na první sloupec (nejvíce vlevo) if (arrGame [0] == 1) {lcdLeft.write ("#");} if (arrGame [0] == 2) {lcdLeft.write ("@");} lcdLeft.setCursor (i, 0); // nastaveno na druhý sloupec (uprostřed vlevo) if (arrGame [1] == 1) {lcdLeft.write ("#");} if (arrGame [1] == 2) {lcdLeft.write ("@");} lcdRight.setCursor (i, 1); // nastaveno na třetí sloupec (vpravo uprostřed) if (arrGame [2] == 1) {lcdRight.write ("#");} if (arrGame [2] == 2) {lcdRight.write ("@");} lcdRight.setCursor (i, 0); // nastaveno na čtvrtý sloupec (úplně vpravo) if (arrGame [3] == 1) {lcdRight.write ("#");} if (arrGame [3] == 2) {lcdRight.napsat("@");} } }

toto používá smyčku k procházení každým řádkem desky, poté zkontroluje, zda se některý sloupec v řádku rovná 1 nebo 2, na základě toho pak vytiskne na LCD buď hashtag, pro dlaždici, která ještě není hit, nebo @ pro dlaždici zásahu.

Krok 7: Funkce PlayBoard

zkopírujte tento kód do svého programu.

void playBoard () {for (int i = 0; i <= 3; i ++) {arrGame [0] = 0;} // vymazat horní řádek arrGame [0] [náhodný (0, 4)] = 1; // nastavení náhodného bodu v horním řádku jako dlaždice (int i = 15; i> = 1; i-) {// práce od spodní části desky k vrcholu pro (int ii = 0; ii <= 3; ii ++) {// pro každou collum arrGame [ii] = arrGame [i - 1] [ii]; }}}

tento kód začíná vymazáním celého horního řádku na 0 nebo žádnou dlaždici a poté nastaví jednu náhodnou dlaždici na 1 a dlaždici zruší.

Poté prochází počítanou smyčkou v opačném pořadí, od 15 do 1, přičemž nastaví řádek tak, aby se rovnal jakémukoli řádku nad ním, čímž se deska pohybuje dolů po LCD

Krok 8: Funkce ClearBoard

zkopírujte tento kód do svého programu.

void clearBoard () {// reset hodnot tick a delay intTick = 0; intDelay = 1000; // projděte desku a nastavte vše na 0 pro (int i = 0; i <= 15; i ++) {for (int ii = 0; ii <= 3; ii ++) {arrGame [ii] = 0; }}}

Tento kód se spouští, když hra nehraje, abyste se ujistili, že celý arrGame je nastaven na 0 nebo žádné dlaždice, pomocí počítaných smyček procházet polem.

Kód také resetuje hodnoty intDelay a intTick.

Krok 9: Funkce titulu

zkopírujte následující kód do svého programu

neplatný název () {// zápis názvu na LCD a mezeru pro skóre lcdRight.setCursor (0, 0); lcdRight.write ("Klavírní dlaždice"); lcdRight.setCursor (0, 1); lcdRight.write ("Skóre:"); // převedení skóre na řetězec char strScore [3]; sprintf (strScore, "%d", intScore); // zobrazení skóre na LCD lcdRight.write (strScore); // přidat diffictuly lcdRight.setCursor (10, 1); if (intDiff == 0) {lcdRight.write ("Snadné"); } if (intDiff == 1) {lcdRight.write ("Medium"); } if (intDiff == 2) {lcdRight.write ("Hard"); } // Stiskněte trochu instrukce lcdLeft.setCursor (0, 0); lcdLeft.write ("Stiskněte Enter"); lcdLeft.setCursor (0, 1); lcdLeft.write („začít!“); }

Tento kód zapíše název hry a skóre na LCD, provede to tak, že pomocí LCD.setCursor řekne LCD, kde má začít psát, a poté napíše řetězec do LCD.write.

Zde je také vytvořena nová proměnná, strScore, slouží k převodu intScore na datový typ řetězce nebo char pomocí funkce sprintf.

Zde se také používá intDiff, na základě svých hodnot vytiskne různé možnosti obtížnosti.

Krok 10: Funkce ButtonsMenu

vložte do svého programu následující kód

void buttonsMenu () {// když stisknete Enter, spustíte hru a vynulujete hodnotu skóre if (intEnter == 1) {bolPlay = true; intScore = 0; playBoard (); drawBoard (); } // když je stisknuto tlačítko 3 zapnout možnost ladění tisku desky na sériový if (intInput == 3) {if (bolSerialBoard == false) {Serial.println ("Serial Board Active"); bolSerialBoard = true; } else {Serial.println ("Serial Board Disabled"); bolSerialBoard = false; }} // nastavení rychlosti hry na obtížnost easy if (intInput == 0) {Serial.print ("Game set to easy ("); Serial.print (intGameSpeedEasy); Serial.println ("ms acceleration)"); intDiff = 0; intGameSpeed = intGameSpeedEasy; } // nastavení rychlosti hry na střední obtížnost if (intInput == 1) {Serial.print ("Hra nastavená na medium ("); Serial.print (intGameSpeedMedium); Serial.println ("akcelerace ms" "); intDiff = 1; intGameSpeed = intGameSpeedMedium; } // nastavení rychlosti hry na obtížnost hard if (intInput == 2) {Serial.print ("Hra nastavena na hard ("); Serial.print (intGameSpeedHard); Serial.println ("zrychlení ms" "); intDiff = 2; intGameSpeed = intGameSpeedHard; }}

tento kód je spuštěn pouze tehdy, když se bolPlay rovná false v prázdné smyčce

pokud je intEnter nastaveno na 1, znamená to, že bylo stisknuto tlačítko Enter, pokud je stisknuto, program nastaví bolPlay na true a hra začne.

Program poté přečte, čemu se intInput rovná. pokud se rovná 0, stiskne se první tlačítko zleva, nahoru až na 3. Pokud je intInput rovno 4, nestiskne se žádné tlačítko.

pokud jsou stisknuta tlačítka 0-2, hra změní obtížnost a také upraví hodnotu rychlosti hry, což znamená, že se zrychlí rychleji.

pokud je stisknuto tlačítko 3, hra aktivuje nebo deaktivuje režim ladění, kde je celá deska vytištěna na sériovém monitoru, aby pomohla při hledání problémů v programu.

Krok 11: Funkce ButtonsGame

zkopírujte následující kód do svého programu

void buttonsGame () {if (intInput! = 4) {// pokud je stisknuto tlačítko if (bolTilePressed == false) {// pouze pokud je bolTilePressed falešná spouštěcí akce pro kontrolu stisknutí tlačítka bolTilePressed = true; // pak nastavte bolTilePressed na true, abyste se ujistili, že není znovu aktivován kyselinou int intLowestTile = 0; // nastaví se na dlaždici s nejnižší dlaždicí int intCheckedTile = 15; // abyste sledovali, které dlaždice byly zkontrolovány, zatímco (intLowestTile == 0) {// pokud není nastaveno nic, zkontrolujte dlaždice (int i = 0; i 100) {// tak dlouho, jak int zpoždění není nižší než 100 intDelay = intDelay - 20; // z toho vezměte hodnotu}} else {Serial.println ("Bylo stisknuto špatné tlačítko"); konec hry(); // jinak hra skončila}}}}}

Kód se spustí pouze tehdy, když se bolPlay v prázdné smyčce rovná true.

Stejně jako tlačítka Nabídka na základě hodnoty intInput zkontroluje, zda hráč narazil na dlaždici nebo ji minul.

Dělá to tak, že prochází arrGame zdola nahoru pomocí cyklu while a hledá, který řádek je nejnižší s dlaždicí Unit. Poté zkontroluje, zda je místo v tomto řádku odpovídající stisknutému tlačítku dlaždicí Unit, nebo ne, pokud není, nastaví ji na 2 místo 1, což znamená, že se zobrazí jako @, v opačném případě spustí GameOver funkce, kterou teprve vytvoříme.

Tato funkce také využívá proměnnou bolTilePressed nastavením na hodnotu true při stisknutí tlačítka a false, pokud není stisknuto žádné tlačítko. To má zajistit, aby uživatel hru omylem neztratil, protože si program myslel, že tlačítko stiskli několikrát, když jej drželi stisknuté.

Krok 12: Funkce GameOver

Zkopírujte následující kód do svého programu

void gameOver () {Serial.println ("Game Over!"); Serial.print ("Vaše skóre bylo:"); Serial.println (intScore); Serial.print ("Vaše rychlost byla:"); Serial.println (intDelay); bolPlay = false; }

To je spuštěno funkcemi checkBottom nebo buttonsGame a spouští konec hry nastavením bolPlay na hodnotu false.

Rovněž vytiskne zprávu na sériový monitor pro skóre uživatelů a dlaždice rychlosti byly přidány v milisekundách.

Krok 13: Funkce vstupu

Zkopírujte následující kód do svého programu.

void input () {intEnter = digitalRead (btnEnter); // čtení zadejte // přečtěte, který z ostatních vstupů, nebo pokud žádný není nastaven 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; }}}} // sériový tisk vstupů if (intEnter == 1) {Serial.println ("Enter Pressed!");} if (intInput! = 4) {Serial.print ("Button Press:"); Serial.println (intInput); } else {// pokud není stisknuto žádné tlačítko reset bolTilePressed bolTilePressed = false; }}

Tento kód se používá s funkcemi buttonsGame a buttonsMenu. na základě tlačítek, která uživatel stiskl, nastaví hodnotu intInput, nebo pokud není stisknuto žádné tlačítko, nastaví intInput na hodnotu 4.

Pokud není stisknuto žádné tlačítko, je místo, kde bolTilePressed resetováno pro funkci buttonsGame.

Rovněž vytiskne zprávu na sériový monitor, na kterém je stisknuto tlačítko.

Krok 14: Funkce BottomCheck

zkopírujte do svého programu následující kód.

void bottomCheck () {for (int i = 0; i <= 3; i ++) {// for the 4 columns if (arrGame [15] == 1) {// if a tile is at the bottom Serial.println („Dlaždice dole“); arrGame [15] = 2; drawBoard (); zpoždění (400); arrGame [15] = 1; drawBoard (); zpoždění (400); arrGame [15] = 2; drawBoard (); zpoždění (400); arrGame [15] = 1; drawBoard (); zpoždění (400); konec hry(); }}}

pomocí smyčky tento kód zkontroluje spodní řádek arrGame, zda neobsahuje dlaždice bez úprav (dlaždice rovnající se 1), pokud je v dolní části obrazovky dlaždice Unhit, bude dlaždice blikat a poté se spustí funkce Over Game.

Krok 15: Funkce WriteSerial

zkopírujte následující kód do svého programu

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

Toto je funkce, kterou následuje možnost ladění, kterou lze povolit ve funkci buttonsMenu. Pokud je bolSerialBoard v této funkci nastaven na hodnotu true, projde to arrGame a vytiskne celou desku do sériového monitoru pro účely testování pomocí pole.

Krok 16: Dokončení

Celý váš kód by neměl být úplný a měl by vypadat nějak takto!

/ * * Název - Klavírní dlaždice; Arduino * Podle - Domenic Marulli * Datum - 11/ *

/ zahrnují knihovny

#zahrnout

// tyto proměnné jsou možnosti, které můžete změnit - vyšší čísla = rychlejší zrychlení hry

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

// Definujte piny

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

// vytváření objektů LCD (n, ~, n, ~, ~, n)

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

// nastavení pole hry

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

// nastavení proměnných pro hru

boolean bolPlay; // sleduje, pokud hráč int intScore; // sleduje skóre hráče int intDiff; // jen estetická věc pro zjištění, na jaké obtížnosti je hra

// nastavení proměnných pro vstup

int intEnter; // sleduje, pokud uživatel stiskne tlačítko Enter int intInput; // sleduje, která tlačítka uživatel stiskne boolean bolTilePressed; // zajistěte, aby hráč neúmyslně nestiskl tlačítko 5x a neprohrál

// nastavení proměnných pro turn

int intTick; // počítá míle (na smyčku) do intDelay int intDelay; // doba, po kterou program čeká do dalšího kola v milis int intGameSpeed;

// ukončení možností ladění

boolean bolSerialBoard; // when true vytiskne desku v sériovém monitoru

// nastavení, které bude spuštěno jednou

neplatné nastavení () {Serial.begin (9600); // spusťte sériový monitor // nastavte proměnné bolPlay = false; intScore = 0; intTick = 0; intDelay = 1000; intDiff = 1; intGameSpeed = intGameSpeedMedium; // begin lcd's lcdLeft.begin (16, 2); lcdRight.begin (16, 2); }

// smyčka, která bude spuštěna každých 10 milisekund

void loop () {vstup (); // zkontroluje přehrávání vstupu if (bolPlay == true) {if (intTick> = intDelay) {// zkontroluje, zda má hra hrát tah nebo pokračovat v čekání Serial.println ("~~~~~~~ ~~ "); // tisk k označení desky pohybující se na // writeSerial (); // pokud je volba povolena, zapište desku do sériového tlačítkaGame (); // kontrola vstupů hráče playBoard (); // přesuňte desku a přidejte novou dlaždici clearLcd (); // vyčistit LCD před kreslením drawBoard (); // nakreslete desku na lcd's bottomCheck (); intTick = 0; // reset intTick} else {buttonsGame (); // kontrola vstupů hráče clearLcd (); // vyčistit LCD před kreslením drawBoard (); // nakreslete desku na lcd's intTick = intTick + intGameSpeed; // přidat do zaškrtnutí}} else {clearLcd (); // vyčistit LCD před kreslením title (); // zobrazení informací o názvu a skóre skóreMenu (); // číst vstup hráče clearBoard (); // zajištění celé desky = 0} zpoždění (10); // odložte arduino o krátký okamžik}

// vyčistí lcd, takže tam nezůstanou žádné nezadané buňky

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

// nakreslí desku na lcd

void drawBoard () {for (int i = 1; i <= 15; i ++) {// nakreslete na levém displeji LCD sloupce 1 a 2 // pokud dlaždice = 0 nic nepíše, = 1 napište „#“, = 2 napište "@" lcdLeft.setCursor (i, 1); // nastaveno na první sloupec (nejvíce vlevo) if (arrGame [0] == 1) {lcdLeft.write ("#");} if (arrGame [0] == 2) {lcdLeft.write ("@");} lcdLeft.setCursor (i, 0); // nastaveno na druhý sloupec (uprostřed vlevo) if (arrGame [1] == 1) {lcdLeft.write ("#");} if (arrGame [1] == 2) {lcdLeft.write ("@");} lcdRight.setCursor (i, 1); // nastaveno na třetí sloupec (vpravo uprostřed) if (arrGame [2] == 1) {lcdRight.write ("#");} if (arrGame [2] == 2) {lcdRight.write ("@");} lcdRight.setCursor (i, 0); // nastaveno na čtvrtý sloupec (úplně vpravo) if (arrGame [3] == 1) {lcdRight.write ("#");} if (arrGame [3] == 2) {lcdRight.napsat("@");} } }

// posune desku dolů a umístí náhodnou hodnotu jako dlaždici

void playBoard () {for (int i = 0; i <= 3; i ++) {arrGame [0] = 0;} // vymazat horní řádek arrGame [0] [náhodný (0, 4)] = 1; // nastavení náhodného bodu v horním řádku jako dlaždice (int i = 15; i> = 1; i-) {// práce od spodní části desky k vrcholu pro (int ii = 0; ii <= 3; ii ++) {// pro každou collum arrGame [ii] = arrGame [i - 1] [ii]; }}}

// nastaví celou desku na 0 a resetuje proměnné na pregame

void clearBoard () {// reset hodnot tick a delay intTick = 0; intDelay = 1000; // projděte desku a nastavte vše na 0 pro (int i = 0; i <= 15; i ++) {for (int ii = 0; ii <= 3; ii ++) {arrGame [ii] = 0; }}}

// zobrazí hlavní nabídku na LCD

neplatný název () {// zápis názvu na LCD a mezeru pro skóre lcdRight.setCursor (0, 0); lcdRight.write ("Klavírní dlaždice"); lcdRight.setCursor (0, 1); lcdRight.write ("Skóre:"); // převedení skóre na řetězec char strScore [3]; sprintf (strScore, "%d", intScore); // zobrazení skóre na LCD lcdRight.write (strScore); // přidat diffictuly lcdRight.setCursor (10, 1); if (intDiff == 0) {lcdRight.write ("Snadné"); } if (intDiff == 1) {lcdRight.write ("Medium"); } if (intDiff == 2) {lcdRight.write ("Hard"); } // Stiskněte trochu instrukce lcdLeft.setCursor (0, 0); lcdLeft.write ("Stiskněte Enter"); lcdLeft.setCursor (0, 1); lcdLeft.write („začít!“); }

// kontroluje tlačítka a co pro ně dělat mimo hru

void buttonsMenu () {// když stisknete Enter, spustíte hru a vynulujete hodnotu skóre if (intEnter == 1) {bolPlay = true; intScore = 0; playBoard (); drawBoard (); } // když je stisknuto tlačítko 3 zapnout možnost ladění tisku desky na sériový if (intInput == 3) {if (bolSerialBoard == false) {Serial.println ("Serial Board Active"); bolSerialBoard = true; } else {Serial.println ("Serial Board Disabled"); bolSerialBoard = false; }} // nastavení rychlosti hry na obtížnost easy if (intInput == 0) {Serial.print ("Game set to easy ("); Serial.print (intGameSpeedEasy); Serial.println ("ms acceleration)"); intDiff = 0; intGameSpeed = intGameSpeedEasy; } // nastavení rychlosti hry na střední obtížnost if (intInput == 1) {Serial.print ("Hra nastavená na medium ("); Serial.print (intGameSpeedMedium); Serial.println ("akcelerace ms" "); intDiff = 1; intGameSpeed = intGameSpeedMedium; } // nastavení rychlosti hry na obtížnost hard if (intInput == 2) {Serial.print ("Hra nastavena na hard ("); Serial.print (intGameSpeedHard); Serial.println ("zrychlení ms" "); intDiff = 2; intGameSpeed = intGameSpeedHard; }}

// kontroluje tlačítka a co pro ně ve hře dělat

void buttonsGame () {if (intInput! = 4) {// pokud je stisknuto tlačítko if (bolTilePressed == false) {// pouze pokud bolTilePressed je falešná spouštěcí akce pro kontrolu stisknutí tlačítka bolTilePressed = true; // pak nastavte bolTilePressed na true, abyste se ujistili, že není znovu aktivován kyselinou int intLowestTile = 0; // nastaví se na dlaždici s nejnižší dlaždicí int intCheckedTile = 15; // abyste sledovali, které dlaždice byly zkontrolovány, zatímco (intLowestTile == 0) {// pokud není nastaveno nic, zkontrolujte dlaždice (int i = 0; i 100) {// tak dlouho, jak int zpoždění není nižší než 100 intDelay = intDelay - 20; // vezměte z toho hodnotu}} else {Serial.println ("Bylo stisknuto špatné tlačítko"); konec hry(); // jinak hra skončila}}}}}

neplatná hraOver () {

Serial.println („Hra skončila!“); Serial.print ("Vaše skóre bylo:"); Serial.println (intScore); Serial.print ("Vaše rychlost byla:"); Serial.println (intDelay); bolPlay = false; }

// kontroluje vstup hráče

void input () {intEnter = digitalRead (btnEnter); // čtení zadejte // přečtěte si, který z ostatních vstupů, nebo pokud žádný není nastaven 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; }}}} // sériový tisk vstupů if (intEnter == 1) {Serial.println ("Enter Pressed!");} if (intInput! = 4) {Serial.print ("Button Press:"); Serial.println (intInput); } else {// pokud není stisknuto žádné tlačítko reset bolTilePressed bolTilePressed = false; }}

// kontroluje selhání spodní části desky

void bottomCheck () {for (int i = 0; i <= 3; i ++) {// for the 4 columns if (arrGame [15] == 1) {// if a tile is at the bottom Serial.println („Dlaždice dole“); arrGame [15] = 2; drawBoard (); zpoždění (400); arrGame [15] = 1; drawBoard (); zpoždění (400); arrGame [15] = 2; drawBoard (); zpoždění (400); arrGame [15] = 1; drawBoard (); zpoždění (400); konec hry(); }}}

// pokud je bolSerialBoard true, vytiskne desku na sériový monitor

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

Jakmile je celý kód zadán, nahrajte jej do svého arduina a užívejte si!