स्मार्ट घरमा पानीको मिटर जडान गर्दै

एक पटक, घर स्वचालन प्रणालीहरू, वा "स्मार्ट होम" जसलाई प्रायः भनिन्थ्यो, धेरै महँगो थियो र केवल धनीहरूले तिनीहरूलाई किन्न सक्थे। आज बजारमा तपाईले प्रकाश, सकेट, भेन्टिलेशन, पानी आपूर्ति र अन्य उपभोक्ताहरू नियन्त्रण गर्न सेन्सरहरू, बटनहरू/स्विचहरू र एक्चुएटरहरू सहित एकदमै सस्तो किटहरू फेला पार्न सक्नुहुन्छ। र सबैभन्दा कुटिल DIY व्यक्ति पनि सुन्दरतामा संलग्न हुन सक्छ र सस्तो मूल्यमा स्मार्ट घरको लागि उपकरणहरू भेला गर्न सक्छ।

सामान्यतया, प्रस्तावित यन्त्रहरू या त सेन्सर वा एक्चुएटरहरू हुन्। तिनीहरूले "जब एक गति सेन्सर ट्रिगर हुन्छ, बत्तीहरू खोल्नुहोस्" वा "निकास नजिकको स्विचले सम्पूर्ण अपार्टमेन्टमा बत्तीहरू बन्द गर्दछ" जस्ता परिदृश्यहरू लागू गर्न सजिलो बनाउँदछ। तर केहि चीजहरू टेलिमेट्रीसँग काम गरेनन्। सबै भन्दा राम्रो, यो तापमान र आर्द्रता को ग्राफ, वा एक विशिष्ट आउटलेट मा तत्काल शक्ति हो।

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

कट तल ESP8266 मा आधारित यन्त्रको मेरो संस्करण हो, जसले पानीको मिटरबाट दालहरू गणना गर्छ र MQTT मार्फत स्मार्ट होम सर्भरमा पठाउँछ। हामी uasyncio लाइब्रेरी प्रयोग गरेर माइक्रोपाइथनमा प्रोग्राम गर्नेछौं। फर्मवेयर सिर्जना गर्दा, मैले धेरै रोचक कठिनाइहरू भेट्टाएँ, जुन म यस लेखमा पनि छलफल गर्नेछु। जाउ!

योजना

सम्पूर्ण सर्किटको मुटु ESP8266 माइक्रोकन्ट्रोलरमा रहेको मोड्युल हो। ESP-12 मूल रूपमा योजना गरिएको थियो, तर मेरो दोषपूर्ण हुन पुग्यो। हामी ESP-07 मोड्युलसँग सन्तुष्ट हुनुपर्दछ, जुन उपलब्ध थियो। सौभाग्य देखि, तिनीहरू दुवै पिन र कार्यक्षमता को मामला मा समान छन्, केवल भिन्नता एन्टेना मा छ - ESP-12 मा निर्मित एक छ, जबकि ESP-07 एक बाह्य छ। यद्यपि, WiFi एन्टेना बिना पनि, मेरो बाथरूममा सिग्नल सामान्य रूपमा प्राप्त हुन्छ।

मानक मोड्युल तारिङ:

• पुल-अप र क्यापेसिटरको साथ बटन रिसेट गर्नुहोस् (यद्यपि दुबै मोड्युल भित्र पहिले नै छन्)
• सक्षम संकेत (CH_PD) लाई पावरमा तानिएको छ
• GPIO15 जमिनमा तानिएको छ। यो सुरुमा मात्र आवश्यक छ, तर मसँग अझै पनि यो खुट्टा जोड्न केहि छैन; मलाई अब यसको आवश्यकता छैन

मोड्युललाई फर्मवेयर मोडमा राख्नको लागि, तपाईंले GPIO2 लाई ग्राउन्डमा सर्ट-सर्किट गर्न आवश्यक छ, र यसलाई अझ सुविधाजनक बनाउनको लागि, मैले बुट बटन प्रदान गरेको छु। सामान्य अवस्थामा, यो पिन शक्तिमा तानिन्छ।

GPIO2 लाइनको अवस्था मात्र सञ्चालनको सुरुमा जाँच गरिन्छ - जब पावर लागू हुन्छ वा रिसेट पछि तुरुन्तै। त्यसोभए मोड्युल सामान्य रूपमा बुट हुन्छ वा फर्मवेयर मोडमा जान्छ। एक पटक लोड भएपछि, यो पिन नियमित GPIO को रूपमा प्रयोग गर्न सकिन्छ। ठिक छ, किनकि त्यहाँ पहिले नै एउटा बटन छ, तपाइँ यसमा केहि उपयोगी प्रकार्य संलग्न गर्न सक्नुहुन्छ।

प्रोग्रामिङ र डिबगिङको लागि म UART प्रयोग गर्नेछु, जुन कम्बोमा आउटपुट हो। जब आवश्यक हुन्छ, म त्यहाँ USB-UART एडाप्टर जडान गर्छु। तपाईले मात्र सम्झनु पर्छ कि मोड्युल 3.3V द्वारा संचालित छ। यदि तपाईंले एडाप्टरलाई यो भोल्टेजमा स्विच गर्न र 5V आपूर्ति गर्न बिर्सनुभयो भने, मोड्युल प्रायः जल्नेछ।

मलाई बाथरूममा बिजुलीको साथ कुनै समस्या छैन - आउटलेट मिटरबाट लगभग एक मिटरमा अवस्थित छ, त्यसैले म 220V द्वारा संचालित हुनेछु। शक्तिको स्रोतको रूपमा मसँग एउटा सानो हुनेछ HLK-PM03 ब्लक गर्नुहोस् Tenstar रोबोट द्वारा। व्यक्तिगत रूपमा, मसँग एनालग र पावर इलेक्ट्रोनिक्सको साथ कठिन समय छ, तर यहाँ एउटा सानो अवस्थामा तयार-बनाएको पावर आपूर्ति छ।

