Arduino - Plăci de pian: 16 pași (cu imagini)

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:45

Bună ziua, oameni de internet, Acesta va fi despre cum să faceți ceea ce DEFINITIV nu este o copiere a unui joc mobil pe un arduino uno r3.

Deci, pentru a începe, veți avea nevoie de toate piesele, care sunt după cum urmează! 1x Arduino Uno r3 (42 USD)

2x ecran tastatură LCD (19 USD fiecare)

5 butoane

Rezistoare 5x 220Ω

28x fire

Bine, odată ce ai toate părțile, este timpul să începi!

Pasul 1: Cablare

Începeți prin a vă conecta arduino-ul și prietenii, așa cum se arată în diagramă, Asigurați-vă că butoanele sunt conectate în sensul corect, cu sloturile A0-4 de pe partea de jos a șinelor butonului, sau arduino va crede că butoanele sunt ținute apăsate constant în loc să fie doar apăsate.

Pasul 2: Declarații de declarație

Toate codurile de aici ar trebui să meargă înainte de configurarea voidă și bucla void, deoarece toate aceste variabile și obiecte sunt utilizate în mai multe dintre funcțiile pe care le vom configura.

Începeți prin a pune:

#include

în partea de sus a codului dvs., acest lucru îi spune arduino-ului să utilizeze biblioteca „LiquidCrystal.h” și funcțiile care fac parte din acesta.

Următorul pas este să definim pinii pe care îi folosim pentru butoanele noastre prin introducerea acestui cod sub # include:

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

Definim termenii btnEnter și btn1 la btn 4 pentru a ușura citirea codului sau pentru a schimba dacă este necesar. Înseamnă că atunci când tastăm btn1, arduino va ști că de fapt ne referim la butonul 15. Deși apelăm porturile 15, 16, 17 și 18, acestea sunt etichetate pe arduino ca A1 A2 A3 și A4, acest lucru se datorează faptului că sunt porturi utilizate special pentru intrări analogice, deși le folosim doar pentru intrări digitale.

În continuare vom crea obiectele care vor controla afișajele cu cristale lichide. Pentru a face acest lucru, puneți acest cod sub definițiile noastre

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

Ceea ce face acest lucru este să-i spună arduino că, atunci când apelăm lcdLeft sau lcdRight, ne referim la un obiect LiquidCrystal. Numerele din parantezele atașate indică arduino-ului ce porturi ar trebui să utilizeze obiectul pentru a trimite mesaje pe ecranul LCD atunci când le folosim funcțiile.

Acum trebuie să declarăm variabilele punând următorul bit de cod sub declarațiile obiectului:

// aceste variabile sunt opțiuni pe care le puteți schimba - numere mai mari = viteză mai mare a jocului în intGameSpeedEasy = 10; int intGameSpeedMedium = 25; int intGameSpeedHard = 80;

// setează variabile pentru gameBoolean bolPlay; // urmărește dacă jucătorul int intScore; // urmărește scorul jucătorului în intDiff; // doar un lucru estetic pentru a spune ce dificultate este jocul // configurați variabile pentru input int intEnter; // urmărește dacă utilizatorul apasă butonul de intrare int intInput; // urmărește ce butoane utilizatorul apasă boolean bolTilePressed; // asigurați-vă că jucătorul nu apasă accidental un buton de 5 ori și pierde // configurați variabilele pentru turn int intTick; // numără mii (pe buclă) până la intDelay int intDelay; // timpul în care programul așteaptă până la următoarea tură în milis int intGameSpeed; // opțiunea de opțiuni de depanare boolean bolSerialBoard; // când true va imprima placa pe monitorul serial

Declarăm o variabilă declarând tipul de date și apoi numele variabilei, de ex. int thisIsAnInteger

Variabilele booleene, cum ar fi bolSerialBoard și bolPlay pot avea doar una dintre cele două valori, adevărat sau fals.

Variabilele întregi (int), cum ar fi intScore și intInput, pot lua numerele întregi ca valori, cum ar fi 1, 5 sau 100.

Câteva alte tipuri de date notabile pe care nu le folosim aici sunt un șir, care este o bucată de text și un float, care este un număr zecimal.

