6 डीओएफ रोबोटिक आर्म की XYZ स्थिति निर्धारण के लिए Arduino Uno का उपयोग करना: 4 चरण

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

यह परियोजना XYZ उलटा गतिज स्थिति प्रदान करने के लिए एक छोटा और अपेक्षाकृत आसान Arduino स्केच लागू करने के बारे में है। मैंने एक 6 सर्वो रोबोटिक आर्म बनाया था, लेकिन जब इसे चलाने के लिए सॉफ़्टवेयर खोजने की बात आई, तो कस्टम सर्वो शील्ड्स जैसे SSC-32 (U) या अन्य प्रोग्राम और ऐप पर चलने वाले कस्टम प्रोग्राम के अलावा बहुत कुछ नहीं था। हाथ से स्थापित करने और संचार करने के लिए जटिल। तब मुझे ओलेग मज़ुरोव का सबसे उत्कृष्ट "अरुडिनो पर रोबोटिक आर्म इनवर्स किनेमेटिक्स" मिला, जहां उन्होंने एक साधारण अरुडिनो स्केच में उलटा किनेमेटिक्स लागू किया।

मैंने उनके कोड को अनुकूलित करने के लिए दो संशोधन किए:

1. मैंने उनके कस्टम सर्वो शील्ड लाइब्रेरी के स्थान पर VarSpeedServo लाइब्रेरी का उपयोग किया क्योंकि मैं तब सर्वो की गति को नियंत्रित कर सकता था और मुझे उनके द्वारा उपयोग किए जाने वाले सर्वो शील्ड का उपयोग नहीं करना पड़ेगा। यहां दिए गए कोड को चलाने पर विचार करने वाले किसी भी व्यक्ति के लिए मेरा सुझाव है कि आप इस VarSpeedServo लाइब्रेरी का उपयोग करें, न कि सर्वो.h लाइब्रेरी का, ताकि आप विकास के दौरान अपने रोबोटिक आर्म मूवमेंट को धीमा कर सकें या आप पा सकें कि आर्म अप्रत्याशित रूप से आपको अंदर धकेल देगा। चेहरा या बदतर क्योंकि यह पूर्ण सर्वो गति से आगे बढ़ रहा होगा।

2. मैं Arduino Uno से सर्वो को जोड़ने के लिए एक साधारण सेंसर/सर्वो शील्ड का उपयोग करता हूं, लेकिन इसके लिए किसी विशेष सर्वो पुस्तकालय की आवश्यकता नहीं है क्योंकि यह सिर्फ Arduino के पिन का उपयोग करता है। इसमें केवल कुछ रुपये खर्च होते हैं लेकिन इसकी आवश्यकता नहीं है। यह Arduino के लिए सर्वो के एक अच्छे स्वच्छ कनेक्शन के लिए बनाता है। और मैं अब कभी भी Arduino Uno में हार्डवायरिंग सर्वो पर वापस नहीं जाऊंगा। यदि आप इस सेंसर/सर्वो शील्ड का उपयोग करते हैं तो आपको एक मामूली संशोधन करने की आवश्यकता है जिसे मैं नीचे रेखांकित करूंगा।

कोड बहुत अच्छा काम करता है और आपको एक एकल फ़ंक्शन का उपयोग करके हाथ को संचालित करने की अनुमति देता है जिसमें आप x, y, x और गति पैरामीटर पास करते हैं। उदाहरण के लिए:

set_arm (0, 240, 100, 0, 20); // पैरामीटर हैं (x, y, z, ग्रिपर कोण, सर्वो गति)

देरी (3000); // इस स्थान पर जाने के लिए हाथ के समय की अनुमति देने के लिए देरी की आवश्यकता है

सरल नहीं हो सका। मैं नीचे स्केच शामिल करूंगा।

ओलेग का वीडियो यहां है: Arduino और USB माउस के साथ रोबोटिक आर्म को नियंत्रित करना

ओलेग का मूल कार्यक्रम, विवरण और संसाधन: Arduino Uno. के लिए Oleg's Inverse Kinematics