अपरेटिङ मोडहरू संकेत गर्न, मैले GPIO2 मा जडान भएको LED प्रदान गरें। यद्यपि, मैले यसलाई बेचेको छैन, किनकि ... ESP-07 मोड्युलमा पहिले नै LED छ, र यो GPIO2 मा पनि जोडिएको छ। तर यो बोर्डमा हुन दिनुहोस्, यदि म यो एलईडी केसमा आउटपुट गर्न चाहन्छु।

सबैभन्दा रोचक भागमा जाऔं। पानीको मिटरको कुनै तर्क छैन; तपाईंले हालको रिडिङको लागि तिनीहरूलाई सोध्न सक्नुहुन्न। हाम्रो लागि उपलब्ध एक मात्र चीज आवेग हो - प्रत्येक लीटर रिड स्विचको सम्पर्कहरू बन्द गर्दै। मेरो रिड स्विच आउटपुटहरू GPIO12/GPIO13 मा जडान भएका छन्। म मोड्युल भित्र प्रोग्रामेटिक रूपमा पुल-अप रेसिस्टर सक्षम गर्नेछु।

सुरुमा, मैले प्रतिरोधकहरू R8 र R9 प्रदान गर्न बिर्सें र बोर्डको मेरो संस्करणमा तिनीहरू छैनन्। तर मैले पहिले नै सबैलाई हेर्नको लागि रेखाचित्र पोस्ट गर्दैछु, यो निरीक्षण सच्याउन लायक छ। यदि फर्मवेयरले गल्ती गर्छ र पिनलाई एकमा सेट गर्छ भने पोर्टलाई जलाउन नदिन र रिड स्विचले यो लाइनलाई भुइँमा सर्ट गर्छ (रेसिस्टरको साथ अधिकतम 3.3V/1000Ohm = 3.3mA प्रवाह हुनेछ)।

बिजुली गयो भने के गर्ने भनेर सोच्ने बेला आएको छ । पहिलो विकल्प भनेको सुरुमा सर्भरबाट प्रारम्भिक काउन्टर मानहरू अनुरोध गर्नु हो। तर यसको लागि एक्सचेन्ज प्रोटोकलको महत्त्वपूर्ण जटिलता आवश्यक पर्दछ। यसबाहेक, यस मामला मा उपकरण को प्रदर्शन सर्भर को स्थिति मा निर्भर गर्दछ। यदि सर्भर पावर बन्द भए पछि सुरु भएन (वा पछि सुरु भयो), पानी मिटरले प्रारम्भिक मानहरू अनुरोध गर्न सक्षम हुने छैन र सही रूपमा काम गर्दैन।

त्यसकारण, मैले I2C मार्फत जडान गरिएको मेमोरी चिपमा बचत काउन्टर मानहरू लागू गर्ने निर्णय गरें। मसँग फ्ल्याश मेमोरीको साइजको लागि कुनै विशेष आवश्यकताहरू छैनन् - तपाईले मात्र 2 नम्बरहरू बचत गर्न आवश्यक छ (तातो र चिसो पानीको मिटर अनुसार लीटरको संख्या)। सबैभन्दा सानो मोड्युलले पनि गर्नेछ। तर तपाईंले रेकर्डिङ चक्रहरूको संख्यामा ध्यान दिन आवश्यक छ। धेरै मोड्युलहरूको लागि यो 100 हजार चक्र हो, केहि को लागी एक मिलियन सम्म।

यो एक लाख धेरै हो जस्तो देखिन्छ। तर मेरो अपार्टमेन्टमा बसेको 4 वर्षको दौडान, मैले 500 क्यूबिक मिटर भन्दा अलि बढी पानी खपत गरें, त्यो 500 हजार लिटर हो! र फ्लैश मा 500 हजार रेकर्ड। र त्यो चिसो पानी मात्र हो। तपाईले पक्कै पनि प्रत्येक दुई वर्षमा चिपलाई पुन: बेच्न सक्नुहुन्छ, तर त्यहाँ FRAM चिपहरू छन्। प्रोग्रामिङ दृष्टिकोणबाट, यो उही I2C EEPROM हो, केवल धेरै ठूलो संख्यामा पुन: लेख्ने चक्रहरू (सयौं लाखहरू) संग। यो मात्र हो कि म अझै पनि त्यस्ता माइक्रोसर्किटहरूको साथ स्टोरमा पुग्न सक्दिन, त्यसैले अहिलेको लागि सामान्य 24LC512 खडा हुनेछ।

मुद्रित सर्किट बोर्ड

सुरुमा घरमै बोर्ड बनाउने योजना बनाएको थिएँ । त्यसैले, बोर्ड एकतर्फी रूपमा डिजाइन गरिएको थियो। तर लेजर आइरन र सोल्डर मास्कको साथ एक घण्टा बिताएपछि (यस बिना यो कुनै पनि प्रकारले सम्भव छैन), मैले अझै पनि चिनियाँबाट बोर्डहरू अर्डर गर्ने निर्णय गरें।

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

एकतर्फी तारिङमा पनि ठूलो समस्या थियो । किनभने बोर्ड एक-पक्षीय रूपमा कोरिएको थियो, त्यसैले ट्र्याक र SMD कम्पोनेन्टहरू एक छेउमा राख्ने योजना बनाइएको थियो, र अर्कोमा आउटपुट कम्पोनेन्टहरू, कनेक्टरहरू र बिजुली आपूर्ति। जब मैले एक महिना पछि बोर्डहरू प्राप्त गरें, मैले मूल योजनाको बारेमा बिर्सें र अगाडि पक्षमा सबै कम्पोनेन्टहरू सोल्डर गरें। र जब यो पावर सप्लाई सोल्डरिंगको लागि आयो तब मात्र यो बाहिरियो कि प्लस र माइनस रिभर्समा तार गरिएको थियो। जम्पर लगाएर खेती गर्नुपर्थ्यो । माथिको तस्विरमा, मैले पहिले नै तारहरू परिवर्तन गरिसकेको छु, तर जमिनलाई बुट बटनको पिन मार्फत बोर्डको एक भागबाट अर्कोमा स्थानान्तरण गरिएको छ (यद्यपि यो दोस्रो तहमा ट्र्याक कोर्न सम्भव हुनेछ)।

