🛌🏾 🗻 🤬 आरओएस और न्यूरल ग्रिड भिखारी रोबोट 👩‍🚒 ↖️ 🖖🏻

आमतौर पर, ऐसे शिल्पों के लिए दो सवाल उठते हैं: "कैसे?" और किस लिए?" प्रकाशन स्वयं पहले प्रश्न के लिए समर्पित है, और मैं तुरंत दूसरे का उत्तर दूंगा:

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

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

रोबोट बेतरतीब ढंग से कमरे के चारों ओर घूमता है, और अगर यह किसी व्यक्ति को नोटिस करता है, तो यह इसे रोल करता है और छोटी चीजों के लिए जार को हिलाता है। मज़े के लिए, मैंने उसके साथ थोड़ी चेहरे की अभिव्यक्ति को जोड़ा - वह जानता है कि उसकी भौहें कैसे हिलानी हैं:

पहले प्रयास के बाद, रोबोट अपना चेहरा फिर से देखने की कोशिश करता है, व्यक्ति की ओर मुड़ता है और बैंक को फिर से हिलाता है। लेकिन अगर आप इस पल को छोड़ दें तो क्या होता है:

रोबोट

मैंने मैगजीन पॉपुलर मैकेनिक्स से एक भीख मांगने वाले रोबोट का विचार लिया । गिममे नामक क्रिस एकर्ट के प्रोटोटाइप ऑथरशिप बहुत ही सौंदर्यवादी रूप से मनभावन लगते हैं।

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

रोबोट का आधार रास्पबेरी पाई 2 बी है , और कोड सी ++ में लिखा गया है और गिटहब पर स्थित है ।

विजन

वास्तविकता को समझने के लिए, रोबोट Paspberry Pi Camera Module v2 कैमरा का उपयोग करता है , जिसे RaspiCam लाइब्रेरी का उपयोग करके नियंत्रित किया जा सकता है ।

फेस डिटेक्शन के लिए, मैंने कई अलग-अलग तरीकों की कोशिश की। OpenCV से क्लासिक डिटेक्टरों की गुणवत्ता ने मुझे संतुष्ट नहीं किया, इसलिए अंत में मैं एक गैर-मानक समाधान के रूप में आया। नियंत्रण फ्रेम OpenVino के तहत डिवाइस Movidius न्यूरल कंप्यूट स्टिक (NCS) पर चल रहे तंत्रिका नेटवर्क में लगे व्यक्तियों का पता लगाना ।

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

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

डिटेक्टर की भविष्यवाणियों को प्राप्त करने के लिए छवि को एनसीएस पर अपलोड करने से पहले, छवि को प्रीप्रोसेस किया जाना चाहिए। मेरी पसंद का डिटेक्टर रंग छवियों के साथ काम करता है

300 \times 300

$300 \times 300$ , इसलिए छवि को पहले संकुचित करने की आवश्यकता है। ऐसा करने के लिए, मैं सबसे हल्की स्केलिंग एल्गोरिथ्म का उपयोग करता हूं - निकटतम पड़ोसी विधि (ओपनसीवी लाइब्रेरी में INTER_NEAREST)। यह प्रक्षेप विधियों की तुलना में थोड़ा तेज काम करता है, और लगभग परिणाम को प्रभावित नहीं करता है। यह छवि चैनलों के आदेश पर भी ध्यान देने योग्य है: डिटेक्टर बीजीआर के आदेश की उम्मीद करता है, इसलिए आपको कैमरे के लिए समान सेट करने की आवश्यकता है।

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

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

इसलिए, मैंने कलमन फ़िल्टर को बंद कर दिया, जिससे केवल चेहरे का मिलान एल्गोरिदम और फ़्रेमों की अनुक्रमिक संख्या का काउंटर मिला, जिस पर चेहरे का पता लगाया गया था - इस तरह मुझे डिटेक्टर की झूठी सकारात्मकता से छुटकारा मिलता है।

ऊपरी मंच, बाएं से दाएं: कैमरा, सिर और भौंहों को नियंत्रित करने के लिए सर्वो, स्विच, पावर टर्मिनल, बिग रेड बटन।

