🦃 ⛹🏽 🐺 हम पानी के मीटर को स्मार्ट होम से जोड़ते हैं 🕟 🐋 👨🏻

एक बार होम ऑटोमेशन सिस्टम, या जैसा कि उन्हें अक्सर "स्मार्ट होम" कहा जाता है, बहुत महंगा था और केवल अमीर लोग ही उन्हें खरीद सकते थे। आज बाजार पर आप प्रकाश, सॉकेट, वेंटिलेशन, पानी की आपूर्ति और अन्य उपभोक्ताओं को नियंत्रित करने के लिए सेंसर, बटन / स्विच और एक्चुएटर्स के साथ काफी सस्ती किट पा सकते हैं। और यहां तक कि ~~सबसे krivoruky~~ DIY-shnik सुंदर और सस्ती के लिए एक स्मार्ट घर के लिए उपकरण एकत्र कर सकते हैं।

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

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

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

योजना

पूरे सर्किट का दिल ESP8266 माइक्रोकंट्रोलर पर मॉड्यूल है। ईएसपी -12 मूल रूप से योजनाबद्ध था, लेकिन मेरा दोषपूर्ण हो गया। मुझे ESP-07 मॉड्यूल के साथ संतोष करना पड़ा, जो उपलब्ध था। सौभाग्य से, वे निष्कर्ष और कार्यक्षमता दोनों में समान हैं, अंतर केवल एंटीना में है - ईएसपी -12 में यह अंतर्निहित है, और ईएसपी -07 में एक बाहरी है। हालांकि, वाईफाई एंटीना के बिना भी, मेरे बाथरूम में सिग्नल सामान्य रूप से पकड़ा जाता है।

मॉड्यूल बाइंडिंग मानक है:

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

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

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

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

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

ऑपरेटिंग मोड को इंगित करने के लिए, मैंने GPIO2 से जुड़ी एक एलईडी प्रदान की। हालांकि, मैंने इसे मिलाप करना शुरू नहीं किया, क्योंकि ESP-07 मॉड्यूल में पहले से ही एक LED, इसके अलावा एक ही GPIO2 जुड़ा हुआ है। लेकिन इसे बोर्ड पर रहने दो - अचानक मैं इस एलईडी को मामले में लाना चाहता हूं।

हम सबसे दिलचस्प से गुजरते हैं। पानी के मीटर का कोई तर्क नहीं है, उन्हें वर्तमान रीडिंग के लिए नहीं कहा जा सकता है। केवल एक चीज जो हमारे पास उपलब्ध है वह है दालें - ईख स्विच के संपर्कों को हर लीटर में बंद करना। रीड स्विच के निष्कर्ष GPIO12 / GPIO13 में स्थापित किए गए हैं। मैं मॉड्यूल के अंदर प्रोग्रामेटिक रूप से पुल-अप रोकनेवाला चालू करूंगा।

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

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

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

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

सर्किट बोर्ड

शुरू में, मैंने घर पर एक शुल्क बनाने की योजना बनाई। इसलिए, बोर्ड को एकतरफा डिजाइन किया गया था। लेकिन एक लंबे समय के बाद एक लेज़र आयरन और एक सोल्डर मास्क (इसके बिना यह आईएल faut नहीं था) के बाद, मैंने चीनी से बोर्ड ऑर्डर करने का फैसला किया।

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

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

यह इस तरह निकला

आवास

अगला चरण आवास है। 3D प्रिंटर के साथ, यह कोई समस्या नहीं है। मैंने बहुत परेशान नहीं किया - मैंने सिर्फ सही आकार का एक बॉक्स खींचा और सही स्थानों पर कटआउट बनाए। कवर छोटे शिकंजा पर शरीर से जुड़ा हुआ है।

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

मामले के अंदर ऐसे स्टंप भी हैं जिन पर बोर्ड लगाया गया है और एक एम 3 स्क्रू के साथ तय किया गया है (बोर्ड पर अधिक जगह नहीं थी)

