IoT मेड ईज़ी: रिमोट वेदर डेटा कैप्चर करना: UV और एयर टेम्परेचर और ह्यूमिडिटी: 7 स्टेप्स

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

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

ब्लॉक आरेख दिखाता है कि हमें अंत में क्या मिलेगा।

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

NodeMCU (ESP8266-12E) - USD 9.00

आर्द्रता और तापमान सेंसर (DHT22) - USD10.00

यूवी सेंसर - यूएसडी 4.00

OLED USD 12.00

ब्रेडबोर्ड - USD1.00

चरण 2: एनालॉग यूवी सेंसर

यह यूवी सेंसर प्रकाश-संवेदी स्पेक्ट्रम पर पाए जाने वाले अल्ट्रा-वायलेट विकिरण के समानुपाती एनालॉग आउटपुट उत्पन्न करता है। यह एक यूवी फोटोडायोड (गैलियम नाइट्राइड पर आधारित) का उपयोग करता है, जो प्रकाश की 240-370nm रेंज का पता लगा सकता है (जिसमें यूवीबी और अधिकांश यूवीए स्पेक्ट्रम शामिल हैं)। फोटोडायोड से सिग्नल का स्तर नैनो-एम्पीयर स्तर में बहुत छोटा होता है, इसलिए मॉड्यूल ने सिग्नल को अधिक पठनीय वोल्ट-स्तर (0 से 1V) तक बढ़ाने के लिए एक परिचालन एम्पलीफायर को एम्बेड किया है।

VCC को 3.3VDC (या 5VDC) और GND को पावर ग्राउंड से जोड़कर सेंसर और op-amp को संचालित किया जा सकता है। एनालॉग सिग्नल को OUT पिन से प्राप्त किया जा सकता है।

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

/* एमवी में यूवी सेंसर पढ़ें और यूवी इंडेक्स कैलकुलेशन को कॉल करें */

शून्य readSensorUV () {बाइट numOfReadings = 5; डेटा सेंसरयूवी = 0; के लिए (int i=0; i< numOfReadings; i++) {dataSensorUV +=analogRead(sensorUVPin); देरी (200); } डेटा सेंसरयूवी / = numOfReadings; डेटा सेंसरयूवी = (डेटा सेंसरयूवी * (3.3 / 1023.0)) * 1000; Serial.println (डेटा सेंसरयूवी); सूचकांक गणना (); }

एक बार हमारे पास यूवी डेटा होने के बाद हम उपरोक्त तालिका में परिभाषित यूवी इंडेक्स की आसानी से गणना कर सकते हैं। फ़ंक्शन indexCalculate() यह हमारे लिए करेगा:

/* यूवी सूचकांक गणना */

शून्य सूचकांक कैलकुलेट () { अगर (डेटा सेंसरयूवी <227) इंडेक्सयूवी = 0; और अगर (227 <= dataSensorUV && dataSensorUV <318) indexUV = 1; और अगर (318 <= dataSensorUV && dataSensorUV <408) indexUV = 2; और अगर (408 <= dataSensorUV && dataSensorUV <503) indexUV = 3; और अगर (503 <= dataSensorUV && dataSensorUV <606) indexUV = 4; और अगर (606 <= dataSensorUV && dataSensorUV <696) indexUV = 5; और अगर (696 <= dataSensorUV && dataSensorUV <795) indexUV = 6; और अगर (795 <= dataSensorUV && dataSensorUV <881) indexUV = 7; और अगर (881 <= dataSensorUV && dataSensorUV <976) indexUV = 8; और अगर (९७६ <= dataSensorUV && dataSensorUV <१०७९) indexUV = ९; और अगर (1079 <= dataSensorUV && dataSensorUV <1170) indexUV = 10; अन्य इंडेक्सयूवी = 11; }

चरण 3: डिस्प्ले इंस्टॉल करना: OLED

परीक्षण उद्देश्यों के लिए, हम अपने यूवी मीटर पर एक OLED शामिल करेंगे (यह चरण पूरी तरह से वैकल्पिक है)।