मैं दिनचर्या के पीछे का सारा गणित नहीं समझता लेकिन अच्छी बात यह है कि आपको कोड का उपयोग करने की आवश्यकता नहीं है। आशा है कि आप इसे आजमाएंगे।

चरण 1: हार्डवेयर संशोधन

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

2. यदि आप उस सेंसर शील्ड का उपयोग करते हैं जिसका मैं उपयोग कर रहा हूं, तो आपको इसके लिए एक काम करने की आवश्यकता है: 5v को शील्ड से Arduino Uno से जोड़ने वाले पिन को रास्ते से बाहर मोड़ें ताकि वह Uno बोर्ड से कनेक्ट न हो। आप ढाल पर बाहरी वोल्टेज का उपयोग केवल अपने सर्वो को शक्ति देने के लिए करना चाहते हैं, न कि Arduino Uno या यह Uno को नष्ट कर सकता है, मुझे पता है कि जब मेरा बाहरी वोल्टेज 5 के बजाय 6 वोल्ट था, तो मैंने दो Uno बोर्डों को जला दिया। यह आपको अनुमति देता है अपने सर्वो को पावर देने के लिए 5v से अधिक का उपयोग करने के लिए, लेकिन यदि आपका बाहरी वोल्टेज 5 वोल्ट से अधिक है, तो किसी भी 5 वोल्ट सेंसर को शील्ड से कनेक्ट न करें या वे तला हुआ हो जाएगा।

चरण 2: VarSpeedServo लाइब्रेरी डाउनलोड करें

आपको इस पुस्तकालय का उपयोग करने की आवश्यकता है जो मानक आर्डिनो सर्वो पुस्तकालय को प्रतिस्थापित करता है क्योंकि यह आपको सर्वो गति को सर्वो लेखन कथन में पारित करने की अनुमति देता है। पुस्तकालय यहाँ स्थित है:

VarSpeedServo लाइब्रेरी

आप बस ज़िप बटन का उपयोग कर सकते हैं, ज़िप फ़ाइल डाउनलोड कर सकते हैं और फिर इसे Arduino IDE के साथ स्थापित कर सकते हैं। एक बार आपके प्रोग्राम में कमांड इंस्टॉल हो जाने पर ऐसा दिखेगा: सर्वो.राइट (१००, २०);

पहला पैरामीटर कोण है और दूसरा सर्वो की गति 0 से 255 (पूर्ण गति) है।

चरण 3: इस स्केच को चलाएं

यहाँ प्रतियोगिता कार्यक्रम है। आपको अपने रोबोटिक आर्म डायमेंशन के लिए कुछ मापदंडों को संशोधित करने की आवश्यकता है:

1. BASE_HGT, HUMERUS, ULNA, GRIPPER की लंबाई मिलीमीटर में।

2. अपना सर्वो पिन नंबर इनपुट करें

3. अटैचमेंट स्टेटमेंट में सर्वो न्यूनतम और अधिकतम इनपुट करें।

4. फिर एक साधारण सेट_आर्म () कमांड और फिर परीक्षण के लिए शून्य_x (), लाइन () और सर्कल () फ़ंक्शन आज़माएं। सुनिश्चित करें कि आपकी सर्वो गति कम है जब आप पहली बार इन कार्यों को चलाते हैं ताकि आपकी बांह और अपनी बांह को नुकसान न पहुंचे।

आपको कामयाबी मिले।

#शामिल VarSpeedServo.h

/* AL5D आर्म के लिए सर्वो नियंत्रण */

/* आर्म आयाम (मिमी) */

# परिभाषित करें BASE_HGT 90 // आधार ऊंचाई

#define HUMERUS 100 // कंधे से कोहनी "हड्डी"

# परिभाषित ULNA 135 // कोहनी से कलाई "हड्डी"

#define GRIPPER 200 // ग्रिपर (incl.heavy ड्यूटी रिस्ट रोटेट मैकेनिज्म) लंबाई"

#define ftl(x) ((x)>=0?(long)((x)+0.5):(long)((x)-0.5)) //float to long रूपांतरण

