Arduino - Piastrelle per pianoforte: 16 passaggi (con immagini)

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:03

Ciao gente di Internet, questo sarà su come realizzare ciò che DEFINITEMENTE non è una fregatura di un gioco per cellulare su un arduino uno r3.

quindi per iniziare, avrai bisogno di tutte le parti, che sono le seguenti! 1x Arduino Uno r3 ($ 42)

2x schermo per tastiera LCD ($ 19 ciascuno)

5x pulsanti

5 resistenze da 220Ω

28x fili

Bene, una volta che hai tutte le parti è ora di iniziare!

Passaggio 1: cablaggio

Inizia collegando il tuo arduino e i tuoi amici come mostrato nello schema, Assicurati che i pulsanti siano collegati nel modo giusto, con gli slot A0-4 sul lato a terra delle guide dei pulsanti, altrimenti l'arduino penserà che i pulsanti vengano tenuti premuti costantemente anziché solo su una pressa.

Passaggio 2: dichiarazioni di dichiarazione

Tutto il codice qui dovrebbe andare prima del tuo void setup e void loop, questo perché tutte queste variabili e oggetti sono usati in molte delle funzioni che configureremo.

Inizia mettendo:

#includere

all'inizio del tuo codice, questo sta dicendo all'arduino di usare la libreria "LiquidCrystal.h" e le funzioni che ne fanno parte.

Il prossimo passo è definire i pin che stiamo usando per i nostri pulsanti inserendo questo codice sotto il nostro #include:

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

Definiamo i termini btnEnter e da btn1 a btn 4 per rendere il codice più facile da leggere o modificare se necessario. Significa che quando digitiamo btn1 l'arduino saprà che in realtà intendiamo il pulsante 15. Sebbene stiamo chiamando le porte 15, 16, 17 e 18, sono etichettate sull'arduino come A1 A2 A3 e A4, questo perché sono porte utilizzate specificamente per gli ingressi analogici, anche se le stiamo utilizzando solo per gli ingressi digitali.

Successivamente creeremo gli oggetti che controlleranno i display a cristalli liquidi. Per fare ciò metti questo codice sotto le nostre definizioni

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

Ciò che fa è dire all'arduino che quando chiamiamo lcdLeft o lcdRight ci riferiamo a un oggetto LiquidCrystal. I numeri tra parentesi allegate indicano all'arduino quali porte l'oggetto dovrebbe utilizzare per inviare messaggi al display LCD quando usiamo le loro funzioni.

Ora dobbiamo dichiarare le variabili inserendo il prossimo bit di codice sotto le dichiarazioni dell'oggetto:

//queste variabili sono opzioni che puoi modificare - numeri più alti = maggiore velocità di gioco intGameSpeedEasy = 10; int intGameSpeedMedium = 25; int intGameSpeedHard = 80;

//imposta le variabili per il gameboolean bolPlay; //traccia se il giocatore int intScore; //traccia il punteggio del giocatore int intDiff; //solo una cosa estetica per dire a quale difficoltà si trova il gioco //imposta le variabili per l'input int intEnter; //traccia se l'utente preme il pulsante di invio int intInput; // tiene traccia dei pulsanti premuti dall'utente boolean bolTilePressed; //assicura che il giocatore non prema accidentalmente un pulsante 5 volte e perda //imposta le variabili per il turno int intTick; //conta i millesimi (per ciclo) fino a intDelay int intDelay; //il tempo di attesa del programma fino al prossimo turno in millis int intGameSpeed; //abit delle opzioni di debug boolean bolSerialBoard; //quando true stamperà la scheda nel monitor seriale

Dichiariamo una variabile indicando il tipo di dati e poi il nome della variabile, es. int thisIsAnInteger

Le variabili booleane, come bolSerialBoard e bolPlay possono avere solo uno dei due valori, vero o falso.

La variabile intera (int) come intScore e intInput può accettare numeri interi come valori, come 1, 5 o 100.

Alcuni altri tipi di dati degni di nota che non stiamo usando qui sono una stringa, che è un pezzo di testo, e un float, che è un numero decimale.

