MIRO एक ओपन इनडोर रोबोट प्लेटफॉर्म है। भाग 5 - सॉफ्टवेयर घटक: ARDUINO (AVR), हम "हुड के नीचे" चढ़ते हैं

इस बार हम ARDUINO (AVR) के लिए कुछ प्रमुख पुस्तकालय विधियों के क्रियान्वयन में थोड़ा गहरे नज़र आएंगे, जो MIRO रोबोट को स्थानांतरित करने के लिए ज़िम्मेदार हैं। यह हिस्सा उन सभी के लिए दिलचस्प होगा, जो यह सोचते थे कि सरलतम एन्कोडर के साथ मोटर्स से लैस ARDUINO पर रोबोट की रैखिक और कोणीय गति को कैसे नियंत्रित किया जाए।

सामग्री की तालिका: भाग 1 , भाग 2 , भाग 3 , भाग 4 , भाग 5

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

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

ये तथ्य ओडोमीटर सेंसर (एमआईआरओ के मामले में, प्रत्येक पहिया के लिए डिजिटल एनकोडर) से लैस चेसिस के आंदोलन से संबंधित तरीकों के एक समूह के कार्यान्वयन को निर्धारित करते हैं।

जैसा कि हमें चौथे भाग में पता चला, सॉफ्टवेयर मॉडल में चेसिस क्लास है, जिसमें व्यक्तिगत चेसिस इंजनों के रोटेशन को नियंत्रित किया जाता है। मैं जोर देना चाहता हूं - चेसिस, ट्रॉली के आंदोलन का नियंत्रण नहीं, बल्कि ट्रॉली के इंजनों का नियंत्रण। ट्रॉली का सीधा नियंत्रण रोबोट और मिरो कक्षाओं में लागू किया गया है।

चलो ऊपर से शुरू करते हैं। नीचे Miro वर्ग की एक विधि दी गई है जो किसी दिए गए रैखिक ( lin_speed , m / s) और कोणीय ( ang_speed , deg / s) गति के साथ एक निश्चित दूरी ( डिस्ट , मीटर) रोबोट की गति को कार्यान्वित करता है। हम अभी तक en_break पैरामीटर पर ध्यान नहीं दे रहे हैं।

int Miro::moveDist(float lin_speed, float ang_speed, float dist, bool en_break) { float _wheelSetAngSpeed[WHEEL_COUNT]; _wheelSetAngSpeed[LEFT] = MIRO_PI2ANG * (lin_speed - (ROBOT_DIAMETER * ang_speed / (2 * MIRO_PI2ANG))) / WHEEL_RADIUS; _wheelSetAngSpeed[RIGHT] = MIRO_PI2ANG * (lin_speed + (ROBOT_DIAMETER * ang_speed / (2 * MIRO_PI2ANG))) / WHEEL_RADIUS; float _wheelSetAng[WHEEL_COUNT]; _wheelSetAng[RIGHT] = _wheelSetAngSpeed[RIGHT] * dist / lin_speed; _wheelSetAng[LEFT] = _wheelSetAngSpeed[LEFT] * dist / lin_speed; return this->chassis.wheelRotateAng(_wheelSetAngSpeed, _wheelSetAng, en_break); } 

इस पद्धति में, बाएं और दाएं इंजन के लिए आवश्यक कोणीय वेगों की गणना पहले की जाती है। काफी स्पष्ट सूत्रों के अनुसार, जो कटौती करने के लिए कोई समस्या नहीं है। केवल यह ध्यान रखना आवश्यक है कि विधि में रैखिक वेग प्रति सेकंड मीटर में निर्दिष्ट किया जाता है, और कोणीय वेग प्रति सेकंड (रेडियन में नहीं)। इसलिए, हम निरंतर MIRO_PI2ANG = 57.29 = 180 / pi की गणना करते हैं । ROBOT_DIAMETER - रोबोट के बाएं और दाएं पहियों के बीच की दूरी (मीटर में), WHEEL_RADIUS - पहिया त्रिज्या (मीटर में भी)। इस तरह के मामलों के लिए सभी संख्यात्मक स्थिरांक डिफेक्स फ़ाइल में समाहित हैं, और config.h फ़ाइल में रोबोट और चेसिस कस्टम पैरामीटर हैं।

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