/* सर्वो नाम/संख्याएं *

* बेस सर्वो HS-485HB * /

#परिभाषित करें BAS_SERVO 4

/* शोल्डर सर्वो HS-5745-MG */

#SHL_SERVO 5 परिभाषित करें

/* एल्बो सर्वो HS-5745-MG */

# परिभाषित करें ELB_SERVO 6

/* कलाई सर्वो HS-645MG */

#परिभाषित WRI_SERVO 7

/* कलाई घुमाएँ सर्वो HS-485HB */

#परिभाषित WRO_SERVO 8

/* ग्रिपर सर्वो HS-422 */

#GRI_SERVO 9 परिभाषित करें

/* पूर्व-गणना */

फ्लोट hum_sq = ह्यूमरस * ह्यूमरस;

फ्लोट uln_sq = ULNA * ULNA;

इंट सर्वोस्पीड = 10;

// सर्वोशील्ड सर्वो; // सर्वोशील्ड ऑब्जेक्ट

वरस्पीड सर्वो सर्वो1, सर्वो2, सर्वो3, सर्वो4, सर्वो5, सर्वो6;

इंट लूपकाउंटर = 0;

इंट पल्सविड्थ = ६.६;

int microsecondsToDegrees;

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

{

सर्वो1.अटैच (BAS_SERVO, ५४४, २४००);

सर्वो2.अटैच(SHL_SERVO, ५४४, २४००);

सर्वो3.अटैच (ELB_SERVO, ५४४, २४००);

सर्वो4.अटैच (WRI_SERVO, ५४४, २४००);

सर्वो5.अटैच (WRO_SERVO, ५४४, २४००);

सर्वो6.अटैच (GRI_SERVO, ५४४, २४००);

देरी (5500);

// सर्वोस.स्टार्ट (); // सर्वो शील्ड शुरू करें

सर्वो_पार्क ();

देरी (4000);

सीरियल.बेगिन (९६००);

Serial.println ("प्रारंभ");

}

शून्य लूप ()

{

लूपकाउंटर +1;

// सेट_आर्म (-300, 0, 100, 0, 10); //

// देरी (7000);

// शून्य_एक्स ();

//रेखा();

//वृत्त();

देरी (4000);

अगर (लूप काउंटर> 1) {

सर्वो_पार्क ();

// सेट_आर्म (0, 0, 0, 0, 10); // पार्क

देरी (5000);

बाहर निकलें (0); }//प्रोग्राम रोकें - जारी रखने के लिए रीसेट को हिट करें

// बाहर निकलें (0);

}

/* व्युत्क्रम किनेमेटिक्स का उपयोग करते हुए आर्म पोजीशनिंग रूटीन */

/* z ऊंचाई है, y आधार केंद्र से दूरी है, x अगल-बगल है। y, z केवल धनात्मक हो सकता है */

// शून्य सेट_आर्म (uint16_t x, uint16_t y, uint16_t z, uint16_t ग्रिप_एंगल)

शून्य सेट_आर्म (फ्लोट एक्स, फ्लोट वाई, फ्लोट जेड, फ्लोट ग्रिप_एंगल_डी, इंट सर्वोस्पीड)

