MQTT का उपयोग करते हुए वायरलेस तापमान सेंसर के साथ AWS IoT के साथ शुरुआत करना: 8 कदम

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

पहले के इंस्ट्रक्शंस में, हम Azure, Ubidots, ThingSpeak, Losant आदि जैसे विभिन्न क्लाउड प्लेटफॉर्म से गुजर चुके हैं। हम लगभग सभी क्लाउड प्लेटफॉर्म में सेंसर डेटा को क्लाउड पर भेजने के लिए MQTT प्रोटोकॉल का उपयोग कर रहे हैं। MQTT के बारे में अधिक जानकारी के लिए, HTTP प्रोटोकॉल पर इसके फायदे और लाभ के लिए आप इस निर्देश का उल्लेख कर सकते हैं।

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

इस निर्देश का पालन करके:

• आप अपने IoT एप्लिकेशन के लिए AWS खाता सेट करने में सक्षम होंगे
• आप ESP32 को AWS IoT कोर से जोड़ पाएंगे
• MQTT और HTTP प्रोटोकॉल का उपयोग करके संदेश भेजें और प्राप्त करें
• AWS में भेजे गए डेटा की कल्पना करें

चरण 1: AWS खाता सेट करना

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

AWS खाता सेट करने के लिए इस ट्यूटोरियल का अनुसरण करें।

चरण 2: हार्डवेयर और सॉफ्टवेयर विनिर्देश

सॉफ्टवेयर विशिष्टता

एक एडब्ल्यूएस खाता

हार्डवेयर विशिष्टता

• ESP32
• वायरलेस तापमान और कंपन सेंसर
• ज़िग्मो गेटवे रिसीवर

चरण 3: वायरलेस कंपन और तापमान सेंसर

यह एक लॉन्ग रेंज इंडस्ट्रियल IoT वायरलेस वाइब्रेशन और टेम्परेचर सेंसर है, जो वायरलेस मेश नेटवर्किंग आर्किटेक्चर का उपयोग करके 2 मील रेंज तक का दावा करता है। 16-बिट कंपन और तापमान सेंसर को शामिल करते हुए, यह सेंसर उपयोगकर्ता द्वारा परिभाषित अंतराल पर अत्यधिक सटीक कंपन डेटा प्रसारित करता है। इसमें निम्नलिखित विशेषताएं हैं:

• औद्योगिक ग्रेड 3-अक्ष कंपन सेंसर ± 32 जी रेंज के साथ
• RMS, MAX और MIN g कंपन की गणना करता है
• लो-पास फिल्टर का उपयोग करके शोर हटाना
• फ़्रीक्वेंसी रेंज (बैंडविड्थ) १२, ८०० हर्ट्ज तक
• नमूना दर 25, 600 हर्ट्ज तक
• 2 मील वायरलेस रेंज के साथ एन्क्रिप्टेड संचार
• ऑपरेटिंग तापमान रेंज -40 से +85 डिग्री सेल्सियस
• वॉल-माउंटेड या मैग्नेट माउंटेड IP65 रेटेड एनक्लोजर विजुअल स्टूडियो और लैब व्यू के लिए उदाहरण सॉफ्टवेयर
• बाहरी जांच विकल्प के साथ कंपन सेंसर
• 4 AA बैटरियों से ५००,००० प्रसारण तक कई गेटवे और मोडेम विकल्प उपलब्ध हैं

चरण 4: ESP32 AWS फर्मवेयर

AWS से जुड़ने के लिए और डेटा भेजना शुरू करने के लिए निम्न चरणों का पालन करें

• निम्नलिखित Github रिपॉजिटरी से AWS लाइब्रेरी डाउनलोड करें
• रेपो को क्लोन करें और AWS_IOT फ़ाइल को Arduino निर्देशिका के लाइब्रेरी फ़ोल्डर में रखें

गिट क्लोन

अब कोड के माध्यम से चलते हैं:

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

चरण 5: वायरलेस कंपन और तापमान सेंसर से सेंसर डेटा प्राप्त करना

हमें वायरलेस तापमान और कंपन सेंसर से 54-बाइट का फ्रेम मिल रहा है। वास्तविक तापमान और कंपन डेटा प्राप्त करने के लिए इस फ्रेम में हेरफेर किया जाता है।

ESP32 में सीरियल उपयोग के लिए तीन UART उपलब्ध हैं

1. RX0 GPIO 3, TX0 GPIO 1
2. RX1 GPIO9, TX1 GPIO 10
3. RX2 GPIO 16, TX2 GPIO 17

और 3 हार्डवेयर सीरियल पोर्ट

• धारावाहिक
• सीरियल1
• सीरियल 2

सबसे पहले, हार्डवेयर सीरियल हेडर फ़ाइल को इनिशियलाइज़ करें। यहां हम RX2 और TX2 उर्फ का उपयोग करेंगे। सीरियल डेटा प्राप्त करने के लिए ESP32 बोर्ड के GPIO 16 और GPIO 17 पिन।

#शामिल

# RXD2 16 को परिभाषित करें # TXD2 17 को परिभाषित करें

Serial2.begin(115200, SERIAL_8N1, RXD2, TXD2); // पिन 16 rx2, 17 tx2, 19200 bps, 8 बिट नो पैरिटी 1 स्टॉप बिट

निम्नलिखित कदम आपको वास्तविक सेंसर मान प्राप्त करने के लिए आगे ले जाएंगे

• तापमान, आर्द्रता, बैटरी और अन्य सेंसर मानों को संग्रहीत करने के लिए चर बनाएं
• हार्डवेयर सीरियल के लिए Rx, tx पिन, बॉड रेट और पैरिटी बिट्स सेट करें
• सबसे पहले, जांचें कि Serial1.उपलब्ध () का उपयोग करके पढ़ने के लिए कुछ है
• हमें 54 बाइट्स का फ्रेम मिलेगा।
• 0x7E की जाँच करें जो कि स्टार्ट बाइट है।
• कंपन डेटा में 3 अक्ष के लिए RMS मान, 3 अक्ष के लिए न्यूनतम मान, 3 अक्ष के लिए अधिकतम मान शामिल होते हैं।
• तापमान और बैटरी मान में 2 बाइट डेटा होगा
• सेंसर का नाम, प्रकार, सेंसर संस्करण प्राप्त करें जिसमें 1 बाइट डेटा होगा और वहां से संबंधित पते से प्राप्त किया जा सकता है

अगर (सीरियल २.उपलब्ध ()) {Serial.println ("सीरियल पढ़ें"); डेटा [0] = Serial2.read (); देरी (के); if(data[0]==0x7E) { Serial.println ("गॉट पैकेट"); जबकि (! Serial2.उपलब्ध ()); के लिए (i = 1; i< ५५; i++) { डेटा = Serial2.read (); देरी(1); } if(data[15]==0x7F) /////// यह जांचने के लिए कि क्या रिसिव डेटा सही है {if(data[22]==0x08) //////// सुनिश्चित करें कि सेंसर टाइप है सही है { rms_x = ((uint16_t)(((डेटा [24])<<16) + ((डेटा [25])<<8) + (डेटा [26]))/100); rms_y = ((uint16_t)(((डेटा[27])<<16) + ((डेटा [28])<<8) + (डेटा [29]))/100); rms_z = ((uint16_t)(((डेटा [30])<<16) + ((डेटा [31])<<8) + (डेटा [32]))/100); int16_t max_x = ((uint16_t)(((डेटा [33])<<16) + ((डेटा [34])<<8) + (डेटा [35]))/100); int16_t max_y = ((uint16_t)(((डेटा [36])<<16) + ((डेटा [37])<<8) + (डेटा [38]))/100); int16_t max_z = ((uint16_t)(((डेटा[39])<<16) + ((डेटा [40])<<8) + (डेटा [41]))/100);

int16_t min_x = ((uint16_t) (((डेटा [42]) << 16) + ((डेटा [43]) << 8) + (डेटा [44]))/100); int16_t min_y = ((uint16_t)(((डेटा [45])<<16) + ((डेटा [46])<<8) + (डेटा [47]))/100); int16_t min_z = ((uint16_t)(((डेटा [48])<<16) + ((डेटा [49])<<8) + (डेटा [50]))/100);

cTemp = ((((डेटा [५१]) * २५६) + डेटा [५२])); फ्लोट बैटरी = ((डेटा [१८] * २५६) + डेटा [१९]); वोल्टेज = 0.00322 * बैटरी; सीरियल.प्रिंट ("सेंसर नंबर"); Serial.println (डेटा [16]); सेंसनंबर = डेटा [16]; सीरियल.प्रिंट ("सेंसर टाइप"); Serial.println (डेटा [22]); Serial.print ("फर्मवेयर संस्करण"); Serial.println (डेटा [17]); सीरियल.प्रिंट ("सेल्सियस में तापमान:"); सीरियल.प्रिंट (cTemp); सीरियल.प्रिंट्लन ("सी"); सीरियल.प्रिंट ("एक्स-अक्ष में आरएमएस कंपन:"); सीरियल.प्रिंट (rms_x); Serial.println ("मिलीग्राम"); सीरियल.प्रिंट ("वाई-अक्ष में आरएमएस कंपन:"); सीरियल.प्रिंट (rms_y); Serial.println ("मिलीग्राम"); सीरियल.प्रिंट ("जेड-अक्ष में आरएमएस कंपन:"); सीरियल.प्रिंट (rms_z); Serial.println ("मिलीग्राम");

Serial.print ("एक्स-अक्ष में न्यूनतम कंपन:");

सीरियल.प्रिंट (min_x); Serial.println ("मिलीग्राम"); Serial.print ("Y-अक्ष में न्यूनतम कंपन:"); सीरियल.प्रिंट (min_y); Serial.println ("मिलीग्राम"); Serial.print ("Z-अक्ष में न्यूनतम कंपन:"); सीरियल.प्रिंट (min_z); Serial.println ("मिलीग्राम");

सीरियल.प्रिंट ("एडीसी मान:");

Serial.println (बैटरी); सीरियल.प्रिंट ("बैटरी वोल्टेज:"); सीरियल.प्रिंट (वोल्टेज); सीरियल.प्रिंट्लन ("\ n"); अगर (वोल्टेज <1) { Serial.println ("बैटरी बदलने का समय"); } } } और { के लिए (i = 0; i< ५४; i++) { Serial.print(data); सीरियल.प्रिंट (","); देरी(1); } } } }

चरण 6: AWS से जुड़ना

• AWS_IOT.h, WiFi.h हेडर फ़ाइलें शामिल करें ताकि AWSioT हब के साथ कनेक्शन स्थापित किया जा सके
• अपना होस्ट पता, क्लाइंट आईडी दर्ज करें जो कि पॉलिसी का नाम होगा, और विषय का नाम जो चीज़ का नाम होगा

//**********AWS क्रेडेंशियल *************//char HOST_ADDRESS="a2smbp7clzm5uw-ats.iot.us-east-1.amazonaws.com"; चार CLIENT_ID = "एनसीडी गेटवे पॉलिसी"; चार TOPIC_NAME= "एनसीडीगेटवेथिंग";

अपने JSON को संग्रहीत करने के लिए एक चर चर बनाएं, इस मामले में, हमने JSON को संग्रहीत करने के लिए एक प्रारूप बनाया है

const char *format = "{"SensorId\":\"%d\", \"messageId\":%d, \"rmsX\":%d, \"rmsY\":%d, \"rmsZ \":%d, \"cTemp\":%d, \"वोल्टेज\":%.2f}";

AWS_IOT वर्ग का एक उदाहरण बनाएँ

एडब्ल्यूएस_आईओटी विशेष; // AWS_IOT वर्ग का उदाहरण

अब निम्न विधि का उपयोग करके AWSioT हब से कनेक्ट करें।

void reconnectMQTT () { अगर (hornbill.connect (HOST_ADDRESS, CLIENT_ID) == 0) { Serial.println ("AWS से कनेक्टेड"); देरी (1000);

अगर(0==hornbill.subscribe(TOPIC_NAME, mySubCallBackHandler))

{ Serial.println ("सब्सक्राइब सक्सेसफुल"); } और { Serial.println ("सब्सक्राइब फेल, चेक द थिंग नेम एंड सर्टिफिकेट्स"); जबकि(1); } } और { Serial.println ("एडब्ल्यूएस कनेक्शन विफल, होस्ट पता जांचें"); जबकि(1); }

देरी (2000);

}

हर 1 मिनट के बाद सेंसर डेटा प्रकाशित करें।

अगर (टिक> = 60) // हर 5 सेकंड में विषय पर प्रकाशित करें {टिक = 0; चार पेलोड [PAYLOAD_MAX_LEN]; snprintf (पेलोड, PAYLOAD_MAX_LEN, फॉर्मेट, सेंस नंबर, msgCount++, rms_x, rms_y, rms_z, cTemp, वोल्टेज); Serial.println (पेलोड); if(hornbill.publish(TOPIC_NAME, पेलोड) == 0) { सीरियल.प्रिंट ("संदेश प्रकाशित करें:"); Serial.println (पेलोड); } और { Serial.println ("प्रकाशन विफल"); } } vTaskDelay(1000 / portTICK_RATE_MS); टिक ++;

चरण 7: AWS में डेटा विज़ुअलाइज़ करना

• अपने एडब्ल्यूएस खाते में लॉगिन करें।
• टूलबार के बाएँ कोने पर, आपको सेवाएँ टैब मिलेगा
• इस टैब पर क्लिक करें और इंटरनेट ऑफ थिंग्स शीर्षक के तहत IoT Core चुनें।
• क्यूओएस का चयन करें और नहीं। ग्राहकों को संदेशों की। विषय का नाम दर्ज करें।

चरण 8: कुल मिलाकर कोड

आप इस जीथब रिपोजिटरी पर समग्र कोड पा सकते हैं।

क्रेडिट

• अरुडिनो जेसन
• वायरलेस तापमान और आर्द्रता सेंसर
• ESP32
• पबसब क्लाइंट