मैं एक अद्भुत उपकरण का मालिक हूं - GPS लकड़हारा Holux M-241। यात्रा करते समय बात बहुत सुविधाजनक और उपयोगी है। एक लकड़हारे की मदद से, मैं एक यात्रा का एक जीपीएस ट्रैक लिखता हूं, जिसके साथ आप फिर अपने तरीके को विस्तार से देख सकते हैं, और उन तस्वीरों को भी संलग्न कर सकते हैं जो आप जीपीएस निर्देशांक पर ले जाते हैं। उसके पास एक छोटी स्क्रीन भी है जो अतिरिक्त जानकारी - घंटे, वर्तमान गति, ऊंचाई और दिशा, ओडोमीटर और बहुत कुछ दिखाती है। यहाँ मैंने एक बार एक छोटी समीक्षा लिखी थी।

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

कुछ बिंदु पर, मुझे एहसास हुआ कि मैं खुद एक लॉगर बना सकता हूं जैसे कि मुझे ज़रूरत है। सौभाग्य से, सभी आवश्यक घटक काफी सस्ते और सस्ती हैं। मैंने Arduino के आधार पर अपना कार्यान्वयन शुरू किया। कटौती के तहत, एक निर्माण डायरी जहां मैंने अपने तकनीकी समाधानों को चित्रित करने की कोशिश की।

सुविधाओं को परिभाषित करना

कई पूछेंगे कि मुझे अपने स्वयं के लकड़हारे को बनाने की आवश्यकता क्यों है, अगर यकीन है कि प्रख्यात निर्माताओं के लिए कुछ तैयार है। हो सकता है कि। सच कहूं तो, मैं वास्तव में इसके लिए नहीं दिख रहा था। लेकिन यकीन है कि वहाँ कुछ याद आ जाएगी। किसी भी मामले में, यह परियोजना मेरे लिए एक प्रशंसक है। हम अपने ड्रीम डिवाइस का निर्माण क्यों नहीं शुरू करते हैं?

इसलिए, मैं अपने होलक्स एम -241 की सराहना करता हूं।

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

हालांकि, कुछ चीजों को थोड़ा बेहतर किया जा सकता है:

AA बैटरियों पर पावर सबसिस्टम एक असंदिग्ध प्लस के रूप में कई द्वारा लिखा जाता है - एक बैटरी लंबे समय तक चलती है, और आप किसी भी जंगल में आपूर्ति को फिर से भर सकते हैं। आप कम से कम एक महीने की स्वायत्त शिविर के लिए स्टॉक कर सकते हैं।

लेकिन मेरे लिए, बैटरी जीवन सरासर बवासीर है। आपको मुट्ठी भर बैटरियां ले जानी होंगी और जो जानते हैं कि वे कितने उच्च गुणवत्ता वाले हैं (अचानक वे 5 साल तक एक शेल्फ पर लेटे रहे और पहले ही स्व-छुट्टी हो गई)। बैटरी के साथ, रक्तस्राव और भी अधिक होता है। मेरा चार्जर केवल जोड़े में चार्ज कर सकता है। हमें बैटरी को डिस्चार्ज करना होगा ताकि वे एक ही डिग्री के डिस्चार्ज हों। नतीजतन, आपको कभी याद नहीं है कि पहले से ही कहां छुट्टी दी गई है, और कहां नहीं।

लकड़हारे का उपयोग करने के 6 वर्षों के लिए, मैंने केवल दो बार बिजली के बिना जंगल में समाप्त किया। एक नियम के रूप में, मुझे दिन में कम से कम एक बार आउटलेट तक पहुंच मिलती है। इस मामले में, अंतर्निहित लिथियम बैटरी अधिक सुविधाजनक होगी। खैर, चरम मामलों में, मेरे पास एक पेवरबैंक है।
डिस्चार्ज की डिग्री का संकेत बहुत ही बेवकूफी से किया जाता है - जब बैटरी डिस्चार्ज होने वाली होती है तो संकेतक चमकने लगता है। इसके अलावा, यह 5 मिनट में मर सकता है, और शायद एक और घंटे काम करता है। इस क्षण को याद करना और लॉग का हिस्सा खोना बहुत आसान है।
विमानन में रुचि रखने वाले व्यक्ति के रूप में, मेरे लिए वर्तमान ऊर्ध्वाधर गति का निरीक्षण करना बहुत दिलचस्प होगा।
कुछ ओडोमीटर - एक से अधिक दूरी को मापने के लिए अक्सर दिलचस्प होता है। उदाहरण के लिए, दूरी प्रति दिन और पूरी यात्रा के लिए।
जब आप डिवाइस को बंद करते हैं या बैटरी को बदलते समय ओडोमीटर रीसेट करता है। यह बहुत असुविधाजनक है। यदि आप एक कैफे में भोजन के लिए रुकते हैं, तो जीपीएस लॉगर को बंद नहीं किया जा सकता क्योंकि मूल्य रीसेट हो जाएगा। उसे इसे चालू छोड़ना होगा और वह किलोमीटर जारी रखेगा और बैटरी खाएगा। यह बहुत अधिक सुविधाजनक होगा कि ओडोमीटर को विराम देने में सक्षम होना चाहिए और समावेशन के बीच के मूल्यों को बचाना होगा ।
साइट मापदंडों का मापन । जब स्कीइंग, उदाहरण के लिए, मुझे साइट पर वंश, ऊंचाई, औसत और अधिकतम गति की लंबाई में रुचि है, जो समय बिताया। आप जो जानना चाहते हैं, वह अभी है, और जब आप ट्रैक डाउनलोड करते हैं तो घर पर नहीं।
शुद्धता खराब है। जब आप तेजी से आगे बढ़ते हैं - और कुछ नहीं। लेकिन जब ट्रैक पर गति छोटी होती है, "शोर" + - 50 मीटर स्पष्ट रूप से दिखाई देते हैं। और खड़े होने के एक घंटे के लिए, आप लगभग एक किलोमीटर "जोर" दे सकते हैं। 10 वर्षों के लिए प्रौद्योगिकी का लाभ बहुत आगे चला गया है और आधुनिक रिसीवर बहुत अधिक सटीकता देते हैं।
पटरियों की विलय की गति केवल 38,400 है। ठीक है, यह 2017 में गंभीर नहीं है कि बड़ी मात्रा में डेटा स्थानांतरित करने के लिए COM पोर्ट का उपयोग किया जाए। आंतरिक फ्लैश के 2 मेगाबाइट को विलय करने में 20 मिनट से अधिक समय लगता है।

इसके अलावा, प्रत्येक प्रोग्राम मर्ज किए गए ट्रैक्स के प्रारूप को नहीं पचा सकता है। देशी उपयोगिता बहुत मनहूस है। सौभाग्य से, BT747 है, जो पर्याप्त रूप से ट्रैक को मर्ज कर सकता है और इसे किसी प्रकार के पचाने योग्य प्रारूप में परिवर्तित कर सकता है।
फ्लैश ड्राइव का आकार केवल 2 एमबी है। एक ओर, यह 5 अंक की बचत के साथ दो सप्ताह की यात्रा के लिए पर्याप्त है। लेकिन सबसे पहले, आंतरिक पैक प्रारूप
रूपांतरण की आवश्यकता है, और दूसरी बात वॉल्यूम बढ़ाने की अनुमति नहीं देती है
किसी कारण से मास स्टोरेज डिवाइस अब फैशन में नहीं है। आधुनिक इंटरफेस फाइलों की उपस्थिति के तथ्य को छिपाने की कोशिश करते हैं। मैं 25 वर्षों से कंप्यूटर के साथ हूं, और किसी भी अन्य तरीके की तुलना में फाइलों के साथ सीधे काम करना मेरे लिए अधिक सुविधाजनक है।