{

फ्लोट ग्रिप_एंगल_आर = रेडियन (ग्रिप_एंगल_डी); // गणना में उपयोग के लिए रेडियन में पकड़ कोण

/* x, y निर्देशांक से आधार कोण और रेडियल दूरी */

फ्लोट bas_angle_r = atan2(x, y);

फ्लोट rdist = sqrt ((x * x) + (y * y));

/* rdist भुजा के लिए y निर्देशांक है */

वाई = rdist;

/* ग्रिप कोण के आधार पर गणना की गई ग्रिप ऑफ़सेट */

फ्लोट ग्रिप_ऑफ_ज़ = (पाप (ग्रिप_एंगल_आर)) * ग्रिपर;

फ्लोट ग्रिप_ऑफ_वाई = (कॉस (ग्रिप_एंगल_आर)) * ग्रिपर;

/* कलाई की स्थिति */

फ्लोट कलाई_ज़ = (जेड - ग्रिप_ऑफ_ज़) - BASE_HGT;

फ्लोट कलाई_वाई = वाई - ग्रिप_ऑफ_वाई;

/* कंधे से कलाई की दूरी (AKA sw) */

फ्लोट s_w = (कलाई_ज़ * कलाई_ज़) + (कलाई_य * कलाई_य);

फ्लोट s_w_sqrt = sqrt (s_w);

/* s_w कोण से जमीन तक */

फ्लोट a1 = atan2 (wrist_z, wrist_y);

/* s_w कोण से ह्यूमरस */

फ्लोट a2 = acos (((hum_sq - uln_sq) + s_w) / (2 * HUMERUS * s_w_sqrt));

/* कंधे का कोण */

फ्लोट shl_angle_r = a1 + a2;

फ्लोट shl_angle_d = डिग्री (shl_angle_r);

/* कोहनी कोण */

फ्लोट elb_angle_r = acos ((hum_sq + uln_sq - s_w) / (2 * HUMERUS * ULNA));

फ्लोट elb_angle_d = डिग्री (elb_angle_r);

फ्लोट elb_angle_dn = -(१८०.० - elb_angle_d);

/* कलाई का कोण */

फ्लोट wri_angle_d = (grip_angle_d - elb_angle_dn) - shl_angle_d;

/* सर्वो दालें */

फ्लोट bas_servopulse = १५००.० - ((डिग्री(bas_angle_r)) * पल्सविड्थ);

फ्लोट shl_servopulse = १५००.० + ((shl_angle_d - ९०.०) * पल्सविड्थ);

फ्लोट elb_servopulse = १५००.० - ((elb_angle_d - ९०.०) * पल्सविड्थ);

// फ्लोट wri_servopulse = १५०० + (wri_angle_d * पल्सविड्थ);

// फ्लोट wri_servopulse = १५०० + (wri_angle_d * पल्सविड्थ);

फ्लोट wri_servopulse = १५०० - (wri_angle_d * पल्सविड्थ); // jimrd द्वारा २०१८/२/११ को अपडेट किया गया - मैंने प्लस को माइनस में बदल दिया - यह सुनिश्चित नहीं है कि यह कोड पहले किसी के लिए कैसे काम करता था। हो सकता है कि एल्बो सर्वो को ऊपर की बजाय 0 डिग्री नीचे की ओर रखा गया हो।

/* सर्वो सेट करें */

//servos.setposition(BAS_SERVO, ftl(bas_servopulse));

microsecondsToDegrees = map(ftl(bas_servopulse), ५४४, २४००, ०, १८०);

सर्वो १.लिखें (माइक्रोसेकंड टोडिग्री, सर्वोस्पीड); // इस फ़ंक्शन का उपयोग करें ताकि आप सर्वो गति सेट कर सकें //

//servos.setposition(SHL_SERVO, ftl(shl_servopulse));

microsecondsToDegrees = map(ftl(shl_servopulse), ५४४, २४००, ०, १८०);

सर्वो २.लिखें (माइक्रोसेकंड टोडिग्री, सर्वोस्पीड);

//servos.setposition(ELB_SERVO, ftl(elb_servopulse));

microsecondsToDegrees = map(ftl(elb_servopulse), ५४४, २४००, ०, १८०);

सर्वो3.लिखें (माइक्रोसेकंड टोडिग्री, सर्वोस्पीड);

//servos.setposition(WRI_SERVO, ftl(wri_servopulse));

microsecondsToDegrees = map(ftl(wri_servopulse), ५४४, २४००, ०, १८०);

सर्वो4.लिखें (माइक्रोसेकंड टोडिग्री, सर्वोस्पीड);

}

/* सर्वो को पार्किंग की स्थिति में ले जाएं */

शून्य सर्वो_पार्क ()

