Arduin और LED, या बच्चों के डिज़ाइनर को कैसे अपग्रेड करें

मेरे बेटे ने चुंबकीय कंस्ट्रक्टर मैगफॉर्मर्स पर दृढ़ता से "हुक" किया। एक बार फिक्सिक्स की एक श्रृंखला के माध्यम से देखने पर जहां एक ही निर्माता को चित्रित किया गया था, बच्चे ने पूछा: "पिताजी, क्यों फिक्स्चर में विवरण हैं जो चमकते हैं, लेकिन हम नहीं करते हैं?"

यह पता चला कि वास्तव में एक "मैगफॉर्मर नियोन एलईडी सेट" है, जहां सामान्य भवन ब्लॉकों के अलावा, एक एलईडी के साथ एक तत्व भी है। इस समय से हमने पहले से ही सभी संभावित आकृतियों और आकारों के मैग्नेट का एक पूरा बॉक्स इकट्ठा कर लिया था (जैसा कि मेरे लिए, चीनी मैगफॉर्मर मूल रूप से नीच नहीं हैं), मैं किसी भी तरह एक और सेट सिर्फ एक लाइट बल्ब की खातिर खरीदना नहीं चाहता था। इसके अलावा, इस सेट में बैकलाइटिंग के बिना एक समान लागत की तुलना में काफी अधिक है।

यह अनुमान लगाने के बाद कि घटकों में केवल कुछ रुपये हैं, जिनमें से अधिकांश मेरे पास पहले से ही थे, मैंने अपना मॉर्गुलका इकट्ठा करने का फैसला किया। हां, और उन प्रभावों के साथ जो मूल नहीं थे।

बिल्ली के नीचे आपको ATTiny85 पर एक ब्लिंकर और WS8212 एल ई डी पर एलईडी पैनल का विकल्प मिलेगा। मैं सर्किटरी के बारे में बात करूँगा, कि कैसे मैंने इस पूरी चीज़ को बैटरी से संचालित किया, साथ ही साथ रास्ते में आने वाली असंबद्ध समस्याओं को भी। मैं परियोजना के सॉफ्टवेयर घटक के बारे में भी विस्तार से बात करूंगा।

पहला कदम

यह मुझे लग रहा था कि एक नियमित एलईडी (यहां तक ​​कि आरजीबी) पर चमक उबाऊ और केले है। लेकिन WS8212 की तरह कुछ महसूस करने के लिए दिलचस्प लग रहा था। ईबीई पर, आकार में 16x16 तक के दोनों व्यक्तिगत एल ई डी और मैट्रीस की पेशकश की गई थी। कई अलग-अलग मॉड्यूल खरीदे जाने के बाद, मैंने 4x4 मैट्रिक्स पर फैसला किया। विभिन्न दृश्य प्रभावों में लिप्त होने के लिए इसमें बहुत सारे एलईडी हैं, जबकि मॉड्यूल आकार में डिज़ाइनर के वर्ग ब्लॉक की खिड़की से तुलनीय है।



एलईडी मैट्रिक्स को नियंत्रित करने के लिए, माइक्रोकंट्रोलर का केवल एक पिन पर्याप्त है, इसलिए भी आर्डिनो नैनो एक बस्ट की तरह दिखता है (इसके अलावा, यह मामले में फिट नहीं होगा)। लेकिन ATTiny85 नियंत्रक पर digispark क्लोन सिर्फ सही निकला - इसमें बहुत अधिक मेमोरी और पिन नहीं है, लेकिन एलईडी ब्लिंकर के लिए पर्याप्त से अधिक है। मॉड्यूल Arduino IDE के साथ पूरी तरह से एकीकृत होता है और इसमें बोर्ड पर एक USB बूटलोडर होता है, इसलिए इस मॉड्यूल को प्रोग्रामिंग करना बहुत सरल और आरामदायक है। मैं लंबे समय से इसे आजमाना चाहता हूं।

सबसे सरल योजना के साथ शुरू किया।



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

लेकिन इसने तुरंत काम नहीं किया। Digispark ATTiny85 मॉड्यूल का सर्किट इसके लिए बहुत डिज़ाइन नहीं किया गया है - या तो यूएसबी पावर है, लेकिन फिर बिजली सीधे माइक्रोकंट्रोलर (+5 बस) के माध्यम से, या वीआईएन इनपुट से आपूर्ति की जाती है, लेकिन फिर पावर 7805 रैखिक स्टेबलाइज़र के माध्यम से होता है। लिथियम चार्ज मॉड्यूल जब विकल्प होता है। यूएसबी कनेक्टर और माइक्रोकंट्रोलर के बीच की खाई में डाला जाता है। मुझे सर्किट को थोड़ा संशोधित करना पड़ा और अतिरिक्त विवरण निकालना पड़ा।