जब मैं केस के पहले फिटिंग संस्करण को प्रिंट करता था तब डिस्प्ले का चयन किया जाता था। मानक दो-लाइन इस मामले में फिट नहीं हुई, लेकिन एक OLED प्रदर्शन SSD1306 128x32 जीम्बल में पाया गया। यह छोटा है, लेकिन मुझे हर दिन उसे देखना नहीं है - यह रोल होगा।

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

उपकरण पूर्ण है। डिस्प्ले मॉड्यूल हॉट-मेल्ट नोजल से सरेस से जोड़ा हुआ है

अंतिम परिणाम केडीपीवी पर देखा जा सकता है

प्रविष्टि

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

यह सभी सरल लगता है, लेकिन बहुत नहीं - कई स्वतंत्र कार्यों को उपकरण में उल्लिखित किया गया है:

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

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

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

मेरा सुझाव है कि वैकल्पिक रूप से भीड़ और प्रतिस्पर्धी मल्टीटास्किंग के बीच अंतर की खोज करें। अब, अंत में कोड पर चलते हैं।

##################################### # 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 की देरी की आवश्यकता होती है, और साथ ही यह नियंत्रित करता है कि कार्य कितनी बार उठता है (जबकि यह कार्य सो रहा है, अन्य कार्य काम करते हैं)। प्रत्येक 25ms फ़ंक्शन जागता है, पिन की जांच करता है और यदि रीड स्विच के संपर्क बंद हो जाते हैं, तो काउंटर से एक और लीटर गुजर गया है और इसे संसाधित करने की आवश्यकता है।

  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))

हम सबसे दिलचस्प बात करते हैं - एमक्यूटीटी के माध्यम से सर्वर के साथ संचार का कार्यान्वयन। ठीक है, प्रोटोकॉल को स्वयं लागू करने की आवश्यकता नहीं है - इंटरनेट पर एक तैयार अतुल्यकालिक कार्यान्वयन पाया गया था। यहां हम इसका इस्तेमाल करेंगे।

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

 ##################################### # 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))

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

MQTTClient बेस क्लास स्वयं कार्य करता है, वाईफाई कनेक्शन शुरू करता है और कनेक्शन खो जाने पर पुन: जुड़ जाता है। जब वाईफाई कनेक्शन की स्थिति बदल जाती है, तो पुस्तकालय 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)

फ़ंक्शन ईमानदारी से उदाहरणों से पाला जाता है। इस मामले में, यह डिस्कनेक्ट (इंटरनेट_आउटेज) की संख्या और उनकी अवधि पर विचार करता है। जब कोई कनेक्शन बहाल किया जाता है, तो डाउनटाइम सर्वर पर भेजा जाता है।

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

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

  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 ब्लिंक मोड प्रदान किए हैं। यदि कनेक्शन खो गया है (या यह बस स्थापित किया जा रहा है), तो डिवाइस जल्दी से झपकी लेगा। यदि कनेक्शन स्थापित है, तो डिवाइस हर 5 सेकंड में एक बार झपकाता है। यदि आवश्यक हो, तो यहां आप अन्य ब्लिंकिंग मोड को लागू कर सकते हैं।

लेकिन एलईडी बहुत लाड़ प्यार कर रही है। हम अभी भी प्रदर्शन के लिए लहराया।

  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)

यह वही है जिसके बारे में मैंने बात की - कोरटाइन के साथ कितना सरल और सुविधाजनक। यह छोटा फ़ंक्शन सभी उपयोगकर्ता सहभागिता का वर्णन करता है। Corutin सिर्फ एक बटन दबाने के लिए इंतजार करता है और 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())

मेरी स्मृति के साथ कुछ बन गया है

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

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

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

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

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

 mpy-cross water_counter.py

यह केवल एक्सटेंशन .mpy के साथ फाइल अपलोड करने के लिए बनी हुई है, डिवाइस के फाइल सिस्टम से संबंधित .py को पहले डिलीट करने की भूल न करें।