यसरी निस्कियो

आवास

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

मैले पहिले नै उल्लेख गरेको छु कि बुट बटन सामान्य-उद्देश्य बटनको रूपमा प्रयोग गर्न सकिन्छ - त्यसैले हामी यसलाई अगाडिको प्यानलमा प्रदर्शन गर्नेछौं। यो गर्नको लागि, मैले एउटा विशेष "कुवा" कोरें जहाँ बटन रहन्छ।

केस भित्र त्यहाँ स्टडहरू पनि छन् जसमा बोर्ड स्थापना गरिएको छ र एकल M3 स्क्रूको साथ सुरक्षित गरिएको छ (बोर्डमा थप ठाउँ थिएन)

मैले केसको पहिलो नमूना संस्करण छाप्दा मैले पहिले नै प्रदर्शन चयन गरेको छु। एक मानक दुई-लाइन रिडर यस अवस्थामा फिट भएन, तर तल त्यहाँ एक OLED प्रदर्शन SSD1306 128 × 32 थियो। यो थोरै सानो छ, तर मैले यसलाई हरेक दिन हेरिरहनु पर्दैन - यो मेरो लागि धेरै छ।

यसरी पत्ता लगाउँदै र कसरी तारहरू यसबाट रुट हुनेछन्, मैले डिस्प्लेलाई केसको बीचमा टाँस्ने निर्णय गरें। एर्गोनोमिक्स, निस्सन्देह, बराबर तल छन् - बटन माथि छ, प्रदर्शन तल छ। तर मैले पहिले नै भनेको छु कि डिस्प्ले संलग्न गर्ने विचार धेरै ढिलो आयो र बटन सार्नको लागि बोर्डलाई पुन: तार गर्न म धेरै अल्छी थिएँ।

उपकरण जम्मा गरिएको छ। डिस्प्ले मोड्युल तातो गोंदको साथ स्नोटमा टाँसिएको छ

अन्तिम परिणाम KDPV मा देख्न सकिन्छ

फर्मवेयर

सफ्टवेयर भागमा जानुहोस्। यस जस्तो साना शिल्पहरूको लागि, मलाई पाइजोन (माइक्रोपाइथन) - कोड धेरै कम्प्याक्ट र बुझ्न सकिने बाहिर जान्छ। सौभाग्य देखि, माइक्रोसेकेन्डहरू निचोड गर्नको लागि दर्ता स्तरमा तल जान आवश्यक छैन - सबै कुरा पाइथनबाट गर्न सकिन्छ।

यस्तो देखिन्छ कि सबै कुरा सरल छ, तर धेरै सरल छैन - उपकरणमा धेरै स्वतन्त्र कार्यहरू छन्:

• प्रयोगकर्ताले बटन पोक गर्छ र डिस्प्लेमा हेर्छ
• लिटरहरू फ्ल्यास मेमोरीमा मानहरू टिक र अपडेट गर्नुहोस्
• मोड्युलले WiFi सिग्नललाई निगरानी गर्दछ र आवश्यक भएमा पुन: जडान गर्दछ
• ठिक छ, झिम्किरहेको बत्ती बिना यो असम्भव छ

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

В थप गम्भीर परियोजना मैले क्लासिक प्रिमप्टिभ मल्टिटास्किङ र FreeRTOS प्रयोग गरें, तर यस अवस्थामा मोडेल धेरै उपयुक्त भयो coroutines र uasync पुस्तकालयहरू । यसबाहेक, coroutines को पाइथन कार्यान्वयन मात्र अचम्मको छ - सबै कुरा प्रोग्रामरको लागि सरल र सुविधाजनक रूपमा गरिन्छ। केवल तपाईंको आफ्नै तर्क लेख्नुहोस्, मलाई बताउनुहोस् कुन ठाउँहरूमा तपाईं स्ट्रिमहरू बीच स्विच गर्न सक्नुहुन्छ।

म वैकल्पिक विषयको रूपमा प्रिमप्टिभ र प्रतिस्पर्धी मल्टिटास्किङ बीचको भिन्नताहरू अध्ययन गर्न सुझाव दिन्छु। अब अन्तमा कोडमा जाऔं।

#####################################
# Counter class - implements a single water counter on specified pin
#####################################
class Counter():
    debounce_ms = const(25)
    
    def __init__(self, pin_num, value_storage):
        self._value_storage = value_storage
        
        self._value = self._value_storage.read()
        self._value_changed = False

        self._pin = Pin(pin_num, Pin.IN, Pin.PULL_UP)

        loop = asyncio.get_event_loop()
        loop.create_task(self._switchcheck())  # Thread runs forever

प्रत्येक काउन्टर काउन्टर वर्गको उदाहरणद्वारा ह्यान्डल गरिन्छ। सबैभन्दा पहिले, प्रारम्भिक काउन्टर मान EEPROM (value_storage) बाट घटाइन्छ - यसरी पावर विफलता लागू भएपछि रिकभरी हुन्छ।

पिन बिल्ट-इन पुल-अपको साथ पावर सप्लाईमा प्रारम्भ गरिएको छ: यदि रिड स्विच बन्द छ भने, लाइन शून्य छ, यदि लाइन खुला छ भने, यसलाई पावर सप्लाईमा तानिन्छ र नियन्त्रकले एउटा पढ्छ।

