IoT मेड ईज: ESP-MicroPython-MQTT-ThingSpeak: 12 कदम

2024 लेखक: John Day | [email protected]. अंतिम बार संशोधित: 2024-01-30 09:21

मेरे पिछले ट्यूटोरियल में, Jupyter का उपयोग करके ESP पर MicroPython, हमने सीखा कि कैसे एक ESP डिवाइस पर MicroPython को स्थापित और चलाना है। हमारे विकास पर्यावरण के रूप में जुपिटर नोटबुक का उपयोग करते हुए, हमने सेंसर (तापमान, आर्द्रता और चमक) से पढ़ना भी सीखा, हम कई संचार प्रोटोकॉल और विधियों का उपयोग करते हैं, एनालॉग, डिजिटल, 1-वायर और I2C, यह हमारे कैप्चर किए गए प्रदर्शित करने के लिए अंतिम है OLED डिस्प्ले पर डेटा।

अब, MQTT प्रोटोकॉल का उपयोग करते हुए इस ट्यूटोरियल पर, हम सभी कैप्चर किए गए डेटा प्राप्त करेंगे, उन्हें एक IoT सेवा, ThingSpeak.com और एक मोबाइल ऐप (थिंग्सव्यू) पर भेजेंगे, जहां हम लॉग इन कर सकते हैं और डेटा के साथ खेल सकते हैं।

यहाँ, हमारी परियोजना का ब्लॉक आरेख:

चरण 1: BoM - सामग्री का बिल

1. NodeMCU - US$ 8.39
2. DHT22 तापमान और सापेक्ष आर्द्रता सेंसर - USD 9.95
3. DS18B20 पनरोक तापमान सेंसर - USD 5.95
4. OLED डिस्प्ले SSD1366- USD 8.99 (वैकल्पिक)
5. एलडीआर (1x)
6. एलईडी (1x) (वैकल्पिक)
7. पुश बटन (1x)
8. रोकनेवाला 4K7 ओम (2x)
9. रोकनेवाला 10K ओम (1x)
10. प्रतिरोधी 220 ओम (1x)

चरण 2: Hw

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

अपवाद सर्वो है, कि हम इस परियोजना में उपयोग नहीं किए जाएंगे।

ऊपर आप पूरा HW देख सकते हैं। वहां दिखाए गए अनुसार उपकरणों को कनेक्ट करें।

चरण 3: माइक्रोपाइथन, आरईपीएल, जुपिटर

आपके पास अपने ईएसपी डिवाइस पर एक माइक्रोपायथन दुभाषिया लोड होना चाहिए। एक बार लोड हो जाने पर, आपको उपलब्ध किसी भी उपलब्ध तरीके/आईडीई का उपयोग करके अपने ईएसपी को प्रोग्राम करना चाहिए, जैसे:

• आरईपीएल
• जुपिटर नोटबुक
• म्यू
• ईएसपीकट (केवल विंडोज़)
• … आदि

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

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

चरण 4: सेंसर

आइए पुस्तकालयों को स्थापित करें, GPIO को परिभाषित करें, ऑब्जेक्ट बनाएं, सभी सेंसर के लिए व्यक्तिगत रूप से कार्य करें:

ए डीएचटी (तापमान और आर्द्रता)

आइए DHT लाइब्रेरी स्थापित करें और एक ऑब्जेक्ट बनाएं:

dht आयात से DHT22

मशीन आयात से पिन dht22 = DHT22 (पिन(12))

अब, DHT सेंसर को पढ़ने के लिए एक फंक्शन बनाएं:

डीईएफ़ रीडडीएचटी ():

dht22.measure() वापसी dht22.temperature(), dht22.humidity() डीएचटी फ़ंक्शन का परीक्षण करें

प्रिंट (readDht ())

परिणाम उदाहरण के लिए होना चाहिए:

(17.7, 43.4)

B. DS18B20 (बाहरी तापमान)

आइए पुस्तकालयों को स्थापित करें और एक वस्तु बनाएं:

वनवायर आयात करें, ds18x20

आयात समय # परिभाषित करें कि कौन सा पिन 1-वायर डिवाइस से जुड़ा होगा ==> पिन 2 (D4) डेटा = पिन (2) # वनवायर ऑब्जेक्ट बनाएं ds = ds18x20. DS18X20 (onewire. OneWire (dat)) bu. पर उपकरणों के लिए स्कैन करें

सेंसर = डीएस स्कैन ()

