🏇🏼 ⏳ 🙏🏿 रोबोट लोडर परियोजना: अपना स्थान का पता लगाना 🏨 👨‍🎓 😧

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

प्रागितिहास

पिछले साल, हमने रूंबा स्व-चालित वैक्यूम क्लीनर प्लेटफॉर्म के साथ प्रयोग किया। एक ब्रांड-न्यू वैक्यूम क्लीनर की कीमत हमें £ 300 के बारे में है (एक इस्तेमाल किया जा सकता है £ 100 या सस्ता के लिए भी पाया जा सकता है), और इसमें पहियों पर दो इलेक्ट्रिक ड्राइव, फ्रंट पर दो टच सेंसर, तल पर एक अवरक्त सेंसर (चरणों का पता लगाने के लिए) और शीर्ष पर (बम स्टेशन खोजने के लिए) शामिल हैं। । सेंसर की सटीक सूची मॉडल पर निर्भर करती है: प्रोटोकॉल नीचे से चार अवरक्त सेंसर प्रदान करता है, जिनमें से प्रत्येक एक बिट ("दृश्यमान / दृश्यमान नहीं") देता है। किसी भी मामले में, कोई रेंजफाइंडर नहीं: सभी उपलब्ध सेंसर एकल-बिट हैं। इसके अलावा, रोम्बा में कोई "प्रोग्रामेबल अरड्यून्स" नहीं हैं, और इसे नियंत्रित करने के लिए, आपको शीर्ष पर एक लैपटॉप (या अरुडिनो) स्थापित करने और आरएस -232 के माध्यम से रोबोट के साथ संवाद करने की आवश्यकता है। वैक्यूम क्लीनर के साथ खेलने के बाद, हमने उसे गोदाम में से एक अलमारियों पर धूल छोड़ दिया।

इस वर्ष हमने Microsoft रोबोटिक्स डेवलपमेंट स्टूडियो (MRDS) को आजमाने का फैसला किया, जिसके प्रचार के लिए Microsoft ने "MRDS रेफरेंस प्लेटफॉर्म" - उपकरण का एक सेट और "मानक" रोबोट को नियंत्रित करने के लिए एक प्रोटोकॉल तैयार किया। यह विनिर्देश रोबोट प्रेमियों को संगत रोबोट बनाने और उनके बीच कार्यक्रमों को स्थानांतरित करने की अनुमति देगा। वैक्यूम क्लीनर के हार्डवेयर की तुलना में, संदर्भ प्लेटफ़ॉर्म बहुत अधिक जटिल और शक्तिशाली है: विनिर्देश में Kinect, तीन अवरक्त रेंजफाइंडर और दो अल्ट्रासोनिक वाले, साथ ही व्हील रोटेशन सेंसर (एनकोडर) शामिल हैं। एमआरडीएस आरपी का कार्यान्वयन अब तक केवल एडी द्वारा बुलाया गया है जिसे एडी (लगभग £ 1000, जो किनेक्ट शामिल नहीं है) कहा जाता है। एमआरडीएस आरपी विनिर्देशन में प्रोटोटाइप रोबोट की तस्वीरों के साथ एडी की असामान्य समानता बताती है कि विनिर्देश लंबन के साथ मिलकर बनाया गया था, दूसरे शब्दों में, पैरलैक्स एक संदर्भ के रूप में माइक्रोसॉफ्ट को अपने मंच पर ले जाने में कामयाब रहा।

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

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

कार्य

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

पहला नेविगेशन प्रयास रेंजफाइंडर पर आधारित था: शेल्फ के लिए रोबोट "ग्रोप" और इसके साथ यात्रा करता है, पूर्व निर्धारित दूरी बनाए रखता है, बस एक चौंका देने वाला शराबी चलता है, एक कदम के माध्यम से एक दीवार के खिलाफ झुकाव। समानता वास्तव में बहुत बड़ी थी: रेंजफाइंडर से संकेत प्राप्त करने में देरी, उन्हें एमआरडीएस में संसाधित करना, मोटर्स के लिए एक टीम का गठन करना, और उनकी जड़ता पर काबू पाना - एक सेकंड के दसवें हिस्से तक। इस समय के दौरान, रोबोट ने शांत रूप से "दूर की ओर" ले जाया, ताकि "पाठ्यक्रम सुधार" हर बार दसियों डिग्री तक पहुंचे, और प्रक्षेपवक्र एक विस्तृत ज़िगज़ैग बन गया। इसके अलावा, एडी रेंजफाइंडर बहुत सटीक नहीं थे - त्रुटि cm 5 सेमी तक है - और काफी संकीर्ण रूप से केंद्रित है, अर्थात। अलमारियों को केवल एक पर, फर्श से पूर्व निर्धारित ऊंचाई से पहचाना गया था।

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

