Arduino - Jubin Piano: 16 Langkah (dengan Gambar)

2024 Pengarang: John Day | [email protected]. Diubah suai terakhir: 2024-01-30 11:10

Hai orang-orang internet, Ini adalah mengenai bagaimana membuat apa yang TIDAK DILAKUKAN dari permainan mudah alih di arduino uno r3.

jadi untuk memulakan, anda memerlukan semua bahagian, seperti berikut! 1x Arduino Uno r3 ($ 42)

2x Perisai Pad Kekunci LCD ($ 19 setiap satu)

Butang 5x

Perintang 5x 220Ω

Wayar 28x

Baiklah, setelah anda mendapat semua bahagian, sudah tiba masanya untuk memulakan!

Langkah 1: Pendawaian

Mulakan dengan memasang arduino dan rakan anda seperti yang ditunjukkan dalam rajah, Pastikan butang dihubungkan dengan cara yang betul, dengan slot A0-4 di bahagian bawah rel butang, atau arduino sebaliknya akan menganggap butang ditahan terus dan bukan hanya pada tekan.

Langkah 2: Penyataan Akuan

Semua kod di sini harus ada sebelum penyediaan kosong dan gelung void anda, ini kerana semua pemboleh ubah dan objek ini digunakan dalam beberapa fungsi yang akan kami siapkan.

Mulakan dengan meletakkan:

#sertakan

di bahagian atas kod anda, ini memberitahu arduino untuk menggunakan perpustakaan "LiquidCrystal.h" dan fungsi-fungsi yang merupakan sebahagian daripadanya.

Langkah seterusnya adalah menentukan pin yang kita gunakan untuk butang kita dengan meletakkan kod ini di bawah #include kami:

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

Kami menentukan istilah btnEnter dan btn1 hingga btn 4 untuk membuat kod lebih mudah untuk kita baca, atau ubah jika perlu. Ini bermaksud bahawa ketika kita mengetik btn1, arduino akan mengetahui bahawa kita sebenarnya bermaksud butang 15. Walaupun kita memanggil port port 15, 16, 17 dan 18, mereka dilabel pada arduino sebagai A1 A2 A3 dan A4, ini kerana mereka adalah port yang digunakan khusus untuk input analog, walaupun kami hanya menggunakannya untuk input digital.

Selanjutnya kita akan membuat objek yang akan mengawal Liquid Crystal Displays. Untuk melakukan ini, letakkan kod ini di bawah takrifan kita

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

Apa yang dilakukannya adalah memberitahu arduino bahawa ketika kita memanggil lcdLeft atau lcdRight kita merujuk pada objek LiquidCrystal. Nombor dalam tanda kurung yang dilampirkan memberitahu arduino mana port yang harus digunakan objek untuk mengirim mesej ke LCD ketika kita menggunakan fungsinya.

Sekarang kita perlu menyatakan pemboleh ubah dengan meletakkan bit kod seterusnya di bawah deklarasi objek:

// pemboleh ubah ini adalah pilihan yang boleh anda ubah - angka yang lebih tinggi = kelajuan permainan yang lebih pantas intintGameSpeedEasy = 10; int intGameSpeedMedium = 25; int intGameSpeedHard = 80;

// sediakan pemboleh ubah untuk bolPlay gameboolean; // menjejaki jika pemain intScore; // menjejaki skor pemain int intif; // hanya perkara estetik untuk memberitahu apa kesukaran permainan // mengatur pemboleh ubah untuk input int intnter; // mengesan sekiranya pengguna menekan butang enter int intInput; // menjejaki butang mana yang pengguna tekan boltile boolean; // pastikan pemain tidak menekan butang 5x secara tidak sengaja dan kalah // sediakan pemboleh ubah untuk giliran int intick; // mengira milies (per gelung) hingga intDelay int intDelay; // masa program menunggu hingga giliran seterusnya dalam milis int intGameSpeed; // kekurangan pilihan debug boolean bolSerialBoard; // apabila benar akan mencetak papan pada monitor bersiri

Kami menyatakan pemboleh ubah dengan menyatakan jenis data dan kemudian nama pemboleh ubah, mis. int iniIsAnInteger

Pemboleh ubah boolean, seperti bolSerialBoard dan bolPlay hanya boleh mempunyai satu daripada dua nilai, benar atau salah.

Pemboleh ubah integer (int) seperti intScore dan intInput boleh mengambil nombor bulat sebagai nilai, seperti 1, 5 atau 100.

Beberapa jenis data terkenal lain yang tidak kami gunakan di sini adalah rentetan, yang merupakan potongan teks, dan float, yang merupakan angka perpuluhan.