यातायात

आंदोलन के लिए, रोबोट में पांच सर्वोस होते हैं: दो FS5103R निरंतर-घूर्णन सर्वो पहियों को स्पिन करते हैं; दो और सामान्य FS5109Ms हैं, जिनमें से एक सिर को घुमाता है, और दूसरा कैन को हिलाता है; अंत में, थोड़ा SG90 अपनी भौहें ले जाता है।

ईमानदार होने के लिए, SG90 मिनी-सर्वोस मुझे लगता है जैसे - मेरे एक सर्वोस में गलत नियंत्रण पल्स चौड़ाई थी, और अन्य चार में से केवल एक बच गया। निष्पक्षता में, मैंने गलती से नौकरों में से एक को अपनी कोहनी के साथ ले लिया, लेकिन अन्य दो बस भार को सहन नहीं कर सके (मैं उन्हें सिर और कैन के लिए उपयोग करता था)। यहां तक कि अंतिम सर्वो, जिसे सबसे सरल काम मिला - भौहें हिलाना, समय-समय पर एक छड़ी को प्रहार करना पड़ता है ताकि यह जाग न जाए। अन्य सर्वोस के साथ, मैंने किसी भी समस्या पर ध्यान नहीं दिया। सच है, निरंतर रोटेशन सर्वोस को कभी-कभी कैलिब्रेट करना पड़ता है ताकि वे निष्क्रिय अवस्था में स्पिन न करें - इसके लिए उन पर एक छोटा नियामक होता है जिसे घड़ी-हेड पेचकश के साथ बदल दिया जा सकता है।

रास्पबेरी के साथ सर्वो का प्रबंधन, यह पता चला है, इतना आसान नहीं है। सबसे पहले, वे द्वारा नियंत्रित होते हैंपल्स-चौड़ाई मॉड्यूलेशन (पीडब्लूएम / पीडब्लूएम) , और रास्पबेरी पर केवल दो पिन हैं जिन पर पीडब्लूएम हार्डवेयर द्वारा समर्थित है । दूसरे, निश्चित रूप से, रास्पबेरी सर्वो को शक्ति देने में सक्षम नहीं होगी, यह इस पर खड़ा नहीं होगा। सौभाग्य से, बाहरी PWM नियंत्रक का उपयोग करके इन समस्याओं को हल किया जाता है।

Adafruit PCA9685 एक 16-चैनल PWM नियंत्रक है जिसे I2C इंटरफ़ेस के माध्यम से नियंत्रित किया जा सकता है । यह भी बहुत सुविधाजनक है कि इसमें सर्वो के लिए बिजली की आपूर्ति के लिए टर्मिनल हैं। इसके अलावा, [सैद्धांतिक रूप से] यह 62 नियंत्रकों तक श्रृंखला संभव है, जबकि 992 नियंत्रण पिन तक प्राप्त होता है - इसके लिए आपको विशेष जंपर्स का उपयोग करके प्रत्येक नियंत्रक को एक अनूठा पता निर्दिष्ट करने की आवश्यकता होती है। इसलिए यदि आपको अचानक सर्वोस की एक सेना की आवश्यकता है - आप जानते हैं कि क्या करना है।

PCA9685 को नियंत्रित करने के लिए, एक उच्च-स्तरीय पुस्तकालय है जो एक WiringPi एक्सटेंशन के रूप में कार्य करता है। इस चीज़ के साथ काम करना काफी सुविधाजनक है - आरंभीकरण के दौरान, यह 16 वर्चुअल पिन बनाता है जिसमें आप एक PWM सिग्नल लिख सकते हैं, लेकिन सबसे पहले आपको टिक की संख्या की गणना करना होगा। रेंज [0, 180] में एक निश्चित कोण पर सर्वो लीवर को चालू करने के लिए, आपको पहले इस कोण को मिलीसेकेंड [SERVO_MS_MIN, SERVO_MS_MAX] में नियंत्रण पल्स लंबाई की सीमा में अनुवाद करना होगा। मेरे सभी सर्वोस के लिए, ये मूल्य क्रमशः 0.6 एमएस और 2.4 एमएस हैं। सामान्य तौर पर, इन मूल्यों को सर्वो डेटाशीट में पाया जा सकता है, लेकिन अभ्यास से पता चला है कि वे अलग-अलग हो सकते हैं, इसलिए उन्हें चयनित करने की आवश्यकता हो सकती है। फिर परिणामी मान को 20 ms (नियंत्रण चक्र की लंबाई का मानक मूल्य) से विभाजित करें और टिकों की अधिकतम संख्या PCA9685 (4096) से गुणा करें:

void driveDegs(float angle, int pin) {
    int ticks = (int) (PCA_MAX_PWM * (angle/180.0f*(SERVO_MS_MAX-SERVO_MS_MIN) + SERVO_MS_MIN) / 20.0f); 
    pwmWrite(pin, ticks);
}

इसी तरह, यह निरंतर रोटेशन सर्वोस के साथ किया जाता है - एक कोण के बजाय, हम सीमा में गति सेट करते हैं [-1,1]।

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

अब आप इसके बारे में क्या कर सकते हैं। सबसे पहले, आप जार को हिला सकते हैं और आइब्रो को हिला सकते हैं - इसके लिए आपको बस पूर्व-चयनित कोणों के लिए सर्वो लीवर को चालू करने की आवश्यकता है।

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

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

अंत में, आप सिर और चेसिस को एक साथ घुमा सकते हैं और अतुल्यकालिक रूप से ताकि समय बर्बाद न करें। मैं इसे इस तरह से करता हूं:

auto waitRotation = std::async(std::launch::async, rotatePlatform, platformAngle);
success = driveHead(headAngle);
waitRotation.wait();

केंद्रीय मंच, बाएं से दाएं: PCA9685, पावर बस, रास्पबेरी पाई, MCP3008 ADC

पथ प्रदर्शन

तब मैंने कुछ भी जटिल नहीं किया था, इसलिए रोबोट नेविगेशन के लिए केवल दो तीव्र GP2Y0A02YK अवरक्त रेंज खोजक का उपयोग करता है। यह भी इतना सरल नहीं है, क्योंकि सेंसर एनालॉग हैं, लेकिन Arduino के विपरीत, रास्पबेरी में कोई एनालॉग इनपुट नहीं है। यह समस्या एनालॉग-टू-डिजिटल कनवर्टर (ADC / ADC) द्वारा हल की गई है - मैं 10-बिट, 8-चैनल MCP3008 का उपयोग करता हूं। इसे एक अलग माइक्रोक्रिसिट के रूप में बेचा जाता है, इसलिए इसे एक मुद्रित सर्किट बोर्ड में मिलाप करना पड़ता था और इसे जोड़ने के लिए अधिक सुविधाजनक बनाने के लिए पिन भी मिलाप किए जाते थे। इसके अलावा, मेरी बाटी की सलाह पर, जो सर्किटरी में अधिक लड़खड़ाती है, मैंने पूरे सर्किट के डिजिटल हिस्से से शोर को अवशोषित करने के लिए बिजली की आपूर्ति के पैरों और जमीन के बीच दो कैपेसिटर (सिरेमिक और इलेक्ट्रोलाइटिक) को मिलाया। सेंसर आउटपुट में तीन वोल्ट से अधिक नहीं है, इसलिए रास्पबेरी के साथ 3.3v को संदर्भ ADC वोल्टेज (VREF) - MCP3008 (VDD) बिजली की आपूर्ति के रूप में जोड़ा जा सकता है।

MCP3008 को SPI इंटरफ़ेस के माध्यम से नियंत्रित किया जा सकता है , और इसके लिए गिटहब पर तैयार कोड खोजना आसान है ।

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

unsigned int analogRead(mcp3008Spi &adc, unsigned char channel)
{
    unsigned char spi_data[3];
    unsigned int val = 0;

    spi_data[0] = 1;  // start bit
    spi_data[1] = 0b10000000 | ( channel << 4); // mode and channel
    spi_data[2] = 0; // anything
    adc.spiWriteRead(spi_data, sizeof(spi_data));
  
    // read value, combine last two bits of second byte with whole third byte
    val = (spi_data[1]<< 8) & 0b1100000000; 
    val |= (spi_data[2] & 0xff);
    return val;
}

तीन बाइट्स को MCP3008 को भेजा जाना चाहिए, जहां पहली बिट में बाइट लिखा है, और दूसरे में मोड और चैनल नंबर (4-7)। हमें तीन बाइट्स भी मिलते हैं, जिसके बाद हमें तीसरे बाइट के साथ दूसरे बाइट के दो सबसे महत्वपूर्ण बिट्स को गोंद करना होगा।

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

सेंसर रीडिंग काफी शोर हो सकती है, विशेष रूप से मुश्किल बाधाओं पर, इसलिए मैं प्रत्येक सेंसर से सिग्नल को सुचारू करने के लिए एक घातीय भारित चलती औसत (EWMA) का उपयोग करता हूं। मैंने आंख द्वारा चौरसाई मापदंडों का चयन किया, ताकि संकेत शोर न करें और वास्तविकता से बहुत पीछे न रहें।

सामने का दृश्य: बैंक, रेंजफाइंडर और बम्पर।

पोषण

सबसे पहले, आइए मूल्यांकन करें कि रोबोट किस वर्तमान में खपत करेगा ( रास्पबेरी और बाह्य उपकरणों की वर्तमान खपत के बारे में ):

रास्पबेरी पाई 2 बी: 350 एमए से कम नहीं, लेकिन लोड के तहत अधिक (750-820 एमए (?) तक);
कैमरा: लगभग 250 mA;
तंत्रिका कम्प्यूट स्टिक: यूएसबी पर 5 वोल्ट के वोल्टेज पर 1 वाट की बिजली की खपत की घोषणा की, यह 200 एमए है;
आईआर सेंसर: 33 एमए प्रत्येक ( डेटाशीट, पीडीएफ );
MCP3008: , 0.5 (, pdf);
PCA9685: , 6 (, pdf);
: ~150-200 1500-2000 (stall current), ( FS5109M, pdf)
HDMI ( ): 50 ;
+ ( ): ~200 .

कुल मिलाकर, यह अनुमान लगाया जा सकता है कि 1.5-2.5 एम्पीयर पर्याप्त होना चाहिए, बशर्ते कि सभी सर्वो एक साथ भारी भार के तहत एक साथ न चलें। उसी समय, रास्पबेरी को सशर्त 5 वोल्ट के वोल्टेज की आवश्यकता होती है, और सर्वो के लिए - 4.8-6 वोल्ट। यह एक शक्ति स्रोत खोजने के लिए बना हुआ है जो इन आवश्यकताओं को पूरा करता है।

नतीजतन, मैंने 18650 बैटरी से रोबोट को बिजली देने का फैसला किया। यदि आप दो रॉबिटन 3.4 / Li18650 बैटरी (3.6 वोल्ट, 3400 एमएएच, अधिकतम निर्वहन वर्तमान 4875 एमए) लेते हैं और उन्हें श्रृंखला में जोड़ते हैं, तो वे 7.2 वोल्ट के वोल्टेज पर 4.8 एम्पीयर तक का उत्पादन कर सकते हैं। 1.5-2.5 एम्पीयर की खपत के साथ, वे एक या दो घंटे के लिए पर्याप्त होना चाहिए।

बैटरियां, वैसे, एक पकड़ है: संकेतित रूप कारक 18650 के बावजूद, उनके आकार से बहुत दूर हैं

18 \times 650

$18 \times 650$ मिमी - बिल्ट-इन चार्ज कंट्रोल सर्किट के कारण वे कई मिलीमीटर लंबे होते हैं। इस वजह से, मुझे बैटरी के डिब्बे को चाकू से मारना पड़ा, ताकि वे वहां फिट हो जाएं।

