Arduino और lm393 स्पीड सेंसर (h206) का उपयोग करके मोबाइल रोबोट के लिए गति, दूरी और कोण माप

हमारे जीवन को सरल बनाने के लिए रोबोटों ने धीरे-धीरे हमारे समाज में रेंगना शुरू कर दिया है। हम पहले से ही ब्रिटेन की सड़कों पर स्टार्सशिप से छह पहिए वाले फूड डिलीवरी रोबोटों को पा सकते हैं, स्मार्ट तरीके से अपने गंतव्य तक पहुंचने के लिए नागरिकों के बीच नेविगेट कर रहे हैं। हर मोबाइल रोबोट जो पर्यावरण में नेविगेट करता है, उसे हमेशा वास्तविक दुनिया के संबंध में अपनी स्थिति और अभिविन्यास के बारे में पता होना चाहिए। GPS, RF Triangulation, Accelerometers, Gyroscopes आदि विभिन्न तकनीकों का उपयोग करके इसे प्राप्त करने के कई तरीके हैं। प्रत्येक तकनीक का अपना लाभ है और यह अपने आप में विशिष्ट है। इस Arduino LM393 स्पीड सेंसर ट्यूटोरियल में हम सरल और आसानी से उपलब्ध LM393 स्पीड सेंसर मॉड्यूल का उपयोग करेंगेArduino का उपयोग करके रोबोट जैसे स्पीड, डिस्टेंस ट्रैवल और एंगल जैसे कुछ महत्वपूर्ण मापदंडों को मापने के लिए। इन मापदंडों के साथ रोबोट अपनी वास्तविक दुनिया की स्थिति जानने में सक्षम होगा और इसका उपयोग सुरक्षित रूप से नेविगेट करने के लिए कर सकता है।

रोबोट बनाने के शौक़ीन लोगों के बीच Arduino सबसे लोकप्रिय विकल्प है, एक साधारण लाइन फॉलोअर से लेकर एक अधिक जटिल सेल्फ-बैलेंसिंग या फ़्लोर क्लीनिंग रोबोट। आप रोबोटिक्स सेक्शन में सभी तरह के रोबोट की जांच कर सकते हैं।

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

LM393 स्पीड सेंसर मॉड्यूल (H206)

इससे पहले कि हम परियोजना के लिए सर्किट आरेख और कोड में शामिल हों, हम LM393 स्पीड सेंसर मॉड्यूल को समझें क्योंकि यह परियोजना में महत्वपूर्ण भूमिका निभाता है। H206 स्पीड सेंसर मॉड्यूल एक इन्फ्रारेड लाइट के होते सेंसर एक LM393 वोल्टेज तुलनित्र आईसी इसलिए नाम LM393 स्पीड सेंसर के साथ एकीकृत। मॉड्यूल में एक ग्रिड प्लेट भी होती है जिसे मोटर के घूर्णन शाफ्ट पर चढ़ना होता है। सभी घटकों को नीचे की छवि में लेबल किया गया है।

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

H206 सेंसर माउंटिंग अरेंजमेंट

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

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

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

DIY Arduino LM393 स्पीड सेंसर रोबोट सर्किट डायग्राम

इस स्पीड और दूरी संवेदन रोबोट का पूरा सर्किट आरेख नीचे दिखाया गया है। बॉट में Arduino Nano का मस्तिष्क होता है, पहियों के लिए दो DC मोटर्स L298N H-Bridge मोटर ड्राइवर मॉड्यूल द्वारा संचालित होते हैं। जॉयस्टिक का उपयोग बॉट की गति और दिशा को नियंत्रित करने के लिए किया जाता है और बॉट की गति, दूरी और परी को मापने के लिए दो स्पीड सेंसर H206 का उपयोग किया जाता है। तब मापा मान 16x2 एलसीडी मॉड्यूल में प्रदर्शित होते हैं । एलसीडी से जुड़े पोटेंशियोमीटर का उपयोग एलसीडी के विपरीत को समायोजित करने के लिए किया जा सकता है और प्रतिरोधक का उपयोग एलसीडी की बैकलाइट में प्रवाहित धारा को सीमित करने के लिए किया जाता है।

पूरा सर्किट एक 7.4V लिथियम सेल के द्वारा संचालित है । यह 7.4V मोटर चालक मॉड्यूल के 12V पिन को आपूर्ति करता है। मोटर चालक मॉड्यूल पर वोल्टेज नियामक तब 7.4V को विनियमित + 5V में परिवर्तित करता है जो कि Arduino, LCD, Sensors और Joystick को बिजली देने के लिए उपयोग किया जाता है।

मोटर को डिजिटल पिन 8,9,10 और 11 Arduino के द्वारा नियंत्रित किया जाता है। चूंकि मोटर की गति को भी नियंत्रित करना होता है इसलिए हमें मोटर के सकारात्मक टर्मिनल को PWM सिग्नल की आपूर्ति करनी चाहिए। इसलिए हमारे पास 9 और 10 पिन हैं जो दोनों PWM सक्षम पिन हैं। X और Y मानों को जॉयस्टिक को क्रमशः एनालॉग पिन A2 और A3 का उपयोग करके पढ़ा जाता है।

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

अब जब हार्डवेयर भाग पूरा हो गया है तो आइए हम लॉगिक्स में जानें कि हम कैसे बॉट की गति, दूरी और सिंगल को मापेंगे और फिर प्रोग्रामिंग सेक्शन में आगे बढ़ेंगे।

LM393 स्पीड सेंसर मॉड्यूल के साथ मापने की गति के पीछे तर्क

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

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

Arduino में हम आसानी से मिलिस () फ़ंक्शन का उपयोग करके इस समय अंतराल की गणना कर सकते हैं । यह मिलिस फ़ंक्शन डिवाइस को शक्ति प्रदान करने के समय से हर मिलि सेकंड के लिए 1 की वृद्धि करेगा। इसलिए जब पहला व्यवधान होता है तो हम एक डमी चर में मिलिस () का मान (इस कोड में pevtime की तरह) बचा सकते हैं और फिर जब दूसरा व्यवधान होता है तो हम pevtime मान को घटाकर लिए गए समय की गणना कर सकते हैं मिलिस () ।

समय लिया = वर्तमान समय - पिछली बार समय- सीमा = मिलिस () - pevtime ; // timetaken में millisec

एक बार जब हमने समय की गणना कर ली है तो हम नीचे दिए गए फॉर्मूले का उपयोग करके आरपीएम के मूल्य की गणना कर सकते हैं, जहां (1000 / समय पर) आरपीएस (प्रति सेकंड क्रांतियों) देता है और आरपीएस को आरपीएम (प्रति मिनट) में बदलने के लिए इसे 60 से गुणा किया जाता है। ।

आरपीएम = (1000 / समयरेखा) * 60;

आरपीएम की गणना के बाद हम वाहन के वेग की गणना कर सकते हैं नीचे दिए गए सूत्रों का उपयोग करके हम पहिया के त्रिज्या को जानते हैं।

वेग = 2। × आरपीएस × पहिया का त्रिज्या। v = radius_of_wheel * rpm * 0.104

ध्यान दें, उपरोक्त सूत्र m / s में वेग की गणना के लिए है, यदि आप किमी / घंटा में गणना करना चाहते हैं तो 0.376 के साथ 0.0104 को बदलें। यदि आप यह जानने के लिए उत्सुक हैं कि 0.104 मूल्य कैसे प्राप्त किया गया था, तो पहिया के सूत्र V = 2π × RPS × त्रिज्या को सरल बनाने का प्रयास करें।

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