तो, अब USB बिजली VIN पिन को आपूर्ति की जाती है और फिर चार्जर इनपुट पर जाती है। चार्जर आउटपुट (वास्तव में, बैटरी सीधे जुड़ा हुआ है) 5V पैर के माध्यम से बोर्ड में वापस जाता है। और यद्यपि वास्तव में 3 से 4.2V (बैटरी वोल्टेज) होगा, यह काफी सामान्य है - माइक्रोकंट्रोलर का ऑपरेटिंग वोल्टेज रेंज 1.8-5.5V है। और यहां तक ​​कि एलईडी मॉड्यूल सामान्य रूप से 2.7V से काम करता है, हालांकि 3.2V के नीचे नीले एलईडी की थोड़ी कमी है और रंग "फ्लोट" पीले रंग में थोड़ा सा है।

ऊर्जा बचाने के लिए, हमेशा ऑन-डी 2 एलईडी भी गायब हो गया। सामान्य योजना अब इस तरह दिखती है



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

मैंने eBay पर एक 6x25x35 आकार की बैटरी खरीदी, लेकिन यह या तो ख़राब हो गई, या मैंने इसे शॉर्ट सर्किट या बड़े चार्ज करंट से मार दिया (डिफ़ॉल्ट रूप से चार्ज करंट 1A पर सेट है और आपको करंट को कम करने के लिए एक रोकनेवाला की आवश्यकता है)। किसी भी मामले में, जब लोड जुड़ा हुआ था, यहां तक ​​कि 10 एमए पर, बैटरी पर वोल्टेज 1 वी तक गिर गया। परीक्षण के समय, मैंने एक छोटे क्वाड्रोकॉप्टर से एक अर्ध-मृत LiPo बैटरी पर स्विच किया। थोड़ी देर बाद मैंने एक अन्य विक्रेता से बैटरी का आदेश दिया और यह अच्छा निकला।

सिद्धांत रूप में, इस पर रोकना संभव होगा, कनेक्टिंग तारों को मिलाप करना और धीरे-धीरे सब कुछ किसी तरह के आवास में धकेलना होगा, लेकिन मैंने सर्किट की खपत को मापने का फैसला किया। और फिर मैं रो पड़ा। ठीक है, काम करने की स्थिति में (जब बल्ब पूरी तरह से चमकते हैं) तो यह चीज़ 130mA तक खा जाती है, इसलिए आराम करने पर, खपत 25mA से अधिक होती है! यानी यह ब्लिंकर एक दिन से भी कम समय में मेरी 600mAh की बैटरी खा जाता है!

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

शेष 15 एमए की खपत माइक्रोकंट्रोलर द्वारा की जाती है। हां, इसे बिस्तर पर रखा जा सकता है और डेटाशीट के अनुसार, खपत को माइक्रोएम्प्स द्वारा मापा जाएगा, लेकिन वास्तव में 1 एमए से कम प्राप्त करना संभव नहीं था। मैंने ADC को बंद कर दिया और पिनों को इनपुट में अनुवादित किया। ऐसा लगता है कि कहीं न कहीं सर्किट में किसी प्रकार का रिसाव है, लेकिन इलेक्ट्रॉनिक्स का मेरा मामूली ज्ञान इसे खोजने और समझने के लिए पर्याप्त नहीं है।

हम योजना को जटिल बनाते हैं

तब मुझे याद आया कि मैंने एक परीक्षण के लिए PT1502 चिप खरीदी है। यह चिप एक लिथियम बैटरी चार्ज नियंत्रक है जो कई नियंत्रण इनपुट के साथ एक बिजली की आपूर्ति के साथ पूरा होता है। एकमात्र कठिनाई यह है कि माइक्रोक्रिसिट 4x4 मिमी के क्यूएफएन 20 पैकेज में आता है और इसके लिए कुछ स्ट्रैपिंग की आवश्यकता होती है। घर पर इसे टांका लगाना मुश्किल है, लेकिन संभव है। शुल्क एक नियमित LUT के लिए मुश्किल है और चीनी से आदेश दिया जाना चाहिए। लेकिन हम कठिनाइयों से डरते नहीं हैं, है ना?

कई बॉक्स में, योजना को निम्नानुसार वर्णित किया जा सकता है।



ऑफ स्टेट में, कंट्रोलर और एल ई डी को बिजली की आपूर्ति नहीं की जाती है। डिवाइस में एक 'पावर' बटन है जो ब्लिंकर को चालू करता है (यह मोड भी स्विच करता है)। एलईडी चमकता है, कहते हैं, एक मिनट, और अगर कोई उपयोगकर्ता गतिविधि नहीं है (कोई भी एक बटन दबाता है), तो डिवाइस बंद हो जाता है। यानी यह न सिर्फ सोने जा रहा है, बल्कि पावर होल्ड सिग्नल द्वारा इसे अपने आप बंद कर देता है। और यह सब कुछ एक बार में बंद कर देता है - दोनों माइक्रोकंट्रोलर और एलईडी। कार्यक्षमता और बंद कार्यक्षमता PT1502 चिप के अंदर कार्यान्वित की जाती है