यहाँ एउटा छुट्टै कार्य पनि सुरु गरिएको छ, जसले पिन पोल गर्नेछ। प्रत्येक काउन्टरले आफ्नै कार्य चलाउनेछ। यहाँ उनको कोड छ

    """ Poll pin and advance value when another litre passed """
    async def _switchcheck(self):
        last_checked_pin_state = self._pin.value()  # Get initial state

        # Poll for a pin change
        while True:
            state = self._pin.value()
            if state != last_checked_pin_state:
                # State has changed: act on it now.
                last_checked_pin_state = state
                if state == 0:
                    self._another_litre_passed()

            # Ignore further state changes until switch has settled
            await asyncio.sleep_ms(Counter.debounce_ms)

सम्पर्क बाउन्स फिल्टर गर्न 25ms को ढिलाइ आवश्यक छ, र एकै समयमा यसले कार्य कति पटक ब्युँझन्छ (यो कार्य सुतिरहेको बेला, अन्य कार्यहरू चलिरहेको छ) नियमन गर्दछ। प्रत्येक 25 मिनेटमा फंक्शन उठ्छ, पिन जाँच गर्दछ र यदि रिड स्विच सम्पर्कहरू बन्द छन् भने, त्यसपछि अर्को लिटर मिटरबाट गुज्रिएको छ र यसलाई प्रशोधन गर्न आवश्यक छ।

    def _another_litre_passed(self):
        self._value += 1
        self._value_changed = True

        self._value_storage.write(self._value)

अर्को लिटर प्रशोधन मामूली छ - काउन्टर मात्र बढ्छ। खैर, फ्लैश ड्राइभमा नयाँ मान लेख्न राम्रो हुनेछ।

प्रयोगको सजिलोको लागि, "उपयोगकर्ताहरू" प्रदान गरिन्छ

    def value(self):
        self._value_changed = False
        return self._value

    def set_value(self, value):
        self._value = value
        self._value_changed = False

खैर, अब पाइथन र uasync पुस्तकालयको आनन्दको फाइदा लिनुहोस् र प्रतीक्षायोग्य काउन्टर वस्तु बनाउनुहोस् (हामी यसलाई कसरी रूसीमा अनुवाद गर्न सक्छौं? तपाईंले आशा गर्न सक्नुहुन्छ?)

    def __await__(self):
        while not self._value_changed:
            yield from asyncio.sleep(0)

        return self.value()

    __iter__ = __await__  

यो यस्तो सुविधाजनक प्रकार्य हो जुन काउन्टर मान अद्यावधिक नभएसम्म पर्खन्छ - प्रकार्य समय-समयमा उठ्छ र _value_changed फ्ल्याग जाँच गर्दछ। यस प्रकार्यको बारेमा राम्रो कुरा यो हो कि कलिङ कोड यस प्रकार्यलाई कल गर्दा सुत्न सक्छ र नयाँ मान प्राप्त नभएसम्म सुत्न सक्छ।

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

दुर्भाग्यवश (वा सौभाग्यवश?) मेरो यन्त्र सक्रिय छ, यसले आफैं MQTT प्रोटोकल मार्फत सन्देशहरू पठाउनु पर्छ र EEPROM मा डाटा लेख्नु पर्छ। र यहाँ प्रतिबन्धहरू खेलमा आउँछन् - तपाइँ अवरोधहरूमा मेमोरी आवंटित गर्न सक्नुहुन्न र ठूलो स्ट्याक प्रयोग गर्न सक्नुहुन्न, जसको मतलब तपाइँ नेटवर्कमा सन्देशहरू पठाउन बिर्सन सक्नुहुन्छ। त्यहाँ micropython.schedule() जस्ता बनहरू छन् जसले तपाईंलाई "जति सक्दो चाँडो" कार्यहरू चलाउन अनुमति दिन्छ, तर प्रश्न उठ्छ, "के कुरा हो?" के हुन्छ यदि हामी अहिले कुनै प्रकारको सन्देश पठाउँदैछौं, र त्यसपछि एक अवरोध आउँछ र चरको मानहरू बिगार्छ। वा, उदाहरणका लागि, सर्भरबाट नयाँ काउन्टर मान आयो जब हामीले पुरानोलाई लेखेका थिएनौं। सामान्यतया, तपाईंले सिंक्रोनाइजेसन ब्लक गर्न आवश्यक छ वा यसलाई कुनै पनि तरिकाबाट बाहिर निकाल्न आवश्यक छ।

र समय-समयमा RuntimeError: तालिका स्ट्याक पूर्ण क्र्यासहरू र कसलाई थाहा छ किन?

स्पष्ट मतदान र uasync संग, यो अवस्थामा यो कुनै न कुनै रूपमा अझ सुन्दर र भरपर्दो हुन्छ

मैले EEPROM सँग सानो कक्षामा काम ल्याएँ

class EEPROM():
    i2c_addr = const(80)

    def __init__(self, i2c):
        self.i2c = i2c
        self.i2c_buf = bytearray(4) # Avoid creation/destruction of the buffer on each call


    def read(self, eeprom_addr):
        self.i2c.readfrom_mem_into(self.i2c_addr, eeprom_addr, self.i2c_buf, addrsize=16)
        return ustruct.unpack_from("<I", self.i2c_buf)[0]    
        
    
    def write(self, eeprom_addr, value):
        ustruct.pack_into("<I", self.i2c_buf, 0, value)
        self.i2c.writeto_mem(self.i2c_addr, eeprom_addr, self.i2c_buf, addrsize=16)

पाइथनमा, बाइटहरूसँग सीधा काम गर्न गाह्रो छ, तर यो मेमोरीमा लेखिएको बाइटहरू हो। मैले ustruct लाइब्रेरी प्रयोग गरेर पूर्णांक र बाइटहरू बीचको रूपान्तरण बाड्नु परेको थियो।

प्रत्येक पटक I2C वस्तु र मेमोरी सेलको ठेगाना स्थानान्तरण नगर्नको लागि, मैले यो सबैलाई सानो र सुविधाजनक क्लासिकमा बेरें।