Fiecare dintre variabilele de aici sunt utilizate în mai multe locuri diferite de program, iată o sinopsis a ceea ce face fiecare

bolPlay spune programului dacă trebuie afișat meniul sau dacă jocul propriu-zis ar trebui să ruleze.

intScore urmărește scorul jucătorului pe măsură ce lovește țiglele, intDiff este utilizat în meniul principal pentru a spune programului ce bit de text să imprime pe ecranele LCD, intEnter este folosit pentru a spune programului dacă este apăsat butonul Enter (cel mai la stânga), intInput este folosit pentru a spune programului care dintre celelalte 4 butoane este apăsat.

bolTilePressed este utilizat pentru a vă asigura că programul citește numai atunci când butonul este apăsat și nu când este ținut.

intGameSpeed, intGameSpeedEasy, intGameSpeedMedium și intGameSpeedHard sunt utilizate pentru a controla cât de repede ar trebui să accelereze jocul în funcție de dificultatea selectată.

intTick și intDelay sunt folosite pentru a opri programul de la mutarea plăcii de fiecare dată când se bucură.

bolSerialBoard este utilizat pentru a permite programului să trimită placa către monitorul serial al arduino ca o serie de numere pentru testare.

În cele din urmă, este timpul să declarăm placa noastră ca o matrice folosind acest cod:

// configurați game arrayint 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}};

O matrice este o matrice pe care orice punct pe care poate fi apelat pentru matematică sau pentru a fi modificat.

Codul dvs. ar trebui să arate acum așa;

// include biblioteci # include

// aceste variabile sunt opțiuni pe care le puteți schimba - numere mai mari = viteză mai mare a jocului

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

// Definiți pinii

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

// creați obiecte LCD (n, ~, n, ~, ~, n)

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

// configurați matrice de jocuri

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

// setează variabile pentru joc

boolean bolPlay; // urmărește dacă playerul int intScore; // urmărește scorul jucătorului în intDiff; // doar un lucru estetic pentru a spune pe ce dificultate este jocul

// setează variabile pentru intrare

int intEnter; // urmărește dacă utilizatorul apasă butonul de intrare int intInput; // urmărește ce butoane utilizatorul apasă boolean bolTilePressed; // asigurați-vă că jucătorul nu apasă accidental un buton de 5 ori și pierde

// setează variabile pentru rând

int intTick; // numără mii (pe buclă) până la intDelay int intDelay; // timpul în care programul așteaptă până la următoarea tură în milis int intGameSpeed;

// acces la opțiunile de depanare

boolean bolSerialBoard; // când true va imprima placa pe monitorul serial

Pasul 3: Funcția de configurare

Bucla de configurare este o funcție citită de arduino o singură dată când pornește inițial.

În bucla de configurare setăm doar valorile câtorva dintre variabilele noastre, deoarece în loc să le setăm o valoare atunci când le declarăm, o facem aici.

Începeți prin introducerea acestui cod în setarea Void.

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

Fiecare linie setează doar o variabilă la o valoare.

bolPlay este setat la false, astfel încât jocul să nu înceapă să se joace.

intScore este setat la 0, deoarece în mod firesc scorul dvs. începe de la 0.

intTick începe de la 0 deoarece programul nu contorizează în prezent nimic.

intDelay este setat la 1000, deoarece aceasta este rata la care plăcile încep.

intDiff este doar un lucru ascetic, astfel încât programul să știe ce să scrie pentru dificultatea jocului.

intGameSpeed este setat la orice este intGameSpeedMedium, adică este setat la dificultatea medie.

Apoi puneți acest cod în setarea Void sub codul pe care tocmai l-ați introdus.

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

Serial.begin (9600);

Acest lucru îi spune arduino să înceapă să comunice cu computerul prin intermediul monitorului serial (vizibil făcând clic pe butonul din dreapta sus al IDE-ului arduino).

Configurarea voastră ar trebui să arate acum așa!