यहां ऐसा कुछ भी नहीं है जिसे महत्वपूर्ण प्रयासों के बिना महसूस नहीं किया जा सकता है।

कुछ भी अलग। मैं स्वयं इसका उपयोग नहीं करता, लेकिन अचानक कोई उपयोगी है:

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

लोहा चुनें

आवश्यकताओं को कम या ज्यादा परिभाषित किया गया है। यह समझने का समय है कि यह सब कैसे लागू किया जा सकता है। मेरे पास मुख्य घटक हैं:

माइक्रोकंट्रोलर - मेरे पास किसी भी परिष्कृत कम्प्यूटेशनल एल्गोरिदम की कोई योजना नहीं है, इसलिए कर्नेल की प्रसंस्करण शक्ति विशेष रूप से महत्वपूर्ण नहीं है। मुझे भरने के लिए विशेष आवश्यकताएं भी नहीं हैं - मानक बाह्य उपकरणों का एक सेट करेगा।

हाथ में केवल विविध आर्डिनोज़ का प्रकीर्णन था, साथ ही stm32f103c8t6 के एक जोड़े को भी। मैंने AVR के साथ शुरू करने का फैसला किया, जिसे मैं नियंत्रक / रजिस्टरों / बाह्य उपकरणों के स्तर पर अच्छी तरह से जानता हूं। अगर मैं प्रतिबंधों में भागता हूं - एसटीएम 32 को महसूस करने का एक कारण होगा।
GPS रिसीवर को NEO6MV2, बीटन बीएन -800 और बीटन बीएन -880 मॉड्यूल से चुना गया था । कुछ समय के लिए मंचों को निष्क्रिय कर दिया। अनुभवी लोगों ने कहा कि पहला रिसीवर आखिरी शताब्दी है। अन्य दो केवल ऐन्टेना के स्थान में एक-दूसरे से भिन्न होते हैं - बीएन -800 में यह तार पर लटका हुआ है, और बीएन-880 में यह मुख्य मॉड्यूल के लिए एक सैंडविच से सरेस से जोड़ा हुआ है। BN-880 ले गया ।
स्क्रीन - मूल बैकलाइट के साथ 128 x 32 एलसीडी का उपयोग करता है। मुझे बिल्कुल वैसा ही नहीं लगा। मैंने SSD1306 कंट्रोलर पर OLED 0.91 और ST7565R कंट्रोलर पर 1.2 ”LCD स्क्रीन खरीदी । मैंने पहले से शुरू करने का फैसला किया, क्योंकि I2C या SPI के अनुसार मानक कंघी के साथ जुड़ना आसान है। लेकिन यह मूल की तुलना में थोड़ा छोटा है, और ईंधन दक्षता के कारणों के लिए छवि को लगातार प्रदर्शित करने के लिए भी इस पर काम नहीं करेगा। दूसरा प्रदर्शन कम लसदार होना चाहिए, लेकिन आपको इसके लिए एक मुश्किल कनेक्टर को मिलाप करने की आवश्यकता है और यह पता लगाना है कि बैकलाइट को कैसे पावर करना है।

छोटी चीजों से:

बटन एक बार एक पूरा बैग खरीदा;
एसडी कार्ड के साथ शील्ड - हाथ में चारों ओर झूठ बोलना;
मैंने लिथियम बैटरी के लिए अलग-अलग चार्ज कंट्रोलर की एक जोड़ी खरीदी, लेकिन मुझे अभी भी यह समझ नहीं आया।

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

लेकिन पहले आपको एक बहुत ही महत्वपूर्ण मुद्दे पर निर्णय लेने की आवश्यकता है - घटकों का पोषण। मुझे 3.3V: GPS और उस पर लगी स्क्रीन से ही सब कुछ ठीक करना उचित लगा और काम करना जानता था। यह USB और SD के लिए देशी वोल्टेज भी है। इसके अलावा, सर्किट को एक लिथियम कैन से संचालित किया जा सकता है।

विकल्प Arduino Pro Mini पर गिरा, जिसे 8MHz / 3.3V संस्करण में पाया जा सकता है। लेकिन उसके पास USB ऑन बोर्ड नहीं था - मुझे USB-UART एडॉप्टर का उपयोग करना था।

पहला कदम

प्रारंभ में, प्रोजेक्ट Arduino IDE में बनाया गया था। लेकिन ईमानदार होने के लिए, मेरी भाषा इसे एक IDE कहने की हिम्मत नहीं करती है - एक संकलक के साथ एक पाठ संपादक की तरह। किसी भी स्थिति में, विजुअल स्टूडियो के बाद, जिसमें मैं पिछले 13 वर्षों से काम कर रहा हूं, मैं आंसू और मैट्युक के बिना अरुडिनो आईडीई में कुछ भी गंभीर नहीं कर सकता।

सौभाग्य से एक निशुल्क Atmel स्टूडियो है, जिसमें विजुअल असिस्ट भी निर्मित बॉक्स से बाहर है !!! कार्यक्रम वह सब कुछ जानता है जिसकी आवश्यकता है, सब कुछ परिचित है और उसके स्थान पर है। खैर, लगभग सब कुछ (मुझे नहीं मिला कि केवल एक फ़ाइल कैसे संकलित की जाए, उदाहरण के लिए, सिंटैक्स की जांच करने के लिए)

स्क्रीन से शुरू - यह फर्मवेयर के कंकाल को डीबग करने के लिए आवश्यक है, और फिर इसे कार्यक्षमता के साथ भरें। वह Adafruit SSD1306 के लिए पहले उपलब्ध पुस्तकालय में रुक गया । वह जानती है कि सभी की जरूरत है और एक बहुत ही सरल इंटरफ़ेस प्रदान करता है।

फोंट के साथ खेला। यह पता चला कि एक फॉन्ट 8kb तक ले सकता है (अक्षरों का आकार 24pt है) - आप विशेष रूप से 32kb कंट्रोलर में नहीं जा सकते। उदाहरण के लिए, समय प्रदर्शित करने के लिए बड़े फोंट की आवश्यकता होती है।

फ़ॉन्ट नमूना कोड

#include <Adafruit_GFX.h> #include <Adafruit_SSD1306.h> #include <gfxfont.h> #include <fonts/FreeMono12pt7b.h> #include <fonts/FreeMono18pt7b.h> ... #include <fonts/FreeSerifItalic24pt7b.h> #include <fonts/FreeSerifItalic9pt7b.h> #include <fonts/TomThumb.h> struct font_and_name { const char * PROGMEM name; GFXfont * font; }; #define FONT(name) {#name, &name} const font_and_name fonts[] = { // FONT(FreeMono12pt7b), FONT(FreeMono18pt7b), /* FONT(FreeMono24pt7b), FONT(FreeMono9pt7b), FONT(FreeMonoBold12pt7b), ... FONT(FreeSerifItalic9pt7b), FONT(TomThumb)*/ }; const unsigned int fonts_count = sizeof(fonts) / sizeof(font_and_name); unsigned int current_font = 0; extern Adafruit_SSD1306 display; void RunFontTest() { display.clearDisplay(); display.setCursor(0,30); display.setFont(fonts[current_font].font); display.print("12:34:56"); display.setCursor(0,6); display.setFont(&TomThumb); display.print(fonts[current_font].name); display.display(); } void SwitchToNextFont() { current_font = ++current_font % fonts_count; }