एक सर्किट आरेख बनाने और एक सर्किट बोर्ड बनाने के लिए सभी को छोड़ दिया गया है। सर्किट्री, अधिकांश भाग के लिए, PT1502 डेटाशीट के साथ-साथ Digispark ATTiny85 मॉड्यूल से लैस है। PT1502 पावर कंट्रोलर के माइक्रोकिरिट को कार्यात्मक रूप से कई भागों में विभाजित किया जाता है, इसलिए इसे सर्किट में ब्लॉक में विभाजित किया जाता है।



यह, वास्तव में, अपने स्वयं के दोहन के साथ एक लिथियम बैटरी चार्ज नियंत्रक है। LED1 चार्ज की स्थिति को इंगित करता है - चालू है, फिर चार्ज चालू है। रेसिस्टर R6 चार्ज करंट को 470mA पर सेट करता है। चूँकि मेरे पास 600mAh की बैटरी है, सिद्धांत रूप में, आप करंट को बढ़ा सकते हैं और 600mA तक 780-800 Ohms पर रेसिस्टर लगा सकते हैं। हालाँकि, मैं अपनी बैटरी की विशेष गुणवत्ता के बारे में निश्चित नहीं हूँ - इसे और अधिक धीरे-धीरे चार्ज करना बेहतर है, लेकिन यह अधिक समय तक चलेगा।

पावर प्लान पर विचार करें



SW1 बटन पूरे सिस्टम को शुरू करता है - PT1502 चिप खुद उठता है और फिर सभी बिजली स्रोतों (जिनमें से यह 3 है) को शुरू करता है। जब बिजली स्थापित हो जाती है, तो माइक्रो सर्किल RESET सिग्नल जारी करके माइक्रोकंट्रोलर को शुरू कर देगा। डिबगिंग में आसानी के लिए, मैंने एक अलग रीसेट बटन भी जोड़ा।

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

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

चलो एक सेकंड के लिए SW1 बटन पर वापस जाएं। मैंने निर्णय लिया कि नियंत्रण के लिए और नियंत्रण के लिए 2 अलग-अलग बटन न बनाएं। इसलिए, एक ही बटन ATTiny85 से भी जुड़ा हुआ है और ऑपरेशन के दौरान ब्लिंकिंग मोड स्विच करता है। डिवाइडर R7-R8 के मूल्यों को चुना जाता है ताकि PB2 माइक्रोकंट्रोलर के पोर्ट को न जलाया जा सके। सभी बैटरी वोल्टेज पर्वतमाला (3.3 - 4.2V) के लिए, वोल्टेज निर्दिष्ट डेटाशीट सीमा (0.7 * वीसीसी - वीसीसी + 0.5 वी) के भीतर नियंत्रक के पैर को आपूर्ति की जाएगी

एक शक्ति स्रोत पर विचार करें



यह एक स्पंदित डीसी-डीसी कनवर्टर है। आउटपुट वोल्टेज प्रतिरोधों R10-R11 द्वारा सेट किया गया है और, डेटशीट से सूत्र के अनुसार, 3.3V पर सेट है। बाकी सब कुछ एक साधारण स्ट्रैपिंग है।

अच्छे के लिए, इस तरह के एक चालित-आउट पावर स्रोत की वास्तव में आवश्यकता नहीं है - यह संभव है कि बैटरी से सीधे माइक्रोकंट्रोलर को बिजली दी जाए। यह सिर्फ इतना है कि इस स्रोत को पहले से ही PT1502 चिप में लागू किया गया है और इसे ज़रूरत पड़ने पर चालू / बंद कर सकते हैं - इसका उपयोग क्यों नहीं करते?



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

आइए तार्किक भाग पर चलते हैं।



USB केबल को Digispark बोर्ड से अपरिवर्तित रखा गया है। यह यूएसबी वोल्टेज (जो 3.3 वी चलाता है) और माइक्रोकंट्रोलर के संकेतों (जो मूल में 5 वी द्वारा संचालित होता है) के समन्वय के लिए आवश्यक है। चूंकि मेरे मामले में माइक्रोकंट्रोलर भी 3.3V द्वारा संचालित है, इसलिए सर्किट को सरलीकृत किया जा सकता है, लेकिन सिर्फ मामले में, मैंने बोर्ड पर मूल सर्किट को तलाक दिया।



माइक्रोकंट्रोलर के बंधन में कुछ भी दिलचस्प नहीं है।

अंतिम स्पर्श कनेक्टर है



वास्तव में, मुझे ATTiny85 पर USB समर्थन और लिथियम बैटरी के साथ एक पावर कंट्रोलर के साथ अपने लिए ऐसा डिबगिंग बोर्ड मिला है। इसलिए, मैंने खुद को केवल एलईडी को लाइन आउटपुट करने के लिए सीमित नहीं किया। इसके बजाय, मैंने कंघी के लिए माइक्रोकंट्रोलर की सभी लाइनों को लाया - उसी समय यह प्रोग्रामर से कनेक्ट करने के लिए सुविधाजनक है।

