Arduino के साथ मोशन डिटेक्शन सिस्टम कैसे बनाएं: 7 कदम

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

Arduino के साथ प्रोग्राम किए गए और Ubidots द्वारा संचालित एक पंख HUZZAH का उपयोग करके एक गति और उपस्थिति उत्पादन काउंटर का निर्माण करें।

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

1. दरवाजा और गेट स्वचालन
2. मुक्त स्थानों को नामित करने के लिए पार्किंग सेंसर
3. रिमोट टैंक स्तर की निगरानी
4. प्रकाश और सुरक्षा के लिए स्मार्ट घर और सुविधाएं
5. कन्वेयर लाइनों में इकाइयों का पता लगाना और गिनती करना
6. मुद्रित सामग्री पर निशान का पता लगाना
7. कार्डबोर्ड, प्लास्टिक और कागज के झुकाव के अंदर तरल का पता लगाना
8. दूरी का पता लगाना
9. लोग काउंटर

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

इस ट्यूटोरियल के लिए, हम रीयल-टाइम प्रोडक्शन काउंटर बनाने पर ध्यान देंगे; एप्लिकेशन कन्वेयर बेल्ट पर गुजरने वाली प्रत्येक इकाई की गणना करेगा। हम अपने एप्लिकेशन को विकसित करने और अपने IoT डैशबोर्ड को प्रदर्शित करने के लिए एक पंख HUZZAH ESP8266, एक अल्ट्रासोनिक सेंसर, और Ubidots प्रोग्राम करने के लिए Arduino IDE का उपयोग करेंगे।

चरण 1: आवश्यकताएँ

1. पंख HUZZAH ESP8266MB7389-100. के साथ
2. अतिध्वनि संवेदक
3. Arduino IDE 1.8.2 या उच्चतर
4. Ubidots खाता -या-एसटीईएम लाइसेंस

चरण 2: सेटअप

• मैं हार्डवेयर सेटअप
• द्वितीय. फर्मवेयर सेटअप
• III. Ubidots अनुप्रयोग विकास (घटनाएँ, चर और डैशबोर्ड)

चरण 3: हार्डवेयर सेटअप

अल्ट्रासोनिक सेंसर MB7389-100 अपनी IPv67 रेटिंग के कारण चुनौतीपूर्ण मौसम की स्थिति में व्यापक रेंज और कम बिजली की खपत आवश्यकताओं के साथ औद्योगिक अनुप्रयोगों के लिए एक कम लागत वाला विकल्प है।

आरंभ करने के लिए, अल्ट्रासोनिक सेंसर को पंख HUZZAH ESP8266 से जोड़ने के लिए नीचे दिए गए आरेख को मिरर करें।

नोट: सेंसर रीडिंग को एनालॉग रीडिंग या पीडब्लूएम के रूप में लिया जा सकता है; नीचे हम पीडब्लूएम रीडिंग के लिए सेटअप की व्याख्या करने जा रहे हैं, अतिरिक्त जानकारी के लिए कृपया ऊपर दिखाए गए उदाहरण देखें।

[वैकल्पिक रूप से] माइक्रो-कंट्रोलर और सेंसरों को धूल, पानी और अन्य खतरनाक पर्यावरणीय कारकों से बचाने के लिए उन्हें IP67 केस के अंदर रखें। मानक मामला ऊपर की तस्वीरों में दिखाए गए जैसा दिखता है।

चरण 4: फर्मवेयर सेटअप

सबसे पहले, आपको Arduino IDE में पंख हुज़ाह स्थापित करना चाहिए और कोड संकलित करना चाहिए। एक साधारण ब्लिंकिंग टेस्ट करके इस सेट अप को सत्यापित करना याद रखें। अपने पंख डिवाइस को जोड़ने के बारे में अधिक जानकारी के लिए इस सहायक हार्डवेयर सेटअप मार्गदर्शिका को देखें।

Ubidots IoT Development Platform पर सेंसर डेटा भेजने के लिए, नीचे दिए गए कोड को Arduino IDE में कॉपी और पेस्ट करें। वाई-फाई नेटवर्क का नाम, पासवर्ड और अपना यूबीडॉट्स खाता टोकन निर्दिष्ट करना याद रखें जहां कोड में संकेत दिया गया है।