गणना

यह सब देर रात एक नैपकिन पर एक ड्राइंग के साथ शुरू हुआ, जब इसने मुझ पर वार किया:

चाप की शुरुआत में, रोबोट बिंदु ए (ज्ञात) पर था, अंत में यह बिंदु बी (अज्ञात) पर निकला, जबकि बाएं पहिया ने ज्ञात पथ एस ₁ = 1r ₁ , और दाएं पहिया - ज्ञात एस ₂ = φr _{2 का सफर किया} । पटरियों के बीच की दूरी डब्ल्यू स्थिर है, और रोबोट के डिजाइन द्वारा निर्धारित की जाती है। हमें मिलता है:
आर ₂ / आर ₁ = एस ₂ / एस ₁ और आर ₂ = आर ₁ + डब्ल्यू , जहां
( आर ₁ + डब्ल्यू ) / आर ₁ = एस ₂ / एस ₁
आर ₁ एस ₁ + डब्ल्यूएस ₁ = आर ₁ एस ₂
आर ₁ = डब्ल्यूएस ₁ / ( एस ₂ - एस ₁ )

इसलिए, रोबोट ने जो कोण दिया वह the = S ₁ / r ₁ = ( S ₂ - S ₁ ) / w , और दूरी है। एबी | = 2 | एएम | = 2 ( r ₁ + w / 2) पाप ( 2/2 ) = (2 wS ₁ / ( S ₂ - S ₁ ) + w ) पाप ( φ / 2) = w sin ( φ / 2) ( S ₂ ) + एस ₁ ) / ( एस ₂ - एस ₁ )

यहां, स्थिति को निर्धारित करने के लिए सभी बड़े और सभी गणित द्वारा: हर बार जब हम गणना की गई φ को रोबोट की दिशा के कोण पर जोड़ते हैं, और एक दूरी से वर्तमान निर्देशांक को स्थानांतरित करते हैं | एबी | व्यावहारिक सवाल रहता है: ऐसी स्थिति अपडेट को कितनी बार करना है? यदि बहुत बार, हम असतत "टिक्स" के साथ माइलेज को मापने वाले व्हील सेंसर की अशुद्धि में चले जाते हैं। यदि बहुत दुर्लभ है, तो एक सर्कल के आर्क द्वारा एक पथ खंड का अनुमान काफी सटीक नहीं होगा।

मैंने तय किया कि "टिक" के समय व्हील सेंसर रीडिंग सीधे सबसे सटीक होती है, इसलिए मैं किसी भी व्हील के प्रत्येक टिक के लिए रोबोट की स्थिति का पुनरावर्तक करता हूं - लेकिन रोबोट के सर्वेक्षण के समय से अधिक नहीं, 80ms के आसपास कहीं भी रिकॉर्ड किया गया; और कम से कम एक बार दूसरा ताकि एक रूका हुआ पहिया (उदाहरण के लिए, जब मोड़) भी दर्ज हो। सभी पंजीकृत "टिक्स" सूची में सहेजे जाते हैं, क्योंकि उस स्थिति को पुनर्गणना करने के लिए मुझे उसी समय के लिए दोनों पहियों को चलाने की आवश्यकता है। हम दोनों पहियों के साथ पिछले "टिक्स" के पहले से अंतराल लेते हैं, और "टिक्स की सूची" के अनुसार उसी क्षण दूसरे पहिया के माइलेज को रैखिक रूप से प्रक्षेपित करते हैं। अंतराल के अंत के लिए - उसी तरह, टिक वाले पहिये के लिए सेंसर द्वारा पढ़ा गया माइलेज लें और दूसरे के माइलेज को रैखिक रूप से एक्सट्रपलेट करें। इस प्रकार, सटीकता यथासंभव संभव होनी चाहिए।