और लगभग सभी लाइनों को एक निश्चित कार्यक्षमता (पीबी 1 - होल्ड लाइन, पीबी 2 - पावर बटन, पीबी 3 / पीबी 4 - यूएसबी, पीबी 5 - रीसेट) से पूरी तरह से बंधे होने दें, भविष्य में कुछ सीमाओं को बायपास करना संभव होगा। उदाहरण के लिए, यूएसबी केबल को मिलाप न करें और पीबी 3 / पीबी 4 लाइनों को छोड़ दें। या, उदाहरण के लिए, एक रीसेट से इनकार करें और पीबी 5 जारी करें। इस बीच, केवल PB0 मुक्त रहता है - और हमारे एलईडी को इससे कनेक्ट करें।

हम बोर्ड में पास होते हैं। 40x40 मिमी में बोर्ड के आकार, घटकों की संख्या और PT1502 चिप के QFN20 आवास की सीमाओं को देखते हुए, मैंने घर पर बोर्ड का निर्माण करने पर भी विचार नहीं किया। इसलिए, मैंने तुरंत सबसे कॉम्पैक्ट टू-लेयर बोर्ड को प्रजनन करना शुरू कर दिया। मुझे यही मिला है



उपयोग में आसानी के लिए, रिवर्स साइड पर मैंने सभी संभावित आउटपुट फ़ंक्शंस पर हस्ताक्षर किए (मुझे Digispark बोर्ड से विचार मिला)



मैंने JLCPCB पर बोर्ड का आदेश दिया। ईमानदार होने के लिए, मैं गुणवत्ता से बहुत संतुष्ट नहीं हूं - यदि आप चिप को कई बार मिलाते हैं, तो PT1502 के छोटे संपर्कों के पास मुखौटा थोड़ा बादल है। खैर, छोटे-छोटे शिलालेख तैरते रहे। हालांकि, अगर सब कुछ पहली बार मिलाप हो, तो मानदंड।

टांका लगाने वाले QFN20 के लिए आपको एक टांका लगाने वाले लोहे की आवश्यकता होती है, बाकी सब कुछ एक निश्चित कौशल के साथ एक निश्चित टांका लगाने वाले लोहे के साथ मिलाप किया जा सकता है। यह सोल्डरेड बोर्ड जैसा दिखता है

आवास

यह पतवार पर आगे बढ़ने का समय है। मैंने इसे 3 डी प्रिंटर पर छापा। नो-फ्रिल्स डिजाइन - बॉक्स और बटन। डिजाइनर के मानक वर्ग मॉड्यूल में जुगनू स्थापित करने के लिए बॉक्स पर विशेष हुक प्रदान किए जाते हैं।



मुख्य बोर्ड और बैटरी मामले में रहते हैं।





एलईडी पैनल को कवर पर लगाया गया है, जो बदले में शिकंजा के साथ मुख्य बॉक्स पर खराब हो गया है

पहले तो मैंने स्क्रू के साथ एलईडी पैनल को कवर करने के लिए सोचा था, लेकिन अंत में मैंने इसे एक डबल-साइड टेप पर चिपका दिया। यह इस तरह निकला



इस रूप में, डिवाइस पहले से ही उपयोग किया जा सकता है, लेकिन यह अभी भी बदसूरत दिखता है - पर्याप्त विसारक नहीं है।

मैंने एक कंस्ट्रक्शन हेअर ड्रायर (विमान के मॉडल पर झांकने) के साथ पीईटी बोतलों के संकोचन की तकनीक का उपयोग करके डिफ्यूज़र का पहला संस्करण बनाने की कोशिश की।

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



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

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

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

प्रविष्टि

एलईडी ब्लिंकर के लिए, आपको विशेष रूप से माइक्रोकंट्रोलर की परिधि में गोता लगाने की आवश्यकता नहीं है - GPIO के साथ काम करने के लिए कुछ फ़ंक्शन पर्याप्त हैं। लेकिन चूंकि मॉड्यूल Arduino प्लेटफॉर्म के साथ डॉक किया गया है, तो इसका लाभ क्यों नहीं उठाया जाए?

सबसे पहले, कुछ परिभाषाएँ और स्थिरांक

// Number of total LEDs on the board. Mine has 4x4 LEDs #define NUM_HW_PIXELS 16 // Pin number where LED data pin is attached #define DATA_PIN 0 // Pin number where mode switch button is attached #define BUTTON_PIN 2 // Power Enabled pin #define POWER_EN_PIN 1 // Max brightness (dimming the light for debugging) #define MAX_VAL 255 