इस प्रकार, इस स्तर पर हम रोबोट चेसिस के प्रत्येक पहिया को घुमाने के लिए किस गति और किस कोण पर आते हैं। और फिर चेसिस ऑब्जेक्ट का व्हीलरोटेटएंग () विधि कहा जाता है।

WheelRotateAng मेथड (फ्लोट * स्पीड, फ्लोट * एंगल, बूल एन_ब्रेक) का उपयोग रोबोट व्हील्स को रोटेट करने के लिए किया जाता है , जिसे एंग [] एरे (सरणी में) द्वारा निर्दिष्ट एंगल द्वारा स्पीड [] एरे (एम / एस) में निर्दिष्ट कोणीय गति के साथ। अंतिम पैरामीटर en_break (पहले से ही हमारे द्वारा पहले से मिला हुआ) उन पर अल्पकालिक रिवर्स वोल्टेज लागू करके एक मोड़ बनाने के बाद पहियों के एक कठिन पड़ाव की आवश्यकता निर्धारित करता है। यह रोबोट की जड़ता को दबाने के लिए आवश्यक है, इसे मोटर्स से नियंत्रण वोल्टेज को हटाने के बाद पहले से ही आवश्यक दूरी से आगे बढ़ने से रोकना चाहिए। पूर्ण संतुष्टि के लिए, निश्चित रूप से, व्हीलआरोटेटएएनजीआरएडी () विधि है, व्हीलआरोटेटएएनजी () के समान अंतर है कि यह रेडियन और रेडियन में सेकेंडों के रूप में रोटेशन कोणों और कोणीय वेगों के मान को पैरामीटर के रूप में लेता है।

WheelRotateAng () विधि का एल्गोरिथ्म इस प्रकार है।

1. सबसे पहले, गति से मूल्यों के पत्राचार [] और कोण [] कुछ सीमा स्थितियों की जाँच की जाती है। जाहिर है, चेसिस की पहिए के रोटेशन की अधिकतम कोणीय गति और न्यूनतम (चलती गति की न्यूनतम गति) दोनों पर भौतिक सीमाएं हैं। इसके अलावा, कोण में कोण [] रोटेशन के न्यूनतम तय कोण से कम नहीं हो सकता है, जो एन्कोडर्स की सटीकता से निर्धारित होता है।

2. अगला, प्रत्येक पहिया के रोटेशन की दिशा की गणना की जाती है। स्पष्ट रूप से उत्पाद के माध्यम से कोण [i] * गति [i] ;

3. प्रत्येक पहिया के लिए "रोटेशन की दूरी" ड्वा [i] की गणना की जाती है - एनकोडर नमूनों की संख्या जो दिए गए कोण [i] द्वारा घूमने के लिए किया जाना चाहिए।
यह मान सूत्र द्वारा निर्धारित किया जाता है:

ड्व [i] = एंग [i] * WHEEL_SEGMENTS / 360 ,
जहां WHEEL_SEGMENTS एनकोडर व्हील (पूर्ण क्रांति) के सेगमेंट की संख्या है।

4. मोटर चालक पर वोल्टेज मान दर्ज किया जाता है।


5. प्रत्येक पहिया के लिए अंशांकन तालिका के अनुसार, PWM सिग्नल का प्रारंभिक मूल्य निर्धारित किया जाता है, जो आवश्यक गति गति [i] के साथ पहिया के रोटेशन को सुनिश्चित करता है। किस तरह की कैलिब्रेशन टेबल है और यह कहां से आया है - हम आगे का विश्लेषण करेंगे।

6. रोटेशन की गति और दिशा की गणना मूल्यों के अनुसार इंजनों का रोटेशन शुरू किया जाता है। वर्ग कार्यान्वयन के पाठ में, _wheel_rotate_sync () निजी विधि इसके लिए जिम्मेदार है।

