Arduino का उपयोग करते हुए सरल और स्मार्ट रोबोटिक आर्म !!!: 5 कदम (चित्रों के साथ)

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

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

तो चलो शुरू हो जाओ…।

चरण 1: आपको जिन चीजों की आवश्यकता होगी: -

यहां उन चीजों की सूची दी गई है जिनकी आपको आवश्यकता होगी: -

1. सर्वो मोटर्स x 5 यूएस के लिए लिंक:- https://amzn.to/2OxbSH7Link फॉर यूरोप:-

2. पोटेंशियोमीटर x 5 (मैंने 100k का उपयोग किया है।) यूएस के लिए लिंक: - https://amzn.to/2ROjhDMLink फॉर यूरोप:-

3. अरुडिनो यूएनओ। (आप Arduino नैनो का भी उपयोग कर सकते हैं) यूएस के लिए लिंक: - https://amzn.to/2DBbENWLink फॉर यूरोप: -

4. ब्रेडबोर्ड। (मैं इस किट का सुझाव देता हूं) अमेरिका के लिए लिंक:- https://amzn.to/2Dy86w4यूरोप के लिए लिंक:-

5. बैटरी। (वैकल्पिक, मैं 5v एडॉप्टर का उपयोग कर रहा हूं)

6. कार्डबोर्ड/लकड़ी/सन-बोर्ड/ऐक्रेलिक जो भी उपलब्ध हो या आसानी से मिल जाए।

और आपको Arduino IDE भी इंस्टॉल करना होगा।

चरण 2: हाथ बनाना: -

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

मैंने सिर्फ दो तरफा टेप का इस्तेमाल किया ताकि सर्वोस को पोप्सिकल स्टिक से चिपका दिया जाए और उन्हें स्क्रू का उपयोग करके जकड़ दिया जाए।

मास्टर आर्म के लिए मैंने पोटेंशियोमीटर को पॉप्सिकल स्टिक्स से चिपकाया और आर्म बनाया।

तस्वीरों का जिक्र करने से आपको एक बेहतर आइडिया मिलेगा।

मैंने आधार के रूप में उपयोग किए जाने वाले A4 आकार के कैनवास बोर्ड पर सब कुछ माउंट किया है।

चरण 3: कनेक्शन बनाना: -

इस चरण में हम सभी आवश्यक कनेक्शन बनाएंगे, ऊपर दिए गए चित्रों को देखें।

• सबसे पहले सभी सर्वो को बिजली की आपूर्ति के समानांतर कनेक्ट करें (लाल तार से + वी और काले या भूरे रंग के तार को जीएनडी से)
• इसके बाद सिग्नल वायर यानी पीले या नारंगी तार को आर्डिनो के पीडब्लूएम पिन से कनेक्ट करें।
• अब पोटेंशियोमीटर को समानांतर में +5v और arduino के Gnd से कनेक्ट करें।
• मध्य टर्मिनल को ardunio के एनालॉग पिन से कनेक्ट करें।

यहां सर्वो को नियंत्रित करने के लिए डिजिटल पिन 3, 5, 6, 9 और 10 का उपयोग किया जाता है

पोटेंशियोमीटर से इनपुट के लिए एनालॉग पिन A0 से A4 का उपयोग किया जाता है।

पिन 3 से जुड़े सर्वो को A0. से जुड़े पोटेंशियोमीटर द्वारा नियंत्रित किया जाएगा

पिन 5 से जुड़े सर्वो को A1 पर पॉट द्वारा नियंत्रित किया जाएगा, और इसी तरह…।

नोट: - भले ही सर्वो arduino द्वारा संचालित नहीं हैं, सर्वो के Gnd को arduino से जोड़ना सुनिश्चित करें अन्यथा हाथ काम नहीं करेगा।

चरण 4: कोडिंग: -

इस कोड का तर्क काफी सरल है, पोटेंशियोमीटर के मूल्यों को एक सरणी में संग्रहीत किया जाता है, फिर रिकॉर्ड को लूप का उपयोग करके ट्रेस किया जाता है और सर्वो मानों के अनुसार कदम उठाते हैं। आप इस ट्यूटोरियल को देख सकते हैं जिसका मैंने संदर्भ के लिए उपयोग किया था "Arduino Potentiometer Servo Control & Memory"

कोड:- (डाउनलोड करने योग्य फाइल संलग्न है।)

पहले हम विश्व स्तर पर सभी आवश्यक चर घोषित करेंगे ताकि हम पूरे कार्यक्रम में उनका उपयोग कर सकें। इसके लिए किसी विशेष स्पष्टीकरण की आवश्यकता नहीं है।

#शामिल