लाइब्रेरी के साथ पूर्ण किए गए फ़ॉन्ट बहुत ही भद्दे होते हैं। मोनोस्पेस फ़ॉन्ट बहुत चौड़ा हो गया - लाइन "12:34:56" फिट नहीं है, सेरिफ़ - सभी संख्याएं अलग-अलग लंबाई के हैं। जब तक पुस्तकालय में मानक 5x7 का फ़ॉन्ट नहीं दिखता है।

यह पता चला कि इन फोंट को कुछ खुले स्रोत ttf फोंट से परिवर्तित किया गया था जो कि केवल छोटे प्रस्तावों के लिए अनुकूलित नहीं हैं।

मुझे अपने फोंट खींचने पड़े। अधिक सटीक रूप से, पहले, समाप्त प्रतीकों से अलग-अलग प्रतीकों को खोदें। ASCII तालिका में प्रतीक ':' संख्या के ठीक बाद बहुत उपयोगी है और इसे एक ब्लॉक में खरीदा जा सकता है। यह भी सुविधाजनक है कि आप सभी वर्णों पर एक फ़ॉन्ट नहीं बना सकते हैं, लेकिन केवल एक सीमा पर, उदाहरण के लिए, 0x30 ('0') से 0x3a (':') तक। इस प्रकार FreeSans18pt7b से यह केवल आवश्यक पात्रों के लिए एक बहुत ही कॉम्पैक्ट फ़ॉन्ट बनाने के लिए निकला। सच है, मुझे चौड़ाई को थोड़ा समायोजित करना था ताकि पाठ स्क्रीन की चौड़ाई में फिट हो जाए।

उप-फ़ॉन्ट FreeSans18pt7b

 // This font consists only of digits and ':' to display current time. // The font is very based on FreeSans18pt7b.h //TODO: 25 pixel height is too much for displaying time. Create another 22px font const uint8_t TimeFontBitmaps[] PROGMEM = { /* 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xE9, 0x20, 0x3F, 0xFC, 0xE3, 0xF1, 0xF8, 0xFC, 0x7E, 0x3F, 0x1F, 0x8E, 0x82, 0x41, 0x00, 0x01, 0xC3, 0x80, ... 0x03, 0x00, 0xC0, 0x60, 0x18, 0x06, 0x03, 0x00, 0xC0, 0x30, 0x18, 0x06, 0x01, 0x80, 0xC0, 0x30, 0x00, */0x07, 0xE0, 0x0F, 0xF8, 0x1F, 0xFC, 0x3C, 0x3C, 0x78, 0x1E, 0x70, 0x0E, 0x70, 0x0E, 0xE0, 0x07, 0xE0, 0x07, 0xE0, 0x07, 0xE0, 0x07, 0xE0, 0x07, 0xE0, 0x07, 0xE0, 0x07, 0xE0, 0x07, 0xE0, 0x07, 0xE0, 0x07, 0xE0, 0x0F, 0x70, 0x0E, 0x70, 0x0E, 0x78, 0x1E, 0x3C, 0x3C, 0x1F, 0xF8, 0x1F, 0xF0, 0x07, 0xE0, 0x03, 0x03, 0x07, 0x0F, 0x3F, 0xFF, 0xFF, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0xE0, 0x1F, 0xF8, 0x3F, 0xFC, 0x7C, 0x3E, 0x70, 0x0F, 0xF0, 0x0F, 0xE0, 0x07, 0xE0, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x0F, 0x00, 0x1E, 0x00, 0x3C, 0x00, 0xF8, 0x03, 0xF0, 0x07, 0xC0, 0x1F, 0x00, 0x3C, 0x00, 0x38, 0x00, 0x70, 0x00, 0x60, 0x00, 0xE0, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x07, 0xF0, 0x07, 0xFE, 0x07, 0xFF, 0x87, 0x83, 0xC3, 0x80, 0xF3, 0x80, 0x39, 0xC0, 0x1C, 0xE0, 0x0E, 0x00, 0x07, 0x00, 0x0F, 0x00, 0x7F, 0x00, 0x3F, 0x00, 0x1F, 0xE0, 0x00, 0x78, 0x00, 0x1E, 0x00, 0x07, 0x00, 0x03, 0xF0, 0x01, 0xF8, 0x00, 0xFE, 0x00, 0x77, 0x00, 0x73, 0xE0, 0xF8, 0xFF, 0xF8, 0x3F, 0xF8, 0x07, 0xF0, 0x00, 0x00, 0x38, 0x00, 0x38, 0x00, 0x78, 0x00, 0xF8, 0x00, 0xF8, 0x01, 0xF8, 0x03, 0xB8, 0x03, 0x38, 0x07, 0x38, 0x0E, 0x38, 0x1C, 0x38, 0x18, 0x38, 0x38, 0x38, 0x70, 0x38, 0x60, 0x38, 0xE0, 0x38, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x38, 0x00, 0x38, 0x00, 0x38, 0x00, 0x38, 0x00, 0x38, 0x00, 0x38, 0x1F, 0xFF, 0x0F, 0xFF, 0x8F, 0xFF, 0xC7, 0x00, 0x03, 0x80, 0x01, 0xC0, 0x00, 0xE0, 0x00, 0x70, 0x00, 0x39, 0xF0, 0x3F, 0xFE, 0x1F, 0xFF, 0x8F, 0x83, 0xE7, 0x00, 0xF0, 0x00, 0x3C, 0x00, 0x0E, 0x00, 0x07, 0x00, 0x03, 0x80, 0x01, 0xC0, 0x00, 0xFC, 0x00, 0xEF, 0x00, 0x73, 0xC0, 0xF0, 0xFF, 0xF8, 0x3F, 0xF8, 0x07, 0xE0, 0x00, 0x03, 0xE0, 0x0F, 0xF8, 0x1F, 0xFC, 0x3C, 0x1E, 0x38, 0x0E, 0x70, 0x0E, 0x70, 0x00, 0x60, 0x00, 0xE0, 0x00, 0xE3, 0xE0, 0xEF, 0xF8, 0xFF, 0xFC, 0xFC, 0x3E, 0xF0, 0x0E, 0xF0, 0x0F, 0xE0, 0x07, 0xE0, 0x07, 0xE0, 0x07, 0x60, 0x07, 0x70, 0x0F, 0x70, 0x0E, 0x3C, 0x3E, 0x3F, 0xFC, 0x1F, 0xF8, 0x07, 0xE0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x06, 0x00, 0x0E, 0x00, 0x1C, 0x00, 0x18, 0x00, 0x38, 0x00, 0x70, 0x00, 0x60, 0x00, 0xE0, 0x00, 0xC0, 0x01, 0xC0, 0x01, 0x80, 0x03, 0x80, 0x03, 0x80, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x0C, 0x00, 0x1C, 0x00, 0x1C, 0x00, 0x07, 0xF0, 0x0F, 0xFE, 0x0F, 0xFF, 0x87, 0x83, 0xC7, 0x80, 0xF3, 0x80, 0x39, 0xC0, 0x1C, 0xE0, 0x0E, 0x78, 0x0F, 0x1E, 0x0F, 0x07, 0xFF, 0x01, 0xFF, 0x03, 0xFF, 0xE3, 0xE0, 0xF9, 0xC0, 0x1D, 0xC0, 0x0F, 0xE0, 0x03, 0xF0, 0x01, 0xF8, 0x00, 0xFC, 0x00, 0xF7, 0x00, 0x73, 0xE0, 0xF8, 0xFF, 0xF8, 0x3F, 0xF8, 0x07, 0xF0, 0x00, 0x07, 0xE0, 0x1F, 0xF8, 0x3F, 0xFC, 0x7C, 0x3C, 0x70, 0x0E, 0xF0, 0x0E, 0xE0, 0x06, 0xE0, 0x07, 0xE0, 0x07, 0xE0, 0x07, 0xE0, 0x0F, 0x70, 0x0F, 0x78, 0x3F, 0x3F, 0xFF, 0x1F, 0xF7, 0x07, 0xC7, 0x00, 0x07, 0x00, 0x06, 0x00, 0x0E, 0x70, 0x0E, 0x70, 0x1C, 0x78, 0x3C, 0x3F, 0xF8, 0x1F, 0xF0, 0x07, 0xC0, 0xFF, 0xF0, 0x00, 0x00, 0x00, 0x07, 0xFF, 0x80 /*, 0xFF, 0xF0, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xB6, 0xD6, 0x00, 0x00, 0x80, 0x03, 0xC0, 0x07, 0xE0, 0x0F, 0xC0, 0x3F, 0x80, 0x7E, 0x00, 0xFC, 0x01, 0xF0, 0x00, 0xE0, 0x00, ... 0x38, 0x38, 0xF8, 0xF0, 0xE0, 0x38, 0x00, 0xFC, 0x03, 0xFC, 0x1F, 0x3E, 0x3C, 0x1F, 0xE0, 0x1F, 0x80, 0x1E, 0x00 */ }; //TODO Recalc offset numbers const GFXglyph TimeFontGlyphs[] PROGMEM = { { 449-449, 16, 25, 19, 2, -24 }, // 0x30 '0' { 499-449, 8, 25, 19, 4, -24 }, // 0x31 '1' { 524-449, 16, 25, 19, 2, -24 }, // 0x32 '2' { 574-449, 17, 25, 19, 1, -24 }, // 0x33 '3' { 628-449, 16, 25, 19, 1, -24 }, // 0x34 '4' { 678-449, 17, 25, 19, 1, -24 }, // 0x35 '5' { 732-449, 16, 25, 19, 2, -24 }, // 0x36 '6' { 782-449, 16, 25, 19, 2, -24 }, // 0x37 '7' { 832-449, 17, 25, 19, 1, -24 }, // 0x38 '8' { 886-449, 16, 25, 19, 1, -24 }, // 0x39 '9' { 936-449, 3, 19, 7, 2, -20 }, // 0x3A ':' }; const GFXfont TimeFont PROGMEM = { (uint8_t *)TimeFontBitmaps, (GFXglyph *)TimeFontGlyphs, 0x30, 0x3A, 20 };