हम और भी गहरे जाते हैं। निम्न एल्गोरिथम के अनुसार _wheel_rotate_sync () विधि काम करती है:

1. एक अनंत लूप में, प्रत्येक पहिये के लिए टर्निंग डिस्ट डेव [i] के एनकोडर प्रतिक्रियाओं के काउंटर को प्राप्त करने के लिए एक चेक बनाया जाता है। यदि काउंटर ड्व [i] में से कोई भी पहुंच जाता है, तो सभी पहिए चक्र को रोकते हैं और बाहर निकलते हैं और फिर फ़ंक्शन (चरण 5) से बाहर निकलते हैं। यह निम्नलिखित कारणों से किया जाता है। रोटेशन के कोण को मापने की विसंगति के कारण, यह एक बहुत ही सामान्य स्थिति है जब एक पहिया की गणना की गई दूरी ड्व [i] एक गैर-पूर्णांक मान को एक छोटे पक्ष में और दूसरे पहिये के ड्व [जे] को बड़ा करके प्राप्त किया जाता है। यह इस तथ्य की ओर जाता है कि पहियों में से एक को रोकने के बाद, दूसरा पहिया एक मोड़ बनाना जारी रखता है। अंतर ड्राइव के साथ चेसिस के लिए (और कई अन्य लोगों के लिए), यह कार्य के अंत में रोबोट के अनियोजित "टर्न" की ओर जाता है। इसलिए, पूरे चेसिस के स्थानिक आंदोलन को व्यवस्थित करने के मामले में, एक बार में सभी इंजनों को रोकना आवश्यक है।

2. यदि ड्व [i] नहीं पहुँचा गया है, तो लूप में एनकोडर के अगले ऑपरेशन के तथ्य की जाँच की जाती है (चर _syncloop [w] , जो एनकोडर इंटरप्ट से अपडेट होता है और इस अनंत लूप में रीसेट होता है)। जब अगला चौराहा होता है, तो कार्यक्रम स्पष्ट सूत्र के अनुसार प्रत्येक पहिया (डाउन / एस) की वर्तमान कोणीय गति के मॉड्यूल की गणना करता है:

डब्ल्यू [i] = (३६० * ताऊ [i]) / WHEEL_SEGMENTS ,
जहां:
ताऊ [i] - एन्कोडर के अंतिम दो प्रतिक्रियाओं के बीच के समय का औसत मूल्य। औसत फिल्टर की "गहराई" MEAN_DEPTH और 8 की चूक से निर्धारित होती है।

3. गणना की गई पहिया गति के आधार पर, पूर्ण त्रुटियों की गणना सेट और वास्तविक कोणीय गति के बीच अंतर के रूप में की जाती है।

4. गणना की गई त्रुटियों के आधार पर, प्रत्येक मोटर के लिए नियंत्रण क्रिया (पीडब्लूएम सिग्नल मूल्य) को ठीक किया जाता है।

5. ड्व [i] तक पहुँचने के बाद, सक्रिय एन_ब्रेक के मामले में, मोटरों पर रिवर्स शॉर्ट-टर्म वोल्टेज लगाया जाता है। इस आशय की अवधि अंशांकन तालिका (नीचे देखें) से निर्धारित होती है और आमतौर पर 15 से 40 एमएस तक होती है।

6. इंजन से तनाव का पूर्ण विमोचन है और _wheel_rotate_sync () से बाहर निकलें।

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

1. मोटर टर्मिनलों पर वोल्टेज। इसकी गणना PWM सिग्नल के मूल्य को वास्तविक वोल्टेज में बदलकर की जाती है। इसके लिए, WheelRotateAng () विधि के चरण 4 में, इंजन चालक पर वास्तविक वोल्टेज दर्ज किया जाता है।

2. किसी दिए गए वोल्टेज के अनुरूप पहिया के रोटेशन की कोणीय गति (कोई भार नहीं)।