Setiap pemboleh ubah di sini digunakan di beberapa tempat yang berbeza oleh program, berikut adalah sinopsis tentang apa yang dilakukan oleh masing-masing

bolPlay memberitahu program jika menu harus dipaparkan atau jika permainan sebenarnya harus dijalankan.

intScore mengesan skor pemain semasa mereka memukul jubin, intDiff digunakan pada menu utama untuk memberitahu program apa teks yang hendak dicetak pada LCD, intEnter digunakan untuk memberitahu program jika butang enter (kiri paling kiri) ditekan, intInput digunakan untuk memberitahu program mana dari 4 butang lain yang ditekan.

bolTilePressed digunakan untuk memastikan program hanya dibaca ketika butang ditekan dan bukan ketika ia dipegang.

intGameSpeed, intGameSpeedEasy, intGameSpeedMedium dan intGameSpeedHard digunakan untuk mengawal seberapa pantas permainan harus dipercepat berdasarkan kesukaran yang dipilih.

intTick dan intDelay digunakan untuk menghentikan program daripada memindahkan papan setiap kali gelung.

bolSerialBoard digunakan untuk membolehkan anda membuat program menghantar papan ke monitor bersiri arduino sebagai rangkaian nombor untuk tujuan ujian.

Akhirnya tiba masanya untuk menyatakan papan kami sebagai tatasusunan menggunakan kod ini:

// sediakan permainan 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}};

Array adalah matriks yang mana satu titik yang boleh dipanggil untuk matematik atau diubah.

Kod anda kini kelihatan seperti ini;

// sertakan perpustakaan # sertakan

// pemboleh ubah ini adalah pilihan yang boleh anda ubah - angka yang lebih tinggi = permainan lebih pantas

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

// Tentukan pin

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

// buat objek LCD (n, ~, n, ~, ~, n)

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

// sediakan susunan permainan

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

// sediakan pemboleh ubah untuk permainan

bolPlay boolean; // menjejaki jika pemain intScore; // menjejaki skor pemain int intif; // hanya perkara estetik untuk memberitahu apa kesukaran permainan ini

// sediakan pemboleh ubah untuk input

int intEnter; // mengesan sekiranya pengguna menekan butang enter int intInput; // menjejaki butang mana yang pengguna tekan boltile boolean; // pastikan pemain tidak menekan butang 5x secara tidak sengaja dan kalah

// sediakan pemboleh ubah untuk giliran

int intTick; // mengira milies (per gelung) hingga intDelay int intDelay; // masa program menunggu hingga giliran seterusnya dalam milis int intGameSpeed;

// mengurangkan pilihan debug

boolean bolSerialBoard; // apabila benar akan mencetak papan pada monitor bersiri

Langkah 3: Fungsi Persediaan

Gelung persediaan adalah fungsi yang dibaca oleh arduino hanya sekali ketika ia bermula.

Dalam gelung persediaan kita hanya menetapkan nilai beberapa pemboleh ubah kita kerana bukannya menetapkannya nilai ketika menyatakannya, kita melakukannya di sini.

Mulakan dengan memasukkan kod ini ke dalam Void Setup anda.

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

Setiap baris hanya menetapkan pemboleh ubah ke nilai.

bolPlay diatur ke false sehingga permainan tidak dapat dimainkan.

intScore ditetapkan ke 0, kerana secara semula jadi skor anda bermula pada 0.

intTick bermula pada 0 kerana program ini tidak mengira apa-apa.

intDelay ditetapkan ke 1000 kerana itulah kadar jubin bermula.

intDiff hanyalah perkara pertapa sehingga program tahu apa yang harus ditulis untuk kesukaran permainan.

intGameSpeed ditetapkan ke intGameSpeedMedium apa pun, yang bermaksud ia ditetapkan pada tahap kesukaran sederhana.

Seterusnya masukkan kod ini dalam Persediaan Void di bawah kod yang baru anda masukkan.

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

Serial.begin (9600);

Ini memberitahu arduino untuk mula berkomunikasi dengan komputer melalui monitor bersiri (kelihatan dengan mengklik butang di kanan atas IDE arduino).

Persediaan Void anda kini kelihatan seperti ini!

batal persediaan () {Serial.begin (9600); // mulakan monitor bersiri // tetapkan pemboleh ubah bolPlay = false; intScore = 0; intTick = 0; intDelay = 1000; intDiff = 1; intGameSpeed = intGameSpeedMedium; // mulakan lcd's lcdLeft.begin (16, 2); lcdRight.begin (16, 2); }

Langkah 4: Fungsi Gelung

Fungsi gelung dijalankan oleh arduino setiap lelaran arduino.

Salin kod berikut ke dalam Void Loop anda.

gelung kosong () {input (); // periksa input bermain jika (bolPlay == true) {if (intTick> = intDelay) {// periksa untuk melihat apakah permainan harus memainkan giliran atau terus menunggu Serial.println ("~~~~~~~ ~~ "); // cetak untuk menandakan papan bergerak pada // writeSerial (); // jika pilihan diaktifkan tulis papan ke butang bersiriGame (); // periksa input pemain playBoard (); // gerakkan papan dan tambahkan jubin clearLcd (); // bersihkan LCD sebelum melukis drawBoard (); // lukis papan ke bahagian bawah lcdCheck (); intTick = 0; // tetapkan semula intTick} lain {buttonGame (); // periksa input pemain clearLcd (); // bersihkan LCD sebelum melukis drawBoard (); // lukis papan ke intTick = intTick + intGameSpeed lcd; // tambah ke tandakan}} lain {clearLcd (); // bersihkan LCD sebelum melukis tajuk (); // butang tajuk paparan dan maklumat skorMenu (); // baca input pemain clearBoard (); // pastikan keseluruhan papan = 0} kelewatan (10); // tunda arduino sebentar lagi}

ketika bolPlay sama dengan benar, ini bermaksud bahawa permainan sedang dimainkan, dan semua kod ketika permainan dimainkan harus dijalankan, tetapi kami hanya ingin papan menambah jubin baru dan bergerak ke bawah ketika intTick lebih besar daripada intDelay kami, jika tidak, kami masih mahu pengguna menekan butang untuk memukul jubin dan untuk intTick meningkat dalam kelajuan.

Sebilangan besar kod ini menggunakan fungsi yang belum kita buat, dan kita akan membuatnya pada langkah seterusnya. Tujuan fungsi-fungsi ini adalah seperti berikut.

Input membaca butang mana yang telah ditekan oleh pengguna.

buttonGame mengawal apa yang dilakukan oleh butang ketika dalam permainan, dan bukan di menu

playBoard menambah jubin baru ke papan, dan kemudian memindahkan semua yang ada di papan ke bawah satu ruang

clearLCD membersihkan LCD untuk memastikan tiada hantu yang tertinggal di belakang jubin

drawBoard melalui arrGame dan mencetaknya ke LCD

clearBoard membersihkan keseluruhan arrGame ketika permainan tidak dimainkan

bottomCheck memeriksa bahagian bawah arrGame untuk keadaan kegagalan

tajuk memaparkan tajuk permainan dan maklumat skor ketika berada di menu

menu butang mengawal apa yang dilakukan oleh input pengguna ketika berada di menu.

gameOver adalah fungsi lain, walaupun tidak dipanggil di sini kerana ia dipanggil di bahagian bawahFungsi periksa dan butangGame.

Langkah 5: Fungsi ClearLCD

untuk membuat fungsi kita mulakan dengan menambahkan ini ke kod

fungsi batalNama () {

}

"functionName" boleh menjadi apa sahaja, selagi ia belum wujud.

Salin kod ini ke dalam program anda:

batal clearLcd () {untuk (int i = 0; i <= 15; i ++) {untuk (int ii = 0; ii <= 1; ii ++) {lcdLeft.setCursor (i, ii); lcdLeft.write (""); lcdRight.setCursor (i, ii); lcdRight.write (""); }}}

ini melalui keseluruhan susunan dengan menggunakan 2 gelung yang dikira untuk melalui setiap titik pada LCD dan menulis ruang.

Tanpa menetapkan semula apa-apa LCD akan mengekalkan apa sahaja yang ditulis sebelumnya

Langkah 6: Fungsi DrawBoard

salin kod ini ke dalam program anda

batal drawBoard () {untuk (int i = 1; i <= 15; i ++) {// lukis kolum 1 dan 2 di sebelah kiri LCD // jika jubin = 0 tulis apa-apa, = 1 tulis "#", = 2 tulis "@" lcdLeft.setCursor (i, 1); // tetapkan ke kolumn pertama (kiri paling jauh) jika (arrGame [0] == 1) {lcdLeft.write ("#");} if (arrGame [0] == 2) {lcdLeft.write ("@");} lcdLeft.setCursor (i, 0); // tetapkan ke kolumn kedua (tengah kiri) jika (arrGame [1] == 1) {lcdLeft.write ("#");} if (arrGame [1] == 2) {lcdLeft.write ("@");} lcdRight.setCursor (i, 1); // tetapkan ke kolumn ketiga (tengah kanan) jika (arrGame [2] == 1) {lcdRight.write ("#");} if (arrGame [2] == 2) {lcdRight.write ("@");} lcdRight.setCursor (i, 0); // tetapkan ke kolumn keempat (paling kanan) jika (arrGame [3] == 1) {lcdRight.write ("#");} if (arrGame [3] == 2) {lcdRight.write ("@");}}}

ini menggunakan gelung untuk melewati setiap baris papan, kemudian memeriksa untuk melihat apakah lajur di baris sama dengan 1 atau 2, berdasarkan itu kemudian mencetak pada LCD sama ada hashtag, untuk jubin yang belum ada tekan, atau @ untuk jubin hit.

Langkah 7: Fungsi PlayBoard

salin kod ini ke dalam program anda.

batal playBoard () {untuk (int i = 0; i <= 3; i ++) {arrGame [0] = 0;} // kosongkan baris atas arrGame [0] [rawak (0, 4)] = 1; // tetapkan titik rawak di baris atas untuk menjadi jubin untuk (int i = 15; i> = 1; i -) {// bekerja dari bahagian bawah papan ke atas untuk (int ii = 0; ii <= 3; ii ++) {// untuk setiap collum arrGame [ii] = arrGame [i - 1] [ii]; }}}

kod ini dimulakan dengan mengosongkan keseluruhan baris atas ke 0, atau tanpa jubin, dan kemudian menetapkan satu jubin rawak menjadi jubin 1, dan unit.

Ia kemudian melalui gelung yang dikira secara terbalik, dari 15 hingga 1, menetapkan baris agar sama dengan baris di atasnya sama, menjadikan papan bergerak ke bawah LCD

Langkah 8: Fungsi ClearBoard

salin kod ini ke dalam program anda.

batal clearBoard () {// tetapkan semula nilai centang dan kelewatan intTick = 0; intDelay = 1000; // pergi melalui papan dan tetapkan semuanya menjadi 0 untuk (int i = 0; i <= 15; i ++) {untuk (int ii = 0; ii <= 3; ii ++) {arrGame [ii] = 0; }}}

Kod ini dijalankan ketika permainan tidak dimainkan untuk memastikan keseluruhan arrGame diatur ke 0, atau tidak ada jubin, dengan menggunakan gelung yang dihitung untuk melewati array.

Kod ini juga menetapkan semula nilai intDelay dan intTick.

Langkah 9: Fungsi Tajuk

salin kod berikut ke dalam program anda

batal tajuk () {// tulis tajuk ke LCD dan ruang untuk skor lcdRight.setCursor (0, 0); lcdRight.write ("Piano Tiles"); lcdRight.setCursor (0, 1); lcdRight.write ("Skor:"); // ubah skor menjadi rentas rentetan [3]; sprintf (strScore, "% d", intScore); // paparan skor ke LCD lcdRight.write (strScore); // tambahkan perbezaan lcdRight.setCursor (10, 1); jika (intDiff == 0) {lcdRight.write ("Mudah"); } jika (intDiff == 1) {lcdRight.write ("Medium"); } jika (intDiff == 2) {lcdRight.write ("Keras"); } // Tekan sedikit arahan lcdLeft.setCursor (0, 0); lcdLeft.write ("Tekan Enter"); lcdLeft.setCursor (0, 1); lcdLeft.write ("untuk bermula!"); }

Kod ini menulis tajuk permainan dan skor ke LCD, ia melakukannya dengan memberitahu LCD di mana hendak mula menaip menggunakan LCD.setCursor dan kemudian menulis rentetan dalam LCD.write.

Pemboleh ubah baru juga dibuat di sini, strScore, ia digunakan untuk menukar intScore menjadi rentetan atau jenis data char menggunakan fungsi sprintf.

intDiff juga digunakan di sini, berdasarkan nilai ia mencetak pilihan kesukaran yang berbeza.

Langkah 10: Fungsi ButtonsMenu

masukkan kod berikut ke dalam program anda

butang kosongMenu () {// ketika enter ditekan mulakan permainan dan tetapkan semula nilai skor jika (intEnter == 1) {bolPlay = true; intScore = 0; papan permainan (); papan lukis (); } // apabila butang 3 ditekan hidupkan pilihan debug untuk mencetak papan secara bersiri jika (intInput == 3) {if (bolSerialBoard == false) {Serial.println ("Serial Board Active"); bolSerialBoard = benar; } lain {Serial.println ("Serial Board Disabled"); bolSerialBoard = salah; }} // tetapkan kelajuan permainan menjadi kesukaran mudah jika (intInput == 0) {Serial.print ("Game set to easy ("); Serial.print (intGameSpeedEasy); Serial.println ("ms acceleration)"); intDiff = 0; intGameSpeed = intGameSpeedEasy; } // tetapkan kelajuan permainan ke kesukaran sederhana jika (intInput == 1) {Serial.print ("Game set ke medium ("); Serial.print (intGameSpeedMedium); Serial.println ("ms acceleration)"); intDiff = 1; intGameSpeed = intGameSpeedMedium; } // tetapkan kelajuan permainan menjadi sukar jika (intInput == 2) {Serial.print ("Game set ke hard ("); Serial.print (intGameSpeedHard); Serial.println ("ms acceleration)"); intDiff = 2; intGameSpeed = intGameSpeedHard; }}

kod ini hanya dijalankan apabila bolPlay sama dengan false di Loop kosong

jika intEnter diatur ke 1 itu berarti butang enter telah ditekan, jika ditekan program mengatur bolPlay ke true dan permainan dimulakan.

Program kemudian membaca sama dengan intInput. jika sama dengan 0 butang pertama dari kiri ditekan, naik ke kanan hingga 3. Jika intInput sama dengan 4 tidak ada butang sedang ditekan.

jika butang 0-2 ditekan permainan mengubah kesukaran, juga menyesuaikan nilai kelajuan permainan, yang bermaksud akan mempercepat lebih cepat.

jika butang 3 ditekan, permainan akan mengaktifkan atau menyahaktifkan mod debug di mana keseluruhan papan dicetak dalam monitor bersiri untuk membantu mencari masalah dalam program.

Langkah 11: Fungsi Permainan Butang

salin kod berikut ke dalam program anda

butang kosong Permainan () {if (intInput! = 4) {// jika butang ditekan jika (bolTilePressed == false) {// hanya jika bolTilePressed adalah tindakan pencetus palsu untuk memeriksa butang tekan bolTilePressed = true; // kemudian tetapkan bolTile Ditekan ke true untuk memastikan ia tidak dipicu lagi secara int intLowestTile = 0; // untuk ditetapkan ke jubin dengan jubin terendah int intCheckedTile = 15; // untuk mengetahui jubin mana yang telah diperiksa semasa (intLowestTile == 0) {// selagi ia tidak ditetapkan untuk memeriksa jubin (int i = 0; i 100) {// selagi int kelewatan tidak lebih rendah daripada 100 intDelay = intDelay - 20; // ambil nilai darinya}} lain {Serial.println ("Butang salah ditekan"); permainan tamat(); // jika tidak, permainan berakhir}}}}}

Kod hanya dijalankan apabila bolPlay sama dengan true di Loop kosong.

Seperti butangMenu berdasarkan nilai intInput ia memeriksa untuk melihat apakah pemain telah memukul ubin atau ketinggalan.

Ia melakukan ini dengan melalui arrGame dari bawah ke atas menggunakan gelung sementara untuk mencari baris mana yang paling rendah dengan jubin unit. Ia kemudian memeriksa untuk melihat apakah tempat di baris itu sesuai dengan butang yang ditekan adalah jubin unit atau tidak, jika tidak, ia menetapkannya sama dengan 2 dan bukan 1, yang bermaksud ia akan dipaparkan sebagai @, jika tidak, ia akan memicu permainan fungsi yang masih belum kita buat.

Fungsi ini juga menggunakan variabel bolTilePressed dengan menetapkannya menjadi true ketika butang ditekan dan salah ketika tidak ada butang ditekan. Ini untuk memastikan pengguna tidak kehilangan permainan secara tidak sengaja kerana program ini menganggap mereka menekan butang berkali-kali ketika mereka menahannya.

Langkah 12: Fungsi GameOver

Salin kod berikut ke dalam program anda

batal gameOver () {Serial.println ("Game Over!"); Serial.print ("Skor anda adalah:"); Serial.println (intScore); Serial.print ("Kelajuan anda:"); Serial.println (intDelay); bolPlay = salah; }

Ini dipicu oleh fungsi checkBottom atau buttonGame dan memicu akhir permainan dengan menetapkan bolPlay menjadi salah.

Ini juga mencetak pesan ke monitor bersiri untuk skor pengguna dan jubin kelajuan ditambahkan dalam milisaat.

Langkah 13: Fungsi Input

Salin kod berikut ke dalam program anda.

input kosong () {intEnter = digitalRead (btnEnter); // read enter // baca input mana yang lain, atau jika tidak ada set ke 4 jika (digitalRead (btn1) == TINGGI) {intInput = 0;} lain {if (digitalRead (btn2) == TINGGI) {intInput = 1;} lain {if (digitalRead (btn3) == TINGGI) {intInput = 2;} lain {if (digitalRead (btn4) == TINGGI) {intInput = 3;} lain {intInput = 4; }}}} // mencetak input jika (intEnter == 1) {Serial.println ("Enter Pressed!");} if (intInput! = 4) {Serial.print ("Button Press:"); Serial.println (intInput); } lain {// jika tiada butang ditekan ulang bolTilePressed bolTilePressed = false; }}

Kod ini digunakan dengan fungsi tombolGame dan buttonMenu. berdasarkan butang pengguna telah menekannya menetapkan nilai intInput, atau jika tidak ada butang ditekan, ia menetapkan intInput menjadi sama dengan 4.

Sekiranya tiada butang ditekan di sinilah bolTilePressed diset semula untuk fungsi tombolGame.

Ini juga mencetak pesan ke monitor bersiri di mana butang ditekan.

Langkah 14: Fungsi Pemeriksaan Bawah

salin kod berikut ke program anda.

kosongkanCheck () {untuk (int i = 0; i <= 3; i ++) {// untuk 4 kolum jika (arrGame [15] == 1) {// jika jubin berada di bahagian bawah Serial.println ("Jubin di bahagian bawah"); arrGame [15] = 2; papan lukis (); kelewatan (400); arrGame [15] = 1; papan lukis (); kelewatan (400); arrGame [15] = 2; papan lukis (); kelewatan (400); arrGame [15] = 1; papan lukis (); kelewatan (400); permainan tamat(); }}}

dengan menggunakan gelung, kod ini akan memeriksa baris bawah arrGame untuk mana-mana jubin unit (jubin sama dengan 1), jika terdapat jubin unhit di bahagian bawah skrin, ia akan memancarkan jubin dan kemudian mencetuskan fungsi permainan lebih.

Langkah 15: Fungsi WriteSerial

salin kod berikut ke dalam program anda

batal writeSerial () {if (bolSerialBoard == true) {untuk (int i = 0; i <= 15; i ++) {untuk (int ii = 0; ii <= 3; ii ++) {Serial.print (arrGame [ii]); Cetakan bersiri (","); } Serial.println (""); }}}

Ini adalah fungsi yang diikuti oleh pilihan debug yang dapat diaktifkan dalam fungsi tombolMenu. Sekiranya bolSerialBoard ditetapkan ke true dalam fungsi itu, ia akan melalui arrGame dan mencetak keseluruhan papan ke monitor bersiri untuk tujuan pengujian dengan menggunakan array.

Langkah 16: Penyelesaian

Semua kod anda tidak boleh lengkap dan kelihatan seperti ini!

/ * * Nama - Jubin Piano; Arduino * Oleh - Domenic Marulli * Tarikh - 11 / *

/ termasuk perpustakaan

#sertakan

// pemboleh ubah ini adalah pilihan yang boleh anda ubah - angka yang lebih tinggi = permainan lebih pantas

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

// Tentukan pin

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

// buat objek LCD (n, ~, n, ~, ~, n)

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

// sediakan susunan permainan

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

// sediakan pemboleh ubah untuk permainan

bolPlay boolean; // menjejaki jika pemain intScore; // menjejaki skor pemain int intif; // hanya perkara estetik untuk memberitahu apa kesukaran permainan ini

// sediakan pemboleh ubah untuk input

int intEnter; // mengesan sekiranya pengguna menekan butang enter int intInput; // menjejaki butang mana yang pengguna tekan boltile boolean; // pastikan pemain tidak menekan butang 5x secara tidak sengaja dan kalah

// sediakan pemboleh ubah untuk giliran

int intTick; // mengira milies (per gelung) hingga intDelay int intDelay; // masa program menunggu hingga giliran seterusnya dalam milis int intGameSpeed;

// mengurangkan pilihan debug

boolean bolSerialBoard; // apabila benar akan mencetak papan pada monitor bersiri

// persediaan yang akan dijalankan sekali

batal persediaan () {Serial.begin (9600); // mulakan monitor bersiri // tetapkan pemboleh ubah bolPlay = false; intScore = 0; intTick = 0; intDelay = 1000; intDiff = 1; intGameSpeed = intGameSpeedMedium; // mulakan lcd's lcdLeft.begin (16, 2); lcdRight.begin (16, 2); }

// gelung yang akan dijalankan setiap 10 milisaat

gelung kosong () {input (); // periksa input bermain jika (bolPlay == true) {if (intTick> = intDelay) {// periksa untuk melihat apakah permainan harus memainkan giliran atau terus menunggu Serial.println ("~~~~~~~ ~~ "); // cetak untuk menandakan papan bergerak pada // writeSerial (); // jika pilihan diaktifkan tulis papan ke butang bersiriGame (); // periksa input pemain playBoard (); // gerakkan papan dan tambahkan jubin clearLcd (); // bersihkan LCD sebelum melukis drawBoard (); // lukis papan ke bahagian bawah lcdCheck (); intTick = 0; // tetapkan semula intTick} lain {buttonGame (); // periksa input pemain clearLcd (); // bersihkan LCD sebelum melukis drawBoard (); // lukis papan ke intTick = intTick + intGameSpeed lcd; // tambah ke tandakan}} lain {clearLcd (); // bersihkan LCD sebelum melukis tajuk (); // butang tajuk paparan dan maklumat skorMenu (); // baca input pemain clearBoard (); // pastikan keseluruhan papan = 0} kelewatan (10); // tunda arduino sebentar lagi}

// membersihkan lcd, sehingga sel-sel yang tidak masuk tidak ditinggalkan di sana

batal clearLcd () {untuk (int i = 0; i <= 15; i ++) {untuk (int ii = 0; ii <= 1; ii ++) {lcdLeft.setCursor (i, ii); lcdLeft.write (""); lcdRight.setCursor (i, ii); lcdRight.write (""); }}}

// menarik papan ke lcd

batal drawBoard () {untuk (int i = 1; i <= 15; i ++) {// lukis kolum 1 dan 2 di sebelah kiri LCD // jika jubin = 0 tulis apa-apa, = 1 tulis "#", = 2 tulis "@" lcdLeft.setCursor (i, 1); // tetapkan ke kolumn pertama (kiri paling jauh) jika (arrGame [0] == 1) {lcdLeft.write ("#");} if (arrGame [0] == 2) {lcdLeft.write ("@");} lcdLeft.setCursor (i, 0); // tetapkan ke kolumn kedua (tengah kiri) jika (arrGame [1] == 1) {lcdLeft.write ("#");} if (arrGame [1] == 2) {lcdLeft.write ("@");} lcdRight.setCursor (i, 1); // tetapkan ke kolumn ketiga (tengah kanan) jika (arrGame [2] == 1) {lcdRight.write ("#");} if (arrGame [2] == 2) {lcdRight.write ("@");} lcdRight.setCursor (i, 0); // tetapkan ke kolumn keempat (paling kanan) jika (arrGame [3] == 1) {lcdRight.write ("#");} if (arrGame [3] == 2) {lcdRight.write ("@");}}}

// menggerakkan papan ke bawah dan meletakkan nilai rawak untuk menjadi jubin

batal playBoard () {untuk (int i = 0; i <= 3; i ++) {arrGame [0] = 0;} // kosongkan baris atas arrGame [0] [rawak (0, 4)] = 1; // tetapkan titik rawak di baris atas untuk menjadi jubin untuk (int i = 15; i> = 1; i -) {// bekerja dari bahagian bawah papan ke atas untuk (int ii = 0; ii <= 3; ii ++) {// untuk setiap collum arrGame [ii] = arrGame [i - 1] [ii]; }}}

// menetapkan keseluruhan papan ke 0 dan menetapkan semula pemboleh ubah ke pregame

batal clearBoard () {// tetapkan semula nilai centang dan kelewatan intTick = 0; intDelay = 1000; // pergi melalui papan dan tetapkan semuanya menjadi 0 untuk (int i = 0; i <= 15; i ++) {untuk (int ii = 0; ii <= 3; ii ++) {arrGame [ii] = 0; }}}

// memaparkan Menu Utama pada LCD

batal tajuk () {// tulis tajuk ke LCD dan ruang untuk skor lcdRight.setCursor (0, 0); lcdRight.write ("Piano Tiles"); lcdRight.setCursor (0, 1); lcdRight.write ("Skor:"); // ubah skor menjadi rentas rentetan [3]; sprintf (strScore, "% d", intScore); // paparan skor ke LCD lcdRight.write (strScore); // tambahkan perbezaan lcdRight.setCursor (10, 1); jika (intDiff == 0) {lcdRight.write ("Mudah"); } jika (intDiff == 1) {lcdRight.write ("Medium"); } jika (intDiff == 2) {lcdRight.write ("Keras"); } // Tekan sedikit arahan lcdLeft.setCursor (0, 0); lcdLeft.write ("Tekan Enter"); lcdLeft.setCursor (0, 1); lcdLeft.write ("untuk bermula!"); }

// periksa butang dan apa yang harus dilakukan untuk mereka semasa di luar permainan

butang kosongMenu () {// ketika enter ditekan mulakan permainan dan tetapkan semula nilai skor jika (intEnter == 1) {bolPlay = true; intScore = 0; papan permainan (); papan lukis (); } // apabila butang 3 ditekan hidupkan pilihan debug untuk mencetak papan secara bersiri jika (intInput == 3) {if (bolSerialBoard == false) {Serial.println ("Serial Board Active"); bolSerialBoard = benar; } lain {Serial.println ("Serial Board Disabled"); bolSerialBoard = salah; }} // tetapkan kelajuan permainan menjadi kesukaran mudah jika (intInput == 0) {Serial.print ("Game set to easy ("); Serial.print (intGameSpeedEasy); Serial.println ("ms acceleration)"); intDiff = 0; intGameSpeed = intGameSpeedEasy; } // tetapkan kelajuan permainan ke kesukaran sederhana jika (intInput == 1) {Serial.print ("Game set ke medium ("); Serial.print (intGameSpeedMedium); Serial.println ("ms acceleration)"); intDiff = 1; intGameSpeed = intGameSpeedMedium; } // tetapkan kelajuan permainan menjadi sukar jika (intInput == 2) {Serial.print ("Game set ke hard ("); Serial.print (intGameSpeedHard); Serial.println ("ms acceleration)"); intDiff = 2; intGameSpeed = intGameSpeedHard; }}

// periksa butang dan apa yang harus dilakukan untuk mereka semasa dalam permainan

butang kosongGame () {if (intInput! = 4) {// jika butang ditekan jika (bolTilePressed == false) {// hanya jika bolTilePressed adalah tindakan pencetus palsu untuk memeriksa butang tekan bolTilePressed = true; // kemudian tetapkan bolTile Ditekan ke true untuk memastikan ia tidak dipicu lagi secara int intLowestTile = 0; // untuk ditetapkan ke jubin dengan jubin terendah int intCheckedTile = 15; // untuk mengetahui jubin mana yang telah diperiksa semasa (intLowestTile == 0) {// selagi ia tidak ditetapkan untuk memeriksa jubin (int i = 0; i 100) {// selagi int kelewatan tidak lebih rendah daripada 100 intDelay = intDelay - 20; // ambil nilai darinya}} lain {Serial.println ("Butang salah ditekan"); permainan tamat(); // jika tidak, permainan berakhir}}}}}

batal permainan Lebih () {

Serial.println ("Game Over!"); Serial.print ("Skor anda adalah:"); Serial.println (intScore); Serial.print ("Kelajuan anda:"); Serial.println (intDelay); bolPlay = salah; }

// memeriksa input pemain

input kosong () {intEnter = digitalRead (btnEnter); // read enter // baca input mana yang lain, atau jika tidak ada set ke 4 jika (digitalRead (btn1) == TINGGI) {intInput = 0;} lain {if (digitalRead (btn2) == TINGGI) {intInput = 1;} lain {if (digitalRead (btn3) == TINGGI) {intInput = 2;} lain {if (digitalRead (btn4) == TINGGI) {intInput = 3;} lain {intInput = 4; }}}} // mencetak input jika (intEnter == 1) {Serial.println ("Enter Pressed!");} if (intInput! = 4) {Serial.print ("Button Press:"); Serial.println (intInput); } lain {// jika tiada butang ditekan ulang bolTilePressed bolTilePressed = false; }}

// memeriksa bahagian bawah papan untuk kegagalan

kosongkanCheck () {untuk (int i = 0; i <= 3; i ++) {// untuk 4 kolum jika (arrGame [15] == 1) {// jika jubin berada di bahagian bawah Serial.println ("Jubin di bahagian bawah"); arrGame [15] = 2; papan lukis (); kelewatan (400); arrGame [15] = 1; papan lukis (); kelewatan (400); arrGame [15] = 2; papan lukis (); kelewatan (400); arrGame [15] = 1; papan lukis (); kelewatan (400); permainan tamat(); }}}

// mencetak papan ke monitor bersiri sekiranya bolSerialBoard benar

batal writeSerial () {if (bolSerialBoard == true) {untuk (int i = 0; i <= 15; i ++) {untuk (int ii = 0; ii <= 3; ii ++) {Serial.print (arrGame [ii]); Cetakan bersiri (","); } Serial.println (""); }}}

Setelah semua kod dimasukkan, muat naik ke arduino anda dan nikmati!