प्रिंट ('डिवाइस मिले:', सेंसर)

मुद्रित परिणाम वास्तव में महत्वपूर्ण नहीं है, हमें पहले पता लगाए गए सेंसर की आवश्यकता होगी: सेंसर [0]। और अब, हम सेंसर डेटा को पढ़ने के लिए एक फ़ंक्शन बना सकते हैं:

डीईएफ़ रीडडी ():

ds.convert_temp () time.sleep_ms (750) रिटर्न ds.read_temp (सेंसर [0])

बनाए गए फ़ंक्शन का उपयोग करके सेंसर का परीक्षण करना हमेशा महत्वपूर्ण होता है

प्रिंट (readDs ()) यदि आपको तापमान मान मिलता है, तो आपका कोड सही है

17.5

C. LDR (चमकदार)

LDR हमारे ESP के एनालॉग पिन का उपयोग करेगा (यह ESP8266 के मामले में केवल एक है और ESP32 के लिए कई है)।

विवरण के लिए मेरा ESP32 ट्यूटोरियल देखें।

पहले जैसा ही किया:

#आयात पुस्तकालय

मशीन से आयात ADC # वस्तु को परिभाषित करें adc = ADC(0) एक साधारण कार्य: adc.read() का उपयोग ADC मान को पढ़ने के लिए किया जा सकता है। लेकिन याद रखें कि आंतरिक एडीसी 0 और 3.3V के बीच के वोल्टेज को 0 से 1023 तक भिन्न-भिन्न डिजिटल मानों में परिवर्तित करेगा। एक बार जब हम "चमक" में रुचि रखते हैं, तो हम अधिकतम प्रकाश को सेंसर से अधिकतम कैप्चर किए गए मान के रूप में मानेंगे (मेरे में) केस ९००) और न्यूनतम प्रकाश जो मेरे मामले में ४० है। उन मूल्यों के होने से हम ४० से ९०० के मूल्य को ० से १००% चमक में "मैप" कर सकते हैं। उसके लिए, हम एक नया फ़ंक्शन बनाएंगे

डीईएफ़ रीडएलडीआर ():

lumPerct = (adc.read()-40)*(10/86) # प्रतिशत में कनवर्ट करें ("मैप") रिटर्न राउंड (lumPerct)

आपको प्रिंट (readLDR ()) का उपयोग करके फ़ंक्शन का परीक्षण करना चाहिए। परिणाम o और १०० के बीच एक पूर्णांक होना चाहिए।

D. पुश-बटन (डिजिटल इनपुट)

यहां हम एक डिजिटल सेंसर के रूप में पुश-बटन का उपयोग कर रहे हैं, लेकिन यह एक एक्चुएटर का "इको" हो सकता है (उदाहरण के लिए एक पंप जिसे चालू/बंद किया गया था)।

# पिन 13 को इनपुट के रूप में परिभाषित करें और आंतरिक पुल-अप रोकनेवाला को सक्रिय करें:

बटन = पिन (13, पिन.इन, पिन. PULL_UP) # बटन स्थिति पढ़ने के लिए फ़ंक्शन: डीफ़ रीडबट (): रिटर्न बटन। वैल्यू ()

आप फ़ंक्शन प्रिंट पढ़ने वाले बटन का परीक्षण कर सकते हैं (पढ़ें लेकिन ())। परिणाम को दबाने पर "1" होना चाहिए। बटन दबाने पर परिणाम "0" होना चाहिए

चरण 5: स्थानीय रूप से सभी सेंसर डेटा को कैप्चर करना और प्रदर्शित करना

अब जब हमने प्रत्येक सेंसर के लिए एक फ़ंक्शन बना लिया है, तो आइए अंतिम एक ऐसा बनाएं जो उन सभी को एक ही समय में पढ़ेगा:

डीईएफ़ कोलेक्टडेटा ():

अस्थायी, हम, = readDht () extTemp = readDs () lum = readLdr () butSts = readbut () वापसी अस्थायी, हम, extTemp, lum, butSts अब यदि आप उपयोग करते हैं

प्रिंट (कोलेक्टडेटा ())

एक टपल में परिणाम होगा जिसमें सेंसर से सभी कैप्चर किए गए डेटा शामिल हैं:

(17.4, 45.2, 17.3125, 103, 1)

हम वैकल्पिक रूप से उन डेटा को स्थानीय डिस्प्ले पर भी दिखा सकते हैं:

# लाइब्रेरी आयात करें और ऑब्जेक्ट बनाएं i2c

मशीन से आयात I2C i2c = I2C(scl=Pin(5), sda=Pin(4)) # आयात पुस्तकालय और पुराने वस्तु आयात ssd1306 i2c = I2C(scl=Pin(5), sda=Pin(4)) पुराने बनाएं = ssd1306. SSD1306_I2C(128, 64, i2c, 0x3c) # एक फ़ंक्शन बनाएं: def displayData(temp, hum, extTemp, lum, butSts): oled.fill(0) oled.text("Temp:" + str(temp) + "oC", 0, 4) oled.text("Hum:" + str(hum) + "%", 0, 16) oled.text("ExtTemp:" + str(extTemp) + "oC", 0, 29) oled.text("Lumin:" + str(lum) + "%", 0, 43) oled.text("Button:" + str(butSts), 0, 57) oled.show() # फ़ंक्शन का उपयोग करके डेटा प्रदर्शित करें डिस्प्लेडेटा (अस्थायी, hum, extTemp, lum, butSts)

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

तो, मुख्य कार्य होगा:

# सभी सेंसर को पढ़ने का मुख्य कार्य

def main (): # एक फ़ंक्शन के साथ डेटा प्रदर्शित करें led.on() temp, hum, extTemp, lum, butSts = colectData() displayData (temp, hum, extTemp, lum, butSts) led.off()

इसलिए, मुख्य () को क्रियान्वित करते हुए, हमें चित्र में दिखाए गए अनुसार OLED पर प्रदर्शित सेंसर डेटा मिलेगा।

चरण 6: ईएसपी स्टार्ट-अप पर स्थानीय स्टेशन कोड चलाना

हमारे पास वह सब हो सकता है जो अब तक हमारे ईएसपी द्वारा निष्पादित की जाने वाली एक फाइल पर विकसित किया गया था।

आइए कोई भी टेक्स्ट एडिटर खोलें और उस पर सभी कोड पेस्ट करें:

# सामान्य पुस्तकालयों का आयात करें

मशीन आयात से पिन आयात समय # पिन 0 को आउटपुट एलईडी के रूप में परिभाषित करें = पिन (0, पिन.आउट) # डीएचटी आयात से डीएचटी डीएचटी 22 डीएचटी 22 = डीएचटी 22 (पिन (12)) # डीएचटी पढ़ने के लिए फ़ंक्शन डीएचटी पढ़ें (): dht22.measure () रिटर्न dht22.temperature(), dht22.humidity() # DS18B20 इंपोर्ट वनवायर, ds18x20 # परिभाषित करें कि कौन सा पिन 1-वायर डिवाइस कनेक्ट होगा ==> पिन 2 (D4) डेटा = पिन (2) # वनवायर बनाएं ऑब्जेक्ट ds = ds18x20. DS18X20(onewire. OneWire(dat)) # बस सेंसर पर उपकरणों के लिए स्कैन = ds.scan() # DS18B20 पढ़ने के लिए फ़ंक्शन readDs(): ds.convert_temp() time.sleep_ms(750) वापसी Round(ds.read_temp(sensors[0]), 1) # मशीन आयात ADC से LDR # ऑब्जेक्ट को परिभाषित करें adc = ADC(0) # ल्युमिनोसिटी को पढ़ने के लिए function readLdr(): lumPerct = (adc.read()-40) *(10/86) # प्रतिशत में कनवर्ट करें ("मैप") रिटर्न राउंड (lumPerct) # पिन 13 को एक इनपुट के रूप में परिभाषित करें और एक आंतरिक पुल-अप रेसिस्टर को सक्रिय करें: बटन = पिन (13, पिन.इन, पिन. PULL_UP) # बटन स्थिति पढ़ने के लिए फ़ंक्शन: डीफ़ रीडबट (): रिटर्न बटन। वैल्यू () # सभी डेटा पढ़ने के लिए फ़ंक्शन: डीफ़ कोल ctData (): अस्थायी, hum, = readDht () extTemp = readDs () lum = readLdr () butSts = readbut () वापसी अस्थायी, hum, extTemp, lum, butSts # आयात पुस्तकालय और मशीन आयात से ऑब्जेक्ट i2c बनाएं I2C i2c = I2C(scl=Pin(5), sda=Pin(4)) # इम्पोर्ट लाइब्रेरी और ऑब्जेक्ट ओलेड इम्पोर्ट ssd1306 i2c = I2C(scl=Pin(5), sda=Pin(4)) oled = ssd1306. SSD1306_I2C(128), 64, i2c, 0x3c) # एक फ़ंक्शन बनाएं: def displayData(temp, hum, extTemp, lum, butSts): oled.fill(0) oled.text("Temp:" + str(temp) + "oC", 0, 4) oled.text ("हम:" + str(hum) + "%", 0, 16) oled.text("ExtTemp:" + str(extTemp) + "oC", 0, 29) पुराना। text("Lumin:" + str(lum) + "%", 0, 43) oled.text("Button:" + str(butSts), 0, 57) old.show() # सभी सेंसर को पढ़ने के लिए मुख्य कार्य def main (): # एक फ़ंक्शन के साथ डेटा प्रदर्शित करें led.on() temp, hum, extTemp, lum, butSts = colectData() displayData(temp, hum, extTemp, lum, butSts) led.off() '''- ----- मुख्य कार्य चलाएँ -------- '''' मुख्य ()