// सर्वो ऑब्जेक्ट सर्वो सर्वो_0; सर्वो सर्वो_1; सर्वो सर्वो_2; सर्वो सर्वो_3; सर्वो सर्वो_4; // पोटेंशियोमीटर ऑब्जेक्ट्स int Pot_0; इंट पॉट_1; इंट पॉट_2; इंट पॉट_3; इंट पॉट_4; // सर्वो स्थिति int Servo_0_Pos स्टोर करने के लिए चर; इंट सर्वो_1_Pos; इंट सर्वो_2_Pos; इंट सर्वो_3_Pos; इंट सर्वो_4_Pos; // पिछली स्थिति मानों को संग्रहीत करने के लिए चर int Prev_0_Pos; इंट पिछला_1_स्थिति; इंट पिछला_2_स्थिति; int Prev_3_Pos; int Prev_4_Pos; // वर्तमान स्थिति मूल्यों को संग्रहीत करने के लिए चर int Current_0_Pos; इंट करंट_1_Pos; इंट करंट_2_Pos; int Current_3_Pos; इंट करंट_4_Pos; इंट सर्वो_पोजिशन; // कोण को स्टोर करता है int Servo_Number; // सर्वो इंट स्टोरेज की स्टोर संख्या [६००]; // डेटा स्टोर करने के लिए ऐरे (बढ़ती सरणी आकार अधिक मेमोरी का उपभोग करेगा) int इंडेक्स = 0; // ऐरे इंडेक्स 0 वें स्थान से शुरू होता है चार डेटा = 0; // सीरियल इनपुट से डेटा स्टोर करने के लिए वेरिएबल।

अब हम एक सेटअप फंक्शन लिखेंगे, जहां हम पिन और उनके फंक्शन सेट करते हैं। यह मुख्य कार्य है जो पहले निष्पादित होता है।

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