if (रोटेशन> = 40) { समयरेखा = मिलिस () - pevtime; // मिलीसेक आरपीएम में समयरेखा = (1000 / समय सीमा) * 60; // rpm pevtime = मिली () की गणना करने के सूत्र ; रोटेशन = 0; }

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

/ * यदि वाहन बंद हो जाता है तो शून्य पर गिराने के लिए * / अगर (मिली () - dtime> 500) // 500ms { आरपीएम = वी = 0 के लिए कोई असमानता नहीं मिली ; // rpm और वेग को शून्य dtime = मिली () के रूप में बनाते हैं; }

पहिया द्वारा यात्रा की गई दूरी को मापने के पीछे तर्क

हम पहले से ही जानते हैं कि जब पहिया एक पूरा रोटेशन करता है, तो Arduino 40 अवरोधों को समझेगा। तो पहिया द्वारा किए गए हर एक रोटेशन के लिए यह स्पष्ट है कि पहिया द्वारा यात्रा की गई दूरी पहिया के परिधि के बराबर है । चूँकि हम पहिये के त्रिज्या को पहले से जानते हैं इसलिए हम नीचे दिए गए सूत्र का उपयोग करके आसानी से तय की गई दूरी की गणना कर सकते हैं

दूरी = 2 (r * रोटेशन की संख्या दूरी = (2 * 3.141 * त्रिज्या_ऑफ_व्हील) * (बाएं_इंट्र / 40)

जहाँ पहिये की परिधि की गणना सूत्र 2 andr के उपयोग से की जाती है और फिर इसे पहिये से बनी घुमावों की संख्या से गुणा किया जाता है।

बॉट के कोण को मापने के पीछे तर्क

रोबोट के दूत को निर्धारित करने के कई तरीके हैं। इन मूल्यों को निर्धारित करने के लिए आमतौर पर एक्सेलेरोमीटर और जाइरोस्कोप का उपयोग किया जाता है। लेकिन एक और सस्ता तरीका दोनों पहियों पर H206 सेंसर का उपयोग करना है। इस तरह से हमें पता चल जाता है कि प्रत्येक पहिया में कितने मोड़ हैं। नीचे दिया गया चित्र दिखाता है कि कोण की गणना कैसे की जाती है।

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

उदाहरण के लिए, यदि वाम पहिया एक पूर्ण रोटेशन (80 इंटरप्ट) करता है, तो बॉट 90 ° बाईं ओर मुड़ता है और इसी तरह यदि राइट व्हील एक पूर्ण रोटेशन (80 इंटरप्ट) बनाता है तो बॉट दाईं ओर -90 ° मुड़ जाएगा। अब हम जानते हैं कि अगर Arduino एक पहिए पर 80 अवरोधों का पता लगाता है तो बॉट 90 ° से बदल गया है और किस पहिये के आधार पर हम बता सकते हैं कि बॉट पॉजिटिव (राईट) या नेगेटिव (लेफ्ट) से निकला है या नहीं। तो बाएं और दाएं कोण की गणना नीचे दिए गए सूत्रों का उपयोग करके की जा सकती है

int angle_left = (left_intr% 360) * (90/80); int angle_right = (right_intr% 360) * (90/80);

जहां 90 को 80 के बीच का अंतर बनाते समय कवर किया गया कोण है। परिणामी मान गुणा संख्या में रुकावट है। हमने 360 के एक मापांक का भी उपयोग किया है ताकि परिणामी मूल्य 36 से अधिक न हो। एक बार जब हम बाएँ और दाएँ कोण दोनों की गणना कर लेते हैं तो जिस कोण पर बॉट सामना कर रहा है वह बस बाएँ कोण को घटाकर सही कोण प्राप्त कर सकता है।

कोण = angle_right - angle_left;

Arduino रोबोट कोड

इस गति और कोण माप रोबोट के लिए पूरा Arduino कोड इस पृष्ठ के अंत में पाया जा सकता है। कार्यक्रम का उद्देश्य उपरोक्त लॉगिक्स का उपयोग करके बॉट की गति, दूरी और कोण की गणना करना और इसे एलसीडी स्क्रीन पर प्रदर्शित करना है। इसके अलावा यह जॉयस्टिक का उपयोग करके बॉट को नियंत्रित करने का विकल्प प्रदान करना चाहिए ।

हम दो मोटर्स के लिए डिजिटल I / O पिन को परिभाषित करके कार्यक्रम शुरू करते हैं । ध्यान दें कि हमें मोटर के नियंत्रण को भी नियंत्रित करना होगा और इसलिए हमें मोटरों को नियंत्रित करने के लिए Arduino पर PWM पिन का उपयोग करना होगा। यहां हमने 8,9,10 और 11 पिन का उपयोग किया है।

#define LM_pos 9 // लेफ्ट मोटर #define LM_neg 8 // लेफ्ट मोटर #define RM_pos 10 // राइट मोटर #define RM_neg 11 // राइट मोटर #define joyX A2 #define joyy A3

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

फ्लोट त्रिज्या_ऑफ_व्हील = 0.033; // अपने पहिया की त्रिज्या को मापें और इसे सेमी में यहां दर्ज करें

सेटअप फ़ंक्शन के अंदर, हम शून्य होने के लिए सभी मान को इनिशियलाइज़ करते हैं और फिर एलसीडी पर एक इंट्रो टेक्स्ट प्रदर्शित करते हैं । हमने डिबगिंग के उद्देश्य के लिए सीरियल मॉनीटर को इनिशियलाइज़ भी किया है। तब हमने उल्लेख किया है कि गति संवेदक H206 बाहरी अवरोधों के रूप में पिन 2 और 3 से जुड़े हैं। यही वह जगह है जहां कभी-कभी व्यवधान का पता लगाया जाता है कि ISR फ़ंक्शन Left_ISR और Right_ISR को तदनुसार निष्पादित किया जाएगा।

शून्य सेटअप () { रोटेशन = rpm = pevtime = 0; // सभी वेरिएबल को शून्य Serial.begin (9600) पर प्रारंभ करें ; lcd.begin (16, 2); // प्रारंभिक 16 * 2 एलसीडी lcd.print ("बॉट मॉनिटर"); // इंट्रो मैसेज लाइन 1 lcd.setCursor (0, 1); lcd.print ("- सर्किटडाइजेस्ट"); // इंट्रो मैसेज लाइन 2 देरी (2000); lcd.clear (); lcd.print ("Lt: Rt:"); lcd.setCursor (0, 1); lcd.print ("S: D: A:"); पिनमोड (LM_pos, OUTPUT); पिनमोड (LM_neg, OUTPUT); पिनमोड (RM_pos, OUTPUT); पिनमोड (RM_neg, OUTPUT); digitalWrite (LM_neg, LOW); digitalWrite (RM_neg, LOW); संलग्नक (digitalPinToInterrupt (2), Left_ISR, CHANGE); // Left_ISR जब बाईं पहिया सेंसर शुरू हो रहा है कहा जाता है attachInterrupt (digitalPinToInterrupt (3), Right_ISR, बदलें); // Right_ISR जब सही पहिया सेंसर शुरू हो रहा है कहा जाता है }

Left_ISR रूटीन के अंदर, हम बस left_intr नामक एक चर बढ़ाते हैं, जिसे बाद में बॉट के कोण को मापने में उपयोग किया जाएगा। Right_ISR के अंदर हम एक ही काम करते हैं लेकिन फिर इसके अलावा हम यहाँ गति की गणना भी करते हैं। चर रोटेशन को हर बाधा के लिए बढ़ाया जाता है और फिर गति की गणना के लिए उपरोक्त तर्क का उपयोग किया जाता है।

शून्य वाम_आईएसआर () { वाम_इंट्र ++; विलंब (10); } void राइट_ISR () { right_intr ++; देरी (10); रोटेशन ++; dtime = मिली (); if (रोटेशन> = 40) { समयरेखा = मिलिस () - pevtime; // मिलीसेक आरपीएम में समयरेखा = (1000 / समय सीमा) * 60; // rpm pevtime = मिली () की गणना करने के सूत्र ; रोटेशन = 0; } }

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

int xValue = analogRead (joyX); int yValue = analogRead (joyY); int त्वरण = नक्शा (xValue, 500, 0, 0, 200); अगर (xValue <500) { एनालॉगवर्इट (LM_pos, त्वरण); analogWrite (RM_pos, त्वरण); } और { analogWrite (LM_pos, 0); analogWrite (RM_pos, 0); } अगर (yValue> 550) एनालॉगवर्इट (RM_pos, 80); अगर (yValue <500) एनालॉगवर्इट (LM_pos, 100);

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

v = radius_of_wheel * rpm * 0.104; //0.033 मीटर की दूरी में पहिया का त्रिज्या है = (2 * 3.141 * त्रिज्या_ऑफ_व्हील) * (बाएं_इंट्र / 40); int angle_left = (left_intr% 360) * (90/80); int angle_right = (right_intr% 360) * (90/80); कोण = angle_right - angle_left; lcd.setCursor (3, 0); lcd.print (""); lcd.setCursor (3, 0); lcd.print (left_intr); lcd.setCursor (11, 0); lcd.print (""); lcd.setCursor (11, 0); lcd.print (right_intr); lcd.setCursor (2, 1); lcd.print (""); lcd.setCursor (2, 1); lcd.print (v); lcd.setCursor (9, 1); lcd.print (""); lcd.setCursor (9, 1); lcd.print (दूरी); lcd.setCursor (13, 1); lcd.print (""); lcd.setCursor (13, 1); lcd.print (कोण);

दूरी, गति और कोण मापने के लिए Arduino रोबोट का परीक्षण

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

एलसीडी पर लेफ्टिनेंट और आरटी शब्द क्रमशः लेफ्ट इंटरप्ट काउंट और राइट इंटरप्ट काउंट का प्रतिनिधित्व करता है । आप सेंसर द्वारा पता लगाने वाले हर अंतर के लिए इन मूल्यों को बढ़ा सकते हैं। मंदिर एस मी / सेकंड में बॉट की गति को इंगित करता है और डी शब्द मीटर में कवर दूरी को इंगित करता है। बॉट के कोण को अंत में प्रदर्शित किया जाता है जहां 0 ° सीधे के लिए है और यह एंटी-क्लॉकवाइज रोटेशन के लिए नकारात्मक है और क्लॉक रोटेशन के लिए सकारात्मक है।

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