इसे सहेजें, उदाहरण के लिए localData.py के रूप में।

इस कोड को सीधे अपने टर्मिनल पर चलाने के लिए आपको Ampy की आवश्यकता होगी।

सबसे पहले, टर्मिनल पर Ampy को हमारे सीरियल पोर्ट को सूचित करें:

निर्यात AMPY_PORT=/dev/tty. SLAB_USBtoUART

अब, हम उन फाइलों को देख सकते हैं जो हमारे ईएसपी रूट डायरेक्टरी के अंदर हैं:

एम्पी एलएसओ

प्रतिक्रिया के रूप में, हमें boot.py मिलेगा, जो कि सिस्टम में चलने वाली पहली फाइल है।

अब, हमारे अजगर स्क्रिप्ट LocalData.py को /main.py के रूप में लोड करने के लिए Ampy का उपयोग करें, इसलिए स्क्रिप्ट बूट के ठीक बाद चलेगी:

ampy डाल localData.py /main/py

यदि हम amp ls अभी कमांड का उपयोग करते हैं, तो आप ESP के अंदर 2 फाइलें देखेंगे: boot.py और main.py

अपने ESP को रीसेट करने से, प्रोग्राम localData.py स्वचालित रूप से चलेगा, सेंसर डेटा डिस्प्ले पर प्रदर्शित होगा।

उपरोक्त टर्मिनल प्रिंट स्क्रीन दिखाती है कि हमने क्या किया है।

उपरोक्त कोड के साथ, डिस्प्ले केवल एक बार दिखाया जाएगा, लेकिन हम मुख्य () फ़ंक्शन पर एक लूप को परिभाषित कर सकते हैं, जो प्रत्येक परिभाषित समय अंतराल (PUB_TIME_SEC) पर डेटा दिखाएगा, और उदाहरण के लिए, जब तक हम बटन दबाते हैं:

# लूप को बटन दबाए जाने तक डेटा मिल रहा है

जबकि बटन.वैल्यू (): एलईडी.ऑन () अस्थायी, हम, एक्स्टटेम्प, लुम, बटस्ट्स = कोलेक्टडेटा () डिस्प्लेडेटा (अस्थायी, हम, एक्स्टटेम्प, लुम, बटस्ट) एलईडी.ऑफ () समय। नींद (PUB_TIME_SEC)

चर PUB_TIME_SEC को उस समय तक घोषित किया जाना चाहिए जब आप अपने नमूने चाहते हैं।

हमारे कोड को और बढ़ाने के लिए, यह सूचित करना अच्छा होगा कि हम लूप से बाहर जाएंगे, इसके लिए हम 2 नए सामान्य कार्यों को परिभाषित करेंगे, एक डिस्प्ले को साफ़ करने के लिए और दूसरा निश्चित समय पर एलईडी को ब्लिंक करने के लिए।

# स्पष्ट प्रदर्शन:

def displayClear(): oled.fill(0) oled.show() # एक ब्लिंक फंक्शन बनाएं def blinkLed(num): for i in range(0, num): led.on() sleep(0.5) led.off() नींद (0.5)

तो, अब हम अपने मुख्य () फ़ंक्शन को फिर से लिख सकते हैं:

जबकि बटन। मूल्य ():

LED.on() अस्थायी, hum, extTemp, lum, butSts = colectData() displayData (temp, hum, extTemp, lum, butSts) led.off () time.sleep (PUB_TIME_SEC) blinkLed(3) displayClear()