यह पता चला कि 18 वां फ़ॉन्ट वास्तव में 25 पिक्सेल ऊंचा है। इस वजह से, वह दूसरे शिलालेख पर थोड़ा फिट बैठता है

उलटा प्रदर्शन, वैसे, यह समझने में मदद करता है कि ड्राइंग क्षेत्र की सीमाएं वास्तव में कहां हैं और इस सीमा के सापेक्ष रेखा कैसे निहित है - प्रदर्शन में बहुत बड़े फ्रेम हैं।

एक लंबे समय के लिए मैंने फोंट को समाप्त कर दिया, लेकिन वे आकार में, या आकार में, या सामग्री में फिट नहीं हुए। उदाहरण के लिए, इंटरनेट पर, एक 8x12 फ़ॉन्ट शाफ्ट (वीजीए कार्ड चरित्र जनरेटर के डंप)। लेकिन वास्तव में, ये फोंट 6x8 हैं, अर्थात। अंतरिक्ष का एक बहुत चलता है - इस तरह के एक छोटे से संकल्प और आकार के मामले में यह महत्वपूर्ण है।

मुझे अपने खुद के फोंट खींचने पड़े, क्योंकि एडफ्टर लाइब्रेरी का फ़ॉन्ट प्रारूप बहुत सरल है। मैंने Paint.net में चित्र तैयार किया - मैंने बस अक्षरों को सही फ़ॉन्ट में आकर्षित किया, फिर उन्हें एक पेंसिल के साथ थोड़ा सही किया। मैंने छवि को पीएनजी के रूप में सहेजा, और फिर इसे जल्दी से अपने घुटने पर लिखी अजगर स्क्रिप्ट पर भेज दिया। इस स्क्रिप्ट ने एक अर्ध-तैयार कोड उत्पन्न किया जो पहले से ही आईडीई कोड में हेक्स कोड में बिंदुवार नियम बनाता है।

उदाहरण के लिए, यह है कि छोटे अक्षर और लाइन रिक्ति के साथ एक मोनोसैप्ड फ़ॉन्ट 8x12 बनाने की प्रक्रिया कैसी दिखती है। अंत में प्रत्येक वर्ण लगभग 7x10 का निकला और डिफ़ॉल्ट रूप से इसने 10 बाइट पर कब्जा कर लिया। प्रत्येक चरित्र को 8-9 बाइट्स में पैक करना संभव होगा (पुस्तकालय यह अनुमति देता है), लेकिन मैंने परेशान नहीं किया। इसके अलावा, इस रूप में, आप सीधे कोड में अलग-अलग पिक्सेल संपादित कर सकते हैं।