{ सीरियल.बेगिन (९६००); // Arduino और IDE के बीच सीरियल संचार के लिए। // सर्वो ऑब्जेक्ट PWM पिन से जुड़े होते हैं। सर्वो_0.अटैच(3); सर्वो_1.अटैच(5); सर्वो_2.अटैच(6); सर्वो_3.अटैच(9); सर्वो_4.अटैच(10); // आरंभीकरण के समय सर्वो को १०० स्थिति पर सेट किया जाता है। सर्वो_0.लिखें (100); सर्वो_1.लिखें (100); सर्वो_2.लिखें (100); सर्वो_3.लिखें (100); सर्वो_4.लिखें (१००); Serial.println ("रिकॉर्ड करने के लिए 'R' दबाएं और खेलने के लिए 'P' दबाएं"); }

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

शून्य Map_Pot ()

{/* सर्वो 180 डिग्री पर घूमता है लेकिन इसे सीमा तक उपयोग करना एक अच्छा विचार नहीं है क्योंकि यह सर्वो को लगातार गुलजार बनाता है जो कष्टप्रद है इसलिए हम सर्वो को बीच में ले जाने के लिए सीमित करते हैं: 1-179 */Pot_0 = analogRead(A0); // पॉट से इनपुट पढ़ें और इसे वेरिएबल पॉट_0 में स्टोर करें। Servo_0_Pos = नक्शा (Pot_0, 0, 1023, 1, 179); // मानचित्र सर्वो 0 से 1023 के बीच के मान के अनुसार सर्वो_0.लिखें (सर्वो_0_Pos); // सर्वो को उस स्थिति में ले जाएं। पॉट_1 = एनालॉग रीड (ए 1); सर्वो_1_Pos = नक्शा (पॉट_1, 0, 1023, 1, 179); सर्वो_1.लिखें (सर्वो_1_Pos); पॉट_2 = एनालॉग रीड (ए 2); Servo_2_Pos = नक्शा (Pot_2, 0, 1023, 1, 179); सर्वो_2.लिखें (सर्वो_2_Pos); पॉट_3 = एनालॉग रीड (ए 3); Servo_3_Pos = नक्शा (Pot_3, 0, 1023, 1, 179); सर्वो_3.लिखें (सर्वो_3_Pos); पॉट_4 = एनालॉगरेड (ए 4); Servo_4_Pos = नक्शा (Pot_4, 0, 1023, 1, 179); सर्वो_4.लिखें (सर्वो_4_Pos); }

अब हम लूप फंक्शन लिखेंगे:

शून्य लूप ()

{मैप_पॉट (); // पॉट मूल्यों को पढ़ने के लिए फ़ंक्शन कॉल जबकि (सीरियल.उपलब्ध ()> 0) {डेटा = सीरियल.रीड (); अगर (डेटा == 'आर') सीरियल.प्रिंट्लन ("रिकॉर्डिंग मूव्स …"); अगर (डेटा == 'पी') Serial.println ("रिकॉर्डेड मूव्स चला रहा है …"); } अगर (डेटा == 'आर') // अगर 'आर' दर्ज किया गया है, तो रिकॉर्डिंग शुरू करें। {// मानों को एक चर में स्टोर करें Prev_0_Pos = Servo_0_Pos; पिछला_1_Pos = सर्वो_1_Pos; पिछला_2_Pos = सर्वो_2_Pos; Prev_3_Pos = Servo_3_Pos; Prev_4_Pos = Servo_4_Pos; मैप_पॉट (); // मैप फ़ंक्शन को तुलना के लिए याद किया जाता है यदि (abs(Prev_0_Pos == Servo_0_Pos)) // निरपेक्ष मान { Servo_0.write(Servo_0_Pos) की तुलना करके प्राप्त किया जाता है; // यदि मान मेल खाते हैं तो सर्वो को फिर से स्थापित किया जाता है यदि (Current_0_Pos! = Servo_0_Pos) // यदि मान मेल नहीं खाते हैं {स्टोरेज [इंडेक्स] = सर्वो_0_Pos + 0; // मान को इंडेक्स ++ में जोड़ा जाता है; // इंडेक्स वैल्यू में 1 की वृद्धि हुई है } Current_0_Pos = Servo_0_Pos; } /* इसी प्रकार सभी सर्वो के लिए मूल्य तुलना की जाती है, +100 प्रत्येक प्रविष्टि के लिए एक अंतर मूल्य के रूप में जोड़ा जाता है। */ अगर (abs(Prev_1_Pos == Servo_1_Pos)) { Servo_1.write(Servo_1_Pos); अगर (Current_1_Pos != Servo_1_Pos) { स्टोरेज [इंडेक्स] = सर्वो_1_Pos + 100; सूचकांक++; } करंट_1_Pos = सर्वो_1_Pos; } अगर (abs(Prev_2_Pos == Servo_2_Pos)) { Servo_2.write(Servo_2_Pos); अगर (Current_2_Pos != Servo_2_Pos) { स्टोरेज [इंडेक्स] = सर्वो_2_Pos + 200; सूचकांक++; } करंट_2_Pos = सर्वो_2_Pos; } अगर (abs(Prev_3_Pos == Servo_3_Pos)) { Servo_3.write(Servo_3_Pos); अगर (Current_3_Pos != Servo_3_Pos) { स्टोरेज [इंडेक्स] = सर्वो_3_Pos + 300; सूचकांक++; } Current_3_Pos = Servo_3_Pos; } अगर (abs(Prev_4_Pos == Servo_4_Pos)) { Servo_4.write(Servo_4_Pos); अगर (Current_4_Pos != Servo_4_Pos) { स्टोरेज [इंडेक्स] = सर्वो_4_Pos + 400; सूचकांक++; } Current_4_Pos = Servo_4_Pos; } /* मान सीरियल मॉनीटर पर मुद्रित होते हैं, '\t' तालिका प्रारूप में मान प्रदर्शित करने के लिए है */ Serial.print(Servo_0_Pos); सीरियल.प्रिंट ("\ टी"); सीरियल.प्रिंट (सर्वो_1_Pos); सीरियल.प्रिंट ("\ टी"); सीरियल.प्रिंट (सर्वो_2_Pos); सीरियल.प्रिंट ("\ टी"); सीरियल.प्रिंट (सर्वो_3_Pos); सीरियल.प्रिंट ("\ टी"); Serial.println(Servo_4_Pos); सीरियल.प्रिंट ("इंडेक्स ="); Serial.println (सूचकांक); देरी (50); } अगर (डेटा == 'पी') // अगर 'पी' दर्ज किया गया है, तो रिकॉर्ड की गई चालें खेलना शुरू करें। { के लिए (int i = 0; i <इंडेक्स; i++) // लूप के लिए उपयोग करके सरणी को पार करें { Servo_Number = Storage / 100; // सर्वो सर्वो की संख्या का पता लगाता है = भंडारण % १००; // सर्वो स्विच (Servo_Number) की स्थिति ढूँढता है {केस 0: Servo_0.write (Servo_Position); टूटना; केस 1: सर्वो_1.लिखें (सर्वो_पोजिशन); टूटना; केस 2: सर्वो_2.लिखें (सर्वो_पोजिशन); टूटना; केस 3: सर्वो_3.लिखें (सर्वो_पोजिशन); टूटना; केस 4: सर्वो_4.राइट (सर्वो_पोजिशन); टूटना; } देरी (५०); } } }

एक बार कोड तैयार हो जाने के बाद, अब इसे arduino बोर्ड पर अपलोड करें।

स्मार्ट आर्म काम करने के लिए तैयार है। फंक्शन अभी तक उतना सहज नहीं है जितना कि स्टॉरपीक द्वारा बनाया गया है।

यदि आप कोड को बेहतर बना सकते हैं या मेरे लिए कोई सुझाव है तो कृपया मुझे टिप्पणी अनुभाग में बताएं।

इसके साथ ही कहा गया है, चलिए परीक्षण की ओर बढ़ते हैं…।

चरण 5: परीक्षण: -

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

रिकॉर्डिंग शुरू करने के लिए, मॉनिटर में 'R' दर्ज करें अब आप उन मूव्स को कर सकते हैं जिन्हें आप रिकॉर्ड करना चाहते हैं।

चालें पूरी होने के बाद आपको रिकॉर्ड की गई चालों को चलाने के लिए 'P' दर्ज करना होगा। जब तक बोर्ड को रीसेट नहीं किया जाता है, तब तक सर्वो चालें चलाना जारी रखेगा।