यह मेरे मैट्रिक्स में पिक्सल की संख्या, पिन नंबर और एल ई डी की अधिकतम चमक को निर्धारित करता है (डिबगिंग के दौरान इसे 50 पर सेट करना सुविधाजनक था ताकि यह मेरी आँखों को अंधा न करे)

मेरे मैट्रिक्स में एल ई डी को एक गैर-स्पष्ट तरीके से व्यवस्थित किया गया है - एक ज़िगज़ैग। इसलिए, अलग-अलग प्रभावों के लिए, मुझे त्याग करना पड़ा।

 // LED indexes for different patterns uint8_t circleLEDIndexes[] = {0, 1, 2, 3, 4, 11, 12, 13, 14, 15, 8, 7}; uint8_t beaconLEDIndexes[] = {6, 5, 10, 9}; uint8_t policeLEDIndexes[] = {7, 6, 10, 11, 4, 5, 9, 8}; 

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

सबसे पहले, बोर्ड और डब्लूएस library२११ लाइब्रेरी को शुरू करने की आवश्यकता है।

 // Driver Ai_WS2811 ws2811; void setup() { // Set up power pinMode(POWER_EN_PIN, OUTPUT); digitalWrite(POWER_EN_PIN, HIGH); // initialize LED data pin pinMode(LED_PIN, OUTPUT); // Initialize button pin pinMode(BUTTON_PIN, INPUT); // Initialize WS8211 library static CRGB ledsBuf[NUM_HW_PIXELS]; ws2811.init(DATA_PIN, NUM_HW_PIXELS, ledsBuf); // Set the watchdog timer to 2 sec wdt_enable(WDTO_2S); } 

सबसे पहले, आपको एकता के लिए पॉवर होल्ड सिग्नल सेट करने की आवश्यकता है - यह PT1502 चिप के लिए एक सिग्नल होगा जो कि माइक्रोकंट्रोलर के घाव है और ठीक से काम कर रहा है। बदले में माइक्रोक्रेकिट नियमित रूप से माइक्रोकंट्रोलर और एलईडी को बिजली की आपूर्ति करेगा, जब तक कि होल्ड सिग्नल को एकता के लिए सेट नहीं किया जाता है।

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

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

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

 void setRgb(uint8_t led_idx, uint8_t r, uint8_t g, uint8_t b) { CRGB * leds = ws2811.getRGBData(); leds[led_idx].r = r; leds[led_idx].g = g; leds[led_idx].b = b; } 

