👩🏽‍🚀 🏑 🛀 प्रकाश स्रोतों TsPKIO-2D रोटर के लिए केंद्रीकृत नियंत्रण कक्ष 🏟️ 👺 🤙🏿

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

संक्षिप्त TOR:

1) रसोई में तीन प्रकाश समूहों का प्रबंधन
2) कमरे में तीन प्रकाश समूहों का प्रबंधन
3) एक ही समय में सभी प्रकाश स्रोतों का प्रबंधन
4) उचित बैटरी जीवन (एक सप्ताह से)
5) लिवोलो कोडिंग, SC2260, EV1527 के साथ संगत

यदि आपको Arduino, Livolo स्विच और चीनी रेडियो सॉकेट पसंद नहीं हैं, तो आपको आगे पढ़ने की आवश्यकता नहीं है। क्योंकि पहला रिमोट के लिए आधार है, और दूसरा और तीसरा परिधि है।

संकल्पना

नियंत्रण तर्क मुझे निम्नानुसार लगा:

"घुंडी" दबाने से प्रकाश समूह के क्षेत्र एक रिंग (रसोई - कमरे - सब कुछ) में बदल जाते हैं।
रोटेशन की दिशा के आधार पर घुंडी को चालू करना, चयनित समूह के प्रकाश को चालू या बंद करना है।
ऑपरेटिंग मोड (चयनित समूह) एक विनीत एलईडी संकेत द्वारा प्रदर्शित किया जाता है।

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

यदि घुंडी को मोड़ने से वांछित परिणाम नहीं मिलता है, तो संयुक्त दबाने और विपरीत दिशा में मुड़ने से आप कमांड को छोड़ सकते हैं। फिर कमांड को हमेशा की तरह दोहराया जा सकता है।

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

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

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

ठीक है, ज़ाहिर है, यह समझने के लिए कि रिमोट के साथ क्या चल रहा है, इसका एक अलग संकेतक है जो कमांड भेजते समय रोशनी करता है।

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

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

इसलिए, जागने के तुरंत बाद, घुंडी की बारी या तो खरोंच से प्रकाश को चालू या बंद करती है।

पहला तरीका

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

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

नियंत्रण भाग ATmega328P के साथ एक प्रयोग का परिणाम था और मौजूदा होम ऑटोमेशन (एक ही Arduino और आदिम रेडियो प्रोटोकॉल पर) द्वारा निर्धारित कहानी की तार्किक निरंतरता है।

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

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

सभी तत्वों को एक छोटे से मामले में रखने के लिए, मुझे थोड़ा नुकसान उठाना पड़ा, लेकिन रिमोट कंट्रोल ने अभी भी काम किया। और यद्यपि, ऐसा प्रतीत होता है, समस्या हल हो गई है, मैं अधिक चाहता था - मूल मामला।

दूसरा तरीका

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

लेकिन जब 3 डी प्रिंटर दिखाई दिया, तो उसने एक ही मूल मामले को बनाने के लिए एक दिन खुद से वादा किया और इस तरह रिमोट कंट्रोल से प्रश्न को बंद कर दिया।

मुझे नहीं पता कि यह अच्छा है या बुरा - मैं वास्तव में नहीं जानता कि मेरी चीजों का मूल्यांकन कैसे करें। लेकिन 3DToday पर टीम MySKU की तुलना में अधिक स्वागत कर रही है (जिसके बारे में मुझे कोई शिकायत नहीं है - यह अपने आप में एक उपहार नहीं है), और उन्होंने मेरे द्वारा किए गए मामले से अधिक मूल्यांकन किया।

लेकिन कार्रवाई की पूरी स्वतंत्रता होने के बाद, मैंने चीनी बैटरी को नष्ट कर दिया और पुराने पुराने 18650 पावर स्रोत को ले लिया। और, जैसा कि आप आसानी से देख सकते हैं, यह इसके आयाम हैं जो बड़े पैमाने पर पूरे मामले के आयामों को निर्धारित करते हैं।

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