3. इस कोणीय वेग के अनुरूप हार्ड स्टॉप सिग्नल की अवधि।
डिफ़ॉल्ट रूप से, अंशांकन तालिका का आकार 10 रिकॉर्ड है ( config.h फ़ाइल में निरंतर WHEEL_TABLE_SIZE द्वारा निर्धारित) - मान "वोल्टेज - कोणीय वेग - स्टॉप सिग्नल की अवधि" के 10 त्रिगुण ।

इस तालिका में 2 और 3 प्रविष्टियों से मानों को निर्धारित करने के लिए, एक विशेष विधि का उपयोग किया जाता है - WheelCalibrate (बाइट व्हील) ।

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

अंशांकन करने के लिए, रोबोट को एक स्टैंड पर रखा गया है, अंशांकन के दौरान सभी पहिया रोटेशन लोड के बिना किया जाता है।

1. सबसे पहले आपको न्यूनतम शुरुआती गति निर्धारित करने की आवश्यकता है। यह बहुत सरलता से किया जाता है। एक चक्र में, नियंत्रण पीडब्लूएम को इंजन से खिलाया जाता है, 0 से शुरू होता है। 1 के वेतन वृद्धि के साथ। प्रत्येक चरण में, प्रोग्राम कुछ समय तक प्रतीक्षा करता है, जो निरंतर WHEEL_TIME_MAX (सामान्य विलंब () ) द्वारा निर्धारित होता है। प्रतीक्षा समय बीत जाने के बाद, यह देखने के लिए जाँच करता है कि क्या शुरुआत पूरी हो गई है (एनकोडर काउंटर के मूल्य को बदलकर)। यदि पुलअवे पूरा हो गया है, तो पहिया के रोटेशन की कोणीय गति की गणना की जाती है। अधिक निश्चितता के लिए, इस शुरुआती गति के अनुरूप PWM के मूल्य में 10 का मान जोड़ा जाता है। यह "मोटर पर वोल्टेज" - "कोणीय वेग" मानों की पहली जोड़ी देता है।

2. प्रारंभिक गति मिलने के बाद, PWM कदम की गणना समान रूप से अंशांकन तालिका को भरने के लिए की जाती है।

3. चक्र में, प्रत्येक नए पीडब्लूएम मान के लिए, पहिया 2 पूर्ण घुमावों को घुमाया जाता है और कोणीय वेग _wheel_rotate_sync () विधि के समान एल्गोरिथ्म के अनुसार मापा जाता है। एक ही चक्र में, क्रमिक सन्निकटन द्वारा, हार्ड स्टॉप सिग्नल अवधि का इष्टतम मूल्य मापा जाता है। प्रारंभ में, कुछ स्पष्ट रूप से महान मूल्य लिया जाता है। और फिर इसे "टर्न-स्टॉप" मोड में परीक्षण किया गया है। इष्टतम के रूप में, स्टॉप सिग्नल की अवधि का अधिकतम मूल्य चुना जाता है, जिस पर सेट "टर्न डिस्टेंस" को पार नहीं किया जाता है। दूसरे शब्दों में, सिग्नल की अवधि का ऐसा मूल्य, जिसकी एक ओर इंजन की आपूर्ति पर, जड़ता दबा दी जाती है, और दूसरी ओर, कोई अल्पकालिक रिवर्स आंदोलन नहीं होता है (जो एक ही एनकोडर द्वारा तय किया जाता है)।

4. कैलिब्रेशन पूरा होने के बाद, कैलिब्रेटेड मोटर पर कंट्रोल वोल्टेज लागू होना बंद हो जाता है और इस व्हील का कैलिब्रेशन टेबल EEPROM में रिकॉर्ड हो जाता है।

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