परीक्षणों के दौरान सीरियल मॉनिटर का उपयोग करना ठीक है, लेकिन क्या हो रहा है जब आप अपने पीसी से दूर अपने प्रोटोटाइप का उपयोग स्टैंड-अलोन मोड में कर रहे हैं? उसके लिए, आइए एक OLED डिस्प्ले, SSD1306 स्थापित करें, जो मुख्य विशेषताएं हैं:

• प्रदर्शन का आकार: 0.96"
• I2C आईआईसी एसपीआई सीरियल
• 128X64
• सफेद OLED एलसीडी एलईडी

विद्युत आरेख का पालन करें और हमारे OLED के 4 पिन कनेक्ट करें:

• वीसीसी 3.3V. पर जाता है
• जीएनडी जमीन पर जाता है
• SCL NodeMCU (GPIO 2) ==>D4. में जाता है
• SDA NodeMCU (GPIO 0) ==>D3. में जाता है

एक बार जब हम डिस्प्ले को कनेक्ट कर लेते हैं, तो आइए हमारे Arduino IDE पर इसकी लाइब्रेरी को डाउनलोड और इंस्टॉल करें: "ESP8266 OLED ड्राइवर SSD1306 डिस्प्ले के लिए" डैनियल आइचॉर्न द्वारा विकसित (सुनिश्चित करें कि आप संस्करण 3.0.0 या इससे बड़े का उपयोग करते हैं!)।

अपने Arduino IDE पर पुस्तकालय स्थापित करें, जो SSD1306Wire.h. पर पाया जा सकता है

एक बार जब आप आईडीई को पुनरारंभ करते हैं, तो पुस्तकालय पहले से ही स्थापित होना चाहिए।

पुस्तकालय अंतर्निहित Wire.h पुस्तकालय का उपयोग करके OLED डिस्प्ले तक पहुंचने के लिए I2C प्रोटोकॉल का समर्थन करता है:

/* ओएलईडी */

#include "SSD1306Wire.h" #include "Wire.h" const int I2C_DISPLAY_ADDRESS = 0x3c; कॉन्स्ट इंट एसडीए_पिन = 0; कॉन्स्ट इंट SCL_PIN = 2; SSD1306वायर डिस्प्ले (I2C_DISPLAY_ADDRESS, SDA_PIN, SCL_PIN);

आइए कुछ महत्वपूर्ण एपीआई सूचीबद्ध करें जिनका उपयोग हमारे OLED डिस्प्ले के साथ किया जाएगा। पूरी सूची ऊपर दिए गए GIThub पर पाई जा सकती है।

ए प्रदर्शन नियंत्रण:

शून्य init (); // डिस्प्ले को इनिशियलाइज़ करें

शून्य डिस्प्लेऑन (शून्य); // डिस्प्ले को शून्य डिस्प्लेऑफ (शून्य) पर चालू करें; // डिस्प्ले को बंद करें शून्य स्पष्ट (शून्य); // स्थानीय पिक्सेल बफर को खाली करें फ्लिपस्क्रीन को लंबवत रूप से (); // डिस्प्ले को उल्टा कर दें

बी पाठ संचालन:

शून्य ड्रॉस्ट्रिंग (int16_t x, int16_t y, स्ट्रिंग टेक्स्ट); // (xpos, ypos, "पाठ")

शून्य सेटफ़ॉन्ट (कॉन्स्ट चार * फ़ॉन्टडेटा); // वर्तमान फ़ॉन्ट सेट करें।

उपलब्ध डिफ़ॉल्ट फ़ॉन्ट:

• एरियलएमटी_सादा_10,

• एरियलएमटी_सादा_16,

• एरियलएमटी_सादा_24

एक बार ओएलईडी और इसकी लाइब्रेरी दोनों स्थापित हो जाने के बाद, आइए इसका परीक्षण करने के लिए एक सरल प्रोग्राम लिखें। अपने आईडीई पर बोले कोड के साथ दर्ज करें, परिणाम एक प्रदर्शन होना चाहिए जैसा कि ऊपर फोटो में दिखाया गया है:

*ओएलईडी*/

#include "SSD1306Wire.h" #include "Wire.h" const int I2C_DISPLAY_ADDRESS = 0x3c; कॉन्स्ट इंट एसडीए_पिन = 0; कॉन्स्ट इंट SCL_PIN = 2; SSD1306वायर डिस्प्ले (I2C_DISPLAY_ADDRESS, SDA_PIN, SCL_PIN); शून्य सेटअप () {Serial.begin(११५२००); डिस्प्ले सेटअप(); } शून्य लूप() { } /* OLED पर सेटअप डेटा आरंभ और प्रदर्शित करें */ void displaySetup() {display.init(); // डिस्प्ले डिस्प्ले को इनिशियलाइज़ करें। क्लियर (); // क्लियर डिस्प्ले डिस्प्ले। फ्लिपस्क्रीन वर्टिकली (); // डिस्प्ले को उल्टा कर दें डिस्प्ले। डिस्प्ले (); // प्रदर्शन पर डेटा डालें Serial.println ("प्रदर्शन परीक्षण शुरू करना"); display.setFont (एरियलएमटी_प्लेन_24); डिस्प्ले.ड्रास्ट्रिंग (30, 0, "ओएलईडी"); // (xpos, ypos, "पाठ") display.setFont(ArialMT_Plain_16); display.drawString(18, 29, "टेस्ट शुरू किया गया"); display.setFont (एरियलएमटी_प्लेन_10); display.drawString(10, 52, "सीरियल बॉडरेट:"); डिस्प्ले.ड्रास्ट्रिंग (९०, ५२, स्ट्रिंग (११५००)); डिस्प्ले.डिस्प्ले (); // प्रदर्शन में देरी (3000) पर डेटा डालें; }

उपरोक्त कार्यक्रम को मेरे GitHub से डाउनलोड किया जा सकता है:

NodeMCU_OLED_Test

चरण 4: एक स्थानीय यूवी मीटर

अब, OLED डिस्प्ले स्थापित होने के साथ, हम एक बैटरी कनेक्ट कर सकते हैं और अपने "UV मीटर" का उपयोग करके कुछ दूरस्थ परीक्षण कर सकते हैं।

# परिभाषित करें SW_VERSION "UV_Sensor_V.1"