{

//servos.setposition(BAS_SERVO, 1500);

सर्वो १.लिखें (९०, १०);

//servos.setposition(SHL_SERVO, 2100);

सर्वो २.लिखें (९०, १०);

//servos.setposition(ELB_SERVO, 2100);

सर्वो ३.लिखें (९०, १०);

//servos.setposition(WRI_SERVO, १८००);

सर्वो ४.लिखें (९०, १०);

//servos.setposition(WRO_SERVO, ६००);

सर्वो ५.लिखें (९०, १०);

//servos.setposition(GRI_SERVO, 900);

सर्वो 6.लिखें (80, 10);

वापसी;

}

शून्य शून्य_x ()

{

के लिए (डबल यैक्सिस = २५०.०; यैक्सिस <४००.०; यैक्सिस += १) {

Serial.print("yaxis=:");Serial.println(yaxis);

set_arm (0, यैक्सिस, 200.0, 0, 10);

देरी(10);

}

के लिए(डबल यैक्सिस = ४००.०; यैक्सिस> २५०.०; यैक्सिस -= १) {

set_arm (0, यैक्सिस, 200.0, 0, 10);

देरी(10);

}

}

/* हाथ को एक सीधी रेखा में ले जाता है */

शून्य रेखा ()

{

के लिए (डबल xaxis = -100.0; xaxis <100.0; xaxis + = 0.5) {

set_arm (xaxis, 250, 120, 0, 10);

देरी(10);

}

के लिए (फ्लोट xaxis = 100.0; xaxis> -100.0; xaxis - = 0.5) {

set_arm (xaxis, 250, 120, 0, 10);

देरी(10);

}

}

शून्य सर्कल ()

{

#define RADIUS 50.0

// फ्लोट कोण = 0;

फ्लोट ज़ैक्सिस, यैक्सिस;

के लिए (फ्लोट कोण = 0.0; कोण <360.0; कोण + = 1.0) {

यैक्सिस = त्रिज्या * पाप (रेडियन(कोण)) + ३००;

zaxis = RADIUS * cos(radians(angle)) + 200;

set_arm (0, यैक्सिस, ज़ैक्सिस, 0, 50);

देरी(10);

}

}

चरण 4: तथ्य, मुद्दे और पसंद…

1. जब मैं सर्कल () सबरूटीन चलाता हूं तो मेरा रोबोट सर्कल की तुलना में अंडाकार आकार में अधिक चलता है। मुझे लगता है कि ऐसा इसलिए है क्योंकि मेरे सर्वो कैलिब्रेटेड नहीं हैं। मैंने उनमें से एक का परीक्षण किया और 1500 माइक्रोसेकंड 90 डिग्री के समान नहीं थे। इस पर काम करेंगे और समाधान निकालने की कोशिश करेंगे। विश्वास न करें कि एल्गोरिदम में कुछ भी गलत है बल्कि मेरी सेटिंग्स के साथ है। अद्यतन २०१८/२/११ - अभी पता चला है कि यह मूल कोड में त्रुटि के कारण है। मैं नहीं देखता कि उनके प्रोग्राम ने इसका उपयोग करके फिक्स्ड कोड कैसे काम किया: फ्लोट wri_servopulse = 1500 - (wri_angle_d * pulseWidth); (मूल कोड जोड़ रहा था)

2. मुझे इस बारे में अधिक जानकारी कहां मिल सकती है कि कैसे सेट_आर्म () फ़ंक्शन काम करता है: ओलेग माज़ुरोव की वेबसाइट सब कुछ बताती है या अधिक जानकारी के लिए लिंक प्रदान करती है:

3. क्या कोई सीमा स्थिति जाँच है? नहीं। जब मेरी रोबोट भुजा को एक अमान्य xyz समन्वयित किया जाता है तो यह बिल्ली को खींचने की तरह इस अजीब तरह की आर्किंग गति करता है। मेरा मानना है कि ओलेग अपने नवीनतम कार्यक्रम में कुछ जाँच करता है जो हाथ की गतिविधियों को प्रोग्राम करने के लिए USB का उपयोग करता है। उसका वीडियो देखें और उसके नवीनतम कोड का लिंक देखें।

4. कोड को साफ करने की जरूरत है और माइक्रोसेकंड कोड को खत्म किया जा सकता है।