यह केवल वोल्टेज को 5 वोल्ट तक कम करने के लिए रहता है। इसके लिए, मैं दो अलग-अलग चरण-डाउन DC-DC कन्वर्टर्स DFRobot Power Module का उपयोग करता हूं। लोहे का यह टुकड़ा आपको 3.6-25 वोल्ट के इनपुट वोल्टेज और कम से कम 0.6 वोल्ट के वोल्टेज अंतर पर वोल्टेज कम करने की अनुमति देता है। सुविधा के लिए, इसमें एक स्विच है जो आपको आउटपुट पर बिल्कुल 5 वोल्ट का चयन करने की अनुमति देता है, या आप एक विशेष नियामक का उपयोग करके एक मनमाना आउटपुट वोल्टेज कॉन्फ़िगर कर सकते हैं। मैंने दोनों कन्वर्टर्स को 5 वोल्ट में सेट किया है; उनमें से एक माइक्रो-यूएसबी कनेक्टर के माध्यम से रास्पबेरी खिलाता है, और दूसरा पीसीए 9685 टर्मिनलों के माध्यम से सर्वो को खिलाता है। रोबोट के तार्किक और बिजली भागों की बिजली की आपूर्ति को अधिकतम करने के लिए यह आवश्यक है ताकि वे एक-दूसरे के साथ हस्तक्षेप न करें।

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

सुविधा के लिए, मुझे एक "पावर बस" भी बनाना था - वास्तव में, जमीन के लिए तीन पंक्तियों की तीन पंक्तियों के साथ बोर्ड का एक टुकड़ा, क्रमशः 3.3v और 5v। बस संबंधित रास्पबेरी पिन से जुड़ती है। केवल IR रेंजफाइंडर 5v बस से संचालित किए जाते हैं, और 3.3v बस से MCP3008 और PCA9685।

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

निचला प्लेटफ़ॉर्म, बाएं से दाएं: बैटरी कम्पार्टमेंट, एनसीएस, डीसी-डीसी कन्वर्टर्स, सर्वो ड्राइव्स विथ व्हील, रेंजफाइंडर।

रोबोट नियंत्रण

रास्पबेरी पाई 2 बी पर कोई वाई-फाई नहीं है, इसलिए मुझे एक ईथरनेट केबल के माध्यम से ssh से कनेक्ट करना होगा (वैसे, यह सीधे राउटर का उपयोग किए बिना, लैपटॉप से किया जा सकता है )। यह इस योजना का पता लगाता है: हम केबल के माध्यम से ssh से जुड़ते हैं, रोबोट शुरू करते हैं और केबल को खींचते हैं। फिर इसे रास्पबेरी तक फिर से पहुंचने के लिए इसकी जगह पर लौटाया जा सकता है। और अधिक सुरुचिपूर्ण समाधान हैं, लेकिन मैंने निर्णय लिया कि इसे जटिल न बनाया जाए।

ताकि रोबोट को आसानी से बंद किए बिना रोका जा सके, मैंने एक बड़े पैमाने पर सोवियत स्विच (एक पनडुब्बी से?) को इसमें जोड़ा, जब आप इसे बंद करते हैं, तो कार्यक्रम समाप्त होता है और रोबोट बंद हो जाता है।

स्विच जमीन पर और रास्पबेरी GPIO पिन में से एक से जोड़ता है, और आप इसे WiringBookii का उपयोग करके पढ़ सकते हैं :

wiringPiSetup();
pinMode(PIN_SWITCH, INPUT);
pullUpDnControl(PIN_SWITCH, PUD_UP);
bool value = digitalRead(BB_PIN_SWITCH);

यह ध्यान देने योग्य है कि इस कनेक्शन के साथ, पिन पर वोल्टेज 3.3v तक खींचा जाना चाहिए, और साथ ही यह खुले राज्य में एक उच्च सिग्नल और बंद राज्य में एक कम सिग्नल का उत्पादन करेगा।

यह सब एक साथ डालें

थ्रेड्स

अब उपरोक्त सभी को एक कार्यक्रम में जोड़ा जाना चाहिए जो रोबोट को नियंत्रित करता है। रोबोट के पहले संस्करण में, मैंने थ्रेड्स ( pthread ) का उपयोग करके ऐसा किया । यह संस्करण मास्टर शाखा में है , लेकिन कोड बहुत डरावना है।

