Arduino - Pllaka pianoje: 16 hapa (me fotografi)

2024 Autor: John Day | [email protected]. E modifikuara e fundit: 2024-01-30 12:22

Përshëndetje njerëz të internetit, kjo do të flasë për atë se si të bëni atë që P DRFUNDIMISHT nuk është një shqyerje e një loje celulare në një arduino uno r3.

kështu që për të filluar, do t'ju duhen të gjitha pjesët, të cilat janë si më poshtë! 1x Arduino Uno r3 (42 dollarë)

2x Mburoja e tastierës LCD (19 dollarë secila)

5x butona

5x 220 rezistorë

Tela 28x

Në rregull, pasi të keni marrë të gjitha pjesët, është koha për të filluar!

Hapi 1: Instalimet elektrike

Filloni duke instaluar tela në arduino dhe miqtë tuaj siç tregohet në diagram, Sigurohuni që butonat të jenë të lidhur në mënyrën e duhur, me hapësirat A0-4 në anën tokësore të shinave të butonave, ose arduino në vend të kësaj do të mendojë se butonat po mbahen vazhdimisht në vend të vetëm në një shtypëse.

Hapi 2: Deklaratat e Deklaratës

I gjithë kodi këtu duhet të shkojë para konfigurimit tuaj void dhe lakut void, kjo ndodh sepse të gjitha këto ndryshore dhe objekte përdoren në disa nga funksionet që do të vendosim.

Filloni duke vënë:

#përfshi

në krye të kodit tuaj, kjo po i thotë arduino të përdorë bibliotekën "LiquidCrystal.h" dhe funksionet që janë pjesë e saj.

Hapi tjetër është të përcaktoni kunjat që po përdorim për butonat tanë duke e vendosur këtë kod nën #përfshini:

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

Ne përcaktojmë termat btnEnter dhe btn1 në btn 4 për ta bërë kodin më të lehtë për ne që të lexojmë, ose të ndryshojmë nëse është e nevojshme. Kjo do të thotë që kur shtypim btn1 arduino do të dijë që në fakt nënkuptojmë butonin 15. Edhe pse ne po i quajmë portet porta 15, 16, 17 dhe 18, ato janë etiketuar në arduino si A1 A2 A3 dhe A4, kjo ndodh sepse ato janë porte të përdorura posaçërisht për hyrje analoge, megjithëse ne po i përdorim ato vetëm për hyrjet dixhitale.

Tjetra ne do të krijojmë objektet që do të kontrollojnë ekranet e kristaleve të lëngëta. Për ta bërë këtë, vendoseni këtë kod nën përcaktimet tona

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

Ajo që bën kjo i thotë arduino se kur thërrasim lcdLeft ose lcdRight ne i referohemi një objekti LiquidCrystal. Numrat në kllapat e bashkangjitura tregojnë arduino se cilat porte objekti duhet të përdorë për të dërguar mesazhe në LCD kur përdorim funksionet e tyre.

Tani duhet të deklarojmë variablat duke vendosur pjesën tjetër të kodit poshtë deklaratave të objektit:

// këto ndryshore janë opsione që mund t'i ndryshoni - numra më të lartë = shpejtësi më të madhe të lojës në intGameSpeedEasy = 10; int intGameSpeedMedium = 25; int intGameSpeedHard = 80;

// vendosni variabla për bolPlay gameboolean; // gjurmon nëse lojtari int intScore; // gjurmon rezultatin e lojtarit int intDiff; // vetëm një gjë estetike për të treguar se në çfarë vështirësie është loja // vendosni variabla për hyrjen në int IntEterer; // gjurmon nëse përdoruesi shtyp butonin enter int intInput; // gjurmon se cilat butona përdoruesi shtyp boolean bolTilePressed; // sigurohuni që lojtari të mos shtypë një buton 5x rastësisht dhe të humbasë // të krijojë variabla për turn int intTick; // numëron miliona (për lak) derisa intDelay int intDelay; // koha kur programi pret deri në kthesën tjetër në millis int intGameSpeed; // heqja e opsioneve të korrigjimit boolean bolSerialBoard; // kur true do të printojë tabelën në monitorin serik

Ne deklarojmë një ndryshore duke deklaruar llojin e të dhënave dhe pastaj emrin e ndryshores, p.sh. int thisIsAnInteger

Variablat Boolean, të tilla si bolSerialBoard dhe bolPlay mund të kenë vetëm një nga dy vlerat, të vërteta ose të rreme.

Variabli i plotë (int) si intScore dhe intInput mund të marrë numra të tërë si vlera, të tilla si 1, 5 ose 100.

Disa lloje të tjera të dukshme të të dhënave që ne nuk po i përdorim këtu janë një varg, i cili është një pjesë e tekstit dhe një notë, e cila është një numër dhjetor.