/* यूवी सेंसर */ # सेंसर परिभाषित करेंUVPin A0 int dataSensorUV = 0; इंट इंडेक्सयूवी = 0; /* OLED */ #include "SSD1306Wire.h" #include "Wire.h" const int I2C_DISPLAY_ADDRESS = 0x3c; कॉन्स्ट इंट एसडीए_पिन = 0; कॉन्स्ट इंट SCL_PIN = 2; SSD1306वायर डिस्प्ले (I2C_DISPLAY_ADDRESS, SDA_PIN, SCL_PIN); शून्य सेटअप () {Serial.begin(११५२००); डिस्प्ले सेटअप(); } शून्य लूप () {readSensorUV (); डिस्प्लेयूवी (); देरी (1000); } /* OLED पर सेटअप डेटा आरंभ और प्रदर्शित करें */ void displaySetup() {display.init(); // डिस्प्ले डिस्प्ले को इनिशियलाइज़ करें। क्लियर (); // क्लियर डिस्प्ले डिस्प्ले। फ्लिपस्क्रीन वर्टिकली (); // डिस्प्ले को उल्टा कर दें डिस्प्ले। डिस्प्ले (); // डिस्प्ले पर डेटा डालें Serial.println ("यूवी सेंसर टेस्ट शुरू करना"); display.setFont (एरियलएमटी_प्लेन_24); display.drawString(10, 0, "MJRoBot"); display.setFont (एरियलएमटी_प्लेन_16); डिस्प्ले.ड्रास्ट्रिंग (0, 29, "यूवी सेंसर टेस्ट"); display.setFont (एरियलएमटी_प्लेन_10); display.drawString(0, 52, "SW Ver.:"); डिस्प्ले.ड्रास्ट्रिंग (45, 52, SW_VERSION); डिस्प्ले.डिस्प्ले (); देरी (3000); } /* UV सेंसर को mV में पढ़ें और UV इंडेक्स कैलकुलेशन को कॉल करें */ void readSensorUV() {बाइट numOfReadings = 5; डेटा सेंसरयूवी = 0; के लिए (int i=0; i< numOfReadings; i++) {dataSensorUV +=analogRead(sensorUVPin); देरी (200); } डेटा सेंसरयूवी / = numOfReadings; डेटा सेंसरयूवी = (डेटा सेंसरयूवी * (3.3 / 1023.0)) * 1000; Serial.println (डेटा सेंसरयूवी); सूचकांक गणना (); } /* यूवी सूचकांक गणना */ शून्य सूचकांक कैलकुलेट () { अगर (डेटा सेंसरयूवी <227) इंडेक्सयूवी = 0; और अगर (227 <= dataSensorUV && dataSensorUV <318) indexUV = 1; और अगर (318 <= dataSensorUV && dataSensorUV <408) indexUV = 2; और अगर (408 <= dataSensorUV && dataSensorUV <503) indexUV = 3; और अगर (503 <= dataSensorUV && dataSensorUV <606) indexUV = 4; और अगर (606 <= dataSensorUV && dataSensorUV <696) indexUV = 5; और अगर (696 <= dataSensorUV && dataSensorUV <795) indexUV = 6; और अगर (795 <= dataSensorUV && dataSensorUV <881) indexUV = 7; और अगर (881 <= dataSensorUV && dataSensorUV <976) indexUV = 8; और अगर (९७६ <= dataSensorUV && dataSensorUV <१०७९) indexUV = ९; और अगर (1079 <= dataSensorUV && dataSensorUV <1170) indexUV = 10; अन्य इंडेक्सयूवी = 11; } /* स्थानीय ओएलईडी पर यूवी मान प्रदर्शित करें*/शून्य डिस्प्लेयूवी() { डिस्प्ले.क्लियर (); display.setFont (एरियलएमटी_प्लेन_16); डिस्प्ले.ड्रास्ट्रिंग (20, 0, "यूवी सेंसर"); डिस्प्ले.ड्रास्ट्रिंग (0, 23, "यूवी (एमवी):"); डिस्प्ले.ड्रास्ट्रिंग (80, 23, स्ट्रिंग (डेटा सेंसरयूवी)); डिस्प्ले.ड्रास्ट्रिंग (0, 48, "यूवी इंडेक्स:"); display.setFont (एरियलएमटी_प्लेन_24); डिस्प्ले.ड्रास्ट्रिंग (82, 42, स्ट्रिंग (इंडेक्सयूवी)); डिस्प्ले.डिस्प्ले (); }

उपरोक्त कोड मेरे GitHun से डाउनलोड किया जा सकता है: NodeMCU_UV_Sensor_OLED.ino

चरण 5: वायु तापमान और आर्द्रता माप के लिए DHT22 स्थापित करना

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

सेंसर को 3.3V और 5V के बीच संचालित किया जाना चाहिए और तापमान के लिए +/- 0.5oC और सापेक्ष आर्द्रता के लिए +/-2% की सटीकता के साथ -40oC से +80oC तक काम करेगा। यह भी ध्यान रखना महत्वपूर्ण है कि इसकी संवेदन अवधि औसतन 2 सेकंड (रीडिंग के बीच न्यूनतम समय) है। Adafruit की साइट DHT22 और उसके भाई DHT11 दोनों के बारे में बहुत सारी जानकारी प्रदान करती है। अधिक जानकारी के लिए, कृपया DHT22/11 ट्यूटोरियल पेज पर जाएँ।

DHT22 में 4 पिन हैं (सेंसर का सामना करना पड़ रहा है, पिन 1 सबसे बाईं ओर है):

1. VCC (हम NodeMCU से 3.3V से जुड़ेंगे);
2. डेटा आउट;
3. जुड़ा नहीं है और
4. ज़मीन।