मैंने कार्यक्रम (IDE?) ESPlorer में सभी विकास किए। यह आपको माइक्रोकंट्रोलर को स्क्रिप्ट अपलोड करने और तुरंत उन्हें निष्पादित करने की अनुमति देता है। मेरे मामले में, सभी ऑब्जेक्ट्स के सभी तर्क और निर्माण फ़ाइल water_counter.py (.mpy) में स्थित हैं। लेकिन यह सब अपने आप शुरू होने के लिए, शुरुआत में मेनफ्रेम नामक एक और फाइल होनी चाहिए। और यह बिल्कुल सही होना चाहिए। पूर्व-संकलित .mpy नहीं। यहाँ इसकी तुच्छ सामग्री है

 import water_counter

हम शुरू करते हैं - सब कुछ काम करता है। लेकिन खतरनाक रूप से कम मुक्त मेमोरी है - लगभग 1kb। मेरे पास अभी भी डिवाइस की कार्यक्षमता का विस्तार करने की योजना है, और यह किलोबाइट स्पष्ट रूप से मेरे लिए पर्याप्त नहीं होगा। लेकिन यह इस मामले के लिए एक रास्ता है।

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

एल्गोरिथ्म इस प्रकार है:

ईएसपी ओपन एसडीके डाउनलोड और इंस्टॉल करें। यह बात ESP8266 के तहत कार्यक्रमों के लिए एक कंपाइलर और लाइब्रेरी बनाती है। यह परियोजना के मुख्य पृष्ठ पर दिए गए निर्देशों के अनुसार इकट्ठा किया गया है (मैंने सेटिंग STANDALONE = Yes चुना)
डाउनलोड करें माइक्रोपिथॉन शॉर्ट्स
Micropython ट्री के अंदर बंदरगाहों / esp8266 / मॉड्यूल में आवश्यक पुस्तकालयों को गिराएं
हम पोर्ट / esp8266 / README.md फ़ाइल में दिए गए निर्देशों के अनुसार फर्मवेयर को इकट्ठा करते हैं
फर्मवेयर को माइक्रोकंट्रोलर में डालें (मैं ESP8266Fasher प्रोग्राम या पायथन एस्कूल के साथ विंडोज पर ऐसा करता हूं)

यही है, अब 'आयात ssd1306' फर्मवेयर से सीधे कोड बढ़ाएगा और इसके लिए रैम खर्च नहीं किया जाएगा। इस ट्रिक के साथ, मैंने फर्मवेयर में केवल लाइब्रेरी कोड डाउनलोड किया, जबकि मुख्य प्रोग्राम कोड फ़ाइल सिस्टम से निष्पादित होता है। यह आपको फर्मवेयर को पुनः स्थापित किए बिना आसानी से कार्यक्रम को संशोधित करने की अनुमति देता है। फिलहाल मेरे पास लगभग 8.5kb RAM मुफ्त है। यह भविष्य में काफी अलग-अलग उपयोगी कार्यक्षमता को लागू करने की अनुमति देगा। ठीक है, अगर वहाँ पर्याप्त स्मृति नहीं है, तो आप फर्मवेयर में मुख्य कार्यक्रम को भी धक्का दे सकते हैं।

और अब इसके साथ क्या करना है?

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

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

डिवाइस कम से कम एक बार संदेश भेजने के बाद, मूल्य तुरंत सूची में दिखाई देगा।

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

मैं केवल कुछ रेखांकन दिखाऊंगा। यह दैनिक मूल्यों का एक सरल ग्राफ है।

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

इस अनुसूची से, मुझे पता चला कि शौचालय जाना 6-7 लीटर पानी है, एक शॉवर लेना - 20-30 लीटर, बर्तन धोने के बारे में 20 लीटर, और स्नान करने के लिए आपको 160 लीटर की आवश्यकता होती है। एक दिन के लिए, मेरा परिवार लगभग 500-600l का उपभोग करता है।

सबसे उत्सुक के लिए, आप प्रत्येक व्यक्तिगत मान के लिए प्रविष्टियों को देख सकते हैं

यहां से मुझे पता चला कि नल खुले होने के साथ 5 सेकंड में लगभग 1 लीटर की गति से पानी बहता है।

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

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

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

निष्कर्ष

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

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

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

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

हमेशा की तरह, मैं रचनात्मक आलोचना के लिए खुला हूं।

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

हम पानी के मीटर को स्मार्ट होम से जोड़ते हैं