ארדואינו - אריחי פסנתר: 16 שלבים (עם תמונות)

2024 מְחַבֵּר: John Day | [email protected]. שונה לאחרונה: 2024-01-30 09:16

שלום לאנשי האינטרנט, זה הולך להיות איך לעשות מה שבטוח אינו פריצה של משחק נייד ב- arduino uno r3.

אז כדי להתחיל, אתה תזדקק לכל החלקים שהם כדלקמן! 1x Arduino Uno r3 ($ 42)

2x מגן לוח מקשים LCD (19 $ לכל אחד)

כפתורים 5x

נגדים 5x 220Ω

28x חוטים

בסדר, ברגע שיש לך את כל החלקים הגיע הזמן להתחיל!

שלב 1: חיווט

התחל על ידי חיווט הארדואינו והחברים שלך כפי שמוצג בתרשים, וודא שהכפתורים מקושרים בצורה הנכונה, עם חריצי A0-4 בצד הקרקע של מסילות הכפתורים, או שהארדואינו יחשוב במקום זאת שהכפתורים מוחזקים כל הזמן במקום רק בלחיצה.

שלב 2: הצהרות הצהרה

כל הקוד כאן צריך לעבור לפני הגדרת הריק ולולאת הריק שלך, זאת מכיוון שכל המשתנים והאובייקטים האלה משמשים בכמה מהפונקציות שנקבע.

התחל בלשים:

#לִכלוֹל

בחלק העליון של הקוד שלך, זה אומר לארדואינו להשתמש בספרייה "LiquidCrystal.h" ובפונקציות שהם חלק ממנו.

השלב הבא הוא להגדיר את הסיכות בהן אנו משתמשים עבור הכפתורים שלנו על ידי הכנסת קוד זה מתחת ל- #include שלנו:

#define btn הזן A0 #הגדר btn1 15 #הגדר btn2 16 #הגדר btn3 17 #הגדר btn4 18

אנו מגדירים את המונחים btnEnter ו- btn1 עד btn 4 כדי להקל עלינו את הקוד לקרוא, או לשנות במידת הצורך. המשמעות היא שכאשר אנו מקלידים btn1 הארדואינו יידע שאנו למעשה מתכוונים ללחצן 15. למרות שאנו קוראים ליציאות 15, 16, 17 ו -18, הם מסומנים על הארדואינו כ- A1 A2 A3 ו- A4, אך הסיבה לכך היא הם יציאות המשמשות במיוחד עבור כניסות אנלוגיות, אם כי אנו משתמשים בהן רק לכניסות דיגיטליות.

בשלב הבא אנו הולכים ליצור את האובייקטים שישלטו על תצוגות הגביש הנוזלי. לשם כך שים את הקוד הזה מתחת להגדרות שלנו

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

מה זה עושה אומר לארדואינו שכאשר אנו קוראים lcdLeft או lcdRight אנו מתייחסים לאובייקט LiquidCrystal. המספרים בסוגריים המצורפים אומרים לארדואינו באיזה יציאות האובייקט צריך להשתמש כדי לשלוח הודעות ל- LCD כאשר אנו משתמשים בפונקציות שלהם.

כעת עלינו להכריז על המשתנים על ידי הכנסת קוד הקוד הבא מתחת להצהרות האובייקט:

// משתנים אלה הם אפשרויות שניתן לשנות - מספרים גבוהים יותר = מהירות משחק מהירה יותר intintameSpeedEasy = 10; int intGameSpeedMedium = 25; int intGameSpeedHard = 80;

// הגדרת משתנים עבור bolPlay gameboolean; // עוקב אחרי אם השחקן int intScore; // עוקב אחר הציון של השחקן int intiff; // רק דבר אסתטי לספר באיזה קושי המשחק נמצא // להגדיר משתנים עבור קלט int intEnter; // עוקב אם המשתמש לוחץ על כפתור enter int intInput; // עוקב אחר אילו כפתורים המשתמש לוחץ על bolTilePressed בוליאני; // לוודא שהשחקן לא לוחץ בטעות על כפתור 5x ומאבד // הגדר משתנים עבור turn int intTick; // סופר מיליונים (לכל לולאה) עד intDelay int intDelay; // הזמן שהתוכנית ממתינה עד לפנייה הבאה ב- millis int intGameSpeed; // abit of debug options boolean bolSerialBoard; // כאשר true ידפיס את הלוח במסך הטורי

אנו מכריזים על משתנה על ידי ציון סוג הנתונים ולאחר מכן שם המשתנה, למשל. int thisIsAnInteger

משתנים בוליאניים, כגון bolSerialBoard ו- bolPlay יכולים להכיל רק אחד משני ערכים, נכון או לא נכון.

משתנה שלם (int) כגון intScore ו- intInput יכול לקחת מספרים שלמים כערכים, כגון 1, 5 או 100.

כמה סוגי נתונים בולטים אחרים שבהם איננו משתמשים כאן הם מחרוזת, שהיא נתח טקסט וצפה, שהיא מספר עשרוני.

כל אחד מהמשתנים כאן משמש את התוכנית במספר מקומות שונים, להלן תקציר של כל אחד מהם

bolPlay אומר לתוכנית אם יש להציג את התפריט או אם המשחק אמור לפעול.

intScore עוקב אחר הציון של השחקן כשהוא פוגע באריחים, intDiff משמש בתפריט הראשי כדי לספר לתוכנית איזה טקסט להדפיס על מסכי ה- LCD, intEnter משמש כדי לספר לתוכנית אם לוחצים על לחצן enter (הכי שמאל), intInput משמש כדי לספר לתוכנית על אילו 4 כפתורים אחרים נלחץ.

bolTilePressed משמש כדי לוודא שהתוכנית קוראת רק כאשר לוחצים על הכפתור ולא כאשר הוא מוחזק.

intGameSpeed, intGameSpeedEasy, intGameSpeedMedium ו- intGameSpeedHard משמשים לשליטה על מהירות המשחק להאיץ על סמך איזה קושי נבחר.

intTick ו- intDelay משמשים כדי למנוע מהתוכנית להזיז את הלוח בכל פעם שהוא לולאה.

bolSerialBoard משמש כדי לאפשר לך לגרום לתוכנית לשלוח את הלוח למסך הסידורי של הארדואינו כסדרת מספרים למטרות בדיקה.

לבסוף הגיע הזמן להכריז על הלוח שלנו כמערך באמצעות קוד זה:

// הגדרת array 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}};

מערך הוא מטריצה שכל נקודה שאפשר לקרוא לה מתמטיקה או לשנות אותה.

הקוד שלך אמור להיראות בערך כך;

// כלול ספריות#כולל

// משתנים אלה הם אפשרויות שניתן לשנות - מספרים גבוהים יותר = מהירות משחק מהירה יותר

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

// הגדר סיכות

#הגדר btn הזן A0 #הגדר btn1 15 #הגדר btn2 16 #הגדר btn3 17 #הגדר btn4 18

// ליצור אובייקטים LCD (n, ~, n, ~, ~, n)

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

// הגדר מערך משחקים

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

// הגדר משתנים למשחק

bolPlay בוליאני; // עוקב אחרי אם השחקן int intScore; // עוקב אחר הציון של השחקן int intiff; // רק דבר אסתטי לספר באיזה קושי המשחק

// הגדר משתנים לקלט

int intEnter; // עוקב אם המשתמש לוחץ על כפתור enter int intInput; // עוקב אחר אילו כפתורים המשתמש לוחץ על bolTilePressed בוליאני; // וודא שהשחקן לא לוחץ על כפתור 5x בטעות ומפסיד

// הגדר משתנים לתור

int intTick; // סופר מיליונים (לכל לולאה) עד intDelay int intDelay; // הזמן שהתוכנית ממתינה עד לפנייה הבאה ב- millis int intGameSpeed;

// abit של אפשרויות באגים

bolSerialBoard בוליאני; // כאשר true ידפיס את הלוח במסך הטורי

שלב 3: פונקציית ההתקנה

לולאת ההתקנה היא פונקציה הנקראת על ידי הארדואינו רק פעם אחת כאשר היא מתחילה בתחילה.

בלולאת ההתקנה אנחנו רק קובעים את הערכים של כמה מהמשתנים שלנו, כי במקום להגדיר להם ערך בעת הצהרה עליהם אנו עושים זאת כאן.

התחל על ידי הכנסת קוד זה להגדרת Void שלך.

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

כל שורה היא רק הגדרת משתנה לערך.

bolPlay מוגדר כ- false כדי שהמשחק לא יתחיל לשחק.

intScore מוגדר ל -0, כי באופן טבעי הציון שלך מתחיל ב -0.

intTick מתחיל ב -0 מכיוון שהתוכנית כרגע לא סופרת כלום.

intDelay מוגדר ל -1000 מכיוון שזהו הקצב שבו האריחים מתחילים.

intDiff הוא רק דבר סגפני כדי שהתוכנית תדע מה לכתוב לקושי של המשחק.

intGameSpeed מוגדר לכל מה שהוא intGameSpeedMedium, כלומר הוא מוגדר בקושי הבינוני.

לאחר מכן הכנס את הקוד הזה להגדרת Void מתחת לקוד שהכנסת זה עתה.

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

Serial.begin (9600);

זה אומר לארדואינו להתחיל לתקשר עם המחשב דרך הצג הסדרתי (גלוי בלחיצה על הכפתור בפינה השמאלית העליונה של ה- arduino IDE).

התקנת ה- Void שלך אמורה להיראות בערך כך!

הגדרת void () {Serial.begin (9600); // הפעל את הצג הטורי // הגדר את המשתנים bolPlay = false; intScore = 0; intTick = 0; intDelay = 1000; intDiff = 1; intGameSpeed = intGameSpeedMedium; // התחל lcdLeft.begin של lcd (16, 2); lcdRight.begin (16, 2); }

שלב 4: פונקציית הלולאה

פונקציית הלולאה מופעלת על ידי הארדואינו בכל איטרציה של הארדואינו.

העתק את הקוד הבא לתוך לולאת הריק שלך.

לולאת void () {input (); // בדוק אם קלט משחק אם (bolPlay == true) {if (intTick> = intDelay) {// בדוק אם המשחק אמור לשחק סיבוב או המשך להמתין Serial.println ("~~~~~~~ ~~ "); // הדפס כדי לסמן את הלוח ממשיך // writeSerial (); // אם האפשרות מופעלת כתוב את הלוח לכפתורים סדרתיים Game (); // בדוק אם קלט השחקן playBoard (); // הזז את הלוח והוסף אריח חדש clearLcd (); // נקו את מסכי ה- LCD לפני ציור DrawBoard (); // צייר את הלוח אל תחתית הצג של המסך (); intTick = 0; // אפס intTick} else {buttonsGame (); // בדוק אם קלט הנגן clearLcd (); // נקו את מסכי ה- LCD לפני ציור DrawBoard (); // צייר את הלוח על intTick = intTick + intGameSpeed של lcd; // הוסף לתקתק}} אחר {clearLcd (); // נקו את מסכי ה- LCD לפני ציור הכותרת (); // להציג כפתורי מידע וניקוד מידע תפריט (); // לקרוא קלט נגן clearBoard (); // ודא שכל הלוח = 0} עיכוב (10); // לעכב את הארדואינו ברגע קצר}

כאשר bolPlay שווה ל- true זה אומר שהמשחק משחק, וכל הקוד לשעת המשחק צריך להיות מופעל, אך אנו רוצים שהלוח יוסיף אריח חדש וירד כלפי מטה כאשר intTick גדול מה- intDelay שלנו, אחרת אנחנו עדיין רוצים לאפשר למשתמש ללחוץ על כפתור כדי לפגוע באריח וכדי ש- intTick תגדיל את המהירות.

רוב הקוד הזה משתמש בפונקציות שעדיין לא נבצע, ואנו נבצע אותן בשלבים הבאים. מטרת הפונקציות הללו היא כדלקמן.

קלט קורא באילו כפתורים המשתמש לחץ.

buttonsGame שולט במה הכפתורים עושים בזמן המשחק, ולא בתפריט

playBoard מוסיף אריח חדש ללוח ולאחר מכן מעביר את כל הלוח למטה בחלל אחד

clearLCD מנקה את מסכי ה- LCD כדי לוודא שלא נותרו רוחות רפאים מאחורי האריחים

drawBoard עובר arrGame ומדפיס אותו על מסכי ה- LCD

clearBoard מנקה את כל arrGame כשהמשחק אינו בשימוש

bottomCheck בודק את התחתון של arrGame אם קיים מצב כשל

הכותרת מציגה את שם המשחק ואת נתוני הניקוד שלו בתפריט

תפריט הכפתורים שולט על מה שתשומות המשתמש משתמשות בתפריט.

gameOver היא פונקציה אחרת, אם כי היא אינה נקראת כאן כפי שהיא נקראת במקום זאת תחתונה בדיקות ולחצנים פונקציות משחק.

שלב 5: הפונקציה ClearLCD

כדי ליצור פונקציה אנו מתחילים בהוספת זה לקוד

void functionName () {

}

"שם הפונקציה" יכול להיות כל דבר, כל עוד הוא לא קיים.

העתק את הקוד הזה לתוכנית שלך:

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

זה עובר במערך כולו באמצעות 2 לולאות נספרות כדי לעבור כל נקודה במסכי ה- LCD ולכתוב רווח.

מבלי להתאפס לשום דבר ה- LCD לא ישמור על כל מה שנכתב קודם לכן

שלב 6: פונקציית DrawBoard

העתק קוד זה לתוכנית שלך

void drawBoard () {for (int i = 1; i <= 15; i ++) {// צייר קולומים 1 ו -2 במסך LCD השמאלי // אם האריח = 0 אל תכתוב כלום, = 1 כתוב "#", = 2 כתוב "@" lcdLeft.setCursor (i, 1); // הגדר לטור הראשון (הכי שמאל) אם (arrGame [0] == 1) {lcdLeft.write ("#");} if (arrGame [0] == 2) {lcdLeft.write ("@");} lcdLeft.setCursor (i, 0); // הגדר לטור השני (במרכז שמאל) אם (arrGame [1] == 1) {lcdLeft.write ("#");} if (arrGame [1] == 2) {lcdLeft.write ("@");} lcdRight.setCursor (i, 1); // הגדר לעמודה השלישית (במרכז ימין) אם (arrGame [2] == 1) {lcdRight.write ("#");} if (arrGame [2] == 2) {lcdRight.write ("@");} lcdRight.setCursor (i, 0); // הגדר לעמודה הרביעית (הכי ימינה) אם (arrGame [3] == 1) {lcdRight.write ("#");} if (arrGame [3] == 2) {lcdRight.write ("@");}}}

זה משתמש בלולאה כדי לעבור בכל שורה של הלוח, ואז הוא בודק אם עמודה כלשהי בשורה שווה ל -1 או 2, על סמך זה היא מדפיסה על ה- LCD או האשטאג, עד שעוד לא יהיה אריח hit, או @ עבור אריח להיט.

שלב 7: הפונקציה PlayBoard

העתק קוד זה לתוכנית שלך.

void playBoard () {for (int i = 0; i <= 3; i ++) {arrGame [0] = 0;} // נקה את השורה העליונה arrGame [0] [אקראי (0, 4)] = 1; // הגדר נקודה אקראית בשורה העליונה כדי להיות אריח עבור (int i = 15; i> = 1; i-) {// עבודה מתחתית הלוח למעלה עבור (int ii = 0; ii <= 3; ii ++) {// עבור כל arrGame [ii] = arrGame [i - 1] [ii]; }}}

קוד זה מתחיל על ידי ניקוי כל השורה העליונה ל- 0, או ללא אריח, ולאחר מכן מגדיר אריח אקראי אחד להיות אריח 1 ובלתי פגום.

לאחר מכן הוא עובר דרך לולאה נספרת לאחור, מ -15 ל -1, ומגדיר את השורה שווה לכל מה שהשורה שמעליה שווה, מה שגורם ללוח לנוע במורד ה- LCD

שלב 8: הפונקציה ClearBoard

העתק קוד זה לתוכנית שלך.

void clearBoard () {// איפוס ערכי עיכוב ועיכוב intTick = 0; intDelay = 1000; // לעבור על הלוח ולהגדיר הכל ל- 0 עבור (int i = 0; i <= 15; i ++) {for (int ii = 0; ii <= 3; ii ++) {arrGame [ii] = 0; }}}

קוד זה מופעל כאשר המשחק אינו משחק כדי לוודא שכל arrGame מוגדר ל- 0, או ללא אריחים, באמצעות לולאות ספורות כדי לעבור את המערך.

הקוד גם מאפס את הערכים של intDelay ו- intTick.

שלב 9: פונקציית הכותרת

העתק את הקוד הבא לתוכנית שלך

void title () {// לכתוב כותרת על מסך LCD ומקום לציון lcdRight.setCursor (0, 0); lcdRight.write ("אריחי פסנתר"); lcdRight.setCursor (0, 1); lcdRight.write ("ציון:"); // להמיר את הציון למחרוזת char strScore [3]; sprintf (strScore, "%d", intScore); // הציג ציון על LCD lcdRight.write (strScore); // הוסף את lcdRight.setCursor diffictuly (10, 1); if (intDiff == 0) {lcdRight.write ("קל"); } if (intDiff == 1) {lcdRight.write ("בינוני"); } if (intDiff == 2) {lcdRight.write ("קשה"); } // לחץ על מעט הוראה lcdLeft.setCursor (0, 0); lcdLeft.write ("הקש Enter"); lcdLeft.setCursor (0, 1); lcdLeft.write ("כדי להתחיל!"); }

קוד זה כותב את כותרת המשחק ואת הציון על מסכי ה- LCD, הוא עושה זאת על ידי אמירת ה- LCD היכן להתחיל להקליד באמצעות LCD.setCursor ולאחר מכן לכתוב את המחרוזת ב- LCD.write.

נוצר כאן גם משתנה חדש, strScore, הוא משמש להמרת intScore לסוג נתוני מחרוזת או char באמצעות הפונקציה sprintf.

intDiff משמש גם כאן, על סמך ערכיו הוא מדפיס את אפשרויות הקושי השונות.

שלב 10: הפונקציה ButtonsMenu

הכנס את הקוד הבא לתוכנית שלך

void buttonsMenu () {// כאשר לוחצים על enter הפעל את המשחק ואפס את ערך הציון אם (intEnter == 1) {bolPlay = true; intScore = 0; playBoard (); drawBoard (); } // כאשר נלחץ על כפתור 3 הפעל אפשרות לאיתור באגים להדפסת הלוח בסדרה אם (intInput == 3) {if (bolSerialBoard == false) {Serial.println ("לוח סידורי פעיל"); bolSerialBoard = true; } else {Serial.println ("לוח סידורי מושבת"); bolSerialBoard = false; }}} // הגדר את מהירות המשחק לקושי קל אם (intInput == 0) {Serial.print ("המשחק מוגדר לקל ("); Serial.print (intGameSpeedEasy); Serial.println ("האצת ms)"); intDiff = 0; intGameSpeed = intGameSpeedEasy; } // הגדר את מהירות המשחק לקושי בינוני אם (intInput == 1) {Serial.print ("המשחק מוגדר לבינוני ("); Serial.print (intGameSpeedMedium); Serial.println ("האצת ms)"); intDiff = 1; intGameSpeed = intGameSpeedMedium; } // הגדר את מהירות המשחק לקושי קשה אם (intInput == 2) {Serial.print ("המשחק מוגדר לקשה ("); Serial.print (intGameSpeedHard); Serial.println ("האצת ms)"); intDiff = 2; intGameSpeed = intGameSpeedHard; }}

קוד זה מופעל רק כאשר bolPlay שווה ל- false בלולאת הריק

אם intEnter מוגדר ל- 1 זה אומר שלחצן הכפתור נדחק, אם לוחצים עליו התוכנית מגדירה את bolPlay ל- true והמשחק מתחיל.

לאחר מכן התוכנית קוראת למה ש- intInput שווה. אם הוא שווה ל -0 הכפתור הראשון משמאל נלחץ, מעלה ימינה עד 3. אם intInput שווה ל- 4 אין לחיצה על לחצן.

אם לוחצים על כפתורים 0-2 המשחק משנה את הקושי, ומתאים גם את ערך מהירות המשחק, כלומר הוא יואץ מהר יותר.

אם תלחץ על כפתור 3 המשחק יפעיל או יבטל מצב באגים שבו הלוח כולו מודפס בצג הטורי כדי לסייע במציאת בעיות בתוכנית.

שלב 11: הפונקציה ButtonsGame

העתק את הקוד הבא לתוכנית שלך

void buttonsGame () {if (intInput! = 4) {// אם לוחצים על כפתור אם (bolTilePressed == false) {// רק אם bolTilePressed היא פעולת טריגר שגויה לבדיקת לחיצה על לחצן bolTilePressed = true; // ולאחר מכן הגדר bolTilePressed ל- true כדי לוודא שהוא לא מופעל במקרה int intLowestTile = 0; // להיות מוגדר לאריח עם האריח הנמוך ביותר int intcheckedTile = 15; // כדי לעקוב אחר אילו אריחים נבדקו בזמן (intLowestTile == 0) {// כל עוד הוא אינו מוגדר לשום דבר בדוק את האריחים עבור (int i = 0; i 100) {// כל עוד int העיכוב אינו נמוך מ- 100 intDelay = intDelay - 20; // קח מזה ערך}}} אחר {Serial.println ("לחצן שגוי נלחץ"); סוף המשחק(); // אחרת המשחק נגמר}}}}}

הקוד מופעל רק כאשר bolPlay שווה לאמיתי בלולאת הריק.

כמו לחצני תפריט מבוסס על הערך של intInput הוא בודק אם השחקן פגע באריח או החמיץ אחד.

זה עושה את זה על ידי מעבר arrGame מלמטה למעלה באמצעות לולאת while כדי לחפש איזו שורה היא הנמוכה ביותר עם אריח לא מותקן. לאחר מכן הוא בודק אם הנקודה בשורה ההיא המתאימה לכפתור הנלחץ היא אריח שאינו חבל או לא, אם הוא לא מופיע הוא מגדיר אותו לשווי 2 במקום 1, כלומר הוא יוצג כ- @, אחרת הוא מפעיל את gameOver פונקציה שעוד לא ניצור.

פונקציה זו גם מנצלת את המשתנה bolTilePressed על ידי הגדרתו כ- true כאשר לוחצים על כפתור ושקר כאשר לא לוחצים על כפתור. זה כדי להבטיח שהמשתמש לא ישחרר את המשחק בטעות מכיוון שהתוכנית חשבה שהם לחצו על הכפתור מספר פעמים כשהם החזיקו אותו.

שלב 12: פונקציית GameOver

העתק את הקוד הבא לתוכנית שלך

void gameOver () {Serial.println ("המשחק נגמר!"); Serial.print ("הציון שלך היה:"); Serial.println (intScore); Serial.print ("המהירות שלך הייתה:"); Serial.println (intDelay); bolPlay = false; }

זה מופעל על ידי הפונקציות checkBottom או buttonsGame ומפעיל את סיום המשחק על ידי הגדרת bolPlay כ- false.

הוא גם מדפיס הודעה למסך הטורי עבור ציון המשתמשים ואריחי המהירות נוספו באלפיות השנייה.

שלב 13: פונקציית הקלט

העתק את הקוד הבא לתוכנית שלך.

קלט חלל () {intEnter = digitalRead (btnEnter); // קרא הזן // קרא איזו מבין התשומות האחרות, או אם אף אחת מהן אינה מוגדרת ל- 4 אם (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; }}}}} // סדרת הדפסה של הכניסות אם (intEnter == 1) {Serial.println ("Enter Pressed!");} if (intInput! = 4) {Serial.print ("Button Press:"); Serial.println (intInput); } אחר {// אם לא לוחצים על כפתור איפוס bolTilePressed bolTilePressed = false; }}

קוד זה משמש עם הלחצנים Game ו- buttonsMenu פונקציות. בהתבסס על הלחצנים שהמשתמש לחץ עליו הוא מגדיר את הערך של intInput, או אם לא לוחצים על כפתור זה מגדיר את intInput שווה ל -4.

אם לא נלחץ על כפתור זה המקום בו bolTilePressed מתאפס עבור הפונקציה buttonsGame.

הוא גם מדפיס הודעה לצג הטורי שבו לוחצים על הכפתור.

שלב 14: הפונקציה BottomCheck

העתק את הקוד הבא לתוכנית שלך.

void bottomCheck () {for (int i = 0; i <= 3; i ++) {// עבור 4 העמודות אם (arrGame [15] == 1) {// אם אריח נמצא בסידרה התחתונה.println ("אריח בתחתית"); arrGame [15] = 2; drawBoard (); עיכוב (400); arrGame [15] = 1; drawBoard (); עיכוב (400); arrGame [15] = 2; drawBoard (); עיכוב (400); arrGame [15] = 1; drawBoard (); עיכוב (400); סוף המשחק(); }}}

באמצעות לולאה קוד זה בודק את השורה התחתונה של arrGame עבור כל אריחים שאינם תואמים (אריחים שווים ל- 1), אם יש אריח ללא חיץ בתחתית המסך הוא יהבהב את האריח ולאחר מכן יפעיל את המשחק over function.

שלב 15: הפונקציה WriteSerial

העתק את הקוד הבא לתוכנית שלך

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

זוהי הפונקציה שאחריה מגיעה אופציית באגים שניתן להפעיל בפונקציית התפריט לחצנים. אם bolSerialBoard מוגדר לאמיתי בפונקציה זו הוא יעבור דרך arrGame וידפיס את הלוח כולו לתוך הצג הטורי למטרות בדיקה באמצעות מערך.

שלב 16: השלמה

כל הקוד שלך לא צריך להיות שלם ולהיראות בערך כך!

/ * * שם - אריחי פסנתר; Arduino * מאת - Domenic Marulli * תאריך - 11/ *

/ כולל ספריות

#לִכלוֹל

// משתנים אלה הם אפשרויות שניתן לשנות - מספרים גבוהים יותר = מהירות משחק מהירה יותר

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

// הגדר סיכות

#הגדר btn הזן A0 #הגדר btn1 15 #הגדר btn2 16 #הגדר btn3 17 #הגדר btn4 18

// ליצור אובייקטים LCD (n, ~, n, ~, ~, n)

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

// הגדר מערך משחקים

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

// הגדר משתנים למשחק

bolPlay בוליאני; // עוקב אחרי אם השחקן int intScore; // עוקב אחר הציון של השחקן int intiff; // רק דבר אסתטי לספר באיזה קושי המשחק

// הגדר משתנים לקלט

int intEnter; // עוקב אם המשתמש לוחץ על כפתור enter int intInput; // עוקב אחר אילו כפתורים המשתמש לוחץ על bolTilePressed בוליאני; // וודא שהשחקן לא לוחץ על כפתור 5x בטעות ומפסיד

// הגדר משתנים לתור

int intTick; // סופר מיליונים (לכל לולאה) עד intDelay int intDelay; // הזמן שהתוכנית ממתינה עד לפנייה הבאה ב- millis int intGameSpeed;

// abit של אפשרויות באגים

bolSerialBoard בוליאני; // כאשר true ידפיס את הלוח במסך הטורי

// ההתקנה שתופעל פעם אחת

הגדרת void () {Serial.begin (9600); // הפעל את הצג הטורי // הגדר את המשתנים bolPlay = false; intScore = 0; intTick = 0; intDelay = 1000; intDiff = 1; intGameSpeed = intGameSpeedMedium; // התחל lcdLeft.begin של lcd (16, 2); lcdRight.begin (16, 2); }

// הלולאה שתופעל כל 10 מילי שניות

לולאת void () {input (); // בדוק אם קלט משחק אם (bolPlay == true) {if (intTick> = intDelay) {// בדוק אם המשחק אמור לשחק סיבוב או המשך להמתין Serial.println ("~~~~~~~ ~~ "); // הדפס כדי לסמן את הלוח ממשיך // writeSerial (); // אם האפשרות מופעלת כתוב את הלוח לכפתורים סדרתיים Game (); // בדוק אם קלט השחקן playBoard (); // הזז את הלוח והוסף אריח חדש clearLcd (); // נקו את מסכי ה- LCD לפני ציור DrawBoard (); // צייר את הלוח אל תחתית הצג של המסך (); intTick = 0; // אפס intTick} else {buttonsGame (); // בדוק אם קלט הנגן clearLcd (); // נקו את מסכי ה- LCD לפני ציור DrawBoard (); // צייר את הלוח על intTick = intTick + intGameSpeed של lcd; // הוסף לתקתק}} אחר {clearLcd (); // נקו את מסכי ה- LCD לפני ציור הכותרת (); // להציג כפתורי מידע וניקוד מידע תפריט (); // לקרוא קלט נגן clearBoard (); // ודא שכל הלוח = 0} עיכוב (10); // לעכב את הארדואינו ברגע קצר}

// מנקה את ה- lcd, כך שלא יישארו שם תאים שאינם נכנסים

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

// מצייר את הלוח על המסכים

void drawBoard () {for (int i = 1; i <= 15; i ++) {// צייר קולומים 1 ו -2 במסך LCD השמאלי // אם האריח = 0 אל תכתוב כלום, = 1 כתוב "#", = 2 כתוב "@" lcdLeft.setCursor (i, 1); // הגדר לטור הראשון (הכי שמאל) אם (arrGame [0] == 1) {lcdLeft.write ("#");} if (arrGame [0] == 2) {lcdLeft.write ("@");} lcdLeft.setCursor (i, 0); // הגדר לטור השני (במרכז שמאל) אם (arrGame [1] == 1) {lcdLeft.write ("#");} if (arrGame [1] == 2) {lcdLeft.write ("@");} lcdRight.setCursor (i, 1); // הגדר לעמודה השלישית (במרכז ימין) אם (arrGame [2] == 1) {lcdRight.write ("#");} if (arrGame [2] == 2) {lcdRight.write ("@");} lcdRight.setCursor (i, 0); // הגדר לעמודה הרביעית (הכי ימינה) אם (arrGame [3] == 1) {lcdRight.write ("#");} if (arrGame [3] == 2) {lcdRight.write ("@");}}}

// מזיז את הלוח כלפי מטה ומציב ערך אקראי להיות אריח

void playBoard () {for (int i = 0; i <= 3; i ++) {arrGame [0] = 0;} // נקה את השורה העליונה arrGame [0] [אקראי (0, 4)] = 1; // הגדר נקודה אקראית בשורה העליונה כדי להיות אריח עבור (int i = 15; i> = 1; i-) {// עבודה מתחתית הלוח למעלה עבור (int ii = 0; ii <= 3; ii ++) {// עבור כל arrGame [ii] = arrGame [i - 1] [ii]; }}}

// מגדיר את הלוח כולו ל- 0 ומאפס משתנים למשחק מוקדם

void clearBoard () {// איפוס ערכי עיכוב ועיכוב intTick = 0; intDelay = 1000; // לעבור על הלוח ולהגדיר הכל ל- 0 עבור (int i = 0; i <= 15; i ++) {for (int ii = 0; ii <= 3; ii ++) {arrGame [ii] = 0; }}}

// מציג את התפריט הראשי במסכי ה- LCD

void title () {// לכתוב כותרת על מסך LCD ומקום לציון lcdRight.setCursor (0, 0); lcdRight.write ("אריחי פסנתר"); lcdRight.setCursor (0, 1); lcdRight.write ("ציון:"); // להמיר את הציון למחרוזת char strScore [3]; sprintf (strScore, "%d", intScore); // הציג ציון על LCD lcdRight.write (strScore); // הוסף את lcdRight.setCursor diffictuly (10, 1); if (intDiff == 0) {lcdRight.write ("קל"); } if (intDiff == 1) {lcdRight.write ("בינוני"); } if (intDiff == 2) {lcdRight.write ("קשה"); } // לחץ על מעט הוראה lcdLeft.setCursor (0, 0); lcdLeft.write ("הקש Enter"); lcdLeft.setCursor (0, 1); lcdLeft.write ("כדי להתחיל!"); }

// בודק את הכפתורים ומה לעשות עבורם כשהם מחוץ למשחק

void buttonsMenu () {// כאשר לוחצים על enter הפעל את המשחק ואפס את ערך הציון אם (intEnter == 1) {bolPlay = true; intScore = 0; playBoard (); drawBoard (); } // כאשר נלחץ על כפתור 3 הפעל אפשרות לאיתור באגים להדפסת הלוח בסדרה אם (intInput == 3) {if (bolSerialBoard == false) {Serial.println ("לוח סידורי פעיל"); bolSerialBoard = true; } else {Serial.println ("לוח סידורי מושבת"); bolSerialBoard = false; }}} // הגדר את מהירות המשחק לקושי קל אם (intInput == 0) {Serial.print ("המשחק מוגדר לקל ("); Serial.print (intGameSpeedEasy); Serial.println ("האצת ms)"); intDiff = 0; intGameSpeed = intGameSpeedEasy; } // הגדר את מהירות המשחק לקושי בינוני אם (intInput == 1) {Serial.print ("המשחק מוגדר לבינוני ("); Serial.print (intGameSpeedMedium); Serial.println ("האצת ms)"); intDiff = 1; intGameSpeed = intGameSpeedMedium; } // הגדר את מהירות המשחק לקושי קשה אם (intInput == 2) {Serial.print ("המשחק מוגדר לקשה ("); Serial.print (intGameSpeedHard); Serial.println ("האצת ms)"); intDiff = 2; intGameSpeed = intGameSpeedHard; }}

// בודק את הכפתורים ומה לעשות עבורם בזמן המשחק

void buttonsGame () {if (intInput! = 4) {// אם לוחצים על כפתור אם (bolTilePressed == false) {// רק אם bolTilePressed היא פעולת טריגר שגויה לבדיקת לחיצה על לחצן bolTilePressed = true; // ולאחר מכן הגדר bolTilePressed ל- true כדי לוודא שהוא לא מופעל במקרה int intLowestTile = 0; // להיות מוגדר לאריח עם האריח הנמוך ביותר int intcheckedTile = 15; // כדי לעקוב אחר אילו אריחים נבדקו בזמן (intLowestTile == 0) {// כל עוד הוא אינו מוגדר לשום דבר בדוק את האריחים עבור (int i = 0; i 100) {// כל עוד int העיכוב אינו נמוך מ- 100 intDelay = intDelay - 20; // קח מזה ערך}}} אחר {Serial.println ("לחצו על כפתור שגוי"); סוף המשחק(); // אחרת המשחק נגמר}}}}}

void gameOver () {

Serial.println ("המשחק נגמר!"); Serial.print ("הציון שלך היה:"); Serial.println (intScore); Serial.print ("המהירות שלך הייתה:"); Serial.println (intDelay); bolPlay = false; }

// בודק את קלט השחקן

קלט חלל () {intEnter = digitalRead (btnEnter); // קרא הזן // קרא איזו מבין התשומות האחרות, או אם אף אחת מהן אינה מוגדרת ל- 4 אם (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; }}}}} // סדרת הדפסה של הכניסות אם (intEnter == 1) {Serial.println ("Enter Pressed!");} if (intInput! = 4) {Serial.print ("Button Press:"); Serial.println (intInput); } אחר {// אם לא נלחץ על כפתור איפוס bolTilePressed bolTilePressed = false; }}

// בודק אם אין תחתית הלוח

void bottomCheck () {for (int i = 0; i <= 3; i ++) {// עבור 4 העמודות אם (arrGame [15] == 1) {// אם אריח נמצא בסידרה התחתונה.println ("אריח בתחתית"); arrGame [15] = 2; drawBoard (); עיכוב (400); arrGame [15] = 1; drawBoard (); עיכוב (400); arrGame [15] = 2; drawBoard (); עיכוב (400); arrGame [15] = 1; drawBoard (); עיכוב (400); סוף המשחק(); }}}

// מדפיס את הלוח לתוך הצג הסדרתי אם bolSerialBoard נכון

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

לאחר הזנת כל הקוד, העלה לארדואינו ותהנה!