एक बार जब आप आमतौर पर 20 मीटर से कम दूरी पर सेंसर का उपयोग करेंगे, तो डेटा और वीसीसी पिन के बीच एक 10K रोकनेवाला जुड़ा होना चाहिए। आउटपुट पिन NodeMCU पिन D3 से जुड़ा होगा (ऊपर चित्र देखें)। एक बार हमारे मॉड्यूल में सेंसर स्थापित हो जाने के बाद, Adafruit GitHub रिपॉजिटरी से DHT लाइब्रेरी डाउनलोड करें और इसे अपनी Arduino की लाइब्रेरी फ़ाइल में स्थापित करें। एक बार जब आप अपने Arduino IDE को पुनः लोड करते हैं, तो "DHT सेंसर लाइब्रेरी" स्थापित होनी चाहिए।

कोड की शुरुआत में, हमें पंक्तियों को शामिल करना चाहिए:

/* DHT22*/

#include "DHT.h" #define DHTPIN D2 #define DHTTYPE DHT22 DHT dht(DHTPIN, DHTTYPE); फ्लोट हम = 0; फ्लोट अस्थायी = 0;

सेंसर को पढ़ने के लिए एक नया फ़ंक्शन बनाया जाएगा:

/* DHT डेटा प्राप्त करें */

शून्य getDhtData (शून्य) {फ्लोट tempIni = अस्थायी; फ्लोट हमिनी = हम; अस्थायी = dht.readTemperature (); हम = dht.readHumidity (); if (isnan(hum) || isnan(temp)) // जांचें कि क्या कोई पठन विफल हुआ है और जल्दी से बाहर निकलें (फिर से प्रयास करने के लिए)। { Serial.println ("DHT सेंसर से पढ़ने में विफल!"); अस्थायी = अस्थायी; हम = हमिनी; वापसी; } }

यूवी और डीएचटी सेंसर सहित पूरा कोड मेरे गिटहब से डाउनलोड किया जा सकता है: NodeMCU_UV_DHT_Sensor_OLED

चरण 6: ThingSpeak.com पर डेटा भेजना

अब तक, हमने केवल एक नियमित और साधारण Arduino बोर्ड के रूप में NodeMCU ESP12-E का उपयोग किया है। बेशक, हमने इस शानदार छोटी चिप की वास्तविक क्षमता को केवल "खरोंच" किया है और अब स्वर्ग में ले जाने का समय है! या सितारों के लिए बेहतर! एहर … बादल के लिए!;-)

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

1. सबसे पहले, आपके पास ThinkSpeak.com पर एक खाता होना चाहिए
2. चैनल बनाने के लिए निर्देशों का पालन करें और अपनी चैनल आईडी को नोट करें और एपीआई कुंजी लिखें
3. अपने वाईफाई नेटवर्क और थिंकस्पीक क्रेडेंशियल के साथ नीचे दिए गए कोड को अपडेट करें
4. IDE पर प्रोग्राम चलाएँ

आइए कोड के सबसे महत्वपूर्ण भागों पर टिप्पणी करें:

सबसे पहले, आइए ESP8266 लाइब्रेरी को कॉल करें, वाईफाई क्लाइंट को परिभाषित करें और अपने स्थानीय राउटर और थिंकस्पीक क्रेडेंशियल्स को परिभाषित करें:

/* ESP12-E और थिंकस्पीक*/

# वाईफाई क्लाइंट क्लाइंट शामिल करें; const char* MY_SSID = "आपका SSD ID यहाँ"; const char* MY_PWD = "आपका पासवर्ड यहाँ"; const char* TS_SERVER = "api.thingspeak.com"; स्ट्रिंग TS_API_KEY = "आपका चैनल एपीआई कुंजी लिखें";

दूसरा, आइए IoT परियोजनाओं के लिए एक बहुत ही महत्वपूर्ण पुस्तकालय शामिल करें: SimpleTimer.h:

/* टाइमर */

#SimpleTimer टाइमर शामिल करें;