फॉन्ट 8x12

 // A simple 8x12 font (slightly modifier Courier New) const uint8_t Monospace8x12Bitmaps[] PROGMEM = { 0x1e, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x1e, //0 0x18, 0x68, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x7f, //1 0x3e, 0x41, 0x41, 0x01, 0x02, 0x0c, 0x10, 0x20, 0x41, 0x7f, //2 0x3e, 0x41, 0x01, 0x01, 0x0e, 0x02, 0x01, 0x01, 0x41, 0x3e, //3 0x02, 0x06, 0x0a, 0x12, 0x12, 0x22, 0x3f, 0x02, 0x02, 0x0f, //4 0x7f, 0x41, 0x40, 0x40, 0x7e, 0x01, 0x01, 0x01, 0x41, 0x3e, //5 0x1e, 0x21, 0x40, 0x40, 0x5e, 0x61, 0x41, 0x41, 0x41, 0x3e, //6 0x7f, 0x41, 0x01, 0x02, 0x02, 0x04, 0x04, 0x04, 0x08, 0x08, //7 0x1e, 0x21, 0x21, 0x21, 0x1e, 0x21, 0x21, 0x21, 0x21, 0x1e, //8 0x1e, 0x21, 0x21, 0x21, 0x23, 0x1d, 0x01, 0x01, 0x22, 0x1c, //9 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, //: }; const GFXglyph Monospace8x12Glyphs[] PROGMEM = { { 0, 8, 10, 8, 0, -11 }, // 0x30 '0' { 10, 8, 10, 8, 0, -11 }, // 0x31 '1' { 20, 8, 10, 8, 0, -11 }, // 0x32 '2' { 30, 8, 10, 8, 0, -11 }, // 0x33 '3' { 40, 8, 10, 8, 0, -11 }, // 0x34 '4' { 50, 8, 10, 8, 0, -11 }, // 0x35 '5' { 60, 8, 10, 8, 0, -11 }, // 0x36 '6' { 70, 8, 10, 8, 0, -11 }, // 0x37 '7' { 80, 8, 10, 8, 0, -11 }, // 0x38 '8' { 90, 8, 10, 8, 0, -11 }, // 0x39 '9' { 100, 8, 10, 8, 0, -11 }, // 0x3A ':' }; const GFXfont Monospace8x12Font PROGMEM = { (uint8_t *)Monospace8x12Bitmaps, (GFXglyph *)Monospace8x12Glyphs, 0x30, 0x3A, 12 };

ढांचा

मूल डिवाइस एक बहुत ही सरल और सुविधाजनक इंटरफ़ेस प्रदान करता है। जानकारी को उन श्रेणियों में वर्गीकृत किया जाता है जो व्यक्तिगत पृष्ठों (स्क्रीन) से प्रदर्शित होती हैं। बटन का उपयोग करके, आप पृष्ठों के माध्यम से साइकिल चला सकते हैं, और वर्तमान आइटम का चयन करने के लिए दूसरे बटन का उपयोग कर सकते हैं या बटन के नीचे हस्ताक्षर में इंगित कार्रवाई कर सकते हैं। यह दृष्टिकोण मुझे बहुत सुविधाजनक लगता है और कुछ भी बदलने की आवश्यकता नहीं है।

मुझे ओओपी की सुंदरता पसंद है, क्योंकि मैंने तुरंत एक छोटे इंटरफ़ेस को चकाचौंध कर दिया, प्रत्येक पृष्ठ इंटरफ़ेस को लागू करता है जैसा कि इसकी आवश्यकता होती है। पृष्ठ जानता है कि कैसे खुद को आकर्षित करना है और बटन पर प्रतिक्रिया को लागू करना है।

 class Screen { Screen * nextScreen; public: Screen(); virtual ~Screen() {} virtual void drawScreen() = 0; virtual void drawHeader(); virtual void onSelButton(); virtual void onOkButton(); virtual PROGMEM const char * getSelButtonText(); virtual PROGMEM const char * getOkButtonText(); Screen * addScreen(Screen * screen); };

वर्तमान स्क्रीन के आधार पर बटन विभिन्न क्रियाएं कर सकते हैं। इसलिए, 8 पिक्सेल की ऊंचाई के साथ स्क्रीन के ऊपर, मैंने बटन के लिए लेबल को सौंपा। हस्ताक्षर के लिए पाठ वर्तमान स्क्रीन पर निर्भर करता है और वर्चुअल फ़ंक्शन getSelButtonText () और getOkButtonText () द्वारा लौटाया जाता है। इसके अलावा हेडर सर्विस आइटम्स जैसे कि GPS सिग्नल स्ट्रेंथ और बैटरी चार्ज को अभी भी प्रदर्शित किया जाएगा। शेष are स्क्रीन उपयोगी जानकारी के लिए उपलब्ध हैं।

जैसा कि मैंने कहा, स्क्रीन को खत्म किया जा सकता है, जिसका अर्थ है कि कहीं न कहीं विभिन्न पृष्ठों के लिए वस्तुओं की एक सूची होनी चाहिए। एक से अधिक स्क्रीन पर, एक सबमेनू की तरह नेस्टेड किया जा सकता है। मैंने स्क्रीनमैनेजर क्लास भी शुरू किया, जो इन सूचियों को प्रबंधित करने वाला था, लेकिन तब मुझे इसका समाधान आसान लगा।

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

 class Screen { Screen * nextScreen; … }; class ParentScreen : public Screen { Screen * childScreen; … };