अंतिम कोड मेरे GitHub से डाउनलोड किया जा सकता है: localData.py और पूर्ण कोड के विकास के लिए उपयोग की जाने वाली ज्यूपिटर नोटबुक: ज्यूपिटर लोकल डेटा डेवलपमेंट।

चरण 7: ईएसपी को स्थानीय वाईफाई से जोड़ना

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

आयात नेटवर्क

वाईफाई_एसएसआईडी = "आपका एसएसआईडी" वाईफाई_पास = "आपका पासवर्ड"

नीचे दिए गए फ़ंक्शन का उपयोग ईएसपी को आपके स्थानीय नेटवर्क से जोड़ने के लिए किया जा सकता है:

डीईएफ़ do_connect ():

wlan = network. WLAN(network. STA_IF) wlan.active(True) अगर नहीं तो wlan.isconnected(): Print('connecting to network…') wlan.connect(WiFi_SSID, WiFi_SSID) जबकि wlan.isconnected (): पास नहीं प्रिंट ('नेटवर्क कॉन्फिग:', wlan.ifconfig ())

फ़ंक्शन चलाकर, आप परिणामस्वरूप IP पता प्राप्त कर सकते हैं:

do_connect ()

परिणाम होगा:

नेटवर्क कॉन्फ़िगरेशन: ('10.0.1.2', '255.255.255.0', '10.0.1.1', '10.0.1.1')

थे, मेरे मामले में, 10.0.1.2, ESP IP पता है।

चरण 8: द थिंगस्पीक

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

चलो शुरू करें!

सबसे पहले, आपके पास ThinkSpeak.com पर एक खाता होना चाहिए। इसके बाद, चैनल बनाने के लिए निर्देशों का पालन करें और अपनी चैनल आईडी पर ध्यान दें और एपीआई कुंजी लिखें।

ऊपर आप हमारे चैनल पर उपयोग किए जाने वाले 5 फ़ील्ड देख सकते हैं।

चरण 9: एमक्यूटीटी प्रोटोकॉल और थिंगस्पीक कनेक्शन

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

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

ThingSpeak™ का URL mqtt.thingspeak.com और पोर्ट 1883 पर MQTT ब्रोकर है। ThingSpeak ब्रोकर MQTT प्रकाशन और MQTT सदस्यता दोनों का समर्थन करता है।

हमारे मामले में, हम उपयोग करेंगे: MQTT Publish

चित्र विषय संरचना का वर्णन करता है। प्रकाशित करने के लिए राइट एपीआई कुंजी आवश्यक है। ब्रोकर CONNACK के साथ एक सही CONNECTrequest स्वीकार करता है।

MQTT प्रोटोकॉल Micropython बायनेरिज़ में एक अंतर्निहित लाइब्रेरी में समर्थित है - इस प्रोटोकॉल का उपयोग आपके ESP8266 से, WIFI पर, एक मुफ्त क्लाउड डेटाबेस में डेटा भेजने के लिए किया जा सकता है।

आइए umqtt.simple लाइब्रेरी का उपयोग करें:

umqtt.simple आयात से MQTTClient

और हमारे सर्वर आईडी को जानने के बाद, हमारा MQTT क्लाइंट ऑब्जेक्ट बनाना संभव है:

सर्वर = "mqtt.thingspeak.com"

क्लाइंट = MQTTClient ("umqtt_client", सर्वर)

अब, आपके ThingSpeak क्रेडेंशियल हाथ में हैं:

CHANNEL_ID = "आपका चैनल आईडी"

WRITE_API_KEY = "आपकी कुंजी यहाँ है"

आइए अपना MQTT "विषय" बनाएं:

विषय = "चैनल/" + CHANNEL_ID + "/प्रकाशित/" + WRITE_API_KEY

आइए हमारे डेटा को थिंगस्पीक IoT सेवा को भेजे जाने के लिए, बनाए गए फ़ंक्शन का उपयोग करके और विशिष्ट डेटा चर के लिए इसकी प्रतिक्रिया को संबद्ध करें:

अस्थायी, हम, extTemp, lum, butSts = colectData ()

उन वेरिएबल्स को अपडेट करके, हम अपना "MQTT पेलोड" बना सकते हैं:

पेलोड = "फ़ील्ड1="+str(temp)+"&field2="+str(hum)+"&field3="+str(extTemp)+"&field4="+str(lum)+"&field5="+str(butSts)