एक और बात यह है कि मैं वास्तव में कनेक्टर्स के लिए कटआउट बनाना पसंद नहीं करता, जो मैं वास्तव में नहीं कर सकता। इसलिए, आपूर्ति श्रृंखला में एवलिन द्वारा हेजहोग द्वारा ज्ञात एक और चाल है: वायरलेस चार्जिंग।

मेरे ज़ाश्श्निक में बस एक और रिसीवर रखा गया था, जिसे मैंने तुरंत कार्रवाई में डाल दिया।

अंत में, अंतिम चाल बहुत स्पष्ट है, लेकिन फिर भी: ताकि रिमोट कंट्रोल तालिका के चारों ओर क्रॉल न हो, मैंने नीचे एक गैर-पर्ची कार चटाई के एक टुकड़े को चिपकाया। और अंत में, यह बात एक निरपेक्ष मोनोलिथ है, हालांकि इसे किसी अन्य स्थान पर पुन: व्यवस्थित करना भी कोई समस्या नहीं है।

दोहराने में क्या लगता है

लोहे का टुकड़ा

1) ATmega328P नियंत्रक - 1 पीसी। (मेरे TQFP पैकेज में, लेकिन कोई भी)
2) 10 kOhm रोकनेवाला - 5 पीसी। (4 एनकोडर उछाल को दबाने के लिए, नियंत्रक के लिए 1)
3) 100 ओम अवरोधक - 3 पीसी।
4) सिरेमिक कैपेसिटर 0.1 माइक्रोफ़ारड - 4 पीसी। (एनकोडर उछाल के नियंत्रक और दमन के लिए)
5) पुश एनकोडर (वाल्कोडर) - 1 पीसी। (मेरे पास PEC12-4220F-S0024 है )
6) एल ई डी - 3 पीसी। (व्यास 3 मिमी)
7) लिथियम बैटरी चार्जिंग बोर्ड - 1 पीसी। (पावर बैंक से, जो हाथ में आया था, सिद्धांत रूप में, कोई भी लोड पर स्वचालित स्विचिंग के साथ करेगा)
8) क्यूई वायरलेस चार्जिंग रिसीवर - 1 पीसी।
9) 433 मेगाहर्ट्ज पर आयाम मॉडुलन के साथ एक ट्रांसमीटर - 1 पीसी। ( इस तरह )
10) एनकोडर बोर्ड के लिए कुछ फाइबर ग्लास
11) 3 डी प्रिंटर
12) उपयुक्त प्लास्टिक (मैंने पीएलए मुद्रित किया)
13) M4x30 शिकंजा - 4 पीसी।

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

उसी तरह, आप संपर्क उछाल के हार्डवेयर दमन के साथ परेशान नहीं कर सकते हैं, और सॉफ़्टवेयर द्वारा प्राप्त करने का प्रयास कर सकते हैं। फिर आप चार और प्रतिरोधों और कैपेसिटर की एक जोड़ी को पार कर सकते हैं।

वैकल्पिक रूप से, आप प्रो-मिनी जैसे रेडी-मेड Arduino बोर्ड का उपयोग कर सकते हैं, लेकिन इस मामले में मैं ऊर्जा की खपत के निम्न स्तर की गारंटी नहीं दे सकता हूं, और आपको इसे स्वयं करना होगा। साथ ही केस को सही करना होगा।

ड्राइविंग:

संदर्भ के लिए, हॉबी इलेक्ट्रॉनिक्स से TQFP-32 पैकेज में ATmega328p पिनआउट:

मेरे एनकोडर के लिए, मैंने एक छोटा बोर्ड आकर्षित किया:

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

मामले के लिए, यह महत्वपूर्ण है कि एनकोडर को छोड़कर, भागों के साथ बोर्ड की ऊंचाई, अधिक नहीं (या बहुत अधिक नहीं) 5 मिमी।

यदि Arduino बोर्ड हाथ में तैयार नहीं है, तो सब कुछ काम करने के लिए, आपको सबसे पहले Armeino bootloader को ATmega328P कंट्रोलर पर लिखना होगा।