हर बार जब रोबोट की स्थिति पुनर्गणना होती है, तो अपने पूर्व निर्धारित लक्ष्य के लिए रोबोट को निर्देशित करने के लिए पहिया गति को एक नए तरीके से सेट करना आवश्यक होता है। यह रोबोट को वांछित "अजिमुथ" के लिए निर्देशित करने के लिए अवास्तविक है, जगह में घूमता है: mentioned 7 मिमी का उल्लिखित पहिया माइलेज त्रुटि रोबोट को घुमाए जाने पर कई डिग्री की त्रुटि में बदल जाती है, अर्थात्। रोबोट जानबूझकर "बेतरतीब ढंग से" जाएगा और इसे सड़क के साथ फिर से चालू करना होगा। इसलिए, यदि लक्ष्य की दिशा वर्तमान एक से बहुत अधिक नहीं है, तो मैंने प्रारंभिक "असर पर लक्ष्य" के बिना, आर्क के साथ लक्ष्य की ओर रोबोट को निर्देशित करने का निर्णय लिया। (यदि वर्तमान दिशा more / 2 से वांछित एक से अधिक है, तो ऐसा चाप अर्धवृत्त से बड़ा होगा, जो स्पष्ट रूप से अव्यावहारिक है। इस मामले में, रोबोट के पास सही दिशा में घूमने के अलावा कोई विकल्प नहीं है।

चाप की गणना करने के लिए, ऊपर दिए गए ड्राइंग पर लौटते हैं। अब हम ए और बी अंक जानते हैं, और इसलिए कोण A ; आपको अनुपात ₂ एस / एस ₁ = आर ₂ / आर ₁ खोजने की आवश्यकता है: यह हमारे चाप के लिए आवश्यक पहिया गति के अनुपात को निर्धारित करेगा। हम विपरीत दिशा में उपरोक्त गणना दोहराते हैं:
| एबी | = 2 | एएम | = 2 ( आर ₁ + डब्ल्यू / 2) पाप (+ / 2)
आर ₁ = | एबी | / (2sin ( φ / 2)) - w / 2
आर ₂ = | एबी | / (2sin ( φ / 2)) + w / 2
r ₂ / r ₁ = 1 + w / (| AB | / (2sin (r / 2)) - w / 2) = 1 + 2 / ((! AB) | ( w · sin ( φ / 2)) - 1 )

इस तरह का एक आर्क हमें लाइन एबी से कितना दूर ले जाएगा? यदि एक रोबोट को चाप को पूरा करने के लिए पक्षों पर दो मीटर खाली जगह की आवश्यकता होती है, तो हमारे गोदाम में बस ऐसा अवसर नहीं होता है: अलमारियों के बीच गलियारे की चौड़ाई केवल डेढ़ मीटर है।

दूरी की गणना करें | म्ह | चाप और रेखा के बीच: | ओह | - | ओम | = r - r cos ( φ / 2) = ( r ₁ + w / 2) (1 - cos ( φ / 2))

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

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

कार्यान्वयन

मैं ReferencePlatform2011 डिलीवरी से MarkRobot सेवा में नई कार्यक्षमता जोड़ने की योजना बना रहा था PositionOperations : PortSet<GetPosition, SetPosition, SetDestination> की भावना में एक नया पोर्टलेट लागू करें PositionOperations : PortSet<GetPosition, SetPosition, SetDestination> , और ताकि सेवा स्वयं, पारदर्शी रूप से उपयोगकर्ता के लिए, पोल सेंसर और मोटर्स पर वोल्टेज सेट करें। वास्तव में, यह इस कार्यान्वयन के लिए नहीं आया था - सेवाओं के बीच जिम्मेदारियों को अलग किए बिना केवल एक मैला प्रोटोटाइप तैयार था। मैं, हालांकि, यह दिखाने की कोशिश करूंगा कि मैंने क्या किया।

पहले आपको निर्देशांक के साथ काम करने के लिए कुछ चाहिए: उन्हें संग्रहीत करने के लिए System.Drawing.PointF में नहीं।

 public struct Position { public readonly double x, y, heading; public Position(double x, double y, double heading) { this.x = x; this.y = y; this.heading = heading; } private static double Sqr(double d) { return d * d; } public double DistanceTo(double x, double y) { return Math.Sqrt(Sqr(this.y - y) + Sqr(this.x - x)); } public static double NormalizeHeading(double heading) { while (heading < -Math.PI) heading += 2 * Math.PI; while (heading > Math.PI) heading -= 2 * Math.PI; return heading; } // turn angle/2, go ahead distance, turn angle/2 again public Position advance(double distance, double angle) { double newHeading = heading + angle / 2, newX = x + distance * Math.Cos(newHeading), newY = y + distance * Math.Sin(newHeading); return new Position(newX, newY, NormalizeHeading(heading + angle)); } }

advance विधि रोटेशन के दिए गए कोण के लिए निर्देशांक के पुनर्गणना को लागू करती है ments और दूरी की यात्रा | एबी |, जैसा कि लेख के बीच में ड्राइंग में है।

(अभी-अभी, यहां कोड की प्रतिलिपि बनाते हुए, मैंने देखा कि मुझे वास्तव में "डबल कोण सूत्र" मिला है, और इसके बजाय इसके द्वारा। AB | कोण, / 2 पर, कोण _{1 1 पर} r ₁ + w / 2 द्वारा स्थानांतरित करना संभव था। ओह अच्छा।)

इसके अलावा, सेवा में EncoderLog का एक उदाहरण है, जिसके अंदर EncoderLog दो उदाहरण हैं - एक " EncoderLog सूची", प्रत्येक पहिया के लिए एक अलग उदाहरण। सूची को SortedList में SortedList किया SortedList है, क्योंकि (सैद्धांतिक रूप से) सेंसर डेटा कालानुक्रमिक क्रम में नहीं आ सकता है। EncoderLog में एकमात्र गैर-तुच्छ विधि "टिक" के बीच या अंतिम "टिक" के बाद किसी भी समय अपना मूल्य प्राप्त करने के लिए पथ का एक रैखिक सन्निकटन है।

 private class PositionKeeping { private static readonly DateTime initialized = DateTime.Now; public class EncoderLog { private SortedList<DateTime, double> log = new SortedList<DateTime, double> { { initialized, 0 } }; public void Register(DateTime at, double reading) { log[at] = reading; } public void Reset(DateTime at, double reading) { log.Clear(); log.Add(at, reading); } public DateTime LastTick { get { return log.Last().Key; } } public double LastReading { get { return log.Last().Value; }} public double ReadingAt(DateTime at) { int index = log.Count - 1; while(index>=0 && log.Keys[index] > at) index--; if(index<0) return double.NaN; // before first reading; impossible // now, log.Keys[index] <= at, and log.Keys[index+1] > at DateTime preceding = log.Keys[index], following = index<log.Count-1 ? log.Keys[index+1] : DateTime.MaxValue; if(following == DateTime.MaxValue) { // last reading precedes at; extrapolate if(index==0) // there's only one reading return log[preceding]; else { DateTime nextPreceding = log.Keys[index-1]; return log[nextPreceding] + (at-nextPreceding).TotalSeconds * (log[preceding]-log[nextPreceding]) / (preceding-nextPreceding).TotalSeconds; } } else // both readings are available; interpolate return log[preceding] + (at-preceding).TotalSeconds * (log[following]-log[preceding]) / (following - preceding).TotalSeconds; } } public EncoderLog leftEnc = new EncoderLog(), rightEnc = new EncoderLog();

"टिक सूचियों" के अलावा, प्रत्येक "टिक" के समय पदों की एक सूची को पोज़िशनकिपिंग में संग्रहीत किया जाना चाहिए - इस सहेजे गए स्थान से हम एक नई स्थिति प्राप्त करने के लिए यात्रा की दूरी को मापेंगे।

  private SortedList<DateTime, Position> position = new SortedList<DateTime, Position> { { initialized, new Position(0, 0, Math.PI / 2) } }; public void Register(DateTime at, Position pos) { position.Add(at, pos); } public void Reset(DateTime at, Position pos) { // the position has changed => old ticks logs become obsolete leftEnc.Reset(at, leftEnc.ReadingAt(at)); rightEnc.Reset(at, rightEnc.ReadingAt(at)); position.Clear(); position.Add(at, pos); } public Position Current { get { return position.Last().Value; } }

यह दोनों पहिया सेंसरों के आंकड़ों के अनुसार नई स्थिति की गणना करके PositionKeeping क्लास को पूरक करने के लिए बनी हुई है - व्युत्पन्न सूत्रों के अनुसार। Update को सेंसर चेक चक्र ( ServiceHandlerBehavior.Concurrent ) से कॉल किया जा सकता है, और सर्विस पोर्ट को एक तर्क के रूप में लेता है, जहां यह एक टिक पंजीकृत होने पर नए निर्देश भेजता है। यह संदेश सेवा की स्थिति को बदलता है, इसलिए इसे ServiceHandlerBehavior.Exclusive रूप में माना जाना चाहिए।

  private static readonly TimeSpan RegisterDelay = TimeSpan.FromSeconds(1); // register null-tick if no actual ticks for this long public void Update(DateTime at, double left, double right, PositionOperations mainPort) { DateTime prevRef = Min(leftEnc.LastTick, rightEnc.LastTick); SetPosition set = new SetPosition { Timestamp = at, LeftEncUpdated = left != leftEnc.LastReading || at > leftEnc.LastTick + RegisterDelay, LeftEncReading = left, RightEncUpdated = right != rightEnc.LastReading || at > rightEnc.LastTick + RegisterDelay, RightEncReading = right }; if(set.LeftEncUpdated || set.RightEncUpdated) { set.Position = Recalculate(prevRef, left, right); mainPort.Post(set); } } private Position Recalculate(DateTime prevRef, double left, double right) { double sLeft = left - leftEnc.ReadingAt(prevRef), sRight = right - rightEnc.ReadingAt(prevRef); Position refPos = position[prevRef]; // has to exist if the encoder reference exists if (Math.Abs(sRight - sLeft) < .5) // less then half-tick difference: go straight return refPos.advance(Constants.CmPerTick * (sRight + sLeft) / 2, 0); else { double angle = Constants.CmPerTick * (sRight - sLeft) / Constants.WheelsDist, distance = Constants.WheelsDist * Math.Sin(angle / 2) * (sRight + sLeft) / (sRight - sLeft); return refPos.advance(distance, angle); } } }

वह सब जो ब्याज की कोड में रहता है वह SetPosition हैंडलर है, जो मोटरों पर वोल्टेज सेट करता है ताकि रोबोट लक्ष्य की ओर SetPosition ।

 [ServiceHandler(ServiceHandlerBehavior.Exclusive)] public void SetPositionHandler(SetPosition set) { if (!set.LeftEncUpdated && !set.RightEncUpdated) { // position updated by an absolute reference. positionKeeping.Reset(set.Timestamp, set.Position); } else { if (set.LeftEncUpdated) positionKeeping.leftEnc.Register(set.Timestamp, set.LeftEncReading); if (set.RightEncUpdated) positionKeeping.rightEnc.Register(set.Timestamp, set.RightEncReading); positionKeeping.Register(set.Timestamp, set.Position); } // the navigator Destination dest = state.dest; double distance = set.Position.DistanceTo(dest.x, dest.y); if (distance < 5) // reached { drivePort.SetDrivePower(0, 0); SendNotification(submgrPort, new DriveDistance()); return; } double heading = Position.NormalizeHeading(Math.Atan2(dest.y - set.Position.y, dest.x - set.Position.x)), power = (distance < 50) ? .2 : .4; // a few magic numbers if (Math.Abs(heading) < .05) { // straight ahead drivePort.SetDrivePower(power, power); return; } double r = distance / (2 * Math.Sin(heading / 2)), hump = r * (1 - Math.Cos(heading / 2)); if (Math.Abs(heading) > Math.PI / 2 || Math.Abs(hump) > Constants.MaxHump) { // not reachable by an arc; rotate if (heading > 0) // rotate left drivePort.SetDrivePower(-.3, .3); else // rotate right drivePort.SetDrivePower(.3, -.3); } else { // go in arc double rLeft = Math.Abs(r - Constants.WheelsDist / 2), rRight = Math.Abs(r + Constants.WheelsDist / 2), rMax = Math.Max(rLeft, rRight); // <Patrician|Away> what does your robot do, sam // <bovril> it collects data about the surrounding environment, then discards it and drives into walls drivePort.SetDrivePower(power * Math.Pow(rLeft / rMax, 9), power * Math.Pow(rRight / rMax, 9)); } }

आगे क्या है?

इस रोबोट ने बहुत अच्छी तरह से चलाई, लेकिन समस्या संचित त्रुटि के कारण उत्पन्न हुई। निर्देशांक को सही करने के लिए, कम से कम 20% बारकोड को सफलतापूर्वक पढ़ने के लिए पर्याप्त था, और LeftEncUpdated = RightEncUpdated = false साथ LeftEncUpdated = RightEncUpdated = false PositionKeeping कॉल PositionKeeping "पुनः आरंभ" PositionKeeping फिर से शुरू करना। पढ़े गए बारकोड के बीच कुछ मीटर के लिए, निर्देशांक निर्धारित करने में त्रुटि 20 सेमी से अधिक नहीं थी - हमने बस रोबोट और अलमारियों के बीच इतना कुछ छोड़ दिया।

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

जाइरोस्कोप और अन्य विदेशी सेंसर के बिना दिशा का सुधार, मैं निम्नलिखित लेख को समर्पित करने जा रहा हूं।

रोबोट लोडर परियोजना: अपना स्थान का पता लगाना

प्रागितिहास

कार्य

गणना

कार्यान्वयन

आगे क्या है?

More articles: