यही हमें प्राप्त करना है, ठीक है, वह अभी भी जानता है कि उस पर हमला करने वाले दुष्ट कैक्टि को कैसे कूदना, चलना और पीटना है, लेकिन हम इस कदम से कदम उठाएंगे :)

भाग # 1 मूल बातें

मैंने अपने आप को एक आर्डिनो, "एक खिलौना तो" का आदेश दिया, मैंने सोचा, एक छोटी किट (परीक्षण के लिए), जिसे बाद में मुझे पछतावा हुआ। मैं क्षमता को प्राप्त करना चाहता था, लेकिन अतिरिक्त मॉड्यूल की कमी के कारण यह काम नहीं कर रहा था, मुझे प्रयोग करना पड़ा, सुरक्षा प्रणाली के लिए आर्डिनो को काट दिया और देखा कि सेंसर ने अपना काम कैसे किया, फिर एक ऑडियो अलार्म बनाने का फैसला किया (किट से व्यावहारिक स्क्वीकर का उपयोग करके), इसलिए कुत्तों को ज़ोर से या ज़ोर से हटा दिया। अचानक भौंकना :) और फिर मेरे हाथ प्रदर्शन 1602 तक पहुंच गए। "हम्म ... यह एक वास्तविक प्रदर्शन है," मैंने सोचा, लेकिन मुझे यह पता लगाने में निराशा हुई कि वह आर्डिनो पर लगभग सभी संपर्कों का लगभग आधा खाता है। मैंने चारों ओर अफवाह फैला दी और "i2C" किट में एक अजीब बोर्ड मिला और यह बहुत ही संदिग्ध था! कि छेद की संख्या प्रदर्शन पर पिंप की संख्या के साथ मेल खाती है। "हम्म, आसान नहीं ..." मैंने सोचा, और उन्हें मिलाप करने का फैसला किया। थोड़ी देर बाद, मुझे एहसास हुआ कि मैंने सही काम किया है और अब मेरा प्रदर्शन केवल दो चैनल खाता है। उन्होंने अध्ययन करना शुरू किया कि यह किस तरह का प्रदर्शन था और वे क्या कर सकते थे। पर्याप्त सामग्री का अध्ययन करने के बाद, मुझे पता चला कि प्रदर्शन पूरी तरह से शाब्दिक है, लेकिन लो और निहारना! यह 5x8 पिक्सल के आयामों के साथ 8 नए पात्रों को संभाल सकता है। तो ठीक है, चलो एक खेल लिखना शुरू करें! सबसे पहले, आपको यह पता लगाने की जरूरत है कि यह किस तरह का खेल होगा, मैंने इसे एक डायनासोर गार्ड क्रोम की तरह बनाने का फैसला किया, लेकिन कुछ चिप्स के साथ, इसलिए बोलने के लिए, शुरुआत के लिए, मुझे लगता है कि यह काम होगा :) लेकिन आपको अभी भी कुछ प्रबंधित करना है, और मल्टी-बटन, लंबे समय तक सोचने की ज़रूरत नहीं है। मैंने किट से IR रिमोट कंट्रोल लिया।



"यह जॉयस्टिक है," मैं अपनी सांस के तहत संदिग्ध रूप से विकृत हो गया, रिमोट कंट्रोल से देरी के बारे में सोच रहा था, आईआर सेंसर की स्पष्टता, और आमतौर पर इस विचार की पर्याप्तता के बारे में, लेकिन ऐसा करने के लिए कुछ भी नहीं था, मैं कंप्यूटर के लिए कीबोर्ड के साथ काम करने के लिए आर्टिनो को प्रशिक्षित कर सकता था, लेकिन यह वास्तव में आलस्य था। करने के लिए। इसलिए मैंने रिमोट कंट्रोल कोड लिखना शुरू किया, ताकि मैं भविष्य में उनके साथ काम कर सकूं। माइक्रोकंट्रोलर के लिए कोड यहां सबसे सरल है:

"--------------------------------------------------------------------------" //   IRremote #include <IRremote.h> decode_results results; IRrecv irrecv (A0); //      void setup () { Serial.begin(9600); //   com  irrecv.enableIRIn(); //    } void loop () { if (irrecv.decode( &results )) //      ,    { Serial.println( results.value, HEX ); //          irrecv.resume(); //            } } "--------------------------------------------------------------------------" 

रिमोट कंट्रोल सिग्नल कोड इस तरह दिखता है: "FF18E7" आपका कोड निश्चित रूप से अलग होगा, लेकिन आपको सार को समझना होगा, और जब आप इस कोड के लिए अपील करते हैं, तो हम शुरुआत में "0x" जोड़ते हैं और हमें (0x18187) मिलता है।

इसे arduino में भरने और इसे उसी तरह से कनेक्ट करने के बाद, हम IR डिवाइस के बटन पर क्लिक करने के बाद, tsiforka के लॉग पोर्ट से रिकॉर्डिंग शुरू कर सकते हैं। लेकिन यहां मैं आपको केवल यह स्पष्ट करना चाहता हूं कि आईआर सेंसर को कैसे कनेक्ट किया जाए।

यदि हम सेंसर को देखते हैं, तो हम तीन पैर, बाएं (एनालॉग सिग्नल), मध्य (जमीन), दाएं (प्लस 5 वी) देखते हैं।



चूँकि मुझे अभी भी कुछ पता नहीं था कि यह कैसे काम करेगा, मैंने प्रयोग शुरू किए। सबसे पहले मैंने स्केच कोड को स्टेप बाई स्टेप बनाया, (देरी से (समय)) सबसे पहले मुझे संदेह नहीं था कि यह एक बुरा विचार है :)
मुख्य जाम क्या है यह माइक्रोकंट्रोलर मल्टीटास्किंग करने में सक्षम नहीं है। वह सभी शाखाओं और कार्यों से गुजरते हुए ऊपर से नीचे तक के कोड पर विचार करता है, और पूरा होने के बाद, वह फिर से शुरू होता है। और अब, जब हमारे पास कोड में इन "देरी" के बहुत सारे हैं, तो हम स्पष्ट देरी को नोटिस करना शुरू करते हैं। वैसे, हाँ, हमें "देरी" की बहुत आवश्यकता क्यों है। जब हम एक गेम बनाते हैं, तो चेक और इंटरैक्शन की संख्या बढ़ने लगती है। उदाहरण के लिए, एक दुश्मन हमारी ओर बढ़ रहा है और मैं इस पर कूदना चाहता हूं, मैं "कूद" दबाता हूं और योजना के अनुसार, मुझे हवा में 0.8f सेकंड के लिए हवा में लटकना पड़ता है, यह पूरा खेल है और इन 0.8f सेकंड के लिए फ्रीज होता है। "केंट" मैंने सोचा और एक समाधान के बारे में सोचना शुरू कर दिया। समाधान जल्दी मिल गया था। माइक्रोकंट्रोलर खुद को शुरू से अंत तक कोड को जल्दी से पढ़ने में सक्षम है (यदि यह उसे परेशान नहीं करता है) और वह यह भी जानता है कि इसके समावेश की शुरुआत से समय की गणना कैसे करें। यह वही है जो हमें चाहिए। अब हम केवल वे चर बनाते हैं जो इस या उस क्रिया के लिए समय संचित करेंगे और एक चर जो अंतर की तुलना उस समय से करता है जो अभी है और कोड को सक्रिय करने में कितना समय लगता है। Arduino प्रति सेकंड, 1000 मिलीसेकंड लेता है, काफी सुविधाजनक है। यहाँ स्पष्ट होने पर एक स्निपेट दिया गया है:

 "--------------------------------------------------------------------------" //    ,  ,        //  long ClearTime = 150; // 150 = 0.15f   ~6    long ClearTimeCheck = 0; // ,       long currentMillis = 0; //   void loop () { currentMillis = millis(); //   =    } void clearscreen () //   { // if (currentMillis - ClearTimeCheck >= ClearTime) //  (  -     0.15f    { ClearTimeCheck = currentMillis; //       lcd.clear(); //   ,     } } "--------------------------------------------------------------------------" 

कठिन नहीं है, है ना?

पूरे कोड को नए तरीके से लिखने के बाद, मल्टीटास्किंग क्रियाओं को अनुकरण करने के लिए खेल जल्दी और स्पष्ट रूप से काम करना शुरू कर दिया :) मैं एक लंबा रास्ता तय किया। आखिरकार, हमें अभी भी एक चरित्र, एक तरह का इंटरफ़ेस और एनीमेशन बनाने की आवश्यकता है। चूंकि हम केवल आठ नए चरित्र बना सकते हैं, इसलिए हमें किसी तरह इसे स्मार्ट तरीके से गड़बड़ करने की आवश्यकता है। मैं अब तक प्रदर्शन पर बहुत सी वस्तुओं को करने की योजना नहीं बनाता, इसलिए, ऐसा इसलिए किया जा सकता है कि मेरे पास एक कोड प्रसंस्करण में स्क्रीन पर सिर्फ आठ सक्रिय ऑब्जेक्ट होंगे। यह क्या होगा? खैर, निश्चित रूप से, मुख्य चरित्र, हिट, खलनायक, दिल और स्वास्थ्य संकेतक। शुरुआत के लिए, यह पर्याप्त है। हां, और मेरे पास स्टॉक में तीन और अनोखी वस्तुएं हैं।

मुख्य चरित्र इस तरह दिखेगा:



एक नए चरित्र में प्रवेश करने की प्रक्रिया, मैं बाइनरी कोड में उत्पादन करता हूं (मुझे बहुत सहज लगता है)
यह इस तरह दिखेगा:

01110
01110
00100
01110
10101
00100
01110
01010

यदि आप बारीकी से देखते हैं, तो एक से, हम अपने चरित्र को देखेंगे, लेकिन ताकि वह बेकार न खड़ा हो, चलो उसे एक एनीमेशन बनाते हैं।



अब हमारे कोड में, बाइनरी नंबरों का एक और सेट जोड़ा जाता है, अर्थात् यह एक:

00000
01110
01110
00100
11111
00100
01110
01010

इस प्रदर्शन पर एनीमेशन कैसे बनाया जाए, मैंने ऊपर दिए गए तर्क का संकेत दिया, और अब चलो अभ्यास करने के लिए, फिलहाल इसे स्क्रीन के केंद्र पर रखें और इसे अभी भी खड़े रहें, और याद रखें, हमारा काम दो एनीमेशन स्प्राइट के लिए केवल एक मेमोरी सेल का उपयोग करना है। यह जितना आसान लगता है, उससे कहीं ज्यादा आसान है:

 "--------------------------------------------------------------------------" #include <Wire.h> #include <LiquidCrystal_I2C.h> LiquidCrystal_I2C lcd(0x3F,16,2); //   long AnimatedTime = 300; //     long AnimatedTimeCheck = 0; //   (    ) int AnimPlayer = 1; //    int GGpozX = 8; //   int GGpozY = 1; //   1  2   0    long currentMillis = 0; //   //   ,     ,    :) enum { SYMBOL_HEIGHT = 8 }; byte Player_1[SYMBOL_HEIGHT] = {B01110,B01110,B00100,B01110,B10101,B00100,B01110,B01010,}; //  1 byte Player_2[SYMBOL_HEIGHT] = {B00000,B01110,B01110,B00100,B11111,B00100,B01110,B01010,}; //  2 void setup() { lcd.init(); lcd.backlight();//    loop(); PlAn(); } void loop() { if (AnimPlayer != 50) { //    ,       :) // --------------------------- Animated -> // -------------------- Player -> if (AnimPlayer == 1){lcd.createChar(0, Player_1);} //  1   1 //(lcd.createChar(    0  7,   )) if (AnimPlayer == 2){lcd.createChar(0, Player_2);} //  2   2 } // --------------------------- <- Animated currentMillis = millis(); //   =    PlAn(); } void PlAn () { if (AnimPlayer == 1) //   1  { lcd.setCursor(GGpozX, GGpozY); //  ""      lcd.write(0); //          "" } if (AnimPlayer == 2) //  №1 { lcd.setCursor(GGpozX, GGpozY); lcd.write(0); } if (currentMillis - AnimatedTimeCheck >= AnimatedTime) //       { AnimatedTimeCheck = currentMillis; //     if (AnimPlayer == 2){AnimPlayer = 1; return;} //  2   1      if (AnimPlayer == 1){AnimPlayer = 2;} // 1  2           ,         } } "--------------------------------------------------------------------------" 

शुरू करने के बाद, हम छोटे आदमी को देखते हैं, जो स्क्रीन के केंद्र में है, दूसरी पंक्ति पर और sways, इसलिए बोलने के लिए।

निष्कर्ष: आज मैंने बात की कि कैसे इंफ्रारेड पोर्ट के माध्यम से डेटा का पता लगाया जाए, कैसे माइक्रोकंट्रोलर कोड की देरी को बाईपास किया जाए और कैसे प्रारंभिक एनीमेशन बनाया जाए।

बाकी जल्द ही आ रहा है :) मेरे पास अभी भी लिखने के लिए बहुत कुछ है, इसलिए मैं इस बात पर ध्यान दूंगा कि यह आपके लिए कैसे दिलचस्प होगा, और यदि ऐसा है, तो कल मैं अगली कड़ी लिखना शुरू करूंगा।

आपका ध्यान के लिए धन्यवाद, ciao कोको!

लेख का दूसरा भाग -> habr.com/post/425367