लेकिन ज्यादातर मामलों में, आरजीबी रंग मॉडल में, रंग गिनना बहुत सुविधाजनक नहीं है, या असंभव भी है। उदाहरण के लिए, किसी भी प्रकार के इंद्रधनुष को बनाते समय , HSV रंग मॉडल के साथ काम करना अधिक सुविधाजनक होता है। प्रत्येक पिक्सेल का रंग रंग टोन और चमक के मूल्य द्वारा निर्धारित किया जाता है। सादगी (अधिकतम उपयोग किया जाता है) के लिए संतृप्ति छोड़ा जाता है। ह्यू मान 0-255 (मानक 0-359 के बजाय) की सीमा तक कम हो जाते हैं।

 /** * HVS to RGB conversion (simplified to the range 0-255) **/ void setHue(uint8_t led_idx, int hue, int brightness) { //this is the algorithm to convert from RGB to HSV double r = 0; double g = 0; double b = 0; double hf = hue/42.6; // Not /60 as range is _not_ 0-360 int i=(int)floor(hue/42.6); double f = hue/42.6 - i; double qv = 1 - f; double tv = f; switch (i) { case 0: r = 1; g = tv; break; case 1: r = qv; g = 1; break; case 2: g = 1; b = tv; break; case 3: g = qv; b = 1; break; case 4: r = tv; b = 1; break; case 5: r = 1; b = qv; break; } brightness = constrain(brightness, 0, MAX_VAL); setRgb(led_idx, constrain(brightness*r, 0, MAX_VAL), constrain(brightness*g, 0, MAX_VAL), constrain(brightness*b, 0, MAX_VAL) ); } 

फ़ंक्शन को एआई_डब्ल्यूएस 8211 लाइब्रेरी से लिया गया है और थोड़ा सा दायर किया गया है। लाइब्रेरी से इस फ़ंक्शन के मूल संस्करण में कुछ कीड़े थे, जिसके कारण इंद्रधनुष पर रंग झटके के साथ दिखाया गया था।

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

यह सबसे सरल प्रभाव है - सभी एलईडी एक रंग से भरे हुए हैं, जो आसानी से बदलता है।

 void rainbow() { static uint8_t hue = 0; hue++; for (int led = 0; led < NUM_HW_PIXELS; led++) setHue(led, hue, MAX_VAL); ws2811.sendLedData(); delay(80); } 

अगला प्रभाव अधिक दिलचस्प है - यह मैट्रिक्स के समोच्च के साथ एक इंद्रधनुष प्रदर्शित करता है, और इंद्रधनुष में रंग धीरे-धीरे एक सर्कल में शिफ्ट होते हैं।

 void slidingRainbow() { static uint8_t pos = 0; pos++; for (int led = 0; led < ARRAY_SIZE(circleLEDIndexes); led++) { int hue = (pos + led*256/ARRAY_SIZE(circleLEDIndexes)) % 256; setHue(circleLEDIndexes[led], hue, MAX_VAL); } ws2811.sendLedData(); delay(10); } 

और यह प्रभाव पूरे मैट्रिक्स को एक यादृच्छिक रंग से भरता है, जो पहले आसानी से रोशनी करता है, और फिर आसानी से निकल जाता है।

 void randomColorsFadeInOut() { static uint8_t color = 0; static bool goesUp = false; static uint8_t curLevel = 0; if(curLevel == 0 && !goesUp) { color = rand() % 256; goesUp = true; } if(curLevel == MAX_VAL && goesUp) { goesUp = false; } for(int led = 0; led < NUM_HW_PIXELS; led++) setHue(led, color, curLevel); if(goesUp) curLevel++; else curLevel--; ws2811.sendLedData(); delay(10); } 

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

 void orangeBeacon() { const int ORANGE_HUE = 17; static uint8_t pos = 0; pos+=3; for (int led = 0; led < ARRAY_SIZE(circleLEDIndexes); led++) { int brightness = brightnessByPos(pos, led*255/ARRAY_SIZE(circleLEDIndexes), 70); setHue(circleLEDIndexes[led], ORANGE_HUE, brightness); } ws2811.sendLedData(); delay(1); } 

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

 int brightnessByPos(int pos, int ledPos, int delta) { int diff = abs(pos - ledPos); if(diff > 127) diff = abs(256-diff); int brightness = MAX_VAL - constrain(MAX_VAL*diff/delta, 0, MAX_VAL); return brightness; } 

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

या, उदाहरण के लिए, एक पुलिस लाल-नीली चमकती रोशनी

 void policeBeacon() { const int RED_HUE = 0; const int BLUE_HUE = 170; static uint8_t pos = 0; pos += 2; for (int led = 0; led < ARRAY_SIZE(policeLEDIndexes); led++) { int ledPos = led*255/ARRAY_SIZE(policeLEDIndexes); int brightness = brightnessByPos(pos, ledPos, 50); setHue(policeLEDIndexes[led], RED_HUE, brightness); if(brightness == 0) { brightness = brightnessByPos((pos+100) % 256, ledPos, 50); setHue(policeLEDIndexes[led], BLUE_HUE, brightness); } } ws2811.sendLedData(); delay(1); } 

चूंकि हम कारों के बारे में बात कर रहे हैं, तो यहां ट्रैफिक लाइट को लागू करने के लिए कोई समस्या नहीं है।

ये ऐसे कार्य हैं जिनमें विभिन्न पदों पर विभिन्न ट्रैफ़िक सिग्नल शामिल हैं।

 void clearPixels() { for(int i=0; i<NUM_HW_PIXELS; i++) { setRgb(i, 0, 0, 0); } } void redTrafficLights() { for(int i=0; i<4; i++) setRgb(i, MAX_VAL, 0, 0); ws2811.sendLedData(); } void yellowTrafficLights() { for(int i=4; i<8; i++) setRgb(i, MAX_VAL, MAX_VAL, 0); ws2811.sendLedData(); } void greenTrafficLights() { for(int i=8; i<16; i++) setRgb(i, 0, MAX_VAL, 0); ws2811.sendLedData(); } 

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

 enum TRAFFIC_LIGHTS { NONE, RED, YELLOW, GREEN }; struct trafficLightState { uint8_t state; uint16_t duration; }; const trafficLightState trafficLightStates[] = { {NONE, 1}, // clear yellow {RED, 7000}, // red {YELLOW, 2000}, // red + yellow {NONE, 1}, // clear red+yellow {GREEN, 7000}, // green {NONE, 300}, // Blinking green {GREEN, 300}, // Blinking green {NONE, 300}, // Blinking green {GREEN, 300}, // Blinking green {NONE, 300}, // Blinking green {GREEN, 300}, // Blinking green {NONE, 1}, // clear green {YELLOW, 2000}, // yellow }; 

वास्तव में फ़ंक्शन जो इसे संसाधित करता है

 void trafficLights() { static uint8_t curStateIdx = 0; static unsigned long curStateTimeStamp = 0; // Switch to a new state when time comes if(millis() - curStateTimeStamp > (unsigned long)trafficLightStates[curStateIdx].duration) { curStateIdx++; curStateIdx %= ARRAY_SIZE(trafficLightStates); curStateTimeStamp = millis(); } switch(trafficLightStates[curStateIdx].state) { case NONE: clearPixels(); ws2811.sendLedData(); break; case RED: redTrafficLights(); break; case YELLOW: yellowTrafficLights(); break; case GREEN: greenTrafficLights(); break; default: break; } // Just waiting delay(10); } 

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

अंतिम प्रभाव जिस पर मेरी कल्पना पर्याप्त थी, तारांकन है। 5 यादृच्छिक एल ई डी यादृच्छिक चमक पर प्रकाश और फिर सुचारू रूप से बंद। यदि एक तारा बाहर जाता है, तो एक यादृच्छिक स्थान पर एक और प्रकाश होगा।

 void stars() { const uint8_t numleds = 5; static uint8_t ledIndexes[numleds] = {0}; static uint8_t curVal[numleds] = {0}; static uint8_t maxVal[numleds] = {0}; for(int i=0; i<numleds; i++) { if(ledIndexes[i] == 0) { uint8_t led = rand() % (NUM_HW_PIXELS+1); CRGB * leds = ws2811.getRGBData(); if(leds[led].r == 0) { ledIndexes[i] = led; maxVal[i] = rand() % (MAX_VAL-1) + 1; curVal[i] = 0; } } else { uint8_t led = ledIndexes[i]; if(curVal[i] < maxVal[i]) curVal[i]++; else if(curVal[i] == maxVal[i]) maxVal[i] = 0; else if(curVal[i] == 0 || --curVal[i] == 0) ledIndexes[i] = 0; setRgb(led-1, curVal[i], curVal[i], curVal[i]); } } ws2811.sendLedData(); delay(80); } 

कहीं न कहीं यहाँ एक दुष्ट बग तबाही मचा रहा है। कभी-कभी तारे तेजी से चमकते हैं, या इसके विपरीत अचानक निकल जाते हैं। लेकिन ईमानदार होने के लिए, मुझे यह पता लगाने के लिए बहुत आलसी था - यह बिल्कुल सामान्य लग रहा है।

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

 void shutdownOnTimeOut(bool resetTimer = false) { static unsigned long periodStartTime = 0; if(periodStartTime == 0 || resetTimer) { periodStartTime = millis(); return; } if(millis() - periodStartTime >= 90000UL) { periodStartTime = 0; shutDown(); } } 

वास्तव में बिजली बंद निम्नानुसार होती है।

 void shutDown() { clearPixels(); ws2811.sendLedData(); wdt_disable(); digitalWrite(POWER_EN_PIN, LOW); // No power after this point while(true) ; } 

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

अंत में, मुख्य लूप जो इसे शुरू करता है

 // List of pointers to functions that serve different modes void (*Modes[])() = { rainbow, slidingRainbow, orangeBeacon, policeBeacon, trafficLights, stars, randomColorsFadeInOut }; void loop() { static uint8_t mode = eeprom_read_byte( (uint8_t*) 10 ); static bool waitingForBtnUp = false; static long btnPressTimeStamp; // Button switches mode if(digitalRead(BUTTON_PIN) == HIGH && !waitingForBtnUp) { delay(20); if(digitalRead(BUTTON_PIN) == HIGH) { mode++; mode %= ARRAY_SIZE(Modes); // num modes clearPixels(); ws2811.sendLedData(); delay(1); eeprom_write_byte( (uint8_t*) 10, mode ); waitingForBtnUp = true; btnPressTimeStamp = millis(); shutdownOnTimeOut(true); } } // Shut down on long press over 5s if(digitalRead(BUTTON_PIN) == HIGH && waitingForBtnUp && millis() - btnPressTimeStamp > 5000) shutDown(); // Detect button release if(digitalRead(BUTTON_PIN) == LOW && waitingForBtnUp) waitingForBtnUp = false; // display LEDs according to current mode Modes[mode](); // pong shutdown timer shutdownOnTimeOut(); // Yes, we still alive wdt_reset(); } 

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

यदि कोई बच्चा, कहता है, एक पुलिस कार खेल रहा था और 1.5 मिनट के बाद आपातकालीन प्रकाश बंद हो गया, तो बेटे पर दूसरी बारी के बाद सबसे अधिक संभावना है कि वह पुलिस कार खेलना जारी रखेगा। ऐसा करने के लिए, चयनित मोड EEPROM (सेल नंबर 10 बुलडोजर से चुना गया है) में सहेजा गया है।

यहां एक वीडियो है जो दिखाता है कि यह कैसे काम करता है।

बूटलोडर

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

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

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

दोनों समस्याओं को ठीक करने का लाभ मुश्किल नहीं है। डिजीस्पार्क ATTiny85 माइक्रोन्यूक्लियस बूटलोडर का उपयोग करता है । यह बूटलोडर हमारी आवश्यकताओं के लिए फाइल करने के लिए काफी आसान है। कॉन्फ़िगरेशन फ़ाइल में संबंधित परिभाषित को सही करने के लिए केवल आवश्यक है।

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

Bootloaderconfig.h फ़ाइल में, बूटलोडर में प्रवेश करने के तरीके का विकल्प है। बॉक्स से बाहर की पेशकश की गई चीज़ों से हमें कुछ भी पसंद नहीं है, लेकिन निकटतम विकल्प ENTRY_JUMPER है। इस विकल्प में, बूटलोडर केवल तभी एक्सेस किया जाता है जब एक विशिष्ट पिन पर एक निश्चित स्तर दिखाई देता है (जम्पर बोर्ड पर बंद है)।

 #define ENTRYMODE ENTRY_JUMPER 

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

हमें 3 कार्यों को परिभाषित करने की आवश्यकता है - आरंभीकरण, विचलन, और वास्तव में जाँच करना कि क्या बूटलोडर में प्रवेश करने का समय है। मूल में, वे सभी सरल हैं और मैक्रोज़ के साथ कार्यान्वित किए जाते हैं। केवल पहले 2 सरल होंगे

 #define HOLD_PIN PB1 #define JUMPER_PIN PB2 #define JUMPER_PORT PORTB #define JUMPER_DDR DDRB #define JUMPER_INP PINB #define bootLoaderInit() {JUMPER_DDR &= ~_BV(JUMPER_PIN); JUMPER_DDR |= _BV(HOLD_PIN); JUMPER_PORT &= ~_BV(JUMPER_PIN); JUMPER_PORT |= _BV(HOLD_PIN); _delay_ms(1);} #define bootLoaderExit() {;} 

bootLoaderInit () इनपुट करने के लिए बटन पिन (JUMPER_PIN) को कॉन्फ़िगर करता है और इसके लिए निलंबित को बंद कर देता है। हमारे पास पहले से ही बोर्ड पर और जमीन पर एक पुल-अप है, और जब आप पिन पर एक बटन दबाते हैं, तो इसके विपरीत, एक होगा। उसी समय, आप तुरंत आउटपुट पर होल्ड सिग्नल कॉन्फ़िगर कर सकते हैं और यूनिट को उस पर सेट कर सकते हैं ...

उदाहरण के लिए बिट अंकगणितीय की व्याख्या के लिए, यहां जाएं , और AVR नियंत्रकों में GPIO सेटअप रजिस्टरों की समझ को, उदाहरण के लिए, यहाँ से चमकाया जा सकता है ।

BootLoaderExit () फ़ंक्शन रिक्त है क्योंकि उजागर विन्यास मुख्य फर्मवेयर के बाद के संक्रमण के लिए काफी उपयुक्त है

BootLoaderStartCondition () फ़ंक्शन, जो मैक्रो प्रारूप में बूटलोडर में प्रवेश करने के लिए ज़िम्मेदार है, में फिट नहीं हुआ है और इसलिए एक पूर्ण कार्य बन गया है

 #ifndef __ASSEMBLER__ // Bootloader condition is to hold the button for 5 seconds inline unsigned char bootLoaderStartCondition() { long int i; for(i=0; i<10000000; i++) if( !(JUMPER_INP & _BV(JUMPER_PIN))) return 0; return 1; } #endif 

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

जैसा कि यह निकला, बूटलोडरकोन्फिग.ह फ़ाइल कोडांतरक फ़ाइलों के संकलन में शामिल है और इसमें कोड त्रुटि का कारण बनता है। मुझे फ़ंक्शन को #ifndef __ASSEMBLER__ ब्लॉक में रखना था

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

 /* * Define bootloader timeout value. * * The bootloader will only time out if a user program was loaded. * * AUTO_EXIT_NO_USB_MS The bootloader will exit after this delay if no USB is connected. * Set to 0 to disable * Adds ~6 bytes. * (This will wait for an USB SE0 reset from the host) * * All values are approx. in milliseconds */ #define AUTO_EXIT_NO_USB_MS 1000 

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

 # hexadecimal address for bootloader section to begin. To calculate the best value: # - make clean; make main.hex; ### output will list data: 2124 (or something like that) # - for the size of your device (8kb = 1024 * 8 = 8192) subtract above value 2124... = 6068 # - How many pages in is that? 6068 / 64 (tiny85 page size in bytes) = 94.8125 # - round that down to 94 - our new bootloader address is 94 * 64 = 6016, in hex = 1780 BOOTLOADER_ADDRESS = 1940 

फिर मैंने बूटलोडर स्टार्ट एड्रेस को एक पेज (64 बाइट्स) पर कम कर दिया, जिससे बूटलोडर स्पेस बढ़ गया।

अन्यथा, USBAsp प्रोग्रामर का उपयोग करके बूटलोडर को संकलित और अपलोड करना कोई समस्या नहीं थी।

निष्कर्ष

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

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

अंत में, यहाँ मेरी परियोजना के लिंक हैं:

फर्मवेयर कोड
सर्किट और बोर्ड
आवास और विसारक मॉडल
मुद्रण के लिए तैयार एसटीएल मॉडल