और एक गैर-अवरुद्ध अनुप्रयोग के लिए, एपीआई में एक फ़ंक्शन व्हीलरोट (फ्लोट * स्पीड) है । यह, जैसा कि मापदंडों की सूची से देखा जा सकता है, बस निर्धारित गति के साथ पहियों के रोटेशन को निष्पादित करता है। और रोटेशन की गति को रोबोट चेसिस के सिंक () विधि में समायोजित किया जाता है, जिसे उसी नाम की Miro वर्ग ऑब्जेक्ट के सिंक () विधि में कहा जाता है। और उपयोगकर्ता के स्केच की संरचना के लिए आवश्यकताओं के अनुसार, इस विधि को ARDUINO स्केच के मुख्य लूप () लूप के प्रत्येक पुनरावृत्ति कहा जाना चाहिए।

चरण 4 में, _wheel_rotate_sync () विधि के विवरण में, मैंने इंजन के "नियंत्रण सुधार" का उल्लेख किया। आपने कैसे अनुमान लगाया)? यह पीआईडी ​​नियंत्रक है)। ठीक है, अधिक सटीक पीडी नियंत्रक। जैसा कि आप जानते हैं (वास्तव में - हमेशा नहीं), नियामक के गुणांक निर्धारित करने का सबसे अच्छा तरीका चयन है)। Config.h कॉन्फ़िगरेशन फ़ाइल में एक परिभाषा है:

 #define DEBUG_WHEEL_PID 

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



क्या कुछ भी समान नहीं है)? नीचे समय है (प्रत्येक बार नियंत्रण चक्र का एक चरण है), और त्रुटि मान दाईं ओर सहेजा गया है (संकेत संरक्षित के साथ)। पीडी नियंत्रक के विभिन्न गुणांक के साथ एक ही पैमाने पर ग्राफ़ के दो जोड़े हैं। "हम्प्स" ओवरशूट की सिर्फ "लहरें" हैं। क्षैतिज सलाखों पर संख्या एक सापेक्ष त्रुटि है (संकेत के संरक्षण के साथ)। नियामक के सरल दृश्य, गुणांक को मैन्युअल रूप से समायोजित करने में मदद करता है। समय के साथ, मैं एक स्वचालित सेटअप करने की उम्मीद करता हूं, लेकिन अभी के लिए।

यहाँ इस तरह के एक है :-)

खैर, अंत में, आइए एक उदाहरण देखें। सीधे API_Miro_moveDist लाइब्रेरी से:

 #include <Miro.h> using namespace miro; byte PWM_pins[2] = { 5, 6 }; byte DIR_pins[2] = { 4, 7 }; byte ENCODER_pins[2] = { 2, 3 }; Miro robot(PWM_pins, DIR_pins, ENCODER_pins); int laps = 0; void setup() { Serial.begin(115200); } void loop() { for (unsigned char i = 0; i < 4; i++) { robot.moveDist(robot.getOptLinSpeed(), 0, 1, true); delay(500); robot.rotateAng(0.5*robot.getOptAngSpeed(), -90, true); delay(500); } Serial.print("Laps: "); Serial.println(laps); laps++; } 

कार्यक्रम के पाठ से सब कुछ स्पष्ट होना चाहिए। यह कैसे काम करता है - वीडियो में।


600 x 600 मिमी टाइल और 5 मिमी टाइल अंतराल। सिद्धांत रूप में, रोबोट को 1 मीटर के किनारे के साथ एक वर्ग के आसपास जाना चाहिए। बेशक, प्रक्षेपवक्र "दूर तैरता है"। लेकिन निष्पक्षता में यह कहने योग्य है कि रोबोट के जिस संस्करण में मैंने परीक्षण के लिए छोड़ा है, उसमें काफी घूमने वाले इंजन हैं जिन्हें धीरे-धीरे चलाना मुश्किल है। लेकिन उच्च गति और फिसलन में एक जगह है, और जड़ता का सामना करना आसान नहीं है। उच्च गियर अनुपात के साथ इंजन (जैसे कि हमारे MIRO रोबोट में, परीक्षण के दौरान बस हाथ पर नहीं) कुछ बेहतर व्यवहार करना चाहिए।

अगर कोई अचूक क्षण हैं - मैं स्पष्ट करने, चर्चा करने और सुधार करने में प्रसन्न हूं। प्रतिक्रिया आम तौर पर दिलचस्प है।