कार्यक्रम चार थ्रेड्स में काम करता है: एक धागा कैमरे से फ्रेम लेता है और एनसीएस पर डिटेक्टर शुरू करता है; दूसरी धारा रेंजफाइंडर के डेटा को पढ़ती है; तीसरा धागा स्विच की निगरानी करता है और वैश्विक चर is_runningको सेट करता हैfalseअगर यह बंद है; मुख्य धागा रोबोट व्यवहार और सर्वो नियंत्रण के लिए जिम्मेदार है। धागे में मुख्य धागे के साथ सामान्य रूप से संकेत होते हैं, जिसके द्वारा वे अपने काम के परिणाम लिखते हैं। मैंने वैक्टर को सीमित किया है जो डिटेक्टर द्वारा पाए जाने वाले चेहरों की जानकारी को म्यूटेक्स तक सीमित करता है, और दूसरे, सरल सामान्य चर को परमाणु घोषित करता है। मुख्य थ्रेड के साथ फेस डिटेक्टर के प्रवाह को समन्वयित करने के लिए, एक ध्वज face_processedहोता है जो कि डिटेक्टर से एक नया परिणाम आने पर रीसेट हो जाता है, और उठाया जाता है जब मुख्य थ्रेड इस परिणाम का उपयोग एक व्यवहार का चयन करने के लिए करता है - यह आवश्यक है ताकि पुराने डेटा को संसाधित न किया जाए जो प्रासंगिक नहीं हो सकता है। हिलने के बाद। धाराओं के साथ

आरओएस

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

ROS अवधारणा

ROS (Robot Operating System) — , , , .

, , , (node), , , .

(topic) (message) , - .

— (service). , , . « », .

.msg .srv . .

ROS .

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

सबसे सरल नोड switch_node,, स्विच की स्थिति की निगरानी करता है। जैसे ही स्विच बंद होता है, नोड boolविषय में टाइप के अनइनफॉर्मेटिव संदेशों को स्पैम करना शुरू कर देता है terminator। यह मुख्य नोड का संकेत है कि यह काम पूरा करने का समय है।

दूसरा नोड, sensor_nodeसमय-समय पर दोनों आईआर रेंजफाइंडर की रीडिंग पढ़ता है और उन्हें sensor_stateएक संदेश में विषय पर भेजता है । इसके अलावा, यह नोड सिग्नल प्रोसेसिंग के लिए जिम्मेदार है: अंशांकन कारकों और स्केलिंग औसत से स्केलिंग।

तीसरा गाँठcamera_nodeवह चेहरों से जुड़ी हर चीज के लिए जिम्मेदार है: वह कैमरे से चित्र लेता है, उन्हें संसाधित करता है, डिटेक्टर के परिणाम प्राप्त करता है, उन्हें ट्रैकर से गुजरता है, और फिर चेहरे को फ्रेम के केंद्र के सबसे करीब पाता है - रोबोट वैसे भी बाकी का उपयोग नहीं करता है, लेकिन छोटे संदेश बनाना चाहता है। संदेश जो नोड को विषय पर भेजता है, उसमें camera_stateफ़्रेम नंबर, एक चेहरा होने का तथ्य (क्योंकि आपको चेहरे की अनुपस्थिति के बारे में भी जानने की आवश्यकता होती है), ऊपरी बाएं कोने के सापेक्ष निर्देशांक, चेहरे की चौड़ाई और ऊंचाई। यह फ़ाइल में संदेश के प्रकार का वर्णन इस तरह दिखता है DetectionBox.msg:

int64 count
bool present
float32 x
float32 y
float32 width
float32 height

चौथा नोड ,, servo_nodeसर्वोस के लिए जिम्मेदार है। सबसे पहले, यह एक ऐसी सेवा का समर्थन करता है servo_actionजो इसकी संख्या के द्वारा सर्वो में से किसी एक क्रिया को करने की अनुमति देता है: पूरे नोड को अपनी प्रारंभिक स्थिति में रखना (भौहें, बैंक, सिर, चेसिस बंद करो); अपनी प्रारंभिक अवस्था में सिर को स्थानांतरित करें; जार को हिलाएं; एक भौं के साथ तीन भावों (अच्छे, तटस्थ, बुरे) में से एक को चित्रित करें। दूसरे, सेवा का उपयोग करके, servo_speedआप अनुरोध में भेजकर दोनों पहियों के लिए नई गति निर्धारित कर सकते हैं। दोनों सेवाएं कुछ भी वापस नहीं करती हैं। अंत में, एक ऐसी सेवा servo_head_platformहै जो आपको वर्तमान स्थिति के सापेक्ष सिर और / या चेसिस को एक निश्चित कोण को घुमाने की अनुमति देती है। यह सेवा trueकम से कम आंशिक रूप से, और सिर को चालू करने के लिए संभव होने पर वापस आती हैfalseअन्यथा, उस स्थिति में जब सिर पहले से ही अनुमेय कोण की सीमा पर है, और हम इसे और भी मोड़ने की कोशिश कर रहे हैं। यदि अनुरोध में दोनों कोण गैर-बीते हैं, तो सेवा एसिंक्रोनस रूप से घूमती है, जैसा कि ऊपर बताया गया है। मुख्य लूप में, सर्वो नोड कुछ नहीं करता है।

यहाँ, उदाहरण के लिए, सेवा का विवरण है servo_head_platform:

float32 head_delta
float32 platform_delta
---
bool head_success

सूचीबद्ध नोड्स में से प्रत्येक terminate_{switch, camera, sensor, servo}खाली प्रतिक्रिया अनुरोध के साथ एक सेवा का समर्थन करता है , जो नोड के संचालन को रोकता है। इसे इस तरह से लागू किया जाता है:

कुछ कोड

...
std::atomic_bool is_running; // global

bool terminate_node(std_srvs::Empty::Request &req, std_srvs::Empty::Response &ignored) {
    is_running = false;
    return true;
}

int main(int argc, char **argv) {
    is_running = true;
    ...
    while (is_running && ros::ok()) {
        // do stuff
    }
    ...
}

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

एक मुख्य नोड भी है beggar_botजिसमें रोबोट के मूल तर्क को लागू किया जाता है। मुख्य लूप की शुरुआत से पहले, यह विषयों की सदस्यता लेता है sensor_stateऔर camera_stateकॉलबैक फ़ंक्शन में वैश्विक चर में संदेशों की सामग्री को बचाता है। उन्हें विषय के लिए भी सदस्यता दी जाती है terminator, कॉलबैक जिसके लिए झंडा होता है is_running, मुख्य लूप को बाधित करता है। इसके अलावा, चक्र शुरू होने से पहले, नोड इमदादी नोड की सेवाओं के लिए इंटरफेस की घोषणा करता है और अन्य नोड्स के शुरू होने के लिए कुछ सेकंड इंतजार करता है। मुख्य लूप समाप्त होने के बाद, यह नोड सेवाओं को कॉल करता हैterminate_{switch, camera, sensor, servo}, इस प्रकार अन्य सभी नोड्स को बंद करना, और फिर इसे स्वयं बंद करना। यही है, जब स्विच बंद कर दिया जाता है, तो सभी पांच नोड ऑपरेशन को पूरा करते हैं।

आरओएस पर स्विच करने से मुझे कार्यक्रम की संरचना को काफी बदलने के लिए मजबूर होना पड़ा। उदाहरण के लिए, पहले एक उच्च आवृत्ति के साथ पहिया की गति को बदलना संभव था, और यह ठीक काम करता था, लेकिन आरओएस सेवा परिमाण के धीमे क्रम में काम करती है, इसलिए मुझे कोड को फिर से लिखना पड़ा, ताकि सेवा को तभी बुलाया जाए जब गति वास्तव में बदल जाती है ("आलसी मोड" में)।

ROS आपको रोबोट के सभी नोड्स को आसानी से चलाने की अनुमति देता है। ऐसा करने के लिए, आपको xml प्रारूप में रोबोट के सभी नोड्स और अन्य विशेषताओं को सूचीबद्ध करने के लिए एक .launch लॉन्च फ़ाइल लिखने की आवश्यकता है , और फिर कमांड चलाएं:

roslaunch beggar_bot robot.launch

ROS बनाम pthread

अब, अंत में, आप ROS संस्करण और pthread संस्करण की गति की तुलना कर सकते हैं। मैं इसे इस तरह से करता हूं: कैमरे के साथ काम करने के लिए जिम्मेदार थ्रेड / नोड अपने एफपीएस (सबसे धीमे तत्व के रूप में) को मानता है, बशर्ते कि बाकी सब भी काम करता हो। Pthread संस्करण के लिए, मुझे लगातार FPS 9.99 या तो, ROS संस्करण के लिए यह लगभग 8.3 निकला। वास्तव में, इस तरह के खिलौने के लिए यह काफी पर्याप्त है, लेकिन ओवरहेड काफी ध्यान देने योग्य है।

रोबोट व्यवहार

यह विचार काफी सरल है: यदि रोबोट किसी व्यक्ति को देखता है, तो उसे उसके पास ड्राइव करना चाहिए और कैन को हिला देना चाहिए। जार को हिलाना काफी सरल और मजेदार है, लेकिन पहले आपको व्यक्ति को प्राप्त करने की आवश्यकता है।

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

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

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

समारोहfollow_faceव्यक्ति की स्थिति लौटाता है। एक व्यक्ति: अनुपस्थित हो सकता है, केंद्र के करीब हो सकता है, रोबोट से बहुत दूर हो सकता है; एक अन्य विकल्प - जब हमने रोबोट को चालू किया और यह नहीं पता कि चेहरे का क्या हुआ (खोज प्रक्रिया में); अभी भी एक दुर्लभ मामला है जब सिर सीमा पर है, यही कारण है कि चेहरे की ओर मुड़ना असंभव है।

मुख्य लूप में एक साधारण बात होती है:

follow_faceजब तक व्यक्ति को एक निश्चित स्थिति (किसी भी, "खोज प्रक्रिया में" को छोड़कर) पर कॉल करें । इस चरण के अंत में, रोबोट सीधे चेहरे पर दिखेगा।
यदि चेहरा मिल गया है और यह करीब है:
1. कैन को हिलाएं;
2. फिर से चेहरा ढूंढो;
3. यदि चेहरा जगह में है, तो भौहों के साथ एक अच्छी अभिव्यक्ति करें और जार को फिर से हिलाएं;
4. यदि चेहरा गायब हो गया है, तो आइब्रो के साथ क्रोधी अभिव्यक्ति करें;
5. चारों ओर मुड़ें, चक्र की शुरुआत में जाएं।
यदि कोई व्यक्ति नहीं है (या यह बहुत दूर है) - कमरे के चारों ओर नेविगेशन:
1. यदि दोनों तरफ की बाधाओं से दूर हैं, तो आगे ड्राइव करें (यदि चेहरा मिल गया था, लेकिन बहुत दूर निकला, रोबोट व्यक्ति के पास जाएगा);
2. यदि बाधाएं दोनों तरफ हैं, तो सीमा में एक यादृच्छिक मोड़ बनाएं $[90, 180] \cup [-180, -90]$ ;
3. यदि बाधा केवल एक तरफ है, तो एक यादृच्छिक कोण पर विपरीत दिशा में मुड़ें $[0, 90]$ ;
4. यदि आगे की गति बहुत अधिक समय तक (संभवतः रुकी रही) जारी रहती है, तो थोड़ा पीछे खींचें और सीमा में एक यादृच्छिक मोड़ बनाएं $[90, 180] \cup [-180, -90]$ ;

यह एल्गोरिदम एक मजबूत कृत्रिम बुद्धि होने का दावा नहीं करता है, हालांकि, यादृच्छिक व्यवहार और एक विस्तृत बम्पर रोबोट को लगभग किसी भी स्थिति से जल्दी या बाद में बाहर निकलने की अनुमति देता है।

निष्कर्ष

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

एक बोनस के रूप में - गैलरी:

आरओएस और न्यूरल ग्रिड भिखारी रोबोट