ऐसा करने के लिए, पहले, Arduino वातावरण में एक नियंत्रक विवरण जोड़ें। ऐसा करने के लिए, आधिकारिक Arduino वेबसाइट पर जाएं और पर्यावरण के अपने संस्करण के लिए उपयुक्त विवरण संग्रह डाउनलोड करें ( 1.6 के लिए , 1.5 के लिए , 1.0 के लिए )।

संग्रह की सामग्री को Arduino पर्यावरण फ़ोल्डर के हार्डवेयर फ़ोल्डर में निकाला जाना चाहिए। भविष्य में, मैं वर्णन करता हूं कि 1.0.3 पर्यावरण के उदाहरण पर क्या हो रहा है, जो मैं अभी भी उपयोग करता हूं।

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

बेशक, आपको अपना बोर्ड और पोर्ट चुनना चाहिए। मैं मेगा चुनता हूं, क्योंकि मेरे पास यह है:

प्रोग्रामर स्केच लोड करने के बाद, आपको लक्ष्य बोर्ड पर स्विच करने की आवश्यकता है। यानी हमारे मामले में - 8 मेगाहर्ट्ज की आवृत्ति और एक आंतरिक मास्टर थरथरानवाला के साथ ATmega328। यह बोर्ड की सूची में होगा यदि ऊपर वर्णित विवरण सही तरीके से कॉपी किए गए हैं:

अब आपको प्रोग्रामर बोर्ड और बोर्ड के MISO, MOSI और SCK लाइनों को भविष्य के Arduino के साथ कनेक्ट करना होगा, और RESET, GND और VCC को भी कनेक्ट करना होगा। प्लस पावर अंतिम स्थान पर सर्वश्रेष्ठ है।

उपरोक्त इन्फोग्राफिक और Arduino Mega के विवरण के आधार पर, निम्न चित्र उभरता है:

एसपीआई - अरुडिनो मेगा - एटीमेगा 328 पी

MISO - 50 - 16
MOSI - 51 - 15
एससीके - 52 - 17
एसएस (RESET) - 53 - 29

आपके स्वाद के लिए शारीरिक संबंध, मैंने एक विशेष रूप से बर्बर विधि का उपयोग किया - साधारण ब्रेडबोर्ड तारों को सीधे बोर्ड के छेद में, सोल्डरिंग और इन्सुलेशन के बिना।

यदि सब कुछ तैयार है, तो बूटलोडर को लिखें। सबसे पहले, सुनिश्चित करें कि सही प्रोग्रामर चुना गया है (सेवा - प्रोग्रामर - Arduino ISP के रूप में):

फिर हम सेवा करते हैं - रिकॉर्ड बूटलोडर:

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

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

आवास

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

मैं इस तथ्य पर ध्यान आकर्षित करता हूं कि मामला विशिष्ट है और इसे भरने के मेरे संस्करण में फिट करने के लिए डिज़ाइन किया गया है।

मैं रोटर को पारदर्शी बनाने का प्रस्ताव देता हूं ताकि यह संकेतक की रोशनी को बिखेर सके। अधिक वजन के लिए, रोटर के अंदर एक एम 16 नट डाला जा सकता है:

अभी भी एक रोटर शर्ट और इसे कवर की जरूरत है। ढक्कन बस अंदर की ओर डाला जाता है और घर्षण पर टिकी होती है। और, ज़ाहिर है, आप बाहरी आवरण के ऊपरी और निचले हिस्सों के बिना नहीं कर सकते।

मैंने 10% की भरने के साथ एक रोटर को मुद्रित किया, बाकी के तत्वों को 5% के भरने के साथ। प्लास्टिक - पीएलए। मेरे प्रिंटर पर नोजल का सेट तापमान पहले तीन परतों पर 200C, अगले पर 185C है। दुर्भाग्य से, मैं यह नहीं कह सकता कि नोजल का सही तापमान क्या है। मेज ठंडी है।

विधानसभा सरल है।

बोर्डों को टिकाऊ मामले के खांचे में रखा जाता है, एलईडी - टिकाऊ मामले के निचले हिस्से के खांचे में पैर। ट्रांसमीटर का एंटीना नीचे लाया जाता है, वायरलेस चार्जिंग रिसीवर को उसी तरह से नीचे लाया जाता है - ताकि यह उसी चार्ज के करीब हो।