class EEPROMValue():
    def __init__(self, i2c, eeprom_addr):
        self._eeprom = EEPROM(i2c)
        self._eeprom_addr = eeprom_addr
        

    def read(self):
        return self._eeprom.read(self._eeprom_addr)


    def write(self, value):
        self._eeprom.write(self._eeprom_addr, value)

I2C वस्तु आफैं यी प्यारामिटरहरूसँग सिर्जना गरिएको छ

i2c = I2C(freq=400000, scl=Pin(5), sda=Pin(4))

हामी सबैभन्दा रोचक भागमा आउँछौं - MQTT मार्फत सर्भरसँग सञ्चारको कार्यान्वयन। खैर, प्रोटोकल आफैं लागू गर्न आवश्यक छैन - मैले यसलाई इन्टरनेटमा फेला पारे तयार एसिन्क्रोनस कार्यान्वयन। यो हामीले प्रयोग गर्नेछौं।

पुस्तकालय MQTTClient मा आधारित रहेको CounterMQTTClient कक्षामा सबै सबैभन्दा रोचक कुराहरू सङ्कलन गरिएका छन्। परिधिबाट सुरु गरौं

#####################################
# Class handles both counters and sends their status to MQTT
#####################################
class CounterMQTTClient(MQTTClient):

    blue_led = Pin(2, Pin.OUT, value = 1)
    button = Pin(0, Pin.IN)

    hot_counter = Counter(12, EEPROMValue(i2c, EEPROM_ADDR_HOT_VALUE))
    cold_counter = Counter(13, EEPROMValue(i2c, EEPROM_ADDR_COLD_VALUE))

यहाँ तपाईंले लाइट बल्ब पिन र बटनहरू, साथै चिसो र तातो पानी मिटर वस्तुहरू सिर्जना र कन्फिगर गर्न सक्नुहुन्छ।

प्रारम्भिकता संग, सबै कुरा यति तुच्छ छैन

    def __init__(self):
        self.internet_outage = True
        self.internet_outages = 0
        self.internet_outage_start = ticks_ms()

        with open("config.txt") as config_file:
            config['ssid'] = config_file.readline().rstrip()
            config['wifi_pw'] = config_file.readline().rstrip()
            config['server'] = config_file.readline().rstrip()
            config['client_id'] = config_file.readline().rstrip()
            self._mqtt_cold_water_theme = config_file.readline().rstrip()
            self._mqtt_hot_water_theme = config_file.readline().rstrip()
            self._mqtt_debug_water_theme = config_file.readline().rstrip()

        config['subs_cb'] = self.mqtt_msg_handler
        config['wifi_coro'] = self.wifi_connection_handler
        config['connect_coro'] = self.mqtt_connection_handler
        config['clean'] = False
        config['clean_init'] = False
        super().__init__(config)

        loop = asyncio.get_event_loop()
        loop.create_task(self._heartbeat())
        loop.create_task(self._counter_coro(self.cold_counter, self._mqtt_cold_water_theme))
        loop.create_task(self._counter_coro(self.hot_counter, self._mqtt_hot_water_theme))
        loop.create_task(self._display_coro())

mqtt_as पुस्तकालयको अपरेटिङ प्यारामिटरहरू सेट गर्न, विभिन्न सेटिङहरूको ठूलो शब्दकोश प्रयोग गरिन्छ - कन्फिगरेसन। अधिकांश पूर्वनिर्धारित सेटिङहरू हाम्रो लागि ठीक छन्, तर धेरै सेटिङहरू स्पष्ट रूपमा सेट गर्न आवश्यक छ। सेटिङहरू सिधै कोडमा नलेख्नको लागि, म तिनीहरूलाई config.txt पाठ फाइलमा भण्डार गर्छु। यसले तपाइँलाई सेटिङहरूको पर्वाह नगरी कोड परिवर्तन गर्न अनुमति दिन्छ, साथै विभिन्न प्यारामिटरहरूसँग धेरै समान यन्त्रहरू रिभेट गर्दछ।

कोडको अन्तिम ब्लकले प्रणालीको विभिन्न प्रकार्यहरू सेवा गर्न धेरै कोराउटिनहरू सुरु गर्दछ। उदाहरणका लागि, यहाँ एउटा कोरुटिन छ जुन सेवाहरू काउन्टर गर्दछ

    async def _counter_coro(self, counter, topic):
        # Publish initial value
        value = counter.value()
        await self.publish(topic, str(value))

        # Publish each new value
        while True:
            value = await counter
            await self.publish_msg(topic, str(value))

कोरुटिनले नयाँ काउन्टर मानको लागि लुपमा पर्खन्छ र, यो देखा पर्ने बित्तिकै, MQTT प्रोटोकल मार्फत सन्देश पठाउँछ। कोडको पहिलो टुक्राले काउन्टर मार्फत पानी नबढे पनि प्रारम्भिक मान पठाउँछ।

आधार वर्ग MQTTClient ले आफैं सेवा गर्दछ, WiFi जडान सुरु गर्छ र जडान हराउँदा पुन: जडान हुन्छ। जब वाइफाइ जडानको स्थितिमा परिवर्तनहरू हुन्छन्, पुस्तकालयले हामीलाई wifi_connection_handler लाई कल गरेर सूचित गर्दछ।

    async def wifi_connection_handler(self, state):
        self.internet_outage = not state
        if state:
            self.dprint('WiFi is up.')
            duration = ticks_diff(ticks_ms(), self.internet_outage_start) // 1000
            await self.publish_debug_msg('ReconnectedAfter', duration)
        else:
            self.internet_outages += 1
            self.internet_outage_start = ticks_ms()
            self.dprint('WiFi is down.')
            
        await asyncio.sleep(0)