Secila prej variablave këtu përdoren në disa vende të ndryshme nga programi, këtu është një përmbledhje e asaj që bën secila prej tyre

bolPlay i tregon programit nëse menyja duhet të shfaqet ose nëse loja aktuale duhet të funksionojë.

intScore gjurmon rezultatin e lojtarit teksa godasin pllakat, intDiff përdoret në menunë kryesore për t'i treguar programit se çfarë pak teksti të printojë në LCD, intEnter përdoret për të treguar programin nëse është shtypur butoni enter (majtas më larg), intInput përdoret për të treguar programin se cili nga 4 butonat e tjerë është shtypur.

bolTilePressed përdoret për t'u siguruar që programi lexohet vetëm kur shtypet butoni dhe jo kur mbahet.

intGameSpeed, intGameSpeedEasy, intGameSpeedMedium dhe intGameSpeedHard përdoren për të kontrolluar sa shpejt loja duhet të përshpejtohet bazuar në vështirësinë e zgjedhur.

intTick dhe intDelay përdoren për të ndaluar programin që të lëvizë tabelën sa herë që ai të lakohet.

bolSerialBoard përdoret për t'ju lejuar të bëni programin të dërgojë tabelën në monitorin serik të arduino si një seri numrash për qëllime testimi.

Më në fund është koha për të deklaruar bordin tonë si një grup duke përdorur këtë kod:

// konfiguroni arrayint lojë 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}};

Një grup është një matricë që çdo pikë në të cilën mund të thirret për matematikë ose të ndryshohet.

Kodi juaj tani duhet të duket diçka si kjo;

// përfshi bibliotekat#përfshi

// këto ndryshore janë opsione që mund t'i ndryshoni - numra më të lartë = shpejtësi më të shpejtë të lojës

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

// Përcaktoni kunjat

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

// krijoni objekte LCD (n, ~, n, ~, ~, n)

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

// konfiguroni grupin e lojërave

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

// vendosni variabla për lojën

boolean bolPlay; // gjurmon nëse lojtari int intScore; // gjurmon rezultatin e lojtarit int intDiff; // vetëm një gjë estetike për të treguar se në çfarë vështirësie është loja

// vendosni variabla për hyrje

int intEERT; // gjurmon nëse përdoruesi shtyp butonin enter int intInput; // gjurmon se cilat butona përdoruesi shtyp boolean bolTilePressed; // sigurohuni që lojtari të mos e shtypë rastësisht një buton 5x dhe të mos humbasë

// vendosni variabla për turn

int intTick; // numëron miliona (për lak) derisa intDelay int intDelay; // koha kur programi pret deri në kthesën tjetër në millis int intGameSpeed;

// heqja e opsioneve të korrigjimit

boolean bolSerialBoard; // kur true do të printojë tabelën në monitorin serik

Hapi 3: Funksioni i konfigurimit

Cikli i konfigurimit është një funksion i lexuar nga arduino vetëm një herë kur fillon fillimisht.

Në lakun e konfigurimit ne thjesht vendosim vlerat e disa prej variablave tanë, sepse në vend që t'i vendosim atyre një vlerë kur i deklarojmë, ne po e bëjmë këtu.

Filloni duke e vendosur këtë kod në Konfigurimin tuaj të pavlefshëm.

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

Çdo rresht po vendos vetëm një ndryshore në një vlerë.

bolPlay është vendosur në false në mënyrë që loja të mos fillojë të luajë.

intScore është vendosur në 0, sepse natyrisht rezultati juaj fillon me 0.

intTick fillon në 0 sepse programi aktualisht nuk numëron asgjë.

intDelay është vendosur në 1000 sepse kjo është shkalla me të cilën fillojnë pllakat.

intDiff është vetëm një gjë asketike në mënyrë që programi të dijë se çfarë të shkruajë për vështirësinë e lojës.

intGameSpeed është vendosur në çfarëdo që është intGameSpeedMedium, që do të thotë se është vendosur në vështirësinë mesatare.

Më pas vendoseni këtë kod në Void Setup poshtë kodit që sapo keni futur.

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

Serial.filloj (9600);

Kjo i thotë arduino të fillojë të komunikojë me kompjuterin përmes monitorit serik (e dukshme duke klikuar butonin në krye të djathtë të arduino IDE).

Konfigurimi juaj Void tani duhet të duket diçka si kjo!

void setup () {Serial.begin (9600); // filloni monitorin serik // vendosni variablat bolPlay = false; intScore = 0; intTick = 0; vonesë = 1000; intDiff = 1; intGameSpeed = intGameSpeedMedium; // filloni lcdLeft.cc's lcd.filloni (16, 2); lcdRight.filloj (16, 2); }

Hapi 4: Funksioni i lakut

Funksioni loop drejtohet nga arduino çdo përsëritje e arduino.

Kopjoni kodin e mëposhtëm në lakun tuaj të pavlefshëm.

void loop () {input (); // kontrolloni për futjen e lojës nëse (bolPlay == true) {if (intTick> = intDelay) {// kontrolloni nëse loja duhet të luajë një kthesë ose të vazhdojë të presë Serial.println ("~~~~~~~ print "); // printoni për të nënkuptuar që tabela të lëvizë // shkruajSerial (); // nëse opsioni është i aktivizuar shkruani tabelën në butonat serialGame (); // kontrolloni për hyrjet e lojtarëve playBoard (); // zhvendos bordin dhe shto një pllakë të re clearLcd (); // pastroni LCD -të para se të vizatoni drawBoard (); // vizatoni tabelën në fundCcck të LCD -së (); intTick = 0; // rivendos intTick} else {buttonsGame (); // kontrolloni për inputet e lojtarit clearLcd (); // pastroni LCD -të para se të vizatoni drawBoard (); // vizatoni tabelën në intTick të lcd = intTick + intGameSpeed; // shto në shënimin}} else {clearLcd (); // pastroni LCD -të para se të vizatoni titullin (); // shfaq titujt dhe butonat e informacionit të rezultatitMenu (); // lexoni futjen e lojtarit clearBoard (); // siguroni të gjithë bordin = 0} vonesë (10); // vononi arduino me një moment të shkurtër}

kur bolPlay është e barabartë me të vërtetë do të thotë që loja po luhet, dhe i gjithë kodi për kohën kur luhet loja duhet të ekzekutohet, por ne duam që bordi të shtojë një pllakë të re dhe të lëvizë poshtë kur intTick është më i madh se intDelay -i ynë, përndryshe ne ende duam të lejojmë përdoruesin të shtypë një buton për të goditur një pllakë dhe që intTick të rritet në shpejtësi.

Pjesa më e madhe e këtij kodi përdor funksione që ne ende duhet të bëjmë, dhe ne do t'i bëjmë ato në hapat e ardhshëm. Qëllimi i këtyre funksioneve është si më poshtë.

Hyrja lexon cilat butona ka shtypur përdoruesi.

buttonsGame kontrollon atë që bëjnë butonat kur janë në lojë, dhe jo në meny

playBoard shton një pllakë të re në tabelë, dhe pastaj lëviz gjithçka në tabelë poshtë një hapësire

clearLCD pastron LCD -të për t'u siguruar që asnjë fantazmë të mos mbetet pas pllakave

drawBoard kalon nëpër arrGame dhe e printon në LCD

clearBoard pastron të gjithë arrGame kur loja nuk është në lojë

bottomCheck kontrollon pjesën e poshtme të arrGame për një gjendje dështimi

titulli shfaq informacionin e titullit të lojës dhe rezultatit kur është në meny

butonat menu kontrollon atë që bëjnë hyrjet e përdoruesit kur janë në meny.

gameOver është një funksion tjetër, megjithëse nuk quhet këtu siç quhet në fund Funksionet e kontrollit dhe butonave të lojës.

Hapi 5: Funksioni ClearLCD

për të krijuar një funksion fillojmë duke e shtuar këtë në kod

void funksionName () {

}

"emri i funksionit" mund të jetë çdo gjë, përderisa nuk ekziston tashmë.

Kopjoni këtë kod në programin tuaj:

pavlefshme clearLcd () {për (int i = 0; i <= 15; i ++) {për (int ii = 0; ii <= 1; ii ++) {lcdLeft.setCursor (i, ii); lcdLeft.write (""); lcdRight.setCursor (i, ii); lcdRight.write (""); }}}

kjo kalon nëpër të gjithë grupin duke përdorur 2 sythe të numëruara për të kaluar nëpër secilën pikë në LCD dhe për të shkruar një hapësirë.

Pa u rivendosur në asgjë LCD -të do të ruajnë gjithçka që është shkruar më parë

Hapi 6: Funksioni DrawBoard

kopjoni këtë kod në programin tuaj

void drawBoard () {për (int i = 1; i <= 15; i ++) {// vizatoni kolumet 1 dhe 2 në LCD -në e majtë // nëse pllaka = 0 nuk shkruan asgjë, = 1 shkruani "#", = 2 shkruani "@" lcdLeft.setCursor (i, 1); // vendosur në kolonën e parë (majtas më larg) nëse (arrGame [0] == 1) {lcdLeft.write ("#");} if (arrGame [0] == 2) {lcdLeft.shkruani ("@");} lcdLeft.setCursor (i, 0); // vendosur në kolonën e dytë (qendra majtas) nëse (arrGame [1] == 1) {lcdLeft.write ("#");} if (arrGame [1] == 2) {lcdLeft.shkruani ("@");} lcdRight.setCursor (i, 1); // vendosur në kolonën e tretë (në të djathtë në qendër) nëse (arrGame [2] == 1) {lcdRight.write ("#");} if (arrGame [2] == 2) {lcdRight.shkruani ("@");} lcdRight.setCursor (i, 0); // vendosur në kolonën e katërt (djathtas) nëse (arrGame [3] == 1) {lcdRight.write ("#");} if (arrGame [3] == 2) {lcdRight.shkruaj("@");} } }

kjo përdor një lak për të kaluar nëpër çdo rresht të tabelës, pastaj kontrollon për të parë nëse ndonjë kolonë në rresht është e barabartë me 1 ose 2, bazuar në atë që më pas printon në LCD ose një hashtag, për një pllakë akoma goditi, ose një @ për një pllakë të goditur.

Hapi 7: Funksioni PlayBoard

kopjoni këtë kod në programin tuaj.

void playBoard () {për (int i = 0; i <= 3; i ++) {arrGame [0] = 0;} // pastro rreshtin e lartë arrGame [0] [rastësore (0, 4)] = 1; // vendosni një pikë të rastësishme në rreshtin e sipërm që të jetë një pllakë për (int i = 15; i> = 1; i-) {// duke punuar nga fundi i tabelës në krye për (int ii = 0; ii <= 3; ii ++) {// për çdo përplasje arrGame [ii] = arrGame [i - 1] [ii]; }}}

ky kod fillon duke pastruar të gjithë rreshtin e sipërm në 0, ose asnjë pllakë, dhe pastaj vendos një pllakë të rastësishme të jetë një pllakë 1, dhe e pazbuluar.

Pastaj kalon nëpër një lak të numëruar në të kundërt, nga 15 në 1, duke e vendosur rreshtin në të barabartë me çfarëdo rreshti mbi të cilin është i barabartë, duke bërë që bordi të lëvizë poshtë LCD -ve

Hapi 8: Funksioni ClearBoard

kopjoni këtë kod në programin tuaj.

void clearBoard () {// rivendos vlerat e shënimit dhe vonesës intTick = 0; vonesë = 1000; // kaloni nëpër tabelë dhe vendosni gjithçka në 0 për (int i = 0; i <= 15; i ++) {për (int ii = 0; ii <= 3; ii ++) {arrGame [ii] = 0; }}}

Ky kod ekzekutohet kur loja nuk po luan për t'u siguruar që e gjithë arrGame është vendosur në 0, ose pa pllaka, duke përdorur sythe të numëruara për të kaluar nëpër grup.

Kodi gjithashtu rivendos vlerat e intDelay dhe intTick.

Hapi 9: Funksioni i Titullit

kopjoni kodin e mëposhtëm në programin tuaj

titull i pavlefshëm () {// shkruaj titullin në LCD dhe hapësirë për rezultatin lcdRight.setCursor (0, 0); lcdRight.write ("Pllaka Piano"); lcdRight.setCursor (0, 1); lcdRight.write ("Rezultati:"); // konvertoni rezultatin në një string string strScore [3]; sprintf (strScore, "%d", intScore); // shfaq rezultatin në LCD lcdRight.write (strScore); // shtoni difiktivisht lcdRight.setCursor (10, 1); if (intDiff == 0) {lcdRight.write ("Lehtë"); } if (intDiff == 1) {lcdRight.write ("Mesatar"); } if (intDiff == 2) {lcdRight.write ("E vështirë"); } // Shtypni pak udhëzime lcdLeft.setCursor (0, 0); lcdLeft.write ("Shtyp Enter"); lcdLeft.setCursor (0, 1); lcdLeft.write ("për të filluar!"); }

Ky kod shkruan titullin e lojës dhe rezultatin në LCD, e bën këtë duke i thënë LCD -së ku të fillojë të shtypë duke përdorur LCD.setCursor dhe më pas duke shkruar vargun në LCD.shkruaj.

Një variabël e re është krijuar gjithashtu këtu, strScore, përdoret për të kthyer intScore në një varg ose tip të dhënash char duke përdorur funksionin sprintf.

intDiff përdoret gjithashtu këtu, bazuar në vlerat e tij, printon opsionet e ndryshme të vështirësisë.

Hapi 10: Funksioni Menu ButtonsMenu

futni kodin e mëposhtëm në programin tuaj

butonat e pavlefshëmMenu () {// kur shtypet enter filloni lojën dhe rivendosni vlerën e rezultatit nëse (intEnter == 1) {bolPlay = true; intScore = 0; playBoard (); drawBoard (); } // kur shtypet butoni 3 aktivizoni opsionin e korrigjimit të printimit të bordit në seri nëse (intInput == 3) {if (bolSerialBoard == false) {Serial.println ("Serial Board Active"); bolSerialBoard = e vërtetë; } else {Serial.println ("Serial Board Disabled"); bolSerialBoard = false; }} // vendosni shpejtësinë e lojës në vështirësi të lehtë nëse (intInput == 0) {Serial.print ("Loja e vendosur në të lehtë ("); Serial.print (intGameSpeedEasy); Serial.println ("ms përshpejtim)"); intDiff = 0; intGameSpeed = intGameSpeedEasy; } // vendosni shpejtësinë e lojës në vështirësi mesatare nëse (intInput == 1) {Serial.print ("Loja e vendosur në mesatare ("); Serial.print (intGameSpeedMedium); Serial.println ("ms përshpejtim")); intDiff = 1; intGameSpeed = intGameSpeedMedium; } // vendosni shpejtësinë e lojës në vështirësi të madhe nëse (intInput == 2) {Serial.print ("Loja e vendosur në hard ("); Serial.print (intGameSpeedHard); Serial.println ("ms përshpejtim)"); intDiff = 2; intGameSpeed = intGameSpeedHard; }}

ky kod ekzekutohet vetëm kur bolPlay është i barabartë me false në Loop void

nëse intEnter është vendosur në 1 do të thotë që butoni enter është shtyrë, nëse shtypet programi vendos bolPlay në true dhe loja fillon.

Programi pastaj lexon se sa është e barabartë intInput. nëse është e barabartë me 0 butoni i parë nga e majta është duke u shtypur, duke shkuar lart në të djathtë deri në 3. Nëse intInput është e barabartë me 4 asnjë buton nuk është duke u shtypur.

nëse shtypen butonat 0-2 loja ndryshon vështirësinë, duke rregulluar edhe vlerën e shpejtësisë së lojës, që do të thotë se do të përshpejtohet më shpejt.

nëse shtypet butoni 3 loja do të aktivizojë ose çaktivizojë një mënyrë debugimi ku e gjithë tabela printohet në monitorin serik për të ndihmuar në gjetjen e çështjeve në program.

Hapi 11: Funksioni ButtonsGame

kopjoni kodin e mëposhtëm në programin tuaj

void buttonsGame () {if (intInput! = 4) {// nëse një buton shtypet nëse (bolTilePressed == false) {// vetëm nëse bolTilePressed është veprim i rremë i nxitjes për kontrollimin e një butoni shtypni bolTilePressed = true; // pastaj vendosni bolTilePressed në true për t'u siguruar që nuk është aktivizuar përsëri në mënyrë intime në intLowestTile = 0; // të vendoset në pllakën me pllakën më të ulët int intCheckedTile = 15; // për të mbajtur shënim se cilat pllaka janë kontrolluar ndërsa (intLowestTile == 0) {// për sa kohë që nuk është vendosur në asgjë kontrolloni pllakat për (int i = 0; i 100) {// për aq kohë sa int vonesa nuk është më e ulët se 100 intDelay = intDelay - 20; // merr një vlerë prej saj}} tjetër {Serial.println ("Shtypur butonin e gabuar"); Loja mbaroi(); // përndryshe loja mbaron}}}}}

Kodi ekzekutohet vetëm kur bolPlay është i barabartë me true në Loop void.

Ashtu si butonatMenu bazuar në vlerën e intInput -it kontrollon për të parë nëse lojtari ka goditur një pllakë apo ka humbur atë.

E bën këtë duke kaluar nëpër arrGame nga poshtë lart duke përdorur një lak while për të kërkuar se cila rresht është më e ulëta me një pllakë të pazbuluar. Pastaj kontrollon për të parë nëse pika në atë rresht që korrespondon me butonin e shtypur është një pllakë e pa goditur apo jo, nëse nuk është e bashkuar e vendos atë në 2 në vend të 1, që do të thotë se do të shfaqet si një @, përndryshe aktivizon lojën funksion të cilin ende nuk e kemi krijuar.

Ky funksion përdor gjithashtu ndryshoren bolTilePressed duke e vendosur atë në të vërtetë kur shtypet një buton dhe e gabuar kur nuk shtypet asnjë buton. Kjo është për të siguruar që përdoruesi të mos e humbë aksidentalisht lojën sepse programi mendoi se ata shtypën butonin disa herë kur e mbajtën atë.

Hapi 12: Funksioni GameOver

Kopjoni kodin e mëposhtëm në programin tuaj

void gameOver () {Serial.println ("Loja ka mbaruar!"); Serial.print ("Rezultati juaj ishte:"); Serial.println (intScore); Serial.print ("Shpejtësia juaj ishte:"); Serial.println (intDelay); bolPlay = false; }

Kjo nxitet nga funksionet checkBottom ose buttonsGame dhe shkakton fundin e lojës duke vendosur që bolPlay të jetë false.

Ai gjithashtu printon një mesazh në monitorin serik për rezultatin e përdoruesve dhe pllakat e shpejtësisë u shtuan në milisekonda.

Hapi 13: Funksioni i hyrjes

Kopjoni kodin e mëposhtëm në programin tuaj.

void input () {intEnter = digitalRead (btnEnter); // lexo enter // lexo se cila nga hyrjet e tjera, ose nëse asnjë nuk është vendosur në 4 nëse (digitalRead (btn1) == HIGH) {intInput = 0;} tjetër {if (digitalRead (btn2) == HIGH) {intInput = 1;} tjetër {if (digitalRead (btn3) == HIGH) {intInput = 2;} else {if (digitalRead (btn4) == HIGH) {intInput = 3;} tjetër {intInput = 4; }}}} // serial printoni hyrjet nëse (intEnter == 1) {Serial.println ("Hyn Shtypur!");} nëse (intInput! = 4) {Serial.print ("Shtypja e Butonit:"); Serial.println (intInput); } else {// nëse nuk është shtypur asnjë buton reset bolTilePressed bolTilePressed = false; }}

Ky kod përdoret me funksionet buttonsGame dhe buttonsMenu. në bazë të butonave që përdoruesi ka shtypur ai vendos vlerën e intInput, ose nëse nuk shtypet asnjë buton e vendos intInput në të barabartë me 4.

Nëse nuk shtypet asnjë buton, kjo është ajo ku bolTilePressed rivendoset për funksionin buttonsGame.

Gjithashtu printon një mesazh në monitorin serik në të cilin shtypet butoni.

Hapi 14: Funksioni BottomCheck

kopjoni kodin e mëposhtëm në programin tuaj.

void bottomCheck () {për (int i = 0; i <= 3; i ++) {// për 4 kolonat if (arrGame [15] == 1) {// nëse një pllakë është në pjesën e poshtme Seriale.println ("Tjegull në fund"); arrGame [15] = 2; drawBoard (); vonesa (400); arrGame [15] = 1; drawBoard (); vonesa (400); arrGame [15] = 2; drawBoard (); vonesa (400); arrGame [15] = 1; drawBoard (); vonesa (400); Loja mbaroi(); }}}

duke përdorur një lak ky kod kontrollon rreshtin e poshtëm të arrGame për çdo pllakë të pazbuluar (pllaka të barabarta me 1), nëse ka një pllakë të pa goditur në pjesën e poshtme të ekranit do të ndezë pllakën dhe më pas do të aktivizojë lojën mbi funksionin.

Hapi 15: Funksioni WriteSerial

kopjoni kodin e mëposhtëm në programin tuaj

void writeSerial () {if (bolSerialBoard == true) {për (int i = 0; i <= 15; i ++) {për (int ii = 0; ii <= 3; ii ++) {Serial.print (arrGame [ii]); Serial.print (","); } Serial.println (""); }}}

Ky është funksioni i ndjekur nga opsioni i korrigjimit që mund të aktivizohet në funksionin buttonsMenu. Nëse bolSerialBoard është vendosur në të vërtetë në atë funksion, ai do të kalojë nëpër arrGame dhe do të printojë të gjithë tabelën në monitorin serik për qëllime testimi duke përdorur një grup.

Hapi 16: Përfundimi

I gjithë kodi juaj nuk duhet të jetë i plotë dhe të duket diçka si kjo!

/ * * Emri - Pllaka pianoje; Arduino * Nga - Domenic Marulli * Data - 11/ *

/ përfshijnë bibliotekat

#përfshi

// këto ndryshore janë opsione që mund t'i ndryshoni - numra më të lartë = shpejtësi më të shpejtë të lojës

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

// Përcaktoni kunjat

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

// krijoni objekte LCD (n, ~, n, ~, ~, n)

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

// konfiguroni grupin e lojërave

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

// vendosni variabla për lojën

boolean bolPlay; // gjurmon nëse lojtari int intScore; // gjurmon rezultatin e lojtarit int intDiff; // vetëm një gjë estetike për të treguar se në çfarë vështirësie është loja

// vendosni variabla për hyrje

int intEERT; // gjurmon nëse përdoruesi shtyp butonin enter int intInput; // gjurmon se cilat butona përdoruesi shtyp boolean bolTilePressed; // sigurohuni që lojtari të mos e shtypë rastësisht një buton 5x dhe të mos humbasë

// vendosni variabla për turn

int intTick; // numëron miliona (për lak) derisa intDelay int intDelay; // koha kur programi pret deri në kthesën tjetër në millis int intGameSpeed;

// heqja e opsioneve të korrigjimit

boolean bolSerialBoard; // kur true do të printojë tabelën në monitorin serik

// konfigurimi që do të ekzekutohet një herë

void setup () {Serial.begin (9600); // filloni monitorin serik // vendosni variablat bolPlay = false; intScore = 0; intTick = 0; vonesë = 1000; intDiff = 1; intGameSpeed = intGameSpeedMedium; // filloni lcdLeft.cc's lcd.filloni (16, 2); lcdRight.filloj (16, 2); }

// lak i cili do të drejtohet çdo 10 milisekonda

void loop () {input (); // kontrolloni për futjen e lojës nëse (bolPlay == true) {if (intTick> = intDelay) {// kontrolloni nëse loja duhet të luajë një kthesë ose të vazhdojë të presë Serial.println ("~~~~~~~ print "); // printoni për të nënkuptuar që tabela të lëvizë // shkruajSerial (); // nëse opsioni është i aktivizuar shkruani tabelën në butonat serialGame (); // kontrolloni për hyrjet e lojtarëve playBoard (); // zhvendos bordin dhe shto një pllakë të re clearLcd (); // pastroni LCD -të para se të vizatoni drawBoard (); // vizatoni tabelën në fundCcck të LCD -së (); intTick = 0; // rivendos intTick} else {buttonsGame (); // kontrolloni për inputet e lojtarit clearLcd (); // pastroni LCD -të para se të vizatoni drawBoard (); // vizatoni tabelën në intTick të lcd = intTick + intGameSpeed; // shto në shënimin}} else {clearLcd (); // pastroni LCD -të para se të vizatoni titullin (); // shfaq titujt dhe butonat e informacionit të rezultatitMenu (); // lexoni futjen e lojtarit clearBoard (); // siguroni të gjithë bordin = 0} vonesë (10); // vononi arduino me një moment të shkurtër}

// pastron LCD -në, kështu që çdo qelizë e pakontrolluar nuk është lënë atje

pavlefshme clearLcd () {për (int i = 0; i <= 15; i ++) {për (int ii = 0; ii <= 1; ii ++) {lcdLeft.setCursor (i, ii); lcdLeft.write (""); lcdRight.setCursor (i, ii); lcdRight.write (""); }}}

// tërheq tabelën në LCD -të

void drawBoard () {për (int i = 1; i <= 15; i ++) {// vizatoni kolumet 1 dhe 2 në LCD -në e majtë // nëse pllaka = 0 nuk shkruan asgjë, = 1 shkruani "#", = 2 shkruani "@" lcdLeft.setCursor (i, 1); // vendosur në kolonën e parë (majtas më larg) nëse (arrGame [0] == 1) {lcdLeft.write ("#");} if (arrGame [0] == 2) {lcdLeft.shkruani ("@");} lcdLeft.setCursor (i, 0); // vendosur në kolonën e dytë (qendra majtas) nëse (arrGame [1] == 1) {lcdLeft.write ("#");} if (arrGame [1] == 2) {lcdLeft.shkruani ("@");} lcdRight.setCursor (i, 1); // vendosur në kolonën e tretë (në të djathtë në qendër) nëse (arrGame [2] == 1) {lcdRight.write ("#");} if (arrGame [2] == 2) {lcdRight.shkruani ("@");} lcdRight.setCursor (i, 0); // vendosur në kolonën e katërt (djathtas) nëse (arrGame [3] == 1) {lcdRight.write ("#");} if (arrGame [3] == 2) {lcdRight.shkruaj("@");} } }

// lëviz tabelën poshtë dhe vendos një vlerë të rastësishme për të qenë një pllakë

void playBoard () {për (int i = 0; i <= 3; i ++) {arrGame [0] = 0;} // pastro rreshtin e lartë arrGame [0] [rastësore (0, 4)] = 1; // vendosni një pikë të rastësishme në rreshtin e sipërm që të jetë një pllakë për (int i = 15; i> = 1; i-) {// duke punuar nga fundi i tabelës në krye për (int ii = 0; ii <= 3; ii ++) {// për çdo përplasje arrGame [ii] = arrGame [i - 1] [ii]; }}}

// vendos të gjithë tabelën në 0 dhe rivendos ndryshoret në lojën paraprake

void clearBoard () {// rivendos vlerat e shënimit dhe vonesës intTick = 0; vonesë = 1000; // kaloni nëpër tabelë dhe vendosni gjithçka në 0 për (int i = 0; i <= 15; i ++) {për (int ii = 0; ii <= 3; ii ++) {arrGame [ii] = 0; }}}

// shfaq menynë kryesore në ekranet LCD

titull i pavlefshëm () {// shkruaj titullin në LCD dhe hapësirë për rezultatin lcdRight.setCursor (0, 0); lcdRight.write ("Pllaka Piano"); lcdRight.setCursor (0, 1); lcdRight.write ("Rezultati:"); // konvertoni rezultatin në një string string strScore [3]; sprintf (strScore, "%d", intScore); // shfaq rezultatin në LCD lcdRight.write (strScore); // shtoni difiktivisht lcdRight.setCursor (10, 1); if (intDiff == 0) {lcdRight.write ("Lehtë"); } if (intDiff == 1) {lcdRight.write ("Mesatar"); } if (intDiff == 2) {lcdRight.write ("E vështirë"); } // Shtypni pak udhëzime lcdLeft.setCursor (0, 0); lcdLeft.write ("Shtyp Enter"); lcdLeft.setCursor (0, 1); lcdLeft.write ("për të filluar!"); }

// kontrollon butonat dhe çfarë të bëni për to ndërsa jeni jashtë loje

butonat e pavlefshëmMenu () {// kur shtypet enter filloni lojën dhe rivendosni vlerën e rezultatit nëse (intEnter == 1) {bolPlay = true; intScore = 0; playBoard (); drawBoard (); } // kur shtypet butoni 3 aktivizoni opsionin e korrigjimit të printimit të bordit në seri nëse (intInput == 3) {if (bolSerialBoard == false) {Serial.println ("Serial Board Active"); bolSerialBoard = e vërtetë; } else {Serial.println ("Serial Board Disabled"); bolSerialBoard = false; }} // vendosni shpejtësinë e lojës në vështirësi të lehtë nëse (intInput == 0) {Serial.print ("Loja e vendosur në të lehtë ("); Serial.print (intGameSpeedEasy); Serial.println ("ms përshpejtim)"); intDiff = 0; intGameSpeed = intGameSpeedEasy; } // vendosni shpejtësinë e lojës në vështirësi mesatare nëse (intInput == 1) {Serial.print ("Loja e vendosur në mesatare ("); Serial.print (intGameSpeedMedium); Serial.println ("ms përshpejtim")); intDiff = 1; intGameSpeed = intGameSpeedMedium; } // vendosni shpejtësinë e lojës në vështirësi të madhe nëse (intInput == 2) {Serial.print ("Loja e vendosur në hard ("); Serial.print (intGameSpeedHard); Serial.println ("ms përshpejtim)"); intDiff = 2; intGameSpeed = intGameSpeedHard; }}

// kontrollon butonat dhe çfarë duhet bërë për to gjatë lojës

void buttonsGame () {if (intInput! = 4) {// nëse një buton shtypet nëse (bolTilePressed == false) {// vetëm nëse bolTilePressed është veprim i rremë i nxitjes për kontrollimin e një butoni shtypni bolTilePressed = true; // pastaj vendosni bolTilePressed në true për t'u siguruar që nuk aktivizohet përsëri në mënyrë intime në intLowestTile = 0; // të vendoset në tjegull me pllakën më të ulët int intCheckedTile = 15; // për të mbajtur shënim se cilat pllaka janë kontrolluar ndërsa (intLowestTile == 0) {// për sa kohë që nuk është vendosur në asgjë kontrolloni pllakat për (int i = 0; i 100) {// për aq kohë sa int vonesa nuk është më e ulët se 100 intDelay = intDelay - 20; // merrni një vlerë prej saj}} tjetër {Serial.println ("Shtypur butonin e gabuar"); Loja mbaroi(); // përndryshe loja mbaron}}}}}

void gameOver () {

Serial.println ("Loja përfundoi!"); Serial.print ("Rezultati juaj ishte:"); Serial.println (intScore); Serial.print ("Shpejtësia juaj ishte:"); Serial.println (intDelay); bolPlay = false; }

// kontrollon hyrjen e lojtarit

void input () {intEnter = digitalRead (btnEnter); // lexo enter // lexo se cila nga hyrjet e tjera, ose nëse asnjë nuk është vendosur në 4 nëse (digitalRead (btn1) == HIGH) {intInput = 0;} tjetër {if (digitalRead (btn2) == HIGH) {intInput = 1;} tjetër {if (digitalRead (btn3) == HIGH) {intInput = 2;} else {if (digitalRead (btn4) == HIGH) {intInput = 3;} tjetër {intInput = 4; }}}} // serial printoni hyrjet nëse (intEnter == 1) {Serial.println ("Hyn Shtypur!");} nëse (intInput! = 4) {Serial.print ("Shtypja e Butonit:"); Serial.println (intInput); } else {// nëse nuk është shtypur asnjë buton reset bolTilePressed bolTilePressed = false; }}

// kontrollon pjesën e poshtme të tabelës për dështim

void bottomCheck () {për (int i = 0; i <= 3; i ++) {// për 4 kolonat if (arrGame [15] == 1) {// nëse një pllakë është në pjesën e poshtme Seriale.println ("Tjegull në fund"); arrGame [15] = 2; drawBoard (); vonesa (400); arrGame [15] = 1; drawBoard (); vonesa (400); arrGame [15] = 2; drawBoard (); vonesa (400); arrGame [15] = 1; drawBoard (); vonesa (400); Loja mbaroi(); }}}

// printon tabelën në monitorin serik nëse bolSerialBoard është e vërtetë

void writeSerial () {if (bolSerialBoard == true) {për (int i = 0; i <= 15; i ++) {për (int ii = 0; ii <= 3; ii ++) {Serial.print (arrGame [ii]); Serial.print (","); } Serial.println (""); }}}

Pasi të jetë futur i gjithë kodi, ngarkoni në arduino tuaj dhe kënaquni!