भरने को एक मध्यवर्ती प्लेट द्वारा तय किया जाता है, जिसके खांचे में एनकोडर वायर हार्नेस गुजरता है।

एनकोडर को ऊपरी प्लेट के साथ तय किया जाता है, सभी को एक साथ M4x30 शिकंजा के साथ कड़ा किया जाता है, जो खुद प्लास्टिक में धागे काटते हैं।

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

कोड

कोड में, आपको अपने परिधीय उपकरणों को चालू और बंद करने के लिए कमांड निर्दिष्ट करने की आवश्यकता है। वैकल्पिक - ऑटो-शटडाउन टाइमआउट बदलें।

यह सब चर खंड में स्थित है।

//  : http://donalmorrissey.blogspot.ru/2010/04/sleeping-arduino-part-5-wake-up-via.html //  Livolo: http://forum.arduino.cc/index.php?action=dlattach;topic=153525.0;attach=108106 #include <avr/sleep.h> #include <avr/power.h> #include <livolo.h> #define adc_disable() (ADCSRA &= ~(1<<ADEN)) // disable ADC (before power-off) #define adc_enable() (ADCSRA |= (1<<ADEN)) // re-enable ADC #define txPin 7 //   Livolo livolo(txPin); #define PULSESHORT 450 #define PULSELONG 1350 #define PULSESYNC 13950 #define encA 5 #define encB 6 //   #define buttonPin 2 //   () #define roomLed 10 //    #define kitchenLed 9 //    #define switchLed 3 //     #define switchLedTimeOut 150 //      #define switchTreshold 4 //      #define offDelay 15000 //   #define rLev 3 //     #define kLev 3 //     #define glev 2 //     #define txPowerPin 8 //    #define kitchenBackLightOn1 12 #define kitchenBackLightOn2 34 #define kitchenMainLightOn 56 #define roomBackLightOn 12 #define roomMainLightOn1 34 #define roomMainLightOn2 56 #define mainLightOn 12 #define kitchenBackLightOff1 12 #define kitchenBackLightOff2 34 #define kitchenMainLightOff 56 #define roomBackLightOff 12 #define roomMainLighOtff1 34 #define roomMainLightOff2 56 #define mainLightOff 12 #define LivoloID 8500 volatile byte rotorMode = 0; //   byte currentMode = 0; //    int curEncA, prevEncA, curButton, prevButton; //   ,  byte encCountPlus = 0; //   byte encCountMinus = 0; //   unsigned long offTimeOut = 0; //    unsigned long modeTimeOut = 0; //        unsigned long switchLedTime = 0; //      unsigned long modeTime = 0; //   unsigned int modeTreshold = 500; //     (  ) unsigned int bounceTreshold = 200; //     byte rLevState = 0; byte kLevState = 0; byte gLevState = 0; //   k - , r - , h - , b -  boolean kBackState = false; boolean kBackState1 = false; boolean kMainState = false; boolean rBackState = false; boolean rMainState = false; boolean rMainState1 = false; boolean hMainState = false; boolean bMainState = false; boolean afterSleep = false; //      boolean modeTimeOutStart = false; boolean switchLedOn = false; boolean allOn = false; //  " "    boolean allOff = false; //  " "    static void ookPulse(int on, int off) { digitalWrite(txPin, HIGH); delayMicroseconds(on); digitalWrite(txPin, LOW); delayMicroseconds(off); } static void rcSend(long remoteCode) { for (byte reSend = 0; reSend < 8; reSend++) { for(byte repeat=0; repeat<4; repeat++){ for (byte i = 24; i>0; i--) { // transmit remoteID byte txPulse=bitRead(remoteCode, i-1); // read bits from remote ID // Serial.print(txPulse); switch (txPulse) { case 0: // 00 ookPulse(PULSESHORT,PULSELONG); //ookPulse(PULSESHORT,PULSELONG); break; case 1: // 11 ookPulse(PULSELONG,PULSESHORT); //ookPulse(PULSELONG,PULSESHORT); break; } // switch } // for loop ookPulse(PULSESHORT,PULSESYNC); // S(ync) // Serial.println(); } // repeat } delay(150); } void switchLedToggle() { digitalWrite(switchLed, HIGH); switchLedTime = millis(); switchLedOn = true; } void lightsUp(boolean lightsUpMode) { //       ""     //   "" -   if (afterSleep == true) { if (lightsUpMode == false) { gLevState = 1; rLevState = 3; kLevState = 3; } else {gLevState = 0; rLevState = 0; kLevState = 0; } afterSleep = false; //   " " } //   if (rotorMode == 2) { if (lightsUpMode == false){ if (allOff == false) { switchLedToggle(); if (digitalRead(buttonPin) == HIGH) { //   gLevState = 0; rLevState = 0; kLevState = 0; rcSend(kitchenBackLightOff1); rcSend(kitchenBackLightOff2); rcSend(roomBackLightOff); livolo.sendButton(LivoloID, mainLightOff); } allOff = true; allOn = false; } } if (lightsUpMode == true){ //  ,    if (allOn == false) { switchLedToggle(); if (digitalRead(buttonPin) == HIGH) { gLevState = 1; rLevState = 3; kLevState = 3; rcSend(kitchenBackLightOn1); rcSend(kitchenBackLightOn2); rcSend(roomBackLightOn); livolo.sendButton(LivoloID, mainLightOff); //    Livolo livolo.sendButton(LivoloID, kitchenMainLightOn); //#1   livolo.sendButton(LivoloID, roomMainLightOn1); // #2 livolo.sendButton(LivoloID, roomMainLightOn2); // #3 livolo.sendButton(LivoloID, mainLightOn); // #6 } allOn = true; allOff = false; } } } //  if (rotorMode == 1) { if (lightsUpMode == false && kLevState > 0) { switchLedToggle(); if (digitalRead(buttonPin) == HIGH) { if (kLevState == 3) { //   livolo.sendButton(LivoloID, kitchenMainLightOff); // #3 } if (kLevState == 2) { //   2 livolo.sendButton(LivoloID, kitchenBackLightOff2); // #6 } if (kLevState == 1) { //   1 rcSend(kitchenBackLightOff1); } } if (kLevState!=0) { kLevState--;} // Serial.println(kLevState); } if (lightsUpMode == true && kLevState < 3) { switchLedToggle(); kLevState++; if (digitalRead(buttonPin) == HIGH) { if (kLevState > 3) {kLevState = 3;} // Serial.println(kLevState); if (kLevState == 1) { //   1 rcSend(kitchenBackLightOn1); } if (kLevState == 2) { //   2 livolo.sendButton(LivoloID, kitchenBackLightOn2); // #6 } if (kLevState == 3) { //   livolo.sendButton(LivoloID, kitchenMainLightOn); // #3 } } } } //  if (rotorMode == 0) { if (lightsUpMode == false && rLevState > 0) { switchLedToggle(); if (digitalRead(buttonPin) == HIGH) { if (rLevState == 3) { //  1 livolo.sendButton(LivoloID, roomMainLighOtff1); //#1 } if (rLevState == 2) { //   livolo.sendButton(LivoloID, roomMainLightOff2); // #2 } if (rLevState == 1) { //   rcSend(roomBackLightOff); } } if (rLevState != 0) { rLevState--; } } if (lightsUpMode == true && rLevState < 3) { switchLedToggle(); rLevState++; if (digitalRead(buttonPin) == HIGH) { if (rLevState == 1) { //   rcSend(roomBackLightOn); } if (rLevState == 2) { //   livolo.sendButton(LivoloID, roomMainLightOn1); //#1 } if (rLevState == 3) { //   1 livolo.sendButton(LivoloID, roomMainLightOn2); // #2 } } } } } void wakeUp() { detachInterrupt(0); } void setMode() { if (rotorMode >= 2 ) { rotorMode = 0; } else { rotorMode++; } offTimeOut = millis(); } void ledBlink() { for (byte iLed = 0; iLed<3; iLed++) { digitalWrite(kitchenLed, HIGH); digitalWrite(roomLed, HIGH); delay(100); digitalWrite(kitchenLed, LOW); digitalWrite(roomLed, LOW); delay(100); } } void setLed() { if (rotorMode == 0) { //  digitalWrite(roomLed, HIGH); digitalWrite(kitchenLed, LOW); } if (rotorMode == 1) { //  digitalWrite(roomLed, LOW); digitalWrite(kitchenLed, HIGH); } if (rotorMode == 2) { //    digitalWrite(roomLed, HIGH); digitalWrite(kitchenLed, HIGH); } } void enterSleep() { // ledBlink(); afterSleep = true; digitalWrite(txPin, LOW); digitalWrite(txPowerPin, LOW); digitalWrite(roomLed, LOW); digitalWrite(kitchenLed, LOW); digitalWrite(switchLed, LOW); pinMode(txPin, INPUT); pinMode(txPowerPin, INPUT); pinMode(roomLed, INPUT); pinMode(kitchenLed, INPUT); pinMode(switchLed, INPUT); attachInterrupt(0, wakeUp, LOW); adc_disable(); set_sleep_mode(SLEEP_MODE_PWR_DOWN); sleep_enable(); sleep_mode(); sleep_disable(); power_all_enable(); pinMode(txPin, OUTPUT); pinMode(txPowerPin, OUTPUT); pinMode(roomLed, OUTPUT); pinMode(kitchenLed, OUTPUT); pinMode(switchLed, OUTPUT); digitalWrite(txPin, LOW); digitalWrite(txPowerPin, HIGH); // ledBlink(); setLed(); offTimeOut = millis(); allOn = false; allOff = false; } void setup() { // Serial.begin(115200); pinMode(txPin, OUTPUT); pinMode(txPowerPin, OUTPUT); pinMode(roomLed, OUTPUT); pinMode(kitchenLed, OUTPUT); pinMode(switchLed, OUTPUT); digitalWrite(txPin, LOW); digitalWrite(txPowerPin, HIGH); digitalWrite(roomLed, LOW); digitalWrite(kitchenLed, LOW); digitalWrite(switchLed, LOW); // pinMode(buttonPin, INPUT_PULLUP); pinMode(buttonPin, INPUT); pinMode(encA, INPUT); pinMode(encB, INPUT); prevEncA = digitalRead(encA); offTimeOut = millis(); rotorMode = 0; setLed(); prevButton = digitalRead(buttonPin); } void loop() { if ((millis() - offTimeOut) > offDelay) { enterSleep(); } else { //     if (switchLedOn == true) { if ((millis() - switchLedTime) > switchLedTimeOut) { digitalWrite(switchLed, LOW); switchLedOn = false; } } //       if (digitalRead(buttonPin) == LOW) { offTimeOut = millis(); } //   curButton = digitalRead(buttonPin); if ((prevButton == HIGH) && (curButton == LOW)) { if (modeTimeOutStart == false) { modeTimeOut = millis(); modeTimeOutStart = true; } } else { if (modeTimeOutStart == true) { modeTime = millis() - modeTimeOut; if ((modeTime < modeTreshold) && (modeTime > bounceTreshold)) { setMode(); modeTimeOutStart = false; prevButton = digitalRead(buttonPin); } else { modeTimeOutStart = false; prevButton = digitalRead(buttonPin); } } } //    if (currentMode != rotorMode) { //       ,     currentMode = rotorMode; //     setLed(); } //   curEncA = digitalRead(encA); if ((prevEncA == LOW) && (curEncA == HIGH)) { offTimeOut = millis(); if (digitalRead(encB) == LOW) { encCountMinus++; encCountPlus = 0; // Serial.println("Encoder Minus"); if (encCountMinus > switchTreshold) { encCountMinus = 0; lightsUp(false); } } else { encCountPlus++; encCountMinus = 0; // Serial.println("Encoder Plus"); if (encCountPlus > switchTreshold) { encCountPlus = 0; lightsUp(true); } } } prevEncA = curEncA; } }

संदर्भ द्वारा केस मॉडल।

वह सब है।

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