प्रकार्य इमानदारीपूर्वक उदाहरणहरूबाट प्रतिलिपि गरिएको छ। यस अवस्थामा, यसले आउटेजहरूको संख्या (internet_outages) र तिनीहरूको अवधि गणना गर्दछ। जब जडान पुनर्स्थापित हुन्छ, एक निष्क्रिय समय सर्भरमा पठाइन्छ।

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

WiFi मा जडान गर्नुको अतिरिक्त, तपाईंले MQTT ब्रोकर (सर्भर) मा जडान स्थापना गर्न आवश्यक छ। पुस्तकालयले पनि यो गर्छ, र जडान स्थापित हुँदा हामीले केही उपयोगी गर्ने अवसर पाउँछौं

    async def mqtt_connection_handler(self, client):
        await client.subscribe(self._mqtt_cold_water_theme)
        await client.subscribe(self._mqtt_hot_water_theme)

यहाँ हामी धेरै सन्देशहरूको सदस्यता लिन्छौं - सर्भरसँग अब सम्बन्धित सन्देश पठाएर हालको काउन्टर मानहरू सेट गर्ने क्षमता छ।

    def mqtt_msg_handler(self, topic, msg):
        topicstr = str(topic, 'utf8')
        self.dprint("Received MQTT message topic={}, msg={}".format(topicstr, msg))

        if topicstr == self._mqtt_cold_water_theme:
            self.cold_counter.set_value(int(msg))

        if topicstr == self._mqtt_hot_water_theme:
            self.hot_counter.set_value(int(msg))

यो प्रकार्यले आगमन सन्देशहरू प्रशोधन गर्दछ, र विषय (सन्देश शीर्षक) मा निर्भर गर्दछ, काउन्टरहरू मध्ये एकको मानहरू अद्यावधिक हुन्छन्।

सहायक कार्यहरूको एक जोडी

    # Publish a message if WiFi and broker is up, else discard
    async def publish_msg(self, topic, msg):
        self.dprint("Publishing message on topic {}: {}".format(topic, msg))
        if not self.internet_outage:
            await self.publish(topic, msg)
        else:
            self.dprint("Message was not published - no internet connection")

यदि जडान स्थापित छ भने यो प्रकार्यले सन्देश पठाउँछ। यदि त्यहाँ कुनै जडान छैन भने, सन्देशलाई बेवास्ता गरिन्छ।

र यो केवल एक सुविधाजनक प्रकार्य हो जसले डिबगिङ सन्देशहरू उत्पन्न गर्दछ र पठाउँछ।

    async def publish_debug_msg(self, subtopic, msg):
        await self.publish_msg("{}/{}".format(self._mqtt_debug_water_theme, subtopic), str(msg))

यति धेरै पाठ, र हामीले अझैसम्म एलईडी झिम्केका छैनौं। यहाँ

    # Blink flash LED if WiFi down
    async def _heartbeat(self):
        while True:
            if self.internet_outage:
                self.blue_led(not self.blue_led()) # Fast blinking if no connection
                await asyncio.sleep_ms(200) 
            else:
                self.blue_led(0) # Rare blinking when connected
                await asyncio.sleep_ms(50)
                self.blue_led(1)
                await asyncio.sleep_ms(5000)

मैले २ ब्लिङ्किङ मोडहरू उपलब्ध गराएको छु। यदि जडान हराएको छ (वा यो भर्खरै स्थापित भइरहेको छ), उपकरण छिट्टै झिम्किनेछ। यदि जडान स्थापित छ भने, उपकरण प्रत्येक 2 सेकेन्डमा एक पटक झिम्काउँछ। आवश्यक भएमा, अन्य झिम्काउने मोडहरू यहाँ लागू गर्न सकिन्छ।

तर एलईडी केवल लाड छ। हामीले डिस्प्लेलाई पनि लक्षित गरेका छौं।

    async def _display_coro(self):
        display = SSD1306_I2C(128,32, i2c)
    
        while True:
            display.poweron()
            display.fill(0)
            display.text("COLD: {:.3f}".format(self.cold_counter.value() / 1000), 16, 4)
            display.text("HOT:  {:.3f}".format(self.hot_counter.value() / 1000), 16, 20)
            display.show()
            await asyncio.sleep(3)
            display.poweroff()

            while self.button():
                await asyncio.sleep_ms(20)

यो मैले कुरा गरिरहेको थिएँ - यो कोरुटिनहरूसँग कति सरल र सुविधाजनक छ। यो सानो प्रकार्यले सम्पूर्ण प्रयोगकर्ता अनुभव वर्णन गर्दछ। कोरुटिनले बटन थिच्नको लागि मात्र पर्खन्छ र 3 सेकेन्डको लागि प्रदर्शन खोल्छ। डिस्प्लेले हालको मिटर रिडिङहरू देखाउँछ।

साना साना कुराहरू अझै बाँकी छन्। यहाँ (पुनः) यो सम्पूर्ण उद्यम सुरु गर्ने प्रकार्य छ। मुख्य लूपले एक मिनेटमा एक पटक विभिन्न डिबगिङ जानकारी पठाउँछ। सामान्यतया, म यसलाई उद्धृत गर्दछु - मलाई लाग्दैन कि त्यहाँ धेरै टिप्पणी गर्न आवश्यक छ

   async def main(self):
        while True:
            try:
                await self._connect_to_WiFi()
                await self._run_main_loop()
                    
            except Exception as e:
                self.dprint('Global communication failure: ', e)
                await asyncio.sleep(20)

    async def _connect_to_WiFi(self):
        self.dprint('Connecting to WiFi and MQTT')
        sta_if = network.WLAN(network.STA_IF)
        sta_if.connect(config['ssid'], config['wifi_pw'])
        
        conn = False
        while not conn:
            await self.connect()
            conn = True

        self.dprint('Connected!')
        self.internet_outage = False

    async def _run_main_loop(self):
        # Loop forever
        mins = 0
        while True:
            gc.collect()  # For RAM stats.
            mem_free = gc.mem_free()
            mem_alloc = gc.mem_alloc()

            try:
                await self.publish_debug_msg("Uptime", mins)
                await self.publish_debug_msg("Repubs", self.REPUB_COUNT)
                await self.publish_debug_msg("Outages", self.internet_outages)
                await self.publish_debug_msg("MemFree", mem_free)
                await self.publish_debug_msg("MemAlloc", mem_alloc)
            except Exception as e:
                self.dprint("Exception occurred: ", e)
            mins += 1

            await asyncio.sleep(60)