Ognuna delle variabili qui viene utilizzata in diversi punti dal programma, ecco una sinossi di ciò che ciascuna fa

bolPlay dice al programma se il menu deve essere visualizzato o se il gioco deve essere in esecuzione.

intScore tiene traccia del punteggio del giocatore mentre colpisce le tessere, intDiff è usato nel menu principale per dire al programma quale bit di testo stampare sugli LCD, intEnter viene utilizzato per dire al programma se viene premuto il pulsante di invio (all'estrema sinistra), intInput viene utilizzato per dire al programma quale degli altri 4 pulsanti viene premuto.

bolTilePressed viene utilizzato per assicurarsi che il programma continui a leggere solo quando viene premuto il pulsante e non quando viene tenuto premuto.

intGameSpeed, intGameSpeedEasy, intGameSpeedMedium e intGameSpeedHard vengono utilizzati per controllare la velocità di accelerazione del gioco in base alla difficoltà selezionata.

intTick e intDelay vengono utilizzati per impedire al programma di spostare la scheda ogni volta che esegue il ciclo.

bolSerialBoard viene utilizzato per consentire al programma di inviare la scheda al monitor seriale di arduino come una serie di numeri a scopo di test.

Finalmente è il momento di dichiarare la nostra scheda come un array usando questo codice:

// imposta il gioco 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} };

Un array è una matrice che qualsiasi punto su cui può essere chiamato per la matematica o per essere modificato.

Il tuo codice dovrebbe ora assomigliare a questo;

// include librerie#include

//queste variabili sono opzioni che puoi modificare - numeri più alti = velocità di gioco più veloce

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

// Definisci i pin

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

// crea oggetti LCD (n, ~, n, ~, ~, n)

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

// imposta l'array di gioco

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

//imposta le variabili per il gioco

booleano bolPlay; //traccia se il giocatore int intScore; //traccia il punteggio del giocatore int intDiff; //solo una cosa estetica per dire a quale difficoltà si trova il gioco

//imposta le variabili per l'input

int intEnter; //traccia se l'utente preme il pulsante di invio int intInput; // tiene traccia dei pulsanti premuti dall'utente boolean bolTilePressed; //assicurati che il giocatore non prema accidentalmente un pulsante 5 volte e perda

//imposta le variabili per il turno

int intTick; //conta i millesimi (per ciclo) fino a intDelay int intDelay; //il tempo di attesa del programma fino al prossimo turno in millis int intGameSpeed;

//abit delle opzioni di debug

booleano bolSerialBoard; //quando true stamperà la scheda nel monitor seriale

Passaggio 3: la funzione di configurazione

Il ciclo di installazione è una funzione letta dall'arduino solo una volta all'avvio iniziale.

Nel ciclo di configurazione stiamo solo impostando i valori di alcune delle nostre variabili perché invece di impostarle un valore quando le dichiariamo, lo stiamo facendo qui.

Inizia inserendo questo codice nella tua configurazione Void.

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

Ogni riga sta semplicemente impostando una variabile su un valore.

bolPlay è impostato su false in modo che il gioco non inizi a giocare.

intScore è impostato su 0, perché naturalmente il tuo punteggio inizia da 0.

intTick inizia da 0 perché il programma non sta attualmente contando nulla.

intDelay è impostato su 1000 perché questa è la velocità con cui iniziano i riquadri.

intDiff è solo una cosa ascetica in modo che il programma sappia cosa scrivere per la difficoltà del gioco.

intGameSpeed è impostato su qualunque sia intGameSpeedMedium, il che significa che è impostato su una difficoltà media.

Quindi inserisci questo codice in Void Setup sotto il codice che hai appena inserito.

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

Serial.begin(9600);

Questo dice ad arduino di iniziare a comunicare con il computer attraverso il monitor seriale (visibile facendo clic sul pulsante in alto a destra dell'IDE di arduino).

La tua configurazione del vuoto dovrebbe ora assomigliare a questa!

void setup() { Serial.begin(9600); //avvia il monitor seriale //imposta le variabili bolPlay = false; punteggio int = 0; intTick = 0; intRitardo = 1000; intDiff = 1; intGameSpeed = intGameSpeedMedium; //begin lcdLeft.begin(16, 2); lcdRight.begin(16, 2); }

Passaggio 4: la funzione loop

La funzione loop viene eseguita da arduino ad ogni iterazione di arduino.

Copia il seguente codice nel tuo Void Loop.

loop vuoto() { input(); //controlla l'input di riproduzione if (bolPlay == true){ if (intTick >= intDelay){ //controlla se il gioco deve giocare un turno o continuare ad aspettare Serial.println("~~~~~~~ ~~");//stampa per indicare che il tabellone si sposta su //writeSerial(); //se l'opzione è abilitata scrivi la scheda in serial buttonsGame(); //verifica gli input del giocatore playBoard(); //sposta la scheda e aggiungi una nuova tessera clearLcd(); //pulisce gli LCD prima di disegnare drawBoard(); //disegna la scacchiera sul bottomCheck(); intTick = 0; //reset intTick } else {buttonGame(); //verifica gli input del giocatore clearLcd(); //pulisce gli LCD prima di disegnare drawBoard(); //disegna la scacchiera sull'LCD intTick = intTick + intGameSpeed; //aggiungi alla spunta } } else { clearLcd(); //pulisce gli LCD prima di disegnare title(); //visualizza i pulsanti delle informazioni sul titolo e sulla partituraMenu(); //leggi l'input del giocatore clearBoard(); //assicura l'intera scheda = 0 } delay(10); //ritarda l'arduino di un breve momento }

quando bolPlay è uguale a true significa che il gioco è in esecuzione e tutto il codice per quando il gioco è in esecuzione dovrebbe essere eseguito, ma vogliamo solo che il tabellone aggiunga una nuova tessera e si sposti verso il basso quando intTick è maggiore del nostro intDelay, altrimenti vogliamo ancora consentire all'utente di premere un pulsante per premere una tessera e per intTick per aumentare la velocità.

La maggior parte di questo codice utilizza funzioni che dobbiamo ancora creare e le realizzeremo nei prossimi passaggi. Lo scopo di queste funzioni è il seguente.

Input legge quali pulsanti l'utente ha premuto.

pulsantiGioco controlla cosa fanno i pulsanti quando sono nel gioco e non nel menu

playBoard aggiunge una nuova tessera alla scacchiera, quindi sposta tutto nella scacchiera in basso di uno spazio

clearLCD pulisce gli LCD per assicurarsi che non rimangano fantasmi dietro le piastrelle

drawBoard passa attraverso arrGame e lo stampa sugli LCD

clearBoard cancella l'intero arrGame quando il gioco non è in gioco

bottomCheck controlla la parte inferiore di arrGame per una condizione di errore

title mostra il titolo del gioco e le informazioni sul punteggio quando si trova nel menu

Il menu dei pulsanti controlla cosa fanno gli input dell'utente quando si trovano nel menu.

gameOver è un'altra funzione, anche se non viene chiamata qui come viene invece chiamata nelle funzioni bottomCheck e buttonGame.

Passaggio 5: la funzione ClearLCD

per creare una funzione iniziamo aggiungendo questo al codice

void nomefunzione() {

}

il "nomefunzione" può essere qualsiasi cosa, purché non esista già.

Copia questo codice nel tuo programma:

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

questo attraversa l'intero array utilizzando 2 loop contati per passare attraverso ogni punto sugli LCD e scrivere uno spazio.

Senza essere resettato a nulla, il display LCD manterrà ciò che è stato scritto in precedenza

Passaggio 6: la funzione DrawBoard

copia questo codice nel tuo programma

void drawBoard() { for (int i = 1; i <= 15; i++){ //disegna le colonne 1 e 2 sul display LCD sinistro //se la piastrella = 0 non scrive nulla, = 1 scrive "#", = 2 scrivi "@" lcdLeft.setCursor(i, 1); //imposta sulla prima colonna (più a sinistra) if (arrGame[0] == 1) {lcdLeft.write("#");} if (arrGame[0] == 2) {lcdLeft.write("@");} lcdLeft.setCursor(i, 0); //imposta sulla seconda colonna (centro sinistra) if (arrGame[1] == 1) {lcdLeft.write("#");} if (arrGame[1] == 2) {lcdLeft.write("@");} lcdRight.setCursor(i, 1); //imposta sulla terza colonna (centro destra) if (arrGame[2] == 1) {lcdRight.write("#");} if (arrGame[2] == 2) {lcdRight.write("@");} lcdRight.setCursor(i, 0); //imposta sulla quarta colonna (più a destra) if (arrGame[3] == 1) {lcdRight.write("#");} if (arrGame[3] == 2) {lcdRight. Scrivi("@");} } }

questo utilizza un ciclo per passare attraverso ogni riga della scheda, quindi controlla se una colonna nella riga è uguale a 1 o 2, in base a ciò stampa sul display LCD un hashtag, per una tessera ancora da essere hit, o una @ per una tessera hit.

Passaggio 7: la funzione PlayBoard

copia questo codice nel tuo programma.

void playBoard() { for (int i = 0; i <= 3; i++){arrGame[0] = 0;} //cancella la riga superiore arrGame[0][random(0, 4)] = 1; //imposta un punto casuale sulla riga superiore come piastrella per (int i = 15; i>= 1; i--){ //lavorando dal basso verso l'alto per (int ii = 0; ii <= 3; ii ++){ //per ogni collum arrGame[ii] = arrGame[i - 1][ii]; } } }

questo codice inizia cancellando l'intera riga superiore su 0 o nessuna tessera, quindi imposta una tessera casuale su 1 e tessera non colpita.

Quindi passa attraverso un ciclo contato al contrario, da 15 a 1, impostando la riga in modo che sia uguale a qualunque sia la riga sopra di essa, facendo muovere la scheda lungo il display LCD

Passaggio 8: la funzione ClearBoard

copia questo codice nel tuo programma.

void clearBoard() { //reimposta i valori di tick e delay intTick = 0; intRitardo = 1000; //passa attraverso la lavagna e imposta tutto a 0 for (int i = 0; i <= 15; i++){ for (int ii = 0; ii <= 3; ii++){ arrGame[ii] = 0; } } }

Questo codice viene eseguito quando il gioco non è in esecuzione per assicurarsi che l'intero arrGame sia impostato su 0 o su nessuna tessera, utilizzando i loop contati per passare attraverso l'array.

Il codice reimposta anche i valori di intDelay e intTick.

Passaggio 9: la funzione del titolo

copia il seguente codice nel tuo programma

void title() { //scrivi il titolo sull'LCD e lo spazio per il punteggio lcdRight.setCursor(0, 0); lcdRight.write("Piano Tiles"); lcdRight.setCursor(0, 1); lcdRight.write("Punteggio: "); //converte il punteggio in una stringa char strScore[3]; sprintf(strScore, "%d", intScore); //visualizza il punteggio su LCD lcdRight.write(strScore); //aggiungo il difficile lcdRight.setCursor(10, 1); if (intDiff == 0){ lcdRight.write("Facile"); } if (intDiff == 1){ lcdRight.write("Medio"); } if (intDiff == 2){ lcdRight.write("Hard"); } //Premere un po' di istruzione lcdLeft.setCursor(0, 0); lcdLeft.write("Premi Invio"); lcdLeft.setCursor(0, 1); lcdLeft.write("per iniziare!"); }

Questo codice scrive il titolo del gioco e il punteggio sugli LCD, lo fa dicendo all'LCD da dove iniziare a digitare utilizzando LCD.setCursor e quindi scrivendo la stringa in LCD.write.

Qui viene creata anche una nuova variabile, strScore, viene utilizzata per convertire intScore in un tipo di dati stringa o char utilizzando la funzione sprintf.

intDiff viene utilizzato anche qui, in base ai suoi valori stampa le diverse opzioni di difficoltà.

Passaggio 10: i pulsantiFunzione del menu

inserisci il seguente codice nel tuo programma

void buttonsMenu(){ // quando viene premuto invio avvia il gioco e reimposta il valore del punteggio if (intEnter == 1){ bolPlay = true; punteggio int = 0; playBoard(); drawBoard(); } // alla pressione del pulsante 3 attiva l'opzione di debug per stampare la scheda in seriale if (intInput == 3){ if (bolSerialBoard == false){ Serial.println("Serial Board Active"); bolSerialBoard = true; } else { Serial.println("Scheda seriale disabilitata"); bolSerialBoard = false; } } //imposta la velocità del gioco su facile difficoltà if (intInput == 0){ Serial.print("Gioco impostato su facile ("); Serial.print(intGameSpeedEasy); Serial.println("ms accelerazione)"); intDiff = 0; intGameSpeed = intGameSpeedEasy; } //imposta la velocità del gioco a media difficoltà if (intInput == 1){ Serial.print("Il gioco è impostato su medio ("); Serial.print(intGameSpeedMedium); Serial.println("ms Acceleration)"); intDiff = 1; intGameSpeed = intGameSpeedMedium; } //imposta la velocità del gioco a difficoltà difficile if (intInput == 2){ Serial.print("Il gioco è impostato su difficile ("); Serial.print(intGameSpeedHard); Serial.println("ms accelerazione)"); intDiff = 2; intGameSpeed = intGameSpeedHard; } }

questo codice viene eseguito solo quando bolPlay è uguale a false nel loop void

se intEnter è impostato a 1 significa che è stato premuto il pulsante invio, se viene premuto il programma imposta bolPlay su true e il gioco inizia.

Il programma legge quindi a cosa è uguale intInput. se è uguale a 0 si preme il primo pulsante da sinistra salendo a destra fino a 3. Se intInput è uguale a 4 non si preme alcun pulsante.

se si premono i pulsanti 0-2 il gioco cambia la difficoltà, regolando anche il valore della velocità di gioco, il che significa che accelererà più velocemente.

se viene premuto il pulsante 3 il gioco attiverà o disattiverà una modalità di debug in cui l'intera scheda viene stampata nel monitor seriale per aiutare a trovare problemi nel programma.

Passaggio 11: i pulsantiFunzione di gioco

copia il seguente codice nel tuo programma

void buttonsGame(){ if (intInput != 4) { //se viene premuto un pulsante if (bolTilePressed == false){ //solo se bolTilePressed è false azione di attivazione per il controllo di un pulsante premere bolTilePressed = true; //poi imposta bolTilePressed su true per assicurarti che non venga nuovamente attivato in modo acido int intLowestTile = 0; //da impostare sul riquadro con il riquadro più basso int intCheckedTile = 15; //per tenere traccia di quali riquadri sono stati controllati while (intLowestTile == 0) { //fintanto che non è impostato su nulla controlla i riquadri per (int i = 0; i 100){ //fintanto che int il ritardo non è inferiore a 100 intDelay = intDelay - 20; //prende un valore da esso } } else { Serial.println("Sbagliato pulsante premuto"); game Over(); //altrimenti game over } } } } }

Il codice viene eseguito solo quando bolPlay è uguale a true nel void Loop.

Come i pulsantiMenu in base al valore di intInput, controlla se il giocatore ha colpito una tessera o ne ha saltata una.

Lo fa passando attraverso arrGame dal basso verso l'alto usando un ciclo while per cercare quale riga è la più bassa con una tessera non colpita. Quindi controlla se il punto in quella riga corrispondente al pulsante premuto è una tessera non colpita o meno, se non è colpita la imposta su uguale a 2 invece di 1, il che significa che verrà visualizzata come @, altrimenti attiva il gameOver funzione che dobbiamo ancora creare.

Questa funzione utilizza anche la variabile bolTilePressed impostandola su true quando viene premuto un pulsante e false quando non viene premuto alcun pulsante. Questo per garantire che l'utente non perda accidentalmente il gioco perché il programma pensava di aver premuto il pulsante più volte quando lo teneva premuto.

Passaggio 12: la funzione GameOver

Copia il seguente codice nel tuo programma

void gameOver() { Serial.println("Game Over!"); Serial.print("Il tuo punteggio è stato: "); Serial.println(intScore); Serial.print("La tua velocità era: "); Serial.println(intDelay); bolPlay = falso; }

Questo viene attivato dalle funzioni checkBottom o buttonGame e attiva la fine del gioco impostando bolPlay su false.

Stampa anche un messaggio nel monitor seriale per il punteggio degli utenti e le tessere velocità sono state aggiunte in millisecondi.

Passaggio 13: la funzione di input

Copia il seguente codice nel tuo programma.

void input() { intEnter = digitalRead(btnEnter); //leggi invio //leggi quale degli altri input, o se nessuno impostato a 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; }}}} //serial stampa gli input if (intEnter == 1){Serial.println("Invio premuto! ");} if (intInput != 4){ Serial.print("Button Press: "); Serial.println(intInput); } else { //se non viene premuto alcun pulsante resetta bolTilePressed bolTilePressed = false; } }

Questo codice viene utilizzato con le funzioni buttonGame e buttonMenu. in base ai pulsanti premuti dall'utente imposta il valore di intInput, oppure se non viene premuto alcun pulsante imposta intInput uguale a 4.

Se non viene premuto alcun pulsante, è qui che viene ripristinato bolTilePressed per la funzione buttonGame.

Stampa anche un messaggio sul monitor seriale su cui viene premuto il pulsante.

Passaggio 14: la funzione BottomCheck

copia il seguente codice nel tuo programma.

void bottomCheck() { for (int i = 0; i <= 3; i++){ //per le 4 colonne if (arrGame[15] == 1){ //se una tessera è in basso Serial.println("Affitto in basso"); arrGame[15] = 2; drawBoard(); ritardo (400); arrGame[15] = 1; drawBoard(); ritardo (400); arrGame[15] = 2; drawBoard(); ritardo (400); arrGame[15] = 1; drawBoard(); ritardo (400); game Over(); } } }

usando un ciclo questo codice controlla la riga inferiore di arrGame per eventuali tessere non colpite (tessere uguali a 1), se c'è una tessera non colpita nella parte inferiore dello schermo, la tessera lampeggerà e quindi attiverà la funzione di game over.

Passaggio 15: la funzione WriteSerial

copia il seguente codice nel tuo programma

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

Questa è la funzione seguita dall'opzione di debug che può essere abilitata nella funzione pulsantiMenu. Se bolSerialBoard è impostato su true in quella funzione, passerà attraverso arrGame e stamperà l'intera scheda nel monitor seriale a scopo di test utilizzando un array.

Passaggio 16: completamento

Tutto il tuo codice non dovrebbe essere completo e assomigliare a questo!

/* * Nome - Riquadri pianoforte; Arduino * Di - Domenic Marulli * Data - 11/*

/ includi librerie

#includere

//queste variabili sono opzioni che puoi modificare - numeri più alti = velocità di gioco più veloce

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

// Definisci i pin

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

// crea oggetti LCD (n, ~, n, ~, ~, n)

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

// imposta l'array di gioco

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

//imposta le variabili per il gioco

booleano bolPlay; //traccia se il giocatore int intScore; //traccia il punteggio del giocatore int intDiff; //solo una cosa estetica per dire a quale difficoltà si trova il gioco

//imposta le variabili per l'input

int intEnter; //traccia se l'utente preme il pulsante di invio int intInput; // tiene traccia dei pulsanti premuti dall'utente boolean bolTilePressed; //assicurati che il giocatore non prema accidentalmente un pulsante 5 volte e perda

//imposta le variabili per il turno

int intTick; //conta i millesimi (per ciclo) fino a intDelay int intDelay; //il tempo di attesa del programma fino al prossimo turno in millis int intGameSpeed;

//abit delle opzioni di debug

booleano bolSerialBoard; //quando true stamperà la scheda nel monitor seriale

//la configurazione che verrà eseguita una volta

void setup() { Serial.begin(9600); //avvia il monitor seriale //imposta le variabili bolPlay = false; punteggio int = 0; intTick = 0; intRitardo = 1000; intDiff = 1; intGameSpeed = intGameSpeedMedium; //begin lcdLeft.begin(16, 2); lcdRight.begin(16, 2); }

//il ciclo che verrà eseguito ogni 10 millisecondi

loop vuoto() { input(); //controlla l'input di riproduzione if (bolPlay == true){ if (intTick >= intDelay){ //controlla se il gioco deve giocare un turno o continuare ad aspettare Serial.println("~~~~~~~ ~~");//stampa per indicare che il tabellone si sposta su //writeSerial(); //se l'opzione è abilitata scrivi la scheda in serial buttonsGame(); //verifica gli input del giocatore playBoard(); //sposta la scheda e aggiungi una nuova tessera clearLcd(); //pulisce gli LCD prima di disegnare drawBoard(); //disegna la scacchiera sul bottomCheck(); intTick = 0; //reset intTick } else {buttonGame(); //verifica gli input del giocatore clearLcd(); //pulisce gli LCD prima di disegnare drawBoard(); //disegna la scacchiera sull'LCD intTick = intTick + intGameSpeed; //aggiungi alla spunta } } else { clearLcd(); //pulisce gli LCD prima di disegnare title(); //visualizza i pulsanti delle informazioni sul titolo e sulla partituraMenu(); //leggi l'input del giocatore clearBoard(); //assicura l'intera scheda = 0 } delay(10); //ritarda l'arduino di un breve momento }

//pulisce l'LCD, quindi le celle non inserite non vengono lasciate lì

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

//disegna la scacchiera sugli lcd

void drawBoard() { for (int i = 1; i <= 15; i++){ //disegna le colonne 1 e 2 sul display LCD sinistro //se la piastrella = 0 non scrive nulla, = 1 scrive "#", = 2 scrivi "@" lcdLeft.setCursor(i, 1); //imposta sulla prima colonna (più a sinistra) if (arrGame[0] == 1) {lcdLeft.write("#");} if (arrGame[0] == 2) {lcdLeft.write("@");} lcdLeft.setCursor(i, 0); //imposta sulla seconda colonna (centro sinistra) if (arrGame[1] == 1) {lcdLeft.write("#");} if (arrGame[1] == 2) {lcdLeft.write("@");} lcdRight.setCursor(i, 1); //imposta sulla terza colonna (centro destra) if (arrGame[2] == 1) {lcdRight.write("#");} if (arrGame[2] == 2) {lcdRight.write("@");} lcdRight.setCursor(i, 0); //imposta sulla quarta colonna (più a destra) if (arrGame[3] == 1) {lcdRight.write("#");} if (arrGame[3] == 2) {lcdRight. Scrivi("@");} } }

//sposta la scacchiera verso il basso e posiziona un valore casuale come tessera

void playBoard() { for (int i = 0; i <= 3; i++){arrGame[0] = 0;} //cancella la riga superiore arrGame[0][random(0, 4)] = 1; //imposta un punto casuale sulla riga superiore come piastrella per (int i = 15; i>= 1; i--){ //lavorando dal basso verso l'alto per (int ii = 0; ii <= 3; ii ++){ //per ogni collum arrGame[ii] = arrGame[i - 1][ii]; } } }

//imposta l'intera scheda a 0 e reimposta le variabili su pre-partita

void clearBoard() { //reimposta i valori di tick e delay intTick = 0; intRitardo = 1000; //passa attraverso la lavagna e imposta tutto a 0 for (int i = 0; i <= 15; i++){ for (int ii = 0; ii <= 3; ii++){ arrGame[ii] = 0; } } }

// visualizza il menu principale sull'LCD

void title() { //scrivi il titolo sull'LCD e lo spazio per il punteggio lcdRight.setCursor(0, 0); lcdRight.write("Piano Tiles"); lcdRight.setCursor(0, 1); lcdRight.write("Punteggio: "); //converte il punteggio in una stringa char strScore[3]; sprintf(strScore, "%d", intScore); //visualizza il punteggio su LCD lcdRight.write(strScore); //aggiungo il difficile lcdRight.setCursor(10, 1); if (intDiff == 0){ lcdRight.write("Facile"); } if (intDiff == 1){ lcdRight.write("Medio"); } if (intDiff == 2){ lcdRight.write("Hard"); } //Premere un po' di istruzione lcdLeft.setCursor(0, 0); lcdLeft.write("Premi Invio"); lcdLeft.setCursor(0, 1); lcdLeft.write("per iniziare!"); }

// controlla i pulsanti e cosa fare per loro fuori dal gioco

void buttonsMenu(){ // quando viene premuto invio avvia il gioco e reimposta il valore del punteggio if (intEnter == 1){ bolPlay = true; punteggio int = 0; playBoard(); drawBoard(); } // alla pressione del pulsante 3 attiva l'opzione di debug per stampare la scheda in seriale if (intInput == 3){ if (bolSerialBoard == false){ Serial.println("Serial Board Active"); bolSerialBoard = true; } else { Serial.println("Scheda seriale disabilitata"); bolSerialBoard = false; } } //imposta la velocità del gioco su facile difficoltà if (intInput == 0){ Serial.print("Gioco impostato su facile ("); Serial.print(intGameSpeedEasy); Serial.println("ms accelerazione)"); intDiff = 0; intGameSpeed = intGameSpeedEasy; } //imposta la velocità del gioco a media difficoltà if (intInput == 1){ Serial.print("Il gioco è impostato su medio ("); Serial.print(intGameSpeedMedium); Serial.println("ms Acceleration)"); intDiff = 1; intGameSpeed = intGameSpeedMedium; } //imposta la velocità del gioco a difficoltà difficile if (intInput == 2){ Serial.print("Il gioco è impostato su difficile ("); Serial.print(intGameSpeedHard); Serial.println("ms accelerazione)"); intDiff = 2; intGameSpeed = intGameSpeedHard; } }

// controlla i pulsanti e cosa fare per loro durante il gioco

void buttonsGame(){ if (intInput != 4) { //se viene premuto un pulsante if (bolTilePressed == false){ //solo se bolTilePressed è false azione di attivazione per il controllo di un pulsante premere bolTilePressed = true; //poi imposta bolTilePressed su true per assicurarti che non venga nuovamente attivato in modo acido int intLowestTile = 0; //da impostare sulla tile con la tile più bassa int intCheckedTile = 15; //per tenere traccia di quali riquadri sono stati controllati while (intLowestTile == 0) { //fintanto che non è impostato su nulla controlla i riquadri per (int i = 0; i 100){ //fintanto che int il ritardo non è inferiore a 100 intDelay = intDelay - 20; //prende un valore da esso } } else { Serial.println("Sbagliato pulsante premuto"); game Over(); //altrimenti game over } } } } }

void gameOver() {

Serial.println("Game Over!"); Serial.print("Il tuo punteggio è stato: "); Serial.println(intScore); Serial.print("La tua velocità era: "); Serial.println(intDelay); bolPlay = falso; }

// controlla l'input del giocatore

void input() { intEnter = digitalRead(btnEnter); //leggi invio //leggi quale degli altri input, o se nessuno impostato a 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; }}}} //serial stampa gli input if (intEnter == 1){Serial.println("Invio premuto! ");} if (intInput != 4){ Serial.print("Button Press: "); Serial.println(intInput); } else { //se non viene premuto alcun pulsante resetta bolTilePressed bolTilePressed = false; } }

// controlla la parte inferiore della scheda per verificare l'errore

void bottomCheck() { for (int i = 0; i <= 3; i++){ //per le 4 colonne if (arrGame[15] == 1){ //se una tessera è in basso Serial.println("Affitto in basso"); arrGame[15] = 2; drawBoard(); ritardo (400); arrGame[15] = 1; drawBoard(); ritardo (400); arrGame[15] = 2; drawBoard(); ritardo (400); arrGame[15] = 1; drawBoard(); ritardo (400); game Over(); } } }

//stampa la scheda nel monitor seriale se bolSerialBoard è true

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

Una volta inserito tutto il codice, caricalo sul tuo arduino e divertiti!