तीसरा, सेटअप () के दौरान, हम सीरियल कम्युनिकेशन शुरू करेंगे, फंक्शन कनेक्टवाईफाई () को कॉल करेंगे और टाइमर्स को परिभाषित करेंगे। ध्यान दें कि कोड की लाइन: timer.setInterval(60000L, sendDataTS); थिंकस्पीक चैनल पर डेटा अपलोड करने के लिए प्रत्येक 60 सेकंड में फ़ंक्शन sendDataTS() को कॉल करेगा।

व्यर्थ व्यवस्था()

{… सीरियल.बेगिन (115200); देरी(10); … ConnectWifi (); timer.setInterval(६००००L, SendDataTS); … }

अंत में, लेकिन कम से कम, लूप () के दौरान, टाइमर को आरंभ करने के लिए केवल एक ही कमांड की आवश्यकता होती है और बस!

शून्य लूप ()

{… टाइमर.रन (); // सरल टाइमर शुरू करता है }

नीचे, आप थिंकस्पीक संचार को संभालने के लिए उपयोग किए जाने वाले दो महत्वपूर्ण कार्यों को देख सकते हैं:

आपके वाईफाई नेटवर्क के साथ ESP12-E कनेक्शन:

/***************************************************

* वाईफाई कनेक्ट करना ******************************** ***/ शून्य कनेक्ट वाईफाई () { सीरियल.प्रिंट ("कनेक्टिंग टू" + * MY_SSID); वाईफाई.बेगिन (MY_SSID, MY_PWD); जबकि (WiFi.status() != WL_CONNECTED) {देरी (1000); सीरियल.प्रिंट ("।"); } सीरियल.प्रिंट्लन (""); Serial.println ("वाईफाई कनेक्टेड"); सीरियल.प्रिंट्लन (""); }

ESP12-E थिंकस्पीक को डेटा भेज रहा है:

/***************************************************

* थिंकस्पीक चैनल को डेटा भेजना ******************************* ******/ शून्य भेजेंडेटा (शून्य) { अगर (क्लाइंट.कनेक्ट (TS_SERVER, 80)) {स्ट्रिंग पोस्टस्ट्र = TS_API_KEY; पोस्टस्ट्र + = "& फ़ील्ड 1 ="; पोस्टस्ट्र + = स्ट्रिंग (डेटा सेंसरयूवी); पोस्टस्ट्र + = "& फ़ील्ड २ ="; पोस्टस्ट्र + = स्ट्रिंग (इंडेक्सयूवी); पोस्टस्ट्र + = "& फ़ील्ड ३ ="; पोस्टस्ट्र + = स्ट्रिंग (अस्थायी); पोस्टस्ट्र + = "& फ़ील्ड ४ ="; पोस्टस्ट्र + = स्ट्रिंग (हम); पोस्टस्ट्र + = "\r\n\r\n"; क्लाइंट.प्रिंट ("पोस्ट / अपडेट HTTP / 1.1 / n"); क्लाइंट.प्रिंट ("होस्ट: api.thingspeak.com\n"); क्लाइंट.प्रिंट ("कनेक्शन: बंद करें / n"); क्लाइंट.प्रिंट ("X-THINGSPEAKAPIKEY:" + TS_API_KEY + "\ n"); client.print ("सामग्री-प्रकार: एप्लिकेशन / x-www-form-urlencoded / n"); क्लाइंट.प्रिंट ("सामग्री-लंबाई:"); क्लाइंट.प्रिंट (postStr.length ()); क्लाइंट.प्रिंट ("\ n / n"); क्लाइंट.प्रिंट (पोस्टस्ट्र); देरी (1000); } भेजा गया++; क्लाइंट.स्टॉप (); }

पूरा कोड मेरे GitHub पर पाया जा सकता है: NodeMCU_UV_DHT_Sensor_OLED_TS_EXT

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

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

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

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

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

बने रहें! अगला ट्यूटोरियल हम रास्पबेरी पाई वेब सर्वर के आधार पर एक दूरस्थ मौसम स्टेशन से एक केंद्रीय एक को डेटा भेजेंगे:

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

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

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