ठीक छ, विवरण पूरा गर्नका लागि केही थप सेटिङहरू र स्थिरताहरू

#####################################
# Constants and configuration
#####################################


config['keepalive'] = 60
config['clean'] = False
config['will'] = ('/ESP/Wemos/Water/LastWill', 'Goodbye cruel world!', False, 0)

MQTTClient.DEBUG = True

EEPROM_ADDR_HOT_VALUE = const(0)
EEPROM_ADDR_COLD_VALUE = const(4)

यो सबै यसरी सुरु हुन्छ

client = CounterMQTTClient()
loop = asyncio.get_event_loop()
loop.run_until_complete(client.main())

मेरो सम्झनामा केहि भयो

त्यसैले, सबै कोड त्यहाँ छ। मैले एम्पी उपयोगिता प्रयोग गरेर फाइलहरू अपलोड गरें - यसले तपाईंलाई आन्तरिक (ESP-07 मा रहेको एउटा) फ्लैश ड्राइभमा अपलोड गर्न र त्यसपछि नियमित फाइलहरूको रूपमा कार्यक्रमबाट पहुँच गर्न अनुमति दिन्छ। त्यहाँ मैले mqtt_as, uasyncio, ssd1306 र मैले प्रयोग गरेको संग्रह पुस्तकालयहरू पनि अपलोड गरें (mqtt_as भित्र प्रयोग गरिएको)।

हामी सुरु गर्छौं र... हामीले मेमोरी एरर पाउँछौं। यसबाहेक, मैले जति धेरै बुझ्ने प्रयास गरें कि मेमोरी कहाँ लिक भइरहेको थियो, मैले जति धेरै डिबग प्रिन्टहरू राखें, यो त्रुटि पहिले देखा पर्‍यो। एउटा छोटो गुगल खोजले मलाई यो बुझ्यो कि माइक्रोकन्ट्रोलरसँग सिद्धान्तमा, केवल 30 kB मेमोरी छ, जसमा 65 kB कोड (पुस्तकालयहरू सहित) मात्र फिट हुन सक्दैन।

तर त्यहाँ एक बाटो छ। यो micropython लाई .py फाइलबाट सीधै कोड कार्यान्वयन गर्दैन - यो फाइल पहिले कम्पाइल गरिएको छ। यसबाहेक, यो सिधै माइक्रोकन्ट्रोलरमा कम्पाइल गरिएको छ, बाइटकोडमा परिणत हुन्छ, जुन त्यसपछि मेमोरीमा भण्डारण गरिन्छ। ठीक छ, कम्पाइलरले काम गर्नको लागि, तपाइँलाई RAM को एक निश्चित मात्रा पनि चाहिन्छ।

चाल भनेको माइक्रोकन्ट्रोलरलाई स्रोत-गहन संकलनबाट बचाउनु हो। तपाईँले ठूलो कम्प्युटरमा फाइलहरू कम्पाइल गर्न सक्नुहुन्छ र माइक्रोकन्ट्रोलरमा तयार-बाइटकोड अपलोड गर्न सक्नुहुन्छ। यो गर्नको लागि, तपाईंले micropython फर्मवेयर डाउनलोड र निर्माण गर्न आवश्यक छ mpy-क्रस उपयोगिता.

मैले मेकफाइल लेखेको छैन, तर म्यानुअल रूपमा सबै आवश्यक फाइलहरू (पुस्तकालयहरू सहित) कम्पाइल गरें।

mpy-cross water_counter.py

.mpy एक्स्टेन्सनसँग फाइलहरू अपलोड गर्न बाँकी छ, पहिले यन्त्रको फाइल प्रणालीबाट सम्बन्धित .py लाई मेटाउन नबिर्सनुहोस्।

मैले कार्यक्रम (IDE?) ESPlorer मा सबै विकास गरे। यसले तपाईंलाई माइक्रोकन्ट्रोलरमा स्क्रिप्टहरू अपलोड गर्न र तिनीहरूलाई तुरुन्तै कार्यान्वयन गर्न अनुमति दिन्छ। मेरो मामलामा, सबै वस्तुहरूको तर्क र सिर्जना water_counter.py (.mpy) फाइलमा अवस्थित छ। तर यो सबै स्वचालित रूपमा सुरु हुनको लागि, त्यहाँ सुरुमा main.py नामक फाइल पनि हुनुपर्छ। यसबाहेक, यो ठ्याक्कै .py हुनुपर्छ, र पूर्व-कम्पाइल गरिएको .mpy होइन। यहाँ यसको मामूली सामग्रीहरू छन्

import water_counter

हामी यसलाई सुरु गर्छौं - सबै काम गर्दछ। तर नि: शुल्क मेमोरी खतरनाक रूपमा सानो छ - लगभग 1kb। मसँग अझै पनि उपकरणको कार्यक्षमता विस्तार गर्ने योजना छ, र यो किलोबाइट स्पष्ट रूपमा मेरो लागि पर्याप्त छैन। तर यो घटनाको लागि पनि एक बाटो छ कि बाहिर निस्कियो।

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

निम्नानुसार एल्गोरिथ्म छ:

• डाउनलोड र स्थापना गर्नुहोस् ESP खोल्नुहोस् SDK। यो चीजले ESP8266 का लागि कार्यक्रमहरूको लागि कम्पाइलर र पुस्तकालयहरू भेला गर्दछ। परियोजनाको मुख्य पृष्ठमा निर्देशनहरू अनुसार भेला भयो (मैले स्ट्यान्डलोन = हो सेटिङ रोजें)
• डाउनलोड गर्नुहोस् माइक्रोपाइथन प्रकार
• माइक्रोपाइथन रूख भित्र पोर्ट/esp8266/मोड्युलहरूमा आवश्यक पुस्तकालयहरू राख्नुहोस्
• हामी फाइलमा निर्देशनहरू अनुसार फर्मवेयर भेला गर्छौं ports/esp8266/README.md
• हामी माइक्रोकन्ट्रोलरमा फर्मवेयर अपलोड गर्छौं (म ESP8266Flasher प्रोग्राम वा Python esptool प्रयोग गरेर Windows मा यो गर्छु)

यो हो, अब 'इम्पोर्ट ssd1306' ले फर्मवेयरबाट सीधै कोड लिनेछ र यसको लागि RAM खपत हुने छैन। यस चालको साथ, मैले फर्मवेयरमा केवल पुस्तकालय कोड अपलोड गरें, जबकि मुख्य प्रोग्राम कोड फाइल प्रणालीबाट निष्पादित हुन्छ। यसले तपाईंलाई फर्मवेयर पुन: कम्पाइल नगरी सजिलैसँग कार्यक्रम परिमार्जन गर्न अनुमति दिन्छ। अहिले मसँग 8.5kb नि:शुल्क RAM छ। यसले हामीलाई भविष्यमा धेरै फरक उपयोगी कार्यक्षमताहरू लागू गर्न अनुमति दिनेछ। ठीक छ, यदि त्यहाँ पर्याप्त मेमोरी छैन भने, तपाइँ फर्मवेयरमा मुख्य कार्यक्रम धकेल्न सक्नुहुन्छ।

त्यसोभए अब हामीले यसको बारेमा के गर्नुपर्छ?

ठीक छ, हार्डवेयर सोल्डर गरिएको छ, फर्मवेयर लेखिएको छ, बक्स छापिएको छ, उपकरण भित्तामा अड्किएको छ र खुसीसाथ बत्ती झिम्काउँछ। तर अहिलेको लागि यो सबै ब्ल्याक बक्स हो (शाब्दिक र लाक्षणिक रूपमा) र यो अझै थोरै प्रयोगको छ। सर्भरमा पठाइएका MQTT सन्देशहरूसँग केही गर्ने समय हो।

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

यन्त्रले कम्तिमा एक पटक सन्देश पठाएपछि, मान तुरुन्तै सूचीमा देखा पर्नेछ।

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

म तपाईलाई केही ग्राफहरू देखाउनेछु। यो दैनिक मानहरूको सरल ग्राफ हो

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

यो ग्राफबाट मैले थाहा पाएँ कि शौचालय जान ६-७ लिटर पानी, नुहाउन २०-३० लिटर, भाँडा धुन २० लिटर र नुहाउन १६० लिटर पानी चाहिन्छ। मेरो परिवारले प्रति दिन लगभग 6-7 लिटर खपत गर्छ।

ती व्यक्तिहरूका लागि जो विशेष गरी उत्सुक छन्, तपाइँ प्रत्येक व्यक्तिगत मूल्यको लागि रेकर्डहरू हेर्न सक्नुहुन्छ

यहाँबाट मैले सिकेँ कि जब ट्याप खुला हुन्छ, पानी लगभग 1 लिटर प्रति 5 सेकेन्डको गतिमा बग्छ।

तर यस फारममा तथ्याङ्कहरू हेर्नको लागि धेरै सुविधाजनक छैन। Majordomo सँग दिन, हप्ता र महिना अनुसार खपत चार्टहरू हेर्ने क्षमता पनि छ। यहाँ, उदाहरणका लागि, बारहरूमा खपत ग्राफ हो

अहिलेसम्म मसँग एक हप्ताको लागि मात्र डाटा छ। एक महिनामा, यो ग्राफ अधिक सूचक हुनेछ - प्रत्येक दिन एक अलग स्तम्भ हुनेछ। मैले म्यानुअल रूपमा प्रविष्ट गरेको मानहरूमा समायोजन गरेर तस्विर थोरै बिग्रिएको छ (सबैभन्दा ठूलो स्तम्भ)। र यो अझै स्पष्ट छैन कि मैले गलत रूपमा पहिलो मानहरू सेट गरें, लगभग एक क्यूब कम, वा यो फर्मवेयरमा बग हो र सबै लिटरहरू गणना गरिएको थिएन। थप समय चाहिन्छ।

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

निष्कर्षमा

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

मिटरबाट एक मिटर टाढा भएमा स्क्रिनमा भएका रिडिङहरू हेर्दा कसै-कसैलाई अनौठो लाग्न सक्छ। तर धेरै टाढाको भविष्यमा, म अर्को अपार्टमेन्टमा जाने योजना गर्छु, जहाँ धेरै पानी राइजरहरू हुनेछन्, र मिटरहरू सम्भवतः अवतरणमा अवस्थित हुनेछन्। त्यसैले रिमोट पढ्ने उपकरण धेरै उपयोगी हुनेछ।

म यन्त्रको कार्यक्षमता विस्तार गर्ने योजना पनि गर्छु। म पहिले नै मोटर चालित भल्भ हेर्दै छु। अब, बॉयलरलाई सहरको पानीमा स्विच गर्न, मैले पुग्न गाह्रो ठाउँमा 3 ट्यापहरू घुमाउनु पर्छ। यो एक बटन संग सम्बन्धित संकेत संग यो गर्न धेरै सुविधाजनक हुनेछ। खैर, निस्सन्देह, यो लीक विरुद्ध सुरक्षा लागू गर्न लायक छ।

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

सधैं जस्तै, म रचनात्मक आलोचना गर्न खुला छु।

स्रोत कोड
सर्किट र बोर्ड
केस मोडेल

स्रोत: www.habr.com