/******************************** पुस्तकालयों में शामिल हैं *************** ****************/#शामिल /****************************** ** स्थिरांक और वस्तुएं *****************//* Ubidots */const char* SSID_NAME = "xxxxxxxx"; // यहां अपना SSID नाम डालें char* SSID_PASS = "xxxxxxxx"; // यहां अपना पासवर्ड डालें चार * टोकन = "Assig_your_ubidots_token"; // यहां अपना TOKENconst char* DEVICE_LABEL = "मोशन-कंट्रोल" डालें; // आपका डिवाइस लेबलकॉन्स्ट चार* VARIABLE_LABEL = "दूरी"; // आपका वेरिएबल लेबलकॉन्स्ट चार* USER_AGENT = "ESP8266";const char* VERSION = "1.0";const char* HTTPSERVER = "industrial.api.ubidots.com";// Ubidots Business users//const char* HTTPSERVER = " चीज़ें.यूबिडॉट्स.कॉम"; // Ubidots शैक्षिक उपयोगकर्ता HTTPPORT = 80;/* अल्ट्रासोनिक सेंसर */const int pwPin1 = 5; // PWM पिन जहां सेंसर जुड़ा हुआ हैWiFiClient क्लाइंटUbi;/******************************** सहायक कार्य *** ********************* शरीर की लंबाई प्राप्त करता है @arg चर का शरीर प्रकार char @return dataLen the चर की लंबाई*/int dataLen(char* variable) { uint8_t dataLen = 0; के लिए (int i = 0; i दूरी / २५.४ */फ्लोट दूरी = पल्सइन (pwPin1, HIGH); sendToUbidots (DEVICE_LABEL, VARIABLE_LABEL, दूरी); देरी (1000);} शून्य भेजें ToUbidots (const char * device_label, const char * चर_लेबल, फ्लोट सेंसर_वैल्यू) {चार * बॉडी = (चार *) मॉलोक (आकार (चार) * 150); चार * डेटा = (चार *) मॉलोक (आकार (चार) * 300); / * भेजने के लिए मूल्यों को संग्रहीत करने के लिए स्थान * / char str_val[10]; /*---- सेंसर के मानों को चार प्रकार में बदल देता है -----*/ /* 4 मिनिनम चौड़ाई है, 2 सटीक है; फ्लोट वैल्यू को str_val*/ dtostrf पर कॉपी किया जाता है (sensor_value, 4, 2, str_val); /* अनुरोध में भेजने के लिए बॉडी बनाता है*/ sprintf(body, "{"%s\":%s}", variable_label, str_val); /* HTTP बनाता है पोस्ट होने का अनुरोध */ sprintf (डेटा, "POST /api/v1.6/devices/%s", device_label); sprintf (डेटा, "%s HTTP/1.1\r\n", डेटा); sprintf(डेटा, "%sHost: चीज़ें.ubidots.com\r\n", डेटा); sprintf(डेटा, "%sUser-Agent: %s/%s\r\n", डेटा, USER_AGENT, संस्करण);, "%sX-Auth-Token: %s\r\n", डेटा, टोकन); स्प्रिंट एफ (डेटा, "% s कनेक्शन: बंद करें / r / n", डेटा); स्प्रिंटफ (डेटा, "% s सामग्री-प्रकार: एप्लिकेशन/जेसन / r / n", डेटा); स्प्रिंटफ (डेटा, "% s सामग्री-लंबाई:% d / r / n / r / n", डेटा, डेटालेन (शरीर)); स्प्रिंटफ (डेटा, "%s%s\r\n\r\n", डेटा, बॉडी); /* प्रारंभिक कनेक्शन */ clientUbi.connect(HTTPSERVER, HTTPPORT); /* क्लाइंट कनेक्शन सत्यापित करें */ if (clientUbi.connect(HTTPSERVER, HTTPPORT)) { Serial.println(F("अपने वेरिएबल पोस्ट करना:")); Serial.println (डेटा); /* HTTP अनुरोध भेजें */ clientUbi.print(data); } /* जबकि क्लाइंट उपलब्ध है सर्वर की प्रतिक्रिया पढ़ें */ जबकि (क्लाइंटयूबी.उपलब्ध ()) { चार सी = क्लाइंटयूबी.रीड (); सीरियल.राइट (सी); } /* फ्री मेमोरी */ फ्री (डेटा); मुक्त निकाय); /* क्लाइंट को रोकें */ clientUbi.stop();}

ProTip: Arduino IDE में सीरियल मॉनिटर खोलकर आप जांच सकते हैं कि आपका डिवाइस सही तरीके से जुड़ा है या नहीं।

आप यह सत्यापित कर सकते हैं कि आपके यूबीडॉट्स बैकएंड में एक डिवाइस बनाया गया है, इसे अपने खाते में डिवाइस प्रबंधन -> डिवाइस में देखकर।

अपने डिवाइस पर क्लिक करके, आप "दूरी" नामक एक चर पाएंगे जहां सेंसर की रीडिंग संग्रहीत की जाती है। यह नाम उस कोड में निर्दिष्ट किया गया था जिसे आपने अभी Arduino IDE में चिपकाया है। यदि आप अपने स्वचालित चरों को समायोजित करना चाहते हैं, तो कृपया डिवाइस कार्ड को संपादित करके या अपने आवेदन के लिए सही चर नामकरण के साथ एक अद्यतन कोड को फ्लैश करके ऐसा करें।

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

चरण 5: Ubidots अनुप्रयोग विकास

यूबीडॉट्स इवेंट कॉन्फ़िगरेशन

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

1. वर्तमान डिवाइस "मोशन-कंट्रोल" के अंदर "बॉक्स" नामक एक नया डिफ़ॉल्ट चर बनाएं, जिसे हर बार एक नई इकाई की गणना करने पर 1 प्राप्त होगा।
2. डिवाइस प्रबंधन -> ईवेंट पर जाएं, और एक नया ईवेंट जोड़ने के लिए पृष्ठ के ऊपरी-दाएं कोने में नीले प्लस आइकन पर क्लिक करें।
3. "अगर ट्रिगर" से शुरू होने वाला अपना ईवेंट कॉन्फ़िगर करें:

• एक चर चुनें: "दूरी"
• मान: मान (डिफ़ॉल्ट)
• से कम या बराबर है [अधिकतम अपेक्षित दूरी} सेंसर और पास से गुजरने वाले बक्से के बीच * हमारे आवेदन 500 मिमी. के लिए कहते हैं
• 0 मिनट के लिए
• सहेजें

4. एक बार ट्रिगर आपके एप्लिकेशन के विनिर्देशों के लिए कॉन्फ़िगर हो जाने के बाद, एक सशर्त क्रिया जोड़ने के लिए ऊपरी-दाएं कोने में नारंगी "प्लस" आइकन पर क्लिक करें।

5. क्रिया के रूप में "चर सेट करें" चुनें।

6. अगला, पहले से बनाए गए डिफ़ॉल्ट चर "बॉक्स" और मान "1" चुनें।

7. परिवर्तन सहेजें। यदि घटना को ठीक से सेट किया गया है, तो यह हर बार "1" भेजेगा जब सेंसर और इकाई के बीच की दूरी एक संकेतित सीमा से अधिक होगी, जो यह बताती है कि पास कोई वस्तु नहीं है - और एक नई इकाई की गणना करनी चाहिए जो अभी-अभी गुजरी है.

फेदर स्पेसिफिक डिवाइस कार्ड में, आप पाएंगे कि वेरिएबल "बॉक्स" जहां किसी यूनिट की उपस्थिति का पता चलने पर "1" भेजा जाता है।

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

8. महसूस की गई इकाइयों की संख्या की कल्पना करें (या किसी वस्तु का पता लगने का समय) अब, "बॉक्स" चर का उपयोग करके, हम एक नया रोलिंग विंडो चर बनाने जा रहे हैं, जो चर "बॉक्स" से प्राप्त रीडिंग की कुल मात्रा को जोड़ देगा। एक परिभाषित स्पैम (मिनट, घंटे, दिन, सप्ताह, आदि)। इस विकास को निष्पादित करने के लिए, इन सरल चरणों का पालन करें:

अपने नए रोलिंग विंडो वेरिएबल में निम्नलिखित क्रेडेंशियल असाइन करें:

एक उपकरण चुनें: गति-नियंत्रण (या उस उपकरण का नाम जिसे आप अपना डेटा भेज रहे हैं)

एक वेरिएबल चुनें: बॉक्स

गणना करें: योग

प्रत्येक: "1" घंटा (या आपके आवेदन अनुरोधों के अनुसार)

अब नए चर के लिए एक नाम निर्दिष्ट करें जो एक घंटे में गिने गए बक्सों (या आंदोलनों) की संख्या को इंगित करता है, जैसे "बक्से/घंटा" या "इकाइयां/घंटे।

चरण 6: डैशबोर्ड कॉन्फ़िगरेशन

अंत में, महसूस की गई इकाइयों की संख्या प्रदर्शित करने के लिए एक डैशबोर्ड बनाएं।

डिवाइस प्रबंधन -> डैशबोर्ड पर जाएं और एक नया विजेट जोड़ें। यह विजेट आज गिने गए बक्सों की मात्रा को घंटे के हिसाब से विभाजित करके प्रदर्शित करेगा।

अपनी गिनती की कल्पना करने के लिए अपने नए विजेट को निम्नलिखित क्रेडेंशियल असाइन करें।

आप अपना डेटा कैसे देखना चाहेंगे?: चार्ट

विजेट का प्रकार चुनें: लाइन चार्ट

एक उपकरण जोड़ें: गति-नियंत्रण

एक चर जोड़ें: बक्से/घंटा

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