और बस! हम नीचे दिए गए कोड की 3 पंक्तियों का उपयोग करके, ThinsSpeak को डेटा भेजने के लिए तैयार हैं:

क्लाइंट.कनेक्ट ()

क्लाइंट.प्रकाशित (विषय, पेलोड) क्लाइंट.डिस्कनेक्ट ()

अब, यदि आप अपने चैनल पृष्ठ पर जाते हैं (जैसा कि ऊपर मेरा है) आप देखेंगे कि 5 क्षेत्रों में से प्रत्येक में आपके सेंसर से संबंधित डेटा होगा।

चरण 10: सेंसर डेटा लकड़हारा

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

पहले घोषित किए गए समान चर (PUB_TIME_SEC) का उपयोग करते हुए, डेटा को लगातार कैप्चर करने के लिए एक सरल मुख्य कार्य, उन्हें हमारे चैनल पर लॉग करना होगा:

जबकि सच:

temp, hum, extTemp, lum, butSts = colectData() पेलोड = "फ़ील्ड1="+str(temp)+"&field2="+str(hum)+"&field3="+str(extTemp)+"&field4="+ str(lum)+"&field5="+str(butSts) client.connect() client.publish(topic, payload) client.disconnect() time.sleep(PUB_TIME_SEC)

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

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

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

लेकिन, एक बार यहां विचार सीख रहा है, आइए डिस्प्ले और एलईडी को भी शामिल करें जैसा हमने पहले किया था। ऐसा करने पर, हमारा "लॉगर" फंक्शन होगा:

जबकि बटन। मूल्य ():

led.on() अस्थायी, हम, extTemp, lum, butSts = colectData() displayData (temp, hum, extTemp, lum, butSts) led.off () अस्थायी, hum, extTemp, lum, butSts = colectData () पेलोड = "field1="+str(temp)+"&field2="+str(hum)+"&field3="+str(extTemp)+"&field4="+str(lum)+"&field5="+str(butSts) क्लाइंट कनेक्ट () क्लाइंट। प्रकाशित (विषय, पेलोड) क्लाइंट। डिस्कनेक्ट () समय। नींद (PUB_TIME_SEC) ब्लिंकलेड (3) डिस्प्ले क्लियर ()

संपूर्ण माइक्रोपायथन स्क्रिप्ट यहां पाई जा सकती है: dataLoggerTS_EXT.py और जुपिटर नोटबुक जिसे विकास के लिए उपयोग किया गया था, यहां भी पाया जा सकता है: IoT ThingSpeak Data Logger EXT.ipynb।

ईएसपी पर स्क्रिप्ट अपलोड करने के लिए, अपने टर्मिनल पर कमांड का उपयोग करें:

ampy डाल dataLoggerTS.py /main.py

और ESP - रीसेट बटन दबाएं। आपके पास ईएसपी डेटा कैप्चर करना और उन्हें ThingSpeak.com पर लॉग इन करना होगा जब तक कि नीचे दबाया न जाए (एलईडी के 3 बार ब्लिंक करने और ओएलईडी बंद होने की प्रतीक्षा करें)।

चरण 11: द थिंग व्यू ऐप

लॉग किया गया डेटा सीधे ThingSpeak.com साइट पर या किसी एपीपी के माध्यम से देखा जा सकता है, उदाहरण के लिए, थिंग्स व्यू!

ThingView CINETICA द्वारा विकसित एक ऐप है, जो आपको अपने ThingSpeak चैनलों को एक आसान तरीके से देखने में सक्षम बनाता है, बस चैनल आईडी दर्ज करें और आप जाने के लिए तैयार हैं।

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

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

ThingView APP को ANDROID और IPHONE के लिए डाउनलोड किया जा सकता है।

चरण 12: निष्कर्ष

हमेशा की तरह, मुझे आशा है कि यह परियोजना दूसरों को इलेक्ट्रॉनिक्स की रोमांचक दुनिया में अपना रास्ता खोजने में मदद कर सकती है!

विवरण और अंतिम कोड के लिए, कृपया मेरे GitHub डिपॉजिटरी पर जाएँ: IoT_TS_MQTT

अधिक परियोजनाओं के लिए, कृपया मेरे ब्लॉग पर जाएँ: MJRoBot.org

दुनिया के दक्षिण से Saludos!

मेरे अगले निर्देश में मिलते हैं!

शुक्रिया, मार्सेलो