डिफ़ॉल्ट रूप से, बटन हैंडलर बस स्क्रीन परिवर्तन फ़ंक्शन को कॉल करता है, इसे वांछित पॉइंटर पास करता है। फ़ंक्शन तुच्छ हो गया - यह सिर्फ पॉइंटर को चालू स्क्रीन पर स्विच करता है। स्क्रीन के घोंसले के शिकार को सुनिश्चित करने के लिए, मैंने एक छोटा सा स्टैक बनाया। तो पूरे स्क्रीन मैनेजर 25 लाइनों और 4 छोटे कार्यों में फिट होते हैं।

 Screen * screenStack[3]; int screenIdx = 0; void setCurrentScreen(Screen * screen) { screenStack[screenIdx] = screen; } Screen * getCurrentScreen() { return screenStack[screenIdx]; } void enterChildScreen(Screen * screen) { screenIdx++; //TODO limit this screenStack[screenIdx] = screen; } void backToParentScreen() { if(screenIdx) screenIdx--; }

सच है, इन संरचनाओं को भरने के लिए कोड बहुत अच्छा नहीं लगता है, लेकिन अभी तक इसका बेहतर आविष्कार नहीं हुआ है।

 Screen * createCurrentTimeScreen() { TimeZoneScreen * tzScreen = new TimeZoneScreen(1, 30); tzScreen = tzScreen->addScreen(new TimeZoneScreen(2, 45)); tzScreen = tzScreen->addScreen(new TimeZoneScreen(-3, 30)); // TODO Add real timezones here CurrentTimeScreen * screen = new CurrentTimeScreen(); screen->addChildScreen(tzScreen); return screen; }

सोचा था

संरचना, निश्चित रूप से, सुंदर निकला, लेकिन मुझे डर है कि यह बहुत सारी स्मृति खाती है। आपको अपने खिलाफ जाना होगा और पॉइंटर्स के साथ एक बड़ी स्टैटिक टेबल को zafigachit करना होगा।

आगे बढ़ो। इंटरफ़ेस के मेरे कार्यान्वयन में, मैं एक संदेश बॉक्स की तरह कुछ करना चाहता था, एक छोटा संदेश जो एक या दो सेकंड के लिए दिखाई देगा, और फिर गायब हो जाएगा। उदाहरण के लिए, यदि आप वर्तमान निर्देशांक के साथ स्क्रीन पर POI (रुचि का बिंदु) बटन दबाते हैं, तो ट्रैक को बिंदु लिखने के अलावा, उपयोगकर्ता को संदेश "वेनपॉइंट सेव्ड" (मूल डिवाइस में, एक अतिरिक्त आइकन बस एक सेकंड के लिए प्रदर्शित किया जाता है) दिखाना अच्छा होगा। या, जब बैटरी कम होती है, तो उपयोगकर्ता को संदेश के साथ "खुश करें" करें।

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

 enum State { IDLE_DISPLAY_OFF, IDLE, MESSAGE_BOX, BUTTON_PRESSED, };

राज्य मशीन का उपयोग करके बटन प्रेस को संभालना भी सुविधाजनक है। इंटरप्ट के माध्यम से शायद यह सही होगा, लेकिन यह अच्छी तरह से निकला। यह इस तरह से काम करता है: अगर आईडीएलई राज्य में एक बटन दबाया गया था, तो उस समय को याद रखें जिसे दबाया गया था और BUTTON_PRESSED स्थिति पर जाएं। इस स्थिति में, हम तब तक प्रतीक्षा करते हैं जब तक उपयोगकर्ता बटन जारी नहीं करता। यहां हम उस अवधि की गणना कर सकते हैं जब बटन दबाया गया था। लघु प्रतिक्रियाओं (<30ms) को केवल अनदेखा किया जाता है - सबसे अधिक संभावना है कि यह संपर्कों का उछाल है। लंबी यात्राओं को पहले से ही एक बटन प्रेस के रूप में व्याख्या की जा सकती है।

मैं साधारण कार्यों के लिए बटन के दोनों लघु प्रेसों का उपयोग करने की योजना बनाता हूं, और विशेष कार्यों के लिए लंबे (> 1 सी)। उदाहरण के लिए, एक छोटा प्रेस शुरू होता है / ओडोमीटर को रोक देता है, एक लंबा प्रेस काउंटर को 0 पर रीसेट करता है।

शायद अन्य राज्यों को जोड़ा जाएगा। इसलिए, उदाहरण के लिए, अगले पृष्ठ पर जाने के बाद मूल लकड़हारा में, स्क्रीन पर मान अक्सर बदलते हैं, और कुछ सेकंड के बाद कम - एक बार प्रति सेकंड। यह दूसरे राज्य को जोड़कर किया जा सकता है।

जब फ्रेम तैयार हो गया, तो मैंने पहले ही जीपीएस कनेक्ट करना शुरू कर दिया। लेकिन यहाँ ऐसी बारीकियाँ थीं जिन्होंने मुझे इस कार्य को स्थगित कर दिया।

फर्मवेयर अनुकूलन

आगे बढ़ने से पहले, मुझे कुछ तकनीकी विवरणों से विचलित होने की आवश्यकता है। तथ्य यह है कि इस जगह के बारे में मैंने मेमोरी की खपत को बढ़ाने के साथ बट करना शुरू किया। यह पता चला कि फर्मवेयर की शुरुआत में PROGMEM संशोधक के बिना घोषित की गई रेखा रैम पर कॉपी की जाती है और पूरे समय में जगह लेती है।

विभिन्न आर्किटेक्चर

संक्षेप में। बड़े कंप्यूटरों पर, वॉन न्यूमैन आर्किटेक्चर का उपयोग किया जाता है जहां कोड और डेटा एक ही एड्रेस स्पेस में स्थित होते हैं। यानी RAM और ROM दोनों के डेटा को एक ही तरीके से पढ़ा जाएगा।

माइक्रोकंट्रोलर आमतौर पर हार्वर्ड आर्किटेक्चर का उपयोग करते हैं, जहां कोड और डेटा को अलग किया जाता है। इस प्रकार आपको मेमोरी और फ्लैश पढ़ने के लिए विभिन्न कार्यों का उपयोग करना होगा। C / C ++ भाषा के दृष्टिकोण से, पॉइंटर्स समान दिखते हैं, लेकिन जब कोई प्रोग्राम लिखते हैं, तो हमें यह जानने की आवश्यकता होती है कि वास्तव में कौन सी मेमोरी हमारे पॉइंटर को इसी फ़ंक्शन को कॉल और कॉल करती है।

सौभाग्य से, पुस्तकालय डेवलपर्स ने पहले ही आंशिक रूप से इस पर ध्यान दिया है। प्रदर्शन पुस्तकालय का मुख्य वर्ग - Adafruit_SSD1306, Arduino मानक पुस्तकालय से प्रिंट वर्ग से विरासत में मिला है।

यह हमें मुद्रण पद्धति के विभिन्न संशोधनों की पूरी श्रृंखला प्रदान करता है - मुद्रण तार, एकल वर्ण, संख्या और कुछ और के लिए। तो यह मुद्रण लाइनों के लिए 2 अलग कार्य है:

 size_t print(const __FlashStringHelper *); size_t print(const char[]);

पहला व्यक्ति जानता है कि आपको फ्लैश ड्राइव से एक लाइन प्रिंट करने की आवश्यकता है और चरित्र द्वारा इसे लोड करता है। दूसरा रैम से वर्ण प्रिंट करता है। वास्तव में, ये दोनों कार्य एक संकेतक को एक स्ट्रिंग में ले जाते हैं, केवल अलग-अलग पते के स्थानों से।

लंबे समय से मैंने वांछित प्रिंट () फ़ंक्शन को कॉल करने का तरीका जानने के लिए इस __FlashStringHelper के लिए arduino कोड में देखा। यह पता चला है कि लोगों ने चाल चली: उन्होंने बस इस प्रकार को आगे की घोषणा के साथ घोषित किया (खुद को घोषित किए बिना) और एक मैक्रो लिखा जिसने एक फ्लैश में लाइनों को __FlashStringHelper प्रकार के लिए लाइनों में डाला। संकलक के लिए बस आवश्यक अतिभारित फ़ंक्शन का चयन करने के लिए

 class __FlashStringHelper; #define F(string_literal) (reinterpret_cast<const __FlashStringHelper *>(PSTR(string_literal)))

यह आपको इस तरह लिखने की अनुमति देता है:

 display.print(F(“String in flash memory”));

लेकिन यह आपको ऐसा लिखने की अनुमति नहीं देता है

 const char text[] PROGMEM = "String in flash memory"; display.print(F(text));

और, जाहिर है, पुस्तकालय कुछ भी प्रदान नहीं करता है जो उस तरह से किया जा सकता है। मुझे पता है कि मेरे कोड में निजी पुस्तकालय के टुकड़ों का उपयोग करना अच्छा नहीं है, लेकिन मुझे क्या करना चाहिए? मैंने अपना मैक्रो आकर्षित किया, जो मुझे चाहिए था।

 #define USE_PGM_STRING(x) reinterpret_cast<const __FlashStringHelper *>(x)

तो टोपी खींचने का कार्य इस प्रकार दिखाई देने लगा:

 void Screen::drawHeader() { display.setFont(NULL); display.setCursor(20, 0); display.print('\x1e'); display.print(USE_PGM_STRING(getSelButtonText())); display.setCursor(80, 0); display.print('\x1e'); display.print(USE_PGM_STRING(getOkButtonText())); }

खैर, जब से मैं फर्मवेयर के निम्न-स्तरीय टुकड़ों में मिला, मैंने और अधिक गहराई से अध्ययन करने का फैसला किया कि यह कैसे अंदर काम करता है।

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

इसलिए, प्रत्येक जोड़ा पुस्तकालय या यहां तक कि कक्षा के बाद, मैंने नोट किया कि स्मृति की खपत कितनी तेजी से बढ़ रही है। इस बिंदु पर, मैं 14 KB से अधिक 32 केबी फ्लैश और 1300 बाइट्स रैम (2k में से) के साथ व्यस्त था। प्रत्येक लापरवाह आंदोलन ने पहले से ही उपयोग किए गए एक और 10 प्रतिशत को जोड़ा। लेकिन मैं अभी भी जीपीएस और एसडी / FAT32 पुस्तकालयों से जुड़ा नहीं हूं, और बिल्ली खुद रो रही थी। मुझे disassembler ~~चेकर~~ को चुनना था और अध्ययन करना था कि संकलक ने क्या किया।

मैंने चुपके से उम्मीद की कि लिंकर अप्रयुक्त कार्यों को बाहर निकालता है। लेकिन यह पता चला कि उनमें से कुछ लिंकर लगभग पूरी तरह से सम्मिलित करता है। फर्मवेयर में, मैंने स्क्रीन के साथ काम करने वाले पुस्तकालय के लाइन ड्राइंग फ़ंक्शन और कुछ अन्य लोगों को पाया, हालांकि कोड में मैंने स्पष्ट रूप से उस समय उन्हें कॉल नहीं किया था। स्पष्ट रूप से, उन्हें या तो नहीं बुलाया जाना चाहिए - अगर मुझे केवल बिटमैप्स से पत्र खींचना है तो मुझे एक रेखा खींचने वाले फ़ंक्शन की आवश्यकता क्यों है? नीले रंग से 5.2kb से अधिक (और वह फोंट की गिनती नहीं कर रहा है)।

प्रदर्शन नियंत्रण पुस्तकालय के अलावा, मैंने भी पाया:

2.6 kb - SoftwareSerial पर (मैंने इसे किसी समय प्रोजेक्ट में खींच लिया)
1.6 kb - I2C
1.3 केबी - हार्डवेयरसिरियल
2 केबी - टिनीगपीएस
वास्तविक kduino पर 2.5 kb (इनिशियलाइज़ेशन, पिन, सभी प्रकार की टेबल, फ़ंक्शन मिलिस के लिए मुख्य टाइमर) (और देरी) (),)

संख्या बहुत सांकेतिक हैं, जैसे आशावादी गंभीरता से मिश्रण कोड है। कुछ फ़ंक्शन एक स्थान पर शुरू हो सकते हैं, और फिर दूसरे पुस्तकालय से एक और, जिसे पहले एक से बुलाया जाता है, तुरंत इसका पालन कर सकता है। इसके अलावा, इन कार्यों की अलग-अलग शाखाएं फ्लैश के दूसरे छोर पर स्थित हो सकती हैं।

मुझे मिला कोड में भी:

एसपीआई द्वारा स्क्रीन नियंत्रण (हालांकि मैंने इसे I2C के माध्यम से जोड़ा है)
आधार वर्गों के तरीके जिन्हें स्वयं नहीं कहा जाता है, क्योंकि वारिसों में पुनर्परिभाषित
ऐसे विध्वंसक जिन्हें डिजाइन द्वारा कभी नहीं बुलाया जाता है
ड्राइंग फ़ंक्शंस (और सभी नहीं - फ़ंक्शंस का एक हिस्सा जो अभी भी फेंक दिया गया है)
मेरे कोड में malloc / free जबकि सभी ऑब्जेक्ट अनिवार्य रूप से स्थिर हैं

लेकिन न केवल फ्लैश मेमोरी की खपत, बल्कि SRAM भी छलांग और सीमा से बढ़ रहा है:

130 बाइट्स - I2C
100 बाइट्स - सॉफ्टवेयरसियर
157 बाइट्स - सीरियल
558 बाइट्स - प्रदर्शन (जिनमें से 512 फ्रेम बफर है)

कोई कम मनोरंजक नहीं था .data अनुभाग। लगभग 700 बाइट्स हैं और यह बात शुरू में एक फ्लैश से रैम में लोड होती है। यह पता चला कि स्मृति में चर के लिए आरक्षित स्थान हैं, और आरम्भिक मूल्यों के साथ। यहां उन चरों और स्थिरांक को जियो, जिन्हें आप PROGMEM घोषित करना भूल गए हैं।

इसमें स्क्रीन के "स्प्लैश स्क्रीन" के साथ एक विषम सरणी थी - फ्रेम बफर के प्रारंभिक मूल्य। सैद्धांतिक रूप से, यदि आप शुरू होने के तुरंत बाद डिस्प्ले () स्क्रीन बनाते हैं, तो आप फूल और एडफ्टर शिलालेख देख सकते हैं, लेकिन मेरे मामले में इस पर फ्लैश मेमोरी खर्च करना व्यर्थ है।

.Data अनुभाग में vtables भी शामिल हैं। उन्हें फ्लैश ड्राइव से मेमोरी में कॉपी किया जाता है, जाहिरा तौर पर रनटाइम में दक्षता के कारणों के लिए। लेकिन आपको रैम के एक बड़े टुकड़े को त्यागना होगा - 150 से अधिक बाइट्स एक दर्जन से अधिक कक्षाएं। इसके अलावा, ऐसा लगता है कि कोई संकलक कुंजी नहीं है, जो प्रदर्शन का बलिदान कर रहा है, फ्लैश मेमोरी में आभासी तालिकाओं को छोड़ देगा।

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

अद्यतन:
संसाधन दक्षता में कम प्रगति। मैं इस भाग के लिए एक अद्यतन कर रहा हूँ, क्योंकि अगले में मैं पूरी तरह से अलग चीजों पर ध्यान देना चाहता हूं।

टिप्पणियों में C ++ के उपयोग के बारे में कुछ घबराहट है। विशेष रूप से, वह इतना बुरा क्यों है और कीमती रैम में अस्थिर रहता है? सामान्य तौर पर, वर्चुअल फ़ंक्शंस, कंस्ट्रक्टर और विध्वंसक ओवरहेड होते हैं। क्यों? चलो यह पता लगाने!

यहां प्रोजेक्ट के किसी चरण में मेमोरी के आंकड़े दिए गए हैं
कार्यक्रम का आकार: 15 458 बाइट्स (30 720 बाइट का अधिकतम 50% इस्तेमाल किया गया) (2.45 सेकंड)
न्यूनतम मेमोरी उपयोग: 1258 बाइट्स (अधिकतम 2048 बाइट का 61%)

प्रयोग नंबर 1 - सी को फिर से लिखना।

मैंने कक्षाओं को फेंक दिया, फ़ंक्शन के लिए पॉइंटर्स के साथ तालिकाओं पर सब कुछ फिर से लिखा।चूंकि स्क्रीन वास्तव में हमेशा समान संरचना होती है, इसलिए सभी डेटा सदस्य सामान्य वैश्विक चर बन गए हैं। कार्यक्रम के आकार के

बाद के आंकड़े
: 14 568 बाइट (अधिकतम 30 720 बाइट का 47%) (2.35 सेकंड)
न्यूनतम मेमोरी उपयोग: 1176 बाइट्स (2048 बाइट अधिकतम का 57%)

कुल। फ्लैश के 900 बाइट और रैम के 80 बाइट जीते। क्या वास्तव में छोड़ दिया फ्लैश खोद नहीं था। रैम के 80 बाइट्स सिर्फ वाइट के आकार के हैं। अन्य सभी डेटा (कक्षा सदस्य) किसी तरह बने रहे।

मुझे यह कहना होगा कि मैंने सब कुछ खराब नहीं किया - मैं बस उस पर ज्यादा समय खर्च किए बिना बड़ी तस्वीर देखना चाहता था। रीफैक्टरिंग के बाद, मैंने स्क्रीनशॉट को "खो" दिया। उनके साथ, खपत थोड़ी अधिक होगी।

लेकिन इस प्रयोग में सबसे महत्वपूर्ण बात यह है कि कोड की गुणवत्ता में काफी गिरावट आई है। एक कार्यात्मक का कोड कई फाइलों में फैल गया है। डेटा के कुछ टुकड़ों के लिए, "एक मालिक" का अस्तित्व समाप्त हो गया, कुछ मॉड्यूल दूसरों की स्मृति में चढ़ने लगे। कोड व्यापक और बदसूरत हो गया है।

प्रयोग # 2 - सी ++ से बाइट्स निचोड़ें

मैंने अपना प्रयोग वापस किया, मैंने कक्षाओं के रूप में सब कुछ छोड़ने का फैसला किया। केवल इस बार, स्क्रीन सांख्यिकीय रूप से वितरित वस्तुओं पर करते हैं। मेरी स्क्रीन पर पृष्ठों की संरचना तय है। आप इसे नए / डिलीट का उपयोग किए बिना संकलन चरण में निर्दिष्ट कर सकते हैं।

कार्यक्रम का आकार: 15 408 बाइट्स (30 720 बाइट का अधिकतम 50% इस्तेमाल किया गया) (2.60 सेकंड)
न्यूनतम मेमोरी उपयोग: 1273 बाइट्स (2048 बाइट अधिकतम 62%)

रैम की खपत थोड़ी बढ़ गई है। लेकिन यह वास्तव में, बेहतर के लिए है। रैम की खपत में वृद्धि को ढेर से वस्तुओं के संचलन द्वारा एक सांख्यिकीय रूप से वितरित स्मृति क्षेत्र में समझाया गया है। यानीवास्तव में, ऑब्जेक्ट्स पहले बनाए गए थे, लेकिन यह आंकड़ों पर नहीं गया था। और अब इन वस्तुओं को स्पष्ट रूप से ध्यान में रखा जाता है।

लेकिन फ्लैश की खपत को कम करने के लिए काम नहीं किया। कोड में अभी भी स्वयं निर्माता शामिल हैं, जिन्हें अभी भी स्टार्टअप पर बुलाया जाता है। यानीसंकलक उन्हें पहले से "निष्पादित" नहीं कर सका और पूर्व-आवंटित क्षेत्रों में सभी मान डाल दिए। और कोड में अभी भी विध्वंसक थे, हालांकि हेजहोग के लिए यह स्पष्ट है कि वस्तुओं को कभी भी नष्ट नहीं किया जाएगा।

कम से कम थोड़ा बचाने की कोशिश में, मैंने पदानुक्रम में सभी विध्वंसक को हटा दिया, और विशेष रूप से बेस क्लास में वर्चुअल विध्वंसक। विचार प्रत्येक व्यवहार्य में कुछ बाइट्स को मुक्त करने के लिए था। और फिर एक आश्चर्य मुझे इंतजार कर रहा था:

कार्यक्रम का आकार: 14,704 बाइट्स (30,720 बाइट अधिकतम 48% का उपयोग किया गया) (2.94 सेकंड)
न्यूनतम मेमोरी उपयोग: 1211 बाइट्स (2048 बाइट अधिकतम 59%)

यह पता चला कि व्यवहार्य एक पॉइंटर से नहीं जाता है, लेकिन पहले से ही 2. इसके अलावा, दोनों को विध्वंसक के साथ करना था। केवल एक विध्वंसक खाली है (जाहिरा तौर पर स्टैक पर वस्तुओं के लिए), और दूसरा एक मुफ्त कॉल के साथ, ढेर पर वस्तुओं के लिए दिखाई देता है (-12 बाइट्स रैम)। इसके अलावा, कूल्हे (8 बाइट्स) से जुड़े चर और उन वस्तुओं के लेबल जो कभी नहीं बनते हैं (स्क्रीन, पेरेंटस्क्रीन - 40 बाइट्स) चले गए हैं।

फ्लैश की खपत में काफी कमी आई है - 700 बाइट्स। न केवल विध्वंसक स्वयं, बल्कि मॉलोक / मुक्त / नए / हटाए गए कार्यान्वयन भी चले गए हैं। एक खाली आभासी विध्वंसक के लिए 700 बाइट्स! 700 बाइट्स, कार्ल!

यह आगे और पीछे हवा नहीं होगा, यहाँ एक ही स्थान पर सभी संख्याएँ हैं

	यह था	सी	सी ++
फ़्लैश	१५ ४५ 15	14568	14704
रैम	1258	1176	1211

निचला रेखा: C ++ में खपत लगभग C के समान ही है। लेकिन एक ही समय में, एनकैप्सुलेशन, इनहेरिटेंस और बहुरूपता शक्ति हैं। मैं खपत में कुछ वृद्धि के साथ इसके लिए भुगतान करने के लिए तैयार हूं। शायद मैं सिर्फ C में खूबसूरती से नहीं लिख सकता, लेकिन क्यों, अगर मैं C ++ में खूबसूरती से लिख सकता हूं?

अंतभाषण

प्रारंभ में, मैं परियोजना के अंत में एक लेख लिखना चाहता था। लेकिन जब से कार्य की प्रगति के रूप में नोट्स तेज गति से जमा होते हैं, लेख बहुत बड़ा होने का खतरा होता है। इसलिए मैंने इसे कई हिस्सों में तोड़ने का फैसला किया। इस भाग में, मैंने तैयारी के चरणों के बारे में बात की: यह समझना कि मैं वास्तव में क्या चाहता हूं, एक मंच चुनना, एक आवेदन ढांचा लागू करना। 10 से अधिक वर्षों से मैंने माइक्रोकंट्रोलर्स के लिए गंभीरता से प्रोग्राम नहीं किया है। यह पता चला कि मैं बड़े कंप्यूटरों के संसाधनों की प्रचुरता से कुछ हद तक खराब हो गया था और यह ATMAga32 की वास्तविकताओं में तंग है। इसलिए, मुझे विभिन्न बैकअप विकल्पों के माध्यम से सोचना पड़ा, जैसे कि पुस्तकालयों की कार्यक्षमता को छोटा करना या स्मृति के कुशल उपयोग के नाम पर एप्लिकेशन को फिर से डिज़ाइन करना। मैं भी अधिक शक्तिशाली नियंत्रकों - ATMega64 या STM32 लाइन से कुछ पर स्विच करने की संभावना को बाहर नहीं करता हूं।

अगले भाग में, मैं बुनियादी कार्यक्षमता के कार्यान्वयन के लिए आगे बढ़ना चाहता हूं - जीपीएस के साथ काम करना। मैंने पहले ही कुछ दिलचस्प रेक का सामना किया है, जिसके बारे में मैं बताना चाहूंगा।

शैली से, लेख एक निर्माण पत्रिका की तरह कुछ निकला। और मुझे रचनात्मक टिप्पणियों पर खुशी होगी - कुछ भी बदलने में देर नहीं हुई। जो लोग मेरे प्रोजेक्ट को जीथब पर शामिल कर सकते हैं ।

पहले भाग का अंत।

दूसरा भाग

Multifunctional DIY लकड़हारा। भाग 1