void setup () {Serial.begin (9600); // porniți monitorul serial // configurați variabilele bolPlay = false; intScore = 0; intTick = 0; intDelay = 1000; intDiff = 1; intGameSpeed = intGameSpeedMedium; // începe lcdLeftLeft.begin (16, 2); lcdRight.begin (16, 2); }

Pasul 4: Funcția Loop

Funcția buclă este rulată de arduino la fiecare iterație a arduino-ului.

Copiați următorul cod în bucla voastră.

bucla void () {input (); // verificați dacă intrarea se joacă dacă (bolPlay == true) {if (intTick> = intDelay) {// verificați dacă jocul ar trebui să joace un rând sau să aștepte în continuare Serial.println ("~~~~~~~ ~~ "); // print pentru a semnifica placa care se deplasează pe // writeSerial (); // dacă opțiunea este activată scrieți placa în butoanele seriale Game (); // verificați intrările jucătorului playBoard (); // mutați placa și adăugați o nouă țiglă clearLcd (); // curățați ecranele LCD înainte de a desena drawBoard (); // desenați placa pe fundul LCD-uluiCheck (); intTick = 0; // resetează intTick} else {buttonsGame (); // verificați intrările jucătorului clearLcd (); // curățați ecranele LCD înainte de a desena drawBoard (); // desenați placa pe intTick-ul lcd = intTick + intGameSpeed; // adaugă la bifă}} else {clearLcd (); // curățați ecranele LCD înainte de a desena titlul (); // afișează butoanele cu informații despre titlu și scoruri Meniu (); // citire intrare player clearBoard (); // asigură întreaga placă = 0} întârziere (10); // întârziere arduino cu un moment scurt}

când bolPlay este egal cu adevărat înseamnă că jocul se joacă și tot codul pentru momentul în care se joacă jocul ar trebui să fie rulat, dar vrem doar ca placa să adauge o nouă țiglă și să se deplaseze în jos când intTick este mai mare decât intDelay, altfel vrem totuși să permitem utilizatorului să apese un buton pentru a lovi o țiglă și ca intTick să crească viteza.

Majoritatea acestui cod folosește funcții pe care încă nu le-am realizat și le vom realiza în pașii următori. Scopul acestor funcții este următorul.

Intrarea citește ce butoane a apăsat utilizatorul.

Butoane Joc controlează ce fac butoanele în joc și nu în meniu

playBoard adaugă o nouă țiglă la tablă, apoi mută totul în tablă într-un spațiu

clearLCD curăță LCD-urile pentru a vă asigura că nu sunt lăsate fantome în spatele plăcilor

drawBoard trece prin arrGame și îl imprimă pe ecranele LCD

clearBoard șterge întregul joc ArrGame când jocul nu este în joc

bottomCheck verifică partea de jos a arrGame pentru o stare de eșec

titlu afișează titlul jocului și informații despre scor când se află în meniu

meniul butoanelor controlează ce fac intrările utilizatorului atunci când se află în meniu.

gameOver este o altă funcție, deși nu este apelată aici, deoarece este numită în partea de jos Verificare și butoane Funcții de joc.

Pasul 5: Funcția ClearLCD

pentru a crea o funcție, începem prin adăugarea acesteia la cod

void functionName () {

}

„functionName” poate fi orice, atâta timp cât nu există deja.

Copiați acest cod în programul dvs.:

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

aceasta rulează prin întreaga matrice utilizând 2 bucle numărate pentru a parcurge fiecare punct de pe ecranele LCD și a scrie un spațiu.

Fără a fi resetat la nimic, ecranele LCD vor menține orice a fost scris anterior

Pasul 6: Funcția DrawBoard

copiați acest cod în programul dvs.

void drawBoard () {for (int i = 1; i <= 15; i ++) {// desenează coloanele 1 și 2 pe ecranul stâng // dacă țiglă = 0 nu scrie nimic, = 1 scrie "#", = 2 scrieți „@” lcdLeft.setCursor (i, 1); // setați la prima coloană (cel mai la stânga) if (arrGame [0] == 1) {lcdLeft.write ("#");} if (arrGame [0] == 2) {lcdLeft.write ("@");} lcdLeft.setCursor (i, 0); // setați la a doua coloană (centru stânga) if (arrGame [1] == 1) {lcdLeft.write ("#");} if (arrGame [1] == 2) {lcdLeft.write ("@");} lcdRight.setCursor (i, 1); // setați la a treia coloană (centru dreapta) if (arrGame [2] == 1) {lcdRight.write ("#");} if (arrGame [2] == 2) {lcdRight.write ("@");} lcdRight.setCursor (i, 0); // setați la a patra coloană (cel mai la dreapta) if (arrGame [3] == 1) {lcdRight.write ("#");} if (arrGame [3] == 2) {lcdRight.scrie("@");} } }

aceasta folosește o buclă pentru a parcurge fiecare rând al plăcii, apoi verifică dacă vreo coloană din rând este egală cu 1 sau 2, pe baza căreia apoi imprimă pe LCD fie un hashtag, pentru o țiglă care încă nu este lovit sau un @ pentru o țiglă de lovit.

Pasul 7: Funcția PlayBoard

copiați acest cod în programul dvs.

void playBoard () {for (int i = 0; i <= 3; i ++) {arrGame [0] = 0;} // ștergeți rândul superior arrGame [0] [random (0, 4)] = 1; // setați un punct aleatoriu pe rândul de sus pentru a fi o țiglă pentru (int i = 15; i> = 1; i -) {// lucrând din partea de jos a plăcii până în partea de sus pentru (int ii = 0; ii <= 3; ii ++) {// pentru fiecare colar arrGame [ii] = arrGame [i - 1] [ii]; }}}

acest cod începe prin ștergerea întregului rând superior la 0 sau fără nici o țiglă și apoi setează o țiglă aleatorie pentru a fi o țiglă 1 și unhit.

Apoi trece printr-o buclă numărată în sens invers, de la 15 la 1, setând rândul să fie egal cu oricare dintre rândurile de deasupra lui este egal, făcând placa să se deplaseze în jos pe ecranul LCD

Pasul 8: Funcția ClearBoard

copiați acest cod în programul dvs.

void clearBoard () {// resetează bifează și întârzie valorile intTick = 0; intDelay = 1000; // treceți prin tablă și setați totul la 0 pentru (int i = 0; i <= 15; i ++) {pentru (int ii = 0; ii <= 3; ii ++) {arrGame [ii] = 0; }}}

Acest cod este rulat atunci când jocul nu se joacă pentru a vă asigura că întregul joc arGame este setat la 0 sau nu are dale, utilizând bucle numărate pentru a parcurge matricea.

Codul resetează, de asemenea, valorile intDelay și intTick.

Pasul 9: Funcția de titlu

copiați următorul cod în programul dvs.

void title () {// scrie titlul pe LCD și spațiu pentru scor lcdRight.setCursor (0, 0); lcdRight.write („Plăci de pian”); lcdRight.setCursor (0, 1); lcdRight.write ("Scor:"); // convertiți scorul într-un șir de caractere strScore [3]; sprintf (strScore, "% d", intScore); // afișează scorul pe LCD lcdRight.write (strScore); // adăugați diferențial lcdRight.setCursor (10, 1); if (intDiff == 0) {lcdRight.write ("Easy"); } if (intDiff == 1) {lcdRight.write ("Medium"); } if (intDiff == 2) {lcdRight.write ("Hard"); } // Apăsați un pic de instrucțiuni lcdLeft.setCursor (0, 0); lcdLeft.write („Apăsați Enter”); lcdLeft.setCursor (0, 1); lcdLeft.write („pentru a începe!”); }

Acest cod scrie titlul jocului și scorul pe LCD-uri, face acest lucru spunându-i LCD-ului unde să înceapă să tastați folosind LCD.setCursor și apoi să scrieți șirul în LCD.write.

O nouă variabilă este, de asemenea, creată aici, strScore, este utilizată pentru a converti intScore într-un șir sau tip de date char folosind funcția sprintf.

IntDiff este, de asemenea, utilizat aici, pe baza valorilor sale, imprimă diferitele opțiuni de dificultate.

Pasul 10: Funcția ButtonsMenu

introduceți următorul cod în programul dvs.

void buttonsMenu () {// când este apăsat Enter începe jocul și resetează valoarea scorului dacă (intEnter == 1) {bolPlay = true; intScore = 0; playBoard (); drawBoard (); } // când butonul 3 este apăsat, activați opțiunea de depanare a imprimării plăcii în serie if (intInput == 3) {if (bolSerialBoard == false) {Serial.println ("Serial Board Active"); bolSerialBoard = adevărat; } else {Serial.println ("Serial Board Disabled"); bolSerialBoard = false; }} // setați viteza jocului la dificultate ușoară dacă (intInput == 0) {Serial.print ("Joc setat la ușor ("); Serial.print (intGameSpeedEasy); Serial.println ("ms accelerare)"); intDiff = 0; intGameSpeed = intGameSpeedEasy; } // setați viteza jocului la dificultate medie dacă (intInput == 1) {Serial.print ("Joc setat la mediu ("); Serial.print (intGameSpeedMedium); Serial.println ("ms accelerare)"); intDiff = 1; intGameSpeed = intGameSpeedMedium; } // setați viteza jocului la dificultate tare dacă (intInput == 2) {Serial.print ("Joc setat la hard ("); Serial.print (intGameSpeedHard); Serial.println ("ms accelerare)"); intDiff = 2; intGameSpeed = intGameSpeedHard; }}

acest cod se execută numai atunci când bolPlay este egal cu fals în bucla nulă

dacă intEnter este setat la 1 înseamnă că butonul Enter a fost apăsat, dacă este apăsat, programul setează bolPlay la true și jocul începe.

Programul citește apoi la ce este egal intInput. dacă este egal cu 0, se apasă primul buton din stânga, urcând spre dreapta până la 3. Dacă intInput este egal cu 4, nu se apasă niciun buton.

dacă butoanele 0-2 sunt apăsate, jocul modifică dificultatea, ajustând și valoarea vitezei jocului, ceea ce înseamnă că va accelera mai repede.

dacă butonul 3 este apăsat, jocul va activa sau dezactiva un mod de depanare în care întreaga placă este tipărită pe monitorul serial pentru a ajuta la găsirea problemelor din program.

Pasul 11: Funcția ButtonsGame

copiați următorul cod în programul dvs.

void buttonsGame () {if (intInput! = 4) {// dacă un buton este apăsat dacă (bolTilePressed == false) {// numai dacă bolTilePressed este o acțiune de declanșare falsă pentru verificarea unui buton apăsați bolTilePressed = true; // apoi setați bolTilePressed la true pentru a vă asigura că nu este declanșat din nou accidental int intLowestTile = 0; // pentru a fi setat la țiglă cu cea mai mică țiglă int intCheckedTile = 15; // pentru a urmări ce plăci au fost verificate în timp ce (intLowestTile == 0) {// atâta timp cât nu este setat la nimic verificați plăcile pentru (int i = 0; i 100) {// atâta timp cât int întârzierea nu este mai mică de 100 intDelay = intDelay - 20; // luați o valoare din aceasta}} else {Serial.println ("Buton greșit apăsat"); joc încheiat(); // altfel joc peste}}}}}

Codul se execută numai atunci când bolPlay este egal cu adevărat în bucla nulă.

Butoane Like Meniu bazat pe valoarea intInput verifică dacă jucătorul a lovit o țiglă sau a ratat una.

Face acest lucru trecând prin arrGame de jos în sus, folosind o buclă while pentru a căuta care rând este cel mai mic cu o țiglă fără lovituri. Apoi verifică dacă punctul din acel rând corespunzător butonului apăsat este sau nu o țiglă, dacă este nelimitat, îl setează la 2 în loc de 1, ceea ce înseamnă că va fi afișat ca un @, altfel declanșează jocul funcție pe care încă trebuie să o creăm.

Această funcție utilizează, de asemenea, variabila bolTilePressed setând-o la adevărat când este apăsat un buton și la fals când nu este apăsat niciun buton. Aceasta este pentru a se asigura că utilizatorul nu pierde accidental jocul, deoarece programul a crezut că a apăsat butonul de mai multe ori când l-a ținut apăsat.

Pasul 12: Funcția GameOver

Copiați următorul cod în programul dvs.

void gameOver () {Serial.println ("Game Over!"); Serial.print ("Scorul dvs. a fost:"); Serial.println (intScore); Serial.print („Viteza ta a fost:”); Serial.println (intDelay); bolPlay = fals; }

Acest lucru este declanșat fie de funcțiile checkBottom, fie de butoanele Game și declanșează sfârșitul jocului setând bolPlay ca fiind fals.

De asemenea, imprimă un mesaj pe monitorul serial pentru scorul utilizatorilor și plăcile de viteză au fost adăugate în milisecunde.

Pasul 13: Funcția de intrare

Copiați următorul cod în programul dvs.

void input () {intEnter = digitalRead (btnEnter); // citiți introduceți // citiți care dintre celelalte intrări sau dacă niciuna nu este setată la 4 dacă (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; }}}} // serial printează intrările if (intEnter == 1) {Serial.println ("Enter Pressed!");} if (intInput! = 4) {Serial.print ("Button Press:"); Serial.println (intInput); } else {// dacă nu este apăsat niciun buton resetați bolTilePressed bolTilePressed = false; }}

Acest cod este utilizat cu funcțiile butoane Joc și butoane Meniu. pe baza butoanelor pe care le-a apăsat utilizatorul, setează valoarea intInput sau dacă nu este apăsat niciun buton, setează intInput la 4.

Dacă nu este apăsat niciun buton, aici se resetează bolTilePressed pentru funcția butoane Game.

De asemenea, imprimă un mesaj pe monitorul serial pe care este apăsat butonul.

Pasul 14: Funcția BottomCheck

copiați următorul cod în programul dvs.

void bottomCheck () {for (int i = 0; i <= 3; i ++) {// pentru cele 4 coloane if (arrGame [15] == 1) {// if a tile is in the bottom Serial.println („Placi de jos”); arrGame [15] = 2; drawBoard (); întârziere (400); arrGame [15] = 1; drawBoard (); întârziere (400); arrGame [15] = 2; drawBoard (); întârziere (400); arrGame [15] = 1; drawBoard (); întârziere (400); joc încheiat(); }}}

folosind o buclă, acest cod verifică rândul inferior al jocului arrGame pentru orice piesă nelegată (dale egale cu 1), dacă există o dală nelimitată în partea de jos a ecranului, aceasta va lumina intermitent și apoi va declanșa funcția joc peste.

Pasul 15: Funcția WriteSerial

copiați următorul cod în programul dvs.

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

Aceasta este funcția urmată de opțiunea de depanare care poate fi activată în funcția butoane Meniu. Dacă bolSerialBoard este setat la adevărat în acea funcție, va trece prin arrGame și va imprima întreaga placă pe monitorul serial în scopuri de testare, utilizând o matrice.

Pasul 16: Finalizare

Tot codul dvs. nu ar trebui să fie complet și să arate cam așa!

/ * * Nume - Plăci de pian; Arduino * De - Domenic Marulli * Data - 11 / *

/ include biblioteci

#include

// aceste variabile sunt opțiuni pe care le puteți schimba - numere mai mari = viteză mai mare a jocului

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

// Definiți pinii

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

// creați obiecte LCD (n, ~, n, ~, ~, n)

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

// configurați matrice de jocuri

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

// setează variabile pentru joc

boolean bolPlay; // urmărește dacă playerul int intScore; // urmărește scorul jucătorului în intDiff; // doar un lucru estetic pentru a spune pe ce dificultate este jocul

// setează variabile pentru intrare

int intEnter; // urmărește dacă utilizatorul apasă butonul de intrare int intInput; // urmărește ce butoane utilizatorul apasă boolean bolTilePressed; // asigurați-vă că jucătorul nu apasă accidental un buton de 5 ori și pierde

// setează variabile pentru rând

int intTick; // numără mii (pe buclă) până la intDelay int intDelay; // timpul în care programul așteaptă până la următoarea tură în milis int intGameSpeed;

// acces la opțiunile de depanare

boolean bolSerialBoard; // când true va imprima placa pe monitorul serial

// configurarea care va fi rulată o dată

void setup () {Serial.begin (9600); // porniți monitorul serial // configurați variabilele bolPlay = false; intScore = 0; intTick = 0; intDelay = 1000; intDiff = 1; intGameSpeed = intGameSpeedMedium; // începe lcdLeftLeft.begin (16, 2); lcdRight.begin (16, 2); }

// bucla care va fi rulată la fiecare 10 milisecunde

bucla void () {input (); // verificați dacă intrarea se joacă dacă (bolPlay == true) {if (intTick> = intDelay) {// verificați dacă jocul ar trebui să joace un rând sau să aștepte în continuare Serial.println ("~~~~~~~ ~~ "); // print pentru a semnifica placa care se deplasează pe // writeSerial (); // dacă opțiunea este activată scrieți placa în butoanele seriale Game (); // verificați intrările jucătorului playBoard (); // mutați placa și adăugați o nouă țiglă clearLcd (); // curățați ecranele LCD înainte de a desena drawBoard (); // desenați placa pe fundul LCD-uluiCheck (); intTick = 0; // resetează intTick} else {buttonsGame (); // verificați intrările jucătorului clearLcd (); // curățați ecranele LCD înainte de a desena drawBoard (); // desenați placa pe intTick-ul lcd = intTick + intGameSpeed; // adaugă la bifă}} else {clearLcd (); // curățați ecranele LCD înainte de a desena titlul (); // afișează butoanele cu informații despre titlu și scoruri Meniu (); // citire intrare player clearBoard (); // asigură întreaga placă = 0} întârziere (10); // întârziere arduino cu un moment scurt}

// curăță LCD-ul, astfel încât celulele necentrate să nu fie lăsate acolo

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

// desenează placa pe lcd-uri

void drawBoard () {for (int i = 1; i <= 15; i ++) {// desenează coloanele 1 și 2 pe ecranul stâng // dacă țiglă = 0 nu scrie nimic, = 1 scrie "#", = 2 scrieți „@” lcdLeft.setCursor (i, 1); // setați la prima coloană (cel mai la stânga) if (arrGame [0] == 1) {lcdLeft.write ("#");} if (arrGame [0] == 2) {lcdLeft.write ("@");} lcdLeft.setCursor (i, 0); // setați la a doua coloană (centru stânga) if (arrGame [1] == 1) {lcdLeft.write ("#");} if (arrGame [1] == 2) {lcdLeft.write ("@");} lcdRight.setCursor (i, 1); // setați la a treia coloană (centru dreapta) if (arrGame [2] == 1) {lcdRight.write ("#");} if (arrGame [2] == 2) {lcdRight.write ("@");} lcdRight.setCursor (i, 0); // setați la a patra coloană (cel mai la dreapta) if (arrGame [3] == 1) {lcdRight.write ("#");} if (arrGame [3] == 2) {lcdRight.scrie("@");} } }

// deplasează placa în jos și plasează o valoare aleatorie pentru a fi o țiglă

void playBoard () {for (int i = 0; i <= 3; i ++) {arrGame [0] = 0;} // ștergeți rândul superior arrGame [0] [random (0, 4)] = 1; // setați un punct aleatoriu pe rândul de sus pentru a fi o țiglă pentru (int i = 15; i> = 1; i -) {// lucrând din partea de jos a plăcii până în partea de sus pentru (int ii = 0; ii <= 3; ii ++) {// pentru fiecare colar arrGame [ii] = arrGame [i - 1] [ii]; }}}

// setează întreaga placă la 0 și resetează variabilele la joc înainte

void clearBoard () {// resetează bifează și întârzie valorile intTick = 0; intDelay = 1000; // treceți prin tablă și setați totul la 0 pentru (int i = 0; i <= 15; i ++) {pentru (int ii = 0; ii <= 3; ii ++) {arrGame [ii] = 0; }}}

// afișează meniul principal pe ecranele LCD

void title () {// scrie titlul pe LCD și spațiu pentru scor lcdRight.setCursor (0, 0); lcdRight.write („Plăci de pian”); lcdRight.setCursor (0, 1); lcdRight.write ("Scor:"); // convertiți scorul într-un șir de caractere strScore [3]; sprintf (strScore, "% d", intScore); // afișează scorul pe LCD lcdRight.write (strScore); // adăugați diferențial lcdRight.setCursor (10, 1); if (intDiff == 0) {lcdRight.write ("Easy"); } if (intDiff == 1) {lcdRight.write ("Medium"); } if (intDiff == 2) {lcdRight.write ("Hard"); } // Apăsați un pic de instrucțiuni lcdLeft.setCursor (0, 0); lcdLeft.write („Apăsați Enter”); lcdLeft.setCursor (0, 1); lcdLeft.write („pentru a începe!”); }

// verifică butoanele și ce să facă pentru ele în afara jocului

void buttonsMenu () {// când este apăsat Enter începe jocul și resetează valoarea scorului dacă (intEnter == 1) {bolPlay = true; intScore = 0; playBoard (); drawBoard (); } // când butonul 3 este apăsat, activați opțiunea de depanare a imprimării plăcii în serie if (intInput == 3) {if (bolSerialBoard == false) {Serial.println ("Serial Board Active"); bolSerialBoard = adevărat; } else {Serial.println ("Serial Board Disabled"); bolSerialBoard = false; }} // setați viteza jocului la dificultate ușoară dacă (intInput == 0) {Serial.print ("Joc setat la ușor ("); Serial.print (intGameSpeedEasy); Serial.println ("ms accelerare)"); intDiff = 0; intGameSpeed = intGameSpeedEasy; } // setați viteza jocului la dificultate medie dacă (intInput == 1) {Serial.print ("Joc setat la mediu ("); Serial.print (intGameSpeedMedium); Serial.println ("ms accelerare)"); intDiff = 1; intGameSpeed = intGameSpeedMedium; } // setați viteza jocului la dificultate tare dacă (intInput == 2) {Serial.print ("Joc setat la hard ("); Serial.print (intGameSpeedHard); Serial.println ("ms accelerare)"); intDiff = 2; intGameSpeed = intGameSpeedHard; }}

// verifică butoanele și ce să facă pentru ele în timpul jocului

void buttonsGame () {if (intInput! = 4) {// dacă un buton este apăsat dacă (bolTilePressed == false) {// numai dacă bolTilePressed este o acțiune de declanșare falsă pentru verificarea unui buton apăsați bolTilePressed = true; // apoi setați bolTilePressed la true pentru a vă asigura că nu este declanșat din nou accidental int intLowestTile = 0; // să fie setat la țiglă cu cea mai mică țiglă int intCheckedTile = 15; // pentru a urmări ce plăci au fost verificate în timp ce (intLowestTile == 0) {// atâta timp cât nu este setat la nimic verificați plăcile pentru (int i = 0; i 100) {// atâta timp cât int întârzierea nu este mai mică de 100 intDelay = intDelay - 20; // luați o valoare din ea}} else {Serial.println ("Buton greșit apăsat"); joc încheiat(); // altfel joc peste}}}}}

void gameOver () {

Serial.println („Joc terminat!”); Serial.print ("Scorul dvs. a fost:"); Serial.println (intScore); Serial.print („Viteza ta a fost:”); Serial.println (intDelay); bolPlay = fals; }

// verifică intrarea jucătorului

void input () {intEnter = digitalRead (btnEnter); // citiți introduceți // citiți care dintre celelalte intrări sau dacă niciuna nu este setată la 4 dacă (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; }}}} // serial printează intrările if (intEnter == 1) {Serial.println ("Enter Pressed!");} if (intInput! = 4) {Serial.print ("Button Press:"); Serial.println (intInput); } else {// dacă nu este apăsat niciun buton resetați bolTilePressed bolTilePressed = false; }}

// verifică partea de jos a plăcii pentru eșec

void bottomCheck () {for (int i = 0; i <= 3; i ++) {// pentru cele 4 coloane if (arrGame [15] == 1) {// if a tile is in the bottom Serial.println („Placi de jos”); arrGame [15] = 2; drawBoard (); întârziere (400); arrGame [15] = 1; drawBoard (); întârziere (400); arrGame [15] = 2; drawBoard (); întârziere (400); arrGame [15] = 1; drawBoard (); întârziere (400); joc încheiat(); }}}

// imprimă placa în monitorul serial dacă bolSerialBoard este adevărat

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

Odată introdus tot codul, încărcați pe arduino și bucurați-vă!