Arduino - पियानो टाइलें: 16 कदम (चित्रों के साथ)

2024 लेखक: John Day | [email protected]. अंतिम बार संशोधित: 2024-01-30 09:22

नमस्कार इंटरनेट लोगों, यह इस बारे में होगा कि कैसे निश्चित रूप से एक arduino uno r3 पर मोबाइल गेम का चीर-फाड़ नहीं है।

तो शुरू करने के लिए, आपको सभी भागों की आवश्यकता होगी, जो इस प्रकार हैं! 1x Arduino Uno r3 ($42)

2x एलसीडी कीपैड शील्ड ($19 प्रत्येक)

5x बटन

5x 220Ω प्रतिरोधक

28x तार

ठीक है, एक बार जब आप सभी भागों को प्राप्त कर लेते हैं, तो यह आरंभ करने का समय है!

चरण 1: वायरिंग

आरेख में दिखाए गए अनुसार अपने arduino और दोस्तों को तार-तार करके शुरू करें, सुनिश्चित करें कि बटन सही तरीके से जुड़े हुए हैं, बटन रेल के ग्राउंड साइड पर A0-4 स्लॉट्स के साथ, या arduino इसके बजाय यह सोचेगा कि बटन केवल एक प्रेस के बजाय लगातार दबाए जा रहे हैं।

चरण 2: घोषणा विवरण

यहां सभी कोड आपके शून्य सेटअप और शून्य लूप से पहले जाना चाहिए, ऐसा इसलिए है क्योंकि इन सभी चर और वस्तुओं का उपयोग हमारे द्वारा स्थापित किए जाने वाले कई कार्यों में किया जाता है।

डालने से शुरू करें:

#शामिल

आपके कोड के शीर्ष पर, यह arduino को "LiquidCrystal.h" लाइब्रेरी और इसके एक भाग के कार्यों का उपयोग करने के लिए कह रहा है।

अगला कदम यह है कि इस कोड को हमारे #include के नीचे डालकर हम अपने बटनों के लिए उपयोग किए जा रहे पिन को परिभाषित करें:

#btnEnter A0 को परिभाषित करें#btn1 15 को परिभाषित करें #btn2 16 को परिभाषित करें #btn3 17 को परिभाषित करें #btn4 18 को परिभाषित करें

कोड को पढ़ने में आसान बनाने के लिए, या यदि आवश्यक हो तो बदलने के लिए हम btnEnter और btn1 से btn 4 शब्दों को परिभाषित करते हैं। इसका मतलब यह है कि जब हम btn1 टाइप करते हैं तो arduino को पता चल जाएगा कि वास्तव में हमारा मतलब बटन 15 है। हालाँकि हम पोर्ट पोर्ट 15, 16, 17 और 18 को कॉल कर रहे हैं, उन्हें arduino पर A1 A2 A3 और A4 के रूप में लेबल किया गया है, ऐसा इसलिए है क्योंकि वे विशेष रूप से एनालॉग इनपुट के लिए उपयोग किए जाने वाले पोर्ट हैं, हालांकि हम उनका उपयोग केवल डिजिटल इनपुट के लिए कर रहे हैं।

आगे हम ऐसे ऑब्जेक्ट बनाने जा रहे हैं जो लिक्विड क्रिस्टल डिस्प्ले को नियंत्रित करेंगे। ऐसा करने के लिए इस कोड को हमारी परिभाषाओं के नीचे रखें

लिक्विड क्रिस्टल एलसीडी लेफ्ट (8, 9, 12, 10, 11, 13); लिक्विड क्रिस्टल एलसीडी राइट (2, 3, 4, 5, 6, 7);

यह जो करता है वह आर्डिनो को बताता है कि जब हम LCDLeft या LCDRight को कॉल करते हैं तो हम लिक्विड क्रिस्टल ऑब्जेक्ट को रेफर कर रहे होते हैं। संलग्न कोष्ठकों में संख्याएं आर्डिनो को बताती हैं कि जब हम उनके कार्यों का उपयोग करते हैं तो एलसीडी को संदेश भेजने के लिए ऑब्जेक्ट को किस पोर्ट का उपयोग करना चाहिए।

अब हमें ऑब्जेक्ट डिक्लेरेशन के नीचे कोड का अगला बिट डालकर वेरिएबल घोषित करने की आवश्यकता है:

// ये वेरिएबल्स वे विकल्प हैं जिन्हें आप बदल सकते हैं - उच्च संख्या = तेज गेम स्पीड अपिंट intGameSpeedEasy = 10; int intGameSpeedMedium = 25; int intGameSpeedHard = ८०;

// gameboolean bolPlay के लिए चर सेट करें; // ट्रैक करता है कि खिलाड़ी int intScore; // खिलाड़ी के स्कोर int intDiff को ट्रैक करता है; // यह बताने के लिए कि खेल किस कठिनाई पर है // इनपुट int intEnter के लिए चर सेट करें; // ट्रैक करता है कि क्या उपयोगकर्ता एंटर बटन int intInput दबाता है; // ट्रैक करता है कि उपयोगकर्ता कौन से बटन दबाता है बूलियन bolTilePressed; // सुनिश्चित करें कि खिलाड़ी गलती से 5x बटन नहीं दबाता है और खो देता है // टर्न इंट इंट टिक के लिए चर सेट करें; // intDelay int intDelay तक मिली (प्रति लूप) की गणना करता है; // वह समय जब प्रोग्राम मिलिस इंट intGameSpeed में अगले मोड़ तक प्रतीक्षा करता है; // डिबग विकल्प बूलियन bolSerialBoard का abit; // जब सच सीरियल मॉनिटर में बोर्ड प्रिंट करेगा

हम डेटा प्रकार और फिर चर का नाम बताकर एक चर घोषित करते हैं, उदा। int thisIsAnInteger

बूलियन चर, जैसे कि bolSerialBoard और bolPlay में केवल दो में से एक मान हो सकता है, सही या गलत।

पूर्णांक चर (int) जैसे कि intScore और intInput पूर्ण संख्याओं को मान के रूप में ले सकते हैं, जैसे 1, 5 या 100।

कुछ अन्य उल्लेखनीय डेटा प्रकार जिनका हम यहां उपयोग नहीं कर रहे हैं, वे हैं एक स्ट्रिंग, जो टेक्स्ट का एक हिस्सा है, और एक फ्लोट, जो एक दशमलव संख्या है।

यहां प्रत्येक चर का उपयोग कार्यक्रम द्वारा कई अलग-अलग स्थानों में किया जाता है, यहां एक सारांश है कि प्रत्येक क्या करता है

bolPlay प्रोग्राम को बताता है कि क्या मेनू प्रदर्शित किया जाना चाहिए या यदि वास्तविक गेम चलना चाहिए।

जैसे ही वे टाइलें मारते हैं, इंटस्कोर खिलाड़ी के स्कोर को ट्रैक करता है, मुख्य मेनू पर intDiff का उपयोग प्रोग्राम को यह बताने के लिए किया जाता है कि LCD पर किस पाठ को प्रिंट करना है, intEnter का उपयोग प्रोग्राम को यह बताने के लिए किया जाता है कि क्या एंटर बटन (सबसे बाईं ओर) दबाया जाता है, intInput का उपयोग प्रोग्राम को यह बताने के लिए किया जाता है कि अन्य 4 बटनों में से कौन सा दबाया गया है।

bolTilePressed का उपयोग यह सुनिश्चित करने के लिए किया जाता है कि प्रोग्राम केवल तभी पढ़ता है जब बटन दबाया जाता है और जब इसे आयोजित किया जाता है।

intGameSpeed, intGameSpeedEasy, intGameSpeedMedium और intGameSpeedHard का उपयोग यह नियंत्रित करने के लिए किया जाता है कि किस कठिनाई के चयन के आधार पर गेम को कितनी जल्दी गति देनी चाहिए।

intTick और intDelay का उपयोग प्रोग्राम को हर बार लूप होने पर बोर्ड को हिलाने से रोकने के लिए किया जाता है।

bolSerialBoard का उपयोग आपको परीक्षण उद्देश्यों के लिए संख्याओं की एक श्रृंखला के रूप में प्रोग्राम को बोर्ड को arduino के सीरियल मॉनिटर पर भेजने की अनुमति देने के लिए किया जाता है।

अंत में इस कोड का उपयोग करके हमारे बोर्ड को एक सरणी के रूप में घोषित करने का समय आ गया है:

// सेट अप गेम ऐरेइंट एआरगेम [१६] [४] = { {०, ०, ०, ०}, {०, ०, ०, ०}, {०, ०, ०, ०}, {०, ०, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {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 = ८०;

// पिन को परिभाषित करें

#btnEnter A0 को परिभाषित करें #btn1 15 को परिभाषित करें #btn2 16 को परिभाषित करें #btn3 17 को परिभाषित करें #btn4 18 को परिभाषित करें

// LCD ऑब्जेक्ट बनाएं (n, ~, n, ~, ~, n)

लिक्विड क्रिस्टल एलसीडी लेफ्ट (8, 9, 12, 10, 11, 13); लिक्विड क्रिस्टल एलसीडीराइट (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}};

// खेल के लिए चर सेट करें

बूलियन बोलप्ले; // ट्रैक करता है कि खिलाड़ी int intScore; // खिलाड़ी के स्कोर int intDiff को ट्रैक करता है; // खेल किस कठिनाई पर है, यह बताने के लिए सिर्फ एक कलात्मक बात

// इनपुट के लिए चर सेट करें

इंट इंट एंटर; // ट्रैक करता है कि क्या उपयोगकर्ता एंटर बटन int intInput दबाता है; // ट्रैक करता है कि उपयोगकर्ता कौन से बटन दबाता है बूलियन bolTilePressed; // सुनिश्चित करें कि खिलाड़ी गलती से 5x बटन नहीं दबाता है और हार जाता है

// बारी के लिए चर सेट करें

इंट इंट टिक; // intDelay int intDelay तक मिली (प्रति लूप) की गणना करता है; // वह समय जब प्रोग्राम मिलिस इंट intGameSpeed में अगले मोड़ तक प्रतीक्षा करता है;

// डिबग विकल्पों में से एक

बूलियन बोलसीरियलबोर्ड; // जब सच सीरियल मॉनिटर में बोर्ड प्रिंट करेगा

चरण 3: सेटअप फ़ंक्शन

सेटअप लूप एक फंक्शन है जिसे arduino द्वारा केवल एक बार पढ़ा जाता है जब यह शुरू में शुरू होता है।

सेटअप लूप में हम केवल अपने कुछ वेरिएबल्स के मान सेट कर रहे हैं क्योंकि उन्हें घोषित करते समय उन्हें एक मान सेट करने के बजाय हम इसे यहां कर रहे हैं।

इस कोड को अपने Void Setup में डालकर शुरू करें।

बोलप्ले = झूठा; इंटस्कोर = 0; इंटटिक = 0; intDelay = १०००; इंटडिफ = 1; intGameSpeed = intGameSpeedMedium;

प्रत्येक पंक्ति केवल एक चर को एक मान पर सेट कर रही है।

bolPlay को गलत पर सेट किया गया है ताकि गेम खेलना शुरू न हो।

intScore 0 पर सेट है, क्योंकि स्वाभाविक रूप से आपका स्कोर 0 से शुरू होता है।

intTick 0 से शुरू होता है क्योंकि प्रोग्राम वर्तमान में कुछ भी नहीं गिन रहा है।

intDelay को 1000 पर सेट किया गया है क्योंकि यह वह दर है जिस पर टाइलें शुरू होती हैं।

intDiff सिर्फ एक तपस्वी चीज है ताकि कार्यक्रम को पता चले कि खेल की कठिनाई के लिए क्या लिखना है।

intGameSpeed जो भी intGameSpeedMedium है, उसे सेट किया गया है, जिसका अर्थ है कि यह मध्यम कठिनाई पर सेट है।

इसके बाद इस कोड को आपके द्वारा अभी डाले गए कोड के नीचे Void सेटअप में डालें।

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

सीरियल.बेगिन (९६००);

यह arduino को सीरियल मॉनिटर के माध्यम से कंप्यूटर के साथ संचार शुरू करने के लिए कहता है (arduino IDE के शीर्ष दाईं ओर स्थित बटन पर क्लिक करके दिखाई देता है)।

आपका Void सेटअप अब कुछ इस तरह दिखना चाहिए!

शून्य सेटअप () {Serial.begin (९६००); // सीरियल मॉनिटर शुरू करें // वेरिएबल सेट करें bolPlay = false; इंटस्कोर = 0; इंटटिक = 0; intDelay = १०००; इंटडिफ = 1; intGameSpeed = intGameSpeedMedium; // एलसीडी की LCDLeft.begin (16, 2) शुरू करें; LCDRight.begin (16, 2); }

चरण 4: लूप फ़ंक्शन

लूप फ़ंक्शन arduino द्वारा arduino के प्रत्येक पुनरावृत्ति द्वारा चलाया जाता है।

निम्नलिखित कोड को अपने Void लूप में कॉपी करें।

शून्य लूप () {इनपुट (); // इनपुट खेलने के लिए जांचें अगर (bolPlay == true) {if (intTick> = intDelay) {// यह देखने के लिए जांचें कि क्या गेम को एक मोड़ खेलना चाहिए या Serial.println ("~~~~~~~ इंतजार करना जारी रखना चाहिए) ~~");///राइटसेरियल () पर चलने वाले बोर्ड को इंगित करने के लिए प्रिंट करें; // यदि विकल्प सक्षम है तो बोर्ड को सीरियल बटन गेम () में लिखें; // प्लेयर इनपुट प्लेबोर्ड के लिए जांचें (); // बोर्ड को स्थानांतरित करें और एक नई टाइल जोड़ें clearLcd (); // ड्रॉबोर्ड () खींचने से पहले एलसीडी को साफ करें; // बोर्ड को एलसीडी के बॉटमचेक पर ड्रा करें (); इंटटिक = 0; // रीसेट इंट टिक} और {बटनगेम (); // खिलाड़ी इनपुट के लिए जाँच करें clearLcd (); // ड्रॉबोर्ड () खींचने से पहले एलसीडी को साफ करें; // बोर्ड को LCD के intTick = intTick + intGameSpeed पर ड्रा करें; // टिक करने के लिए जोड़ें}} और {clearLcd (); // शीर्षक बनाने से पहले एलसीडी को साफ करें (); // शीर्षक और स्कोर जानकारी बटन प्रदर्शित करेंमेनू (); // प्लेयर इनपुट क्लियरबोर्ड पढ़ें (); // पूरे बोर्ड को सुनिश्चित करें = 0} देरी (10); // आर्डिनो को थोड़े समय के लिए विलंबित करें}

जब bolPlay सत्य के बराबर होता है, तो इसका मतलब है कि खेल चल रहा है, और जब खेल चल रहा है तो सभी कोड चलाना चाहिए, लेकिन हम केवल बोर्ड को एक नई टाइल जोड़ना चाहते हैं और नीचे चले जाते हैं जब intTick हमारे intDelay से अधिक होता है, अन्यथा हम अभी भी उपयोगकर्ता को एक टाइल हिट करने के लिए एक बटन दबाने और गति में वृद्धि करने के लिए intTick की अनुमति देना चाहते हैं।

इस कोड में से अधिकांश उन कार्यों का उपयोग करते हैं जिन्हें हमने अभी तक नहीं बनाया है, और हम उन्हें अगले चरणों में बनाएंगे। इन कार्यों का उद्देश्य इस प्रकार है।

इनपुट पढ़ता है कि उपयोगकर्ता ने कौन से बटन दबाए हैं।

बटनगेम नियंत्रित करता है कि खेल में बटन क्या करते हैं, न कि मेनू में

playBoard बोर्ड में एक नई टाइल जोड़ता है, और फिर बोर्ड की सभी चीज़ों को एक स्थान पर नीचे ले जाता है

clearLCD यह सुनिश्चित करने के लिए LCDs को साफ करता है कि टाइल्स के पीछे कोई भूत नहीं बचा है

drawBoard arrGame के माध्यम से जाता है और इसे LCDs पर प्रिंट करता है

जब खेल खेल में न हो तो clearBoard पूरे arrGame को साफ़ कर देता है

बॉटमचेक विफलता की स्थिति के लिए arrGame के निचले भाग की जाँच करता है

शीर्षक मेनू पर होने पर खेल का शीर्षक और स्कोर जानकारी प्रदर्शित करता है

बटन मेनू नियंत्रित करता है कि मेनू में उपयोगकर्ता के इनपुट क्या करते हैं।

गेमओवर एक अन्य फ़ंक्शन है, हालांकि इसे यहां नहीं कहा जाता है क्योंकि इसे इसके बजाय बॉटमचेक और बटनगेम फ़ंक्शन में कहा जाता है।

चरण 5: ClearLCD फ़ंक्शन

एक फ़ंक्शन बनाने के लिए हम इसे कोड में जोड़कर शुरू करते हैं

शून्य फ़ंक्शननाम () {

}

"फ़ंक्शननाम" कुछ भी हो सकता है, जब तक कि यह पहले से मौजूद न हो।

इस कोड को अपने प्रोग्राम में कॉपी करें:

void clearLcd() { के लिए (int i = 0; i <= 15; i++){ for (int ii = 0; ii <= 1; ii++){ LCDLeft.setCursor(i, ii); LCDLeft.लिखें (""); LCDRight.setCursor (i, ii); LCDRight.लिखें (""); } } }

यह एलसीडी पर प्रत्येक बिंदु के माध्यम से जाने और एक जगह लिखने के लिए 2 गिनती लूप का उपयोग करके पूरे सरणी के माध्यम से चलता है।

कुछ भी रीसेट किए बिना एलसीडी जो कुछ भी पहले लिखा गया था उसे बनाए रखेगा

चरण 6: ड्राबोर्ड फ़ंक्शन

इस कोड को अपने प्रोग्राम में कॉपी करें

शून्य ड्रॉबोर्ड () {के लिए (int i = 1; i <= 15; i ++) {// बाएं एलसीडी पर कॉलम 1 और 2 ड्रा करें // यदि टाइल = 0 कुछ भी नहीं लिखें, = 1 "#", = 2 लिखें "@" लिखें LCDLeft.setCursor(i, 1); // पहले कॉलम पर सेट करें (सबसे दूर बाएं) अगर (arrGame[0] == 1) {lcdLeft.write("#");} if (arrGame[0] == 2) {lcdLeft.लिखें ("@");} LCDLeft.setCursor(i, 0); // दूसरे कॉलम पर सेट करें (बीच में बाएं) अगर (arrGame[1] == 1) {lcdLeft.write("#");} if (arrGame[1] == 2) {lcdLeft.लिखें ("@");} LCDRight.setCursor(i, 1); // तीसरे कॉलम (केंद्र दाएं) पर सेट करें यदि (arrGame[2] == 1) {lcdRight.write("#");} if (arrGame[2] == 2) {lcdRight.लिखें ("@");} LCDRight.setCursor(i, 0); // चौथे कॉलम पर सेट करें (सबसे दूर दाईं ओर) अगर (arrGame[3] == 1) {lcdRight.write("#");} if (arrGame[3] == 2) {lcdRight ।लिखो("@");} } }

यह बोर्ड की प्रत्येक पंक्ति के माध्यम से जाने के लिए एक लूप का उपयोग करता है, फिर यह देखने के लिए जांच करता है कि पंक्ति में कोई कॉलम 1 या 2 के बराबर है या नहीं, इसके आधार पर यह एलसीडी पर या तो एक हैशटैग प्रिंट करता है, एक टाइल के लिए अभी तक हिट, या एक हिट टाइल के लिए @।

चरण 7: प्लेबोर्ड फ़ंक्शन

इस कोड को अपने प्रोग्राम में कॉपी करें।

शून्य प्लेबोर्ड () {के लिए (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 तक उलटे गिनते हुए लूप से गुजरता है, पंक्ति को उसके ऊपर की पंक्ति के बराबर सेट करता है, जिससे बोर्ड एलसीडी को नीचे ले जाता है

चरण 8: क्लियरबोर्ड फ़ंक्शन

इस कोड को अपने प्रोग्राम में कॉपी करें।

शून्य क्लियरबोर्ड () {// रीसेट टिक और विलंब मान intTick = 0; intDelay = १०००; // बोर्ड के माध्यम से जाएं और सब कुछ 0 के लिए सेट करें (int i = 0; i <= 15; i++){ के लिए (int ii = 0; ii <= 3; ii++){ arrGame[ii] = 0; } } }

यह कोड तब चलाया जाता है जब यह सुनिश्चित करने के लिए गेम नहीं चल रहा है कि संपूर्ण arrGame 0 पर सेट है, या कोई टाइल नहीं है, सरणी के माध्यम से जाने के लिए गिने हुए लूप का उपयोग करके।

कोड intDelay और intTick के मानों को भी रीसेट करता है।

चरण 9: शीर्षक समारोह

निम्नलिखित कोड को अपने प्रोग्राम में कॉपी करें

शून्य शीर्षक () {// एलसीडी पर शीर्षक लिखें और स्कोर के लिए स्थान LCDRight.setCursor (0, 0); LCDRight.write ("पियानो टाइलें"); LCDRight.setCursor (0, 1); LCDRight.write ("स्कोर:"); // स्कोर को एक स्ट्रिंग चार strScore [3] में बदलें; स्प्रिंटफ (स्ट्रस्कोर, "% डी", इंटस्कोर); // LCD LCDRight.write (strScore) पर स्कोर प्रदर्शित करें; // मुश्किल से LCDRight.setCursor(10, 1) जोड़ें; अगर (intDiff == 0) {lcdRight.write("Easy"); } अगर (intDiff == 1){lcdRight.write("Medium"); } अगर (intDiff == 2){lcdRight.write("Hard"); } // थोड़ा सा निर्देश दबाएं LCDLeft.setCursor(0, 0); LCDLeft.write ("एंटर दबाएं"); LCDLeft.setCursor(0, 1); LCDLeft.write ("शुरू करने के लिए!"); }

यह कोड एलसीडी पर खेल का शीर्षक और स्कोर लिखता है, यह एलसीडी को यह बताकर करता है कि LCD.setCursor का उपयोग करके टाइपिंग कहां से शुरू करें और फिर LCD.write में स्ट्रिंग लिखें।

यहां एक नया वेरिएबल भी बनाया गया है, strScore, इसका उपयोग sprintf फ़ंक्शन का उपयोग करके intScore को एक स्ट्रिंग या चार डेटा प्रकार में बदलने के लिए किया जाता है।

intDiff का उपयोग यहां भी किया जाता है, इसके मूल्यों के आधार पर यह विभिन्न कठिनाई विकल्पों को प्रिंट करता है।

चरण 10: बटनमेनू फ़ंक्शन

अपने प्रोग्राम में निम्न कोड डालें

शून्य बटनमेनू () {// जब एंटर दबाया जाता है तो खेल शुरू करें और स्कोर मान को रीसेट करें यदि (इंट एंटर == 1) {बोलप्ले = सच; इंटस्कोर = 0; प्लेबोर्ड (); ड्राबोर्ड (); } // जब बटन 3 दबाया जाता है तो सीरियल में बोर्ड को प्रिंट करने के डिबग विकल्प को चालू करें यदि (intInput == 3){ if (bolSerialBoard == false){ Serial.println("Serial Board Active"); बोलसेरियलबोर्ड = सच; } और { Serial.println ("सीरियल बोर्ड अक्षम"); बोलसेरियलबोर्ड = झूठा; } } // खेल की गति को आसान कठिनाई पर सेट करें यदि (intInput == 0){ Serial.print("Game set to Easy ("); Serial.print(intGameSpeedEasy); Serial.println ("ms त्वरण)"); इंटडिफ = 0; intGameSpeed = intGameSpeedEasy;) इंटडिफ = 1; intGameSpeed = intGameSpeedMedium;) इंटडिफ = 2; intGameSpeed = intGameSpeedHard; } }

यह कोड केवल तभी चलाया जाता है जब bolPlay शून्य लूप में असत्य के बराबर हो

यदि intEnter 1 पर सेट है तो इसका मतलब है कि एंटर बटन को धक्का दिया गया है, अगर इसे दबाया जा रहा है तो प्रोग्राम bolPlay को सही पर सेट करता है और गेम शुरू होता है।

प्रोग्राम तब पढ़ता है कि intInput किसके बराबर है। यदि यह 0 के बराबर है तो बाईं ओर से पहला बटन दबाया जा रहा है, दाईं ओर 3 तक जा रहा है। यदि intInput 4 के बराबर है तो कोई बटन नहीं दबाया जा रहा है।

यदि बटन 0-2 दबाए जाते हैं तो खेल कठिनाई को बदल देता है, खेल की गति मान को भी समायोजित करता है, जिसका अर्थ है कि यह तेजी से गति करेगा।

यदि बटन 3 दबाया जाता है तो गेम डिबग मोड को सक्रिय या निष्क्रिय कर देगा जहां कार्यक्रम में मुद्दों को खोजने में सहायता के लिए सीरियल मॉनिटर में पूरा बोर्ड मुद्रित होता है।

चरण 11: बटन गेम फ़ंक्शन

निम्नलिखित कोड को अपने प्रोग्राम में कॉपी करें

शून्य बटनगेम () { अगर (intInput! = 4) {// यदि एक बटन दबाया जाता है अगर (bolTilePressed == false) {// केवल अगर bolTilePressed एक बटन प्रेस की जाँच के लिए झूठी ट्रिगर क्रिया है bolTilePressed = true; // फिर यह सुनिश्चित करने के लिए bolTilePressed को सही पर सेट करें कि यह फिर से शुरू नहीं हुआ है int intLowestTile = 0; // सबसे कम टाइल वाली टाइल पर सेट किया जाना है int intcheckedTile = 15; // इस बात पर नज़र रखने के लिए कि किन टाइलों की जाँच की गई है (intLowestTile == 0) {// जब तक कि यह किसी भी चीज़ पर सेट नहीं है (int i = 0; i 100) के लिए टाइलों की जाँच करें {// जब तक int देरी 100 से कम नहीं है intDelay = intDelay - 20; // इससे एक मान लें}} और { Serial.println ("गलत बटन दबाया गया"); खेल खत्म(); //अन्यथा खेल खत्म } } } } }

कोड केवल तभी चलाया जाता है जब शून्य लूप में बोलप्ले सत्य के बराबर होता है।

इंटइनपुट के मूल्य के आधार पर बटनमेनू की तरह यह देखने के लिए जांच करता है कि खिलाड़ी ने टाइल मारा है या चूक गया है।

यह नीचे से ऊपर तक arrGame के माध्यम से थोड़ी देर के लूप का उपयोग करके यह देखने के लिए करता है कि कौन सी पंक्ति एक अनहिट टाइल के साथ सबसे कम है। इसके बाद यह देखने के लिए जांच करता है कि पुश किए गए बटन के अनुरूप उस पंक्ति में स्पॉट एक अनहिट टाइल है या नहीं, अगर यह अनहिट है तो इसे 1 के बजाय 2 के बराबर सेट करता है, जिसका अर्थ है कि यह @ के रूप में प्रदर्शित होगा, अन्यथा यह गेमओवर को ट्रिगर करता है फ़ंक्शन जिसे हमें अभी बनाना है।

जब कोई बटन दबाया जाता है तो यह फ़ंक्शन bolTilePressed चर को सही पर सेट करके और कोई बटन दबाए जाने पर गलत का उपयोग करता है। यह सुनिश्चित करने के लिए है कि उपयोगकर्ता गलती से गेम को नहीं खोता है क्योंकि प्रोग्राम ने सोचा था कि जब उन्होंने इसे दबाए रखा तो उन्होंने कई बार बटन दबाया।

चरण 12: गेमओवर फ़ंक्शन

निम्नलिखित कोड को अपने प्रोग्राम में कॉपी करें

शून्य गेमओवर () {Serial.println ("गेम ओवर!"); Serial.print ("आपका स्कोर था:"); सीरियल.प्रिंट्लन (इंटस्कोर); Serial.print ("आपकी गति थी:"); Serial.println (intDelay); बोलप्ले = झूठा; }

यह या तो चेकबॉटम या बटनगेम फ़ंक्शन द्वारा ट्रिगर किया जाता है और बोलप्ले को गलत पर सेट करके गेम के अंत को ट्रिगर करता है।

यह उपयोगकर्ताओं के स्कोर के लिए सीरियल मॉनिटर में एक संदेश भी प्रिंट करता है और गति टाइलें मिलीसेकंड में जोड़ दी जाती हैं।

चरण 13: इनपुट फ़ंक्शन

निम्नलिखित कोड को अपने प्रोग्राम में कॉपी करें।

शून्य इनपुट () { intEnter = digitalRead (btnEnter); // पढ़ें दर्ज करें 1;} और {अगर (डिजिटल रीड (बीटीएन 3) == हाई) {इंट इनपुट = 2;} और {अगर (डिजिटल रीड (बीटीएन 4) == हाई) {इंट इनपुट = 3;} और {इंट इनपुट = 4; }}}} // सीरियल इनपुट प्रिंट करें अगर (intEnter == 1){Serial.println("Enter Pressed!");} if (intInput != 4){ Serial.print("Button Press:"); Serial.println (intInput); } और {// यदि कोई बटन दबाया नहीं जाता है तो रीसेट करें bolTilePressed bolTilePressed = false; } }

इस कोड का उपयोग बटन गेम और बटनमेनू फ़ंक्शन के साथ किया जाता है। उपयोगकर्ता द्वारा दबाए गए बटनों के आधार पर यह intInput का मान सेट करता है, या यदि कोई बटन दबाया नहीं जाता है तो यह intInput को बराबर 4 पर सेट करता है।

यदि कोई बटन नहीं दबाया जाता है तो यह वह जगह है जहां bolTilePressed को बटनगेम फ़ंक्शन के लिए रीसेट किया जाता है।

यह सीरियल मॉनीटर को एक संदेश भी प्रिंट करता है जिस पर बटन दबाया जाता है।

चरण 14: बॉटमचेक फंक्शन

निम्नलिखित कोड को अपने प्रोग्राम में कॉपी करें।

शून्य बॉटमचेक () { के लिए (int i = 0; i <= 3; i ++) {// 4 कॉलम के लिए अगर (arrGame [15] == 1) {// यदि एक टाइल नीचे सीरियल में है.println ("नीचे टाइल"); एआरगेम[15] = 2; ड्राबोर्ड (); देरी (400); एआरगेम [१५] = १; ड्राबोर्ड (); देरी (400); एआरगेम[15] = 2; ड्राबोर्ड (); देरी (400); एआर गेम [१५] = १; ड्राबोर्ड (); देरी (400); खेल खत्म(); } } }

एक लूप का उपयोग करके यह कोड किसी भी अनहिट टाइल (1 के बराबर टाइल) के लिए arrGame की निचली पंक्ति की जांच करता है, अगर स्क्रीन के नीचे एक अनहिट टाइल है तो यह टाइल को फ्लैश करेगा और फिर गेम को फ़ंक्शन पर ट्रिगर करेगा।

चरण 15: राइटसेरियल फंक्शन

निम्नलिखित कोड को अपने प्रोग्राम में कॉपी करें

शून्य लिखना सीरियल () { अगर (बोलसेरियल बोर्ड == सच) {के लिए (इंट आई = 0; आई <= 15; आई ++) {के लिए (इंट ii = 0; ii <= 3; ii ++) {सीरियल प्रिंट (एआरगेम) [मैं] [द्वितीय]); सीरियल.प्रिंट ("", "); } सीरियल.प्रिंट्लन (""); } } }

यह डिबग विकल्प द्वारा पीछा किया जाने वाला फ़ंक्शन है जिसे बटनमेनू फ़ंक्शन में सक्षम किया जा सकता है। यदि उस फ़ंक्शन में bolSerialBoard सत्य पर सेट है, तो यह arrGame से गुजरेगा और एक सरणी का उपयोग करके परीक्षण उद्देश्यों के लिए पूरे बोर्ड को सीरियल मॉनिटर में प्रिंट करेगा।

चरण 16: समापन

आपका पूरा कोड पूरा नहीं होना चाहिए और कुछ इस तरह दिखना चाहिए!

/* *नाम - पियानो टाइलें; Arduino * By - Domenic Marulli * Date - 11/*

/ पुस्तकालय शामिल करें

#शामिल

// ये चर विकल्प हैं जिन्हें आप बदल सकते हैं - उच्च संख्या = तेज खेल गति

int intGameSpeedEasy = 10; int intGameSpeedMedium = 25; int intGameSpeedHard = ८०;

// पिन को परिभाषित करें

#btnEnter A0 को परिभाषित करें #btn1 15 को परिभाषित करें #btn2 16 को परिभाषित करें #btn3 17 को परिभाषित करें #btn4 18 को परिभाषित करें

// LCD ऑब्जेक्ट बनाएं (n, ~, n, ~, ~, n)

लिक्विड क्रिस्टल एलसीडी लेफ्ट (8, 9, 12, 10, 11, 13); लिक्विड क्रिस्टल एलसीडीराइट (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}};

// खेल के लिए चर सेट करें

बूलियन बोलप्ले; // ट्रैक करता है कि खिलाड़ी int intScore; // खिलाड़ी के स्कोर int intDiff को ट्रैक करता है; // खेल किस कठिनाई पर है, यह बताने के लिए सिर्फ एक कलात्मक बात

// इनपुट के लिए चर सेट करें

इंट इंट एंटर; // ट्रैक करता है कि क्या उपयोगकर्ता एंटर बटन int intInput दबाता है; // ट्रैक करता है कि उपयोगकर्ता कौन से बटन दबाता है बूलियन bolTilePressed; // सुनिश्चित करें कि खिलाड़ी गलती से 5x बटन नहीं दबाता है और हार जाता है

// बारी के लिए चर सेट करें

इंट इंट टिक; // intDelay int intDelay तक मिली (प्रति लूप) की गणना करता है; // वह समय जब प्रोग्राम मिलिस इंट intGameSpeed में अगले मोड़ तक प्रतीक्षा करता है;

// डिबग विकल्पों में से एक

बूलियन बोलसीरियलबोर्ड; // जब सच सीरियल मॉनिटर में बोर्ड प्रिंट करेगा

// सेटअप जो एक बार चलाया जाएगा

शून्य सेटअप () {Serial.begin (९६००); // सीरियल मॉनिटर शुरू करें // वेरिएबल सेट करें bolPlay = false; इंटस्कोर = 0; इंटटिक = 0; intDelay = १०००; इंटडिफ = 1; intGameSpeed = intGameSpeedMedium; // एलसीडी की LCDLeft.begin (16, 2) शुरू करें; LCDRight.begin (16, 2); }

// लूप जो हर 10 मिलीसेकंड पर चलाया जाएगा

शून्य लूप () {इनपुट (); // इनपुट खेलने के लिए जांचें अगर (bolPlay == true) {if (intTick> = intDelay) {// यह देखने के लिए जांचें कि क्या गेम को एक मोड़ खेलना चाहिए या Serial.println ("~~~~~~~ इंतजार करना जारी रखना चाहिए) ~~");///राइटसेरियल () पर चलने वाले बोर्ड को इंगित करने के लिए प्रिंट करें; // यदि विकल्प सक्षम है तो बोर्ड को सीरियल बटन गेम () में लिखें; // प्लेयर इनपुट प्लेबोर्ड के लिए जांचें (); // बोर्ड को स्थानांतरित करें और एक नई टाइल जोड़ें clearLcd (); // ड्रॉबोर्ड () खींचने से पहले एलसीडी को साफ करें; // बोर्ड को एलसीडी के बॉटमचेक पर ड्रा करें (); इंटटिक = 0; // रीसेट इंट टिक} और {बटनगेम (); // खिलाड़ी इनपुट के लिए जाँच करें clearLcd (); // ड्रॉबोर्ड () खींचने से पहले एलसीडी को साफ करें; // बोर्ड को LCD के intTick = intTick + intGameSpeed पर ड्रा करें; // टिक करने के लिए जोड़ें}} और {clearLcd (); // शीर्षक बनाने से पहले एलसीडी को साफ करें (); // शीर्षक और स्कोर जानकारी बटन प्रदर्शित करेंमेनू (); // प्लेयर इनपुट क्लियरबोर्ड पढ़ें (); // पूरे बोर्ड को सुनिश्चित करें = 0} देरी (10); // आर्डिनो को थोड़े समय के लिए विलंबित करें}

// एलसीडी को साफ करता है, इसलिए कोई भी गैर-प्रविष्ट सेल वहां नहीं छोड़ा जाता है

void clearLcd() { के लिए (int i = 0; i <= 15; i++){ for (int ii = 0; ii <= 1; ii++){ LCDLeft.setCursor(i, ii); LCDLeft.लिखें (""); LCDRight.setCursor (i, ii); LCDRight.लिखें (""); } } }

// बोर्ड को एलसीडी पर खींचता है

शून्य ड्रॉबोर्ड () {के लिए (int i = 1; i <= 15; i ++) {// बाएं एलसीडी पर कॉलम 1 और 2 ड्रा करें // यदि टाइल = 0 कुछ भी नहीं लिखें, = 1 "#", = 2 लिखें "@" लिखें LCDLeft.setCursor(i, 1); // पहले कॉलम पर सेट करें (सबसे दूर बाएं) अगर (arrGame[0] == 1) {lcdLeft.write("#");} if (arrGame[0] == 2) {lcdLeft.लिखें ("@");} LCDLeft.setCursor(i, 0); // दूसरे कॉलम पर सेट करें (बीच में बाएं) अगर (arrGame[1] == 1) {lcdLeft.write("#");} if (arrGame[1] == 2) {lcdLeft.लिखें ("@");} LCDRight.setCursor(i, 1); // तीसरे कॉलम (केंद्र दाएं) पर सेट करें यदि (arrGame[2] == 1) {lcdRight.write("#");} if (arrGame[2] == 2) {lcdRight.लिखें ("@");} LCDRight.setCursor(i, 0); // चौथे कॉलम पर सेट करें (सबसे दूर दाईं ओर) अगर (arrGame[3] == 1) {lcdRight.write("#");} if (arrGame[3] == 2) {lcdRight ।लिखो("@");} } }

// बोर्ड को नीचे ले जाता है और एक टाइल होने के लिए एक यादृच्छिक मान रखता है

शून्य प्लेबोर्ड () {के लिए (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 पर सेट करता है और चर को प्रीगेम में रीसेट करता है

शून्य क्लियरबोर्ड () {// रीसेट टिक और विलंब मान intTick = 0; intDelay = १०००; // बोर्ड के माध्यम से जाएं और सब कुछ 0 के लिए सेट करें (int i = 0; i <= 15; i++){ के लिए (int ii = 0; ii <= 3; ii++){ arrGame[ii] = 0; } } }

// एलसीडी पर मुख्य मेनू प्रदर्शित करता है

शून्य शीर्षक () {// एलसीडी पर शीर्षक लिखें और स्कोर के लिए स्थान LCDRight.setCursor (0, 0); LCDRight.write ("पियानो टाइलें"); LCDRight.setCursor (0, 1); LCDRight.write ("स्कोर:"); // स्कोर को एक स्ट्रिंग चार strScore [3] में बदलें; स्प्रिंटफ (स्ट्रस्कोर, "% डी", इंटस्कोर); // LCD LCDRight.write (strScore) पर स्कोर प्रदर्शित करें; // मुश्किल से LCDRight.setCursor(10, 1) जोड़ें; अगर (intDiff == 0) {lcdRight.write("Easy"); } अगर (intDiff == 1){lcdRight.write("Medium"); } अगर (intDiff == 2){lcdRight.write("Hard"); } // थोड़ा सा निर्देश दबाएं LCDLeft.setCursor(0, 0); LCDLeft.write ("एंटर दबाएं"); LCDLeft.setCursor(0, 1); LCDLeft.write ("शुरू करने के लिए!"); }

// बटन की जाँच करता है और खेल से बाहर होने पर उनके लिए क्या करना है

शून्य बटनमेनू () {// जब एंटर दबाया जाता है तो खेल शुरू करें और स्कोर मान को रीसेट करें यदि (इंट एंटर == 1) {बोलप्ले = सच; इंटस्कोर = 0; प्लेबोर्ड (); ड्राबोर्ड (); } // जब बटन 3 दबाया जाता है तो सीरियल में बोर्ड को प्रिंट करने के डिबग विकल्प को चालू करें यदि (intInput == 3){ if (bolSerialBoard == false){ Serial.println("Serial Board Active"); बोलसेरियलबोर्ड = सच; } और { Serial.println ("सीरियल बोर्ड अक्षम"); बोलसेरियलबोर्ड = झूठा; } } // खेल की गति को आसान कठिनाई पर सेट करें यदि (intInput == 0){ Serial.print("Game set to Easy ("); Serial.print(intGameSpeedEasy); Serial.println ("ms त्वरण)"); इंटडिफ = 0; intGameSpeed = intGameSpeedEasy;) इंटडिफ = 1; intGameSpeed = intGameSpeedMedium;) इंटडिफ = 2; intGameSpeed = intGameSpeedHard; } }

// बटन की जाँच करता है और खेल में रहते हुए उनके लिए क्या करना है

शून्य बटन गेम () { अगर (intInput! = 4) {// यदि एक बटन दबाया जाता है अगर (bolTilePressed == false) {// केवल अगर bolTilePressed एक बटन प्रेस की जाँच के लिए झूठी ट्रिगर क्रिया है bolTilePressed = true; // फिर यह सुनिश्चित करने के लिए bolTilePressed को सही पर सेट करें कि यह फिर से शुरू नहीं हुआ है int intLowestTile = 0; // सबसे कम टाइल वाली टाइल पर सेट करने के लिए int intcheckedTile = 15; // इस बात पर नज़र रखने के लिए कि किन टाइलों की जाँच की गई है (intLowestTile == 0) {// जब तक कि यह किसी भी चीज़ पर सेट नहीं है (int i = 0; i 100) के लिए टाइलों की जाँच करें {// जब तक int देरी 100 से कम नहीं है intDelay = intDelay - 20; // इससे एक मान लें}} और { Serial.println ("गलत बटन दबाया गया"); खेल खत्म(); //अन्यथा खेल खत्म } } } } }

शून्य गेमओवर () {

Serial.println ("गेम ओवर!"); Serial.print ("आपका स्कोर था:"); सीरियल.प्रिंट्लन (इंटस्कोर); Serial.print ("आपकी गति थी:"); Serial.println (intDelay); बोलप्ले = झूठा; }

// खिलाड़ी इनपुट के लिए जाँच करता है

शून्य इनपुट () { intEnter = digitalRead (btnEnter); // पढ़ें दर्ज करें 1;} और {अगर (डिजिटल रीड (बीटीएन 3) == हाई) {इंट इनपुट = 2;} और {अगर (डिजिटल रीड (बीटीएन 4) == हाई) {इंट इनपुट = 3;} और {इंट इनपुट = 4; }}}} // सीरियल इनपुट प्रिंट करें अगर (intEnter == 1){Serial.println("Enter Pressed!");} if (intInput != 4){ Serial.print("Button Press:"); Serial.println (intInput); } और {// यदि कोई बटन दबाया नहीं जाता है तो रीसेट करें bolTilePressed bolTilePressed = false; } }

// विफलता के लिए बोर्ड के नीचे की जाँच करें

शून्य बॉटमचेक () { के लिए (int i = 0; i <= 3; i ++) {// 4 कॉलम के लिए अगर (arrGame [15] == 1) {// यदि एक टाइल नीचे सीरियल में है.println ("नीचे टाइल"); एआरगेम[15] = 2; ड्राबोर्ड (); देरी (400); एआरगेम [१५] = १; ड्राबोर्ड (); देरी (400); एआरगेम[15] = 2; ड्राबोर्ड (); देरी (400); एआरगेम [१५] = १; ड्राबोर्ड (); देरी (400); खेल खत्म(); } } }

// यदि bolSerialBoard सत्य है तो बोर्ड को सीरियल मॉनिटर में प्रिंट करता है

शून्य लिखना सीरियल () { अगर (बोलसेरियलबोर्ड == सच) {के लिए (इंट आई = 0; आई <= 15; आई ++) {के लिए (इंट ii = 0; ii <= 3; ii ++) {सीरियल प्रिंट (एआरगेम) [मैं] [द्वितीय]); सीरियल.प्रिंट ("", "); } सीरियल.प्रिंट्लन (""); } } }

एक बार सभी कोड दर्ज हो जाने के बाद, अपने arduino पर अपलोड करें और आनंद लें!