अल्ट्रासोनिक रेंजफाइंडर के साथ सरल रोबोट

यह विषय Arduino नैनो पर आधारित एक साधारण रोबोट बनाने के लिए समर्पित है। यह माना जाता है कि पाठक एक शुरुआत है और इस मुद्दे का केवल बुनियादी ज्ञान रखता है। मैंने हर चीज को यथासंभव विस्तृत और स्पष्ट करने की कोशिश की।

कार्य का परिचय

आइए अवधारणा के साथ शुरू करें: हम एक ऐसा रोबोट चाहते हैं जो स्वतंत्र रूप से कमरे में घूम सके, जबकि इसके रास्ते में आने वाली सभी बाधाओं से बचा जा सके।
कार्य निर्धारित किया गया था। अब दुकानों पर चल रहा है! 1) प्लेटफार्म। ऐसे विकल्प हैं: अपने आप को सब कुछ करने के लिए, भागों को खरीदें (उदाहरण के लिए तामिया) और उनसे इकट्ठा करें, या एक तैयार किया हुआ खरीदें। मैं आखिरी विकल्प पर आ गया। किसी कारण से, मुझे टैंक, कुआं या ट्रैक्टर का दृश्य पसंद आया, और अंत में मैं इस विकल्प ( DF रोबोट से मंच) पर बस गया:



शामिल एक मंच (प्रत्येक ट्रैक पर एक इंजन) और एक बैटरी डिब्बे है।
खैर, कुछ भी जटिल नहीं है, चलिए आगे बढ़ते हैं।

रेंज फाइंडर

सोनार (उर्फ रेंजफाइंडर, उर्फ ​​अल्ट्रासोनिक मॉड्यूल) रेंजफाइंडर के रूप में, विकल्प शुरू में अल्ट्रासोनिक और अवरक्त के बीच था। चूंकि अल्ट्रासोनिक विशेषताएं बहुत बेहतर हैं (अधिकतम रेंज लगभग 4-5 मीटर, बनाम 30-60 सेमी), और कीमत उसी के बारे में है, विकल्प अल्ट्रासोनिक पर गिर गया। सबसे आम मॉडल HC-SR04 है ।



यह समझने के लिए कि यह फल कैसे काम करता है, इंटरनेट पर डेटाशीट + पर्याप्त जानकारी है।
मैं आपको मुख्य बात बताऊंगा। फोटो 2 सिलेंडर दिखाता है। उनमें से एक रिसीवर है, दूसरा एक ट्रांसमीटर है। रिसीवर अल्ट्रासोनिक तरंगों को उत्पन्न करता है, ट्रांसमीटर ऑब्जेक्ट से परावर्तित तरंग प्राप्त करता है, और हमें इसके बारे में बताएं। इसके बोर्ड पर 4 पिन (5V, GND, ट्रिग, इको) हैं ।
ऑपरेशन एल्गोरिथ्म इस प्रकार है:

हम ट्रिग पैर के लिए 10 μs का संकेत लागू करते हैं , जो जनरेटर शुरू करता है, ट्रांसमीटर (8 पीसी) पर छोटी दालों का एक पैकेट बनाता है। इसके अलावा, रिसीवर परावर्तित संकेत प्राप्त करता है और एक आयताकार संकेत इको पैर पर उत्पन्न होता है, जिसकी लंबाई दालों के उत्सर्जन और रिसीवर द्वारा उनका पता लगाने के बीच के समय के आनुपातिक होती है।

वास्तविक समय जिसके लिए ध्वनि रिसीवर तक पहुंचती है, निश्चित रूप से, एक पैसा होगा। इससे दूरी तय करने के लिए, आप एक सरल सूत्र का उपयोग कर सकते हैं:

s = vt / 2 , s दूरी है, v ध्वनि की गति है, t वह समय है जब रिसीवर पर सिग्नल प्राप्त हुआ था।

खैर, आधे में क्यों बंटा, मुझे लगता है कि हर कोई समझता है। केवल इस मामले में, इस सूत्र की आवश्यकता नहीं है। मैं इसे पूरी तरह से प्रक्रिया की भौतिकी को समझने के लिए यहाँ लाता हूँ।
पर्याप्त रूप से लंबी अवधि के साथ पहले से ही उत्पन्न संकेत इको आउटपुट से आता है। डेटाशीट को देखते हुए, हम पुनर्गणना सूत्र देखेंगे: s = t / 58 , s दूरी है, t पल्स अवधि है Echo, s सेंटीमीटर में दूरी है।

ठीक है, सभी तरह की मूल बातें सुलझ गईं। आइए Arduino के तहत कोड पर चलते हैं:

const int Trig = 3; // निरूपित करें कि कौन सा पैर और क्या हम कॉन्स्टेंस इंट इको = 2 कनेक्ट करते हैं;
शून्य सेटअप ()
{
पिनमोड (Trig, OUTPUT);
pinMode (इको, INPUT);
सीरियल.बेगिन (9600); // मॉनिटर पर परिणाम प्रदर्शित करने के लिए सीरियल पोर्ट को आरम्भ करें
}

अहस्ताक्षरित int time_us = 0; // समय अंतराल के भंडारण के लिए चर
अहस्ताक्षरित int दूरी_सम = 0; // सेंटीमीटर में दूरी के भंडारण के लिए चर

शून्य लूप ()
{
digitalWrite (ट्रिग, हाई); // माइक्रोकंट्रोलर के आउटपुट के लिए एक संकेत भेजें
देरीमाइक्रोसेकंड (10); // 10 माइक्रोसेकंड पकड़ो
digitalWrite (Trig, LOW); // फिर हटा दें
time_us = pulIn (इको, हाई); // नाड़ी की लंबाई मापें
दूरी_सम = समय_स / 58; // सेंटीमीटर में कनवर्ट करें
सीरियल.प्रिंट (दूरी_सम); // पोर्ट के लिए प्रिंट करें
सिरियल.प्रिंट ("");
देरी (500);
}

ड्राइवर

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

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

आप इन उपकरणों के बारे में थोड़ा पढ़ सकते हैं, उदाहरण के लिए, यहां ।

चलिए आगे बढ़ते हैं। इन उद्देश्यों के लिए, मैंने खुद को एक L293D चिप खरीदी, जो वास्तव में बाद में चर्चा की जाएगी। सार्वभौमिक रूप से उपलब्ध इसका उपयोग करना आसान है, और एक सुविधाजनक डिप 16 केस है।
इसका अधिकतम प्रवाह अपेक्षाकृत छोटा (600 mA) है, जो किसी विशिष्ट कार्य के लिए पर्याप्त से अधिक है। यदि आपको और अधिक की आवश्यकता है, उदाहरण के लिए, L293B (1A), आदि ...
मैं लगभग भूल गया, यह पुल आपको 2 मोटरों को इससे जोड़ने की अनुमति देता है, प्रत्येक तरफ एक।
यह समझने के लिए कि उसके साथ कैसे बातचीत करें, मुझे एक अच्छा लेख मिला, और हम इसका उपयोग करेंगे:

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



- इस चिप का समावेश सर्किट, वास्तव में, डेटाशीट से लिया गया है।

संक्षेप में उसके पैरों पर जाएँ:

1) मोटर का प्रारंभ 1। जब तक आप इस पैर पर हाई नहीं डालते हैं, तब तक आप बाकी के साथ जो भी करते हैं, वह मोटर काम नहीं करेगा। हालांकि यह 1,2E लिखा है - एक मोटर है। भ्रमित मत करो। तथ्य यह है कि एक मोटर को नियंत्रित करने के लिए आपको माइक्रोकंट्रोलर के 2 पैरों की आवश्यकता होगी, और तदनुसार, एच - पुल। हमने एक पैर हाई, दूसरे LOW - मोटर स्पून को एक दिशा में रखा। पहले LOW, दूसरे हाई पर लागू होते हैं - यह विपरीत में स्पिन करेगा। चलो दोनों LOW पर लागू होते हैं - यह बंद हो जाएगा।
2) 1 ए । इस पैर पर आप 1 मोटर इनपुट को नियंत्रित करने के लिए माइक्रोकंट्रोलर (कम वर्तमान) से एक संकेत भेजेंगे।
3) 1 य । और यह एक संकेत (उच्च धारा) है, जो सीधे मोटर में जाता है। इसकी उपस्थिति में, यह पूरी तरह से इनपुट 1 ए को दिए गए सिग्नल को दोहराता है।
4) - 5) पृथ्वी
6) 2Y यहां हम मोटर के दूसरे पैर को जोड़ते हैं।
7) 2A मोटर के दूसरे इनपुट को नियंत्रित करने के लिए माइक्रोकंट्रोलर से संकेत।
8) यहां हम उस वोल्टेज को लागू करते हैं जो मोटर्स खिलाएगा। वास्तव में, जो हम इस इनपुट को देते हैं वह पैरों पर 1Y , 2Y को अनलॉक किया जाएगा।
9) - 16) पहले आठ के साथ एक पूर्ण सादृश्य, लेकिन दूसरी मोटर के लिए।

अगला, समावेशन सर्किट:





जब मोटर चालू किया जाता है, तो बिजली के उछाल को हटाने के लिए, हम एक संधारित्र का उपयोग करते हैं, जैसा कि नीचे दिखाया गया है:



और अंत में, स्रोत कोड प्रदान किया गया है, मेरे छोटे संस्करण के साथ, जो उपरोक्त सभी को सारांशित करता है:

const int motor1Pin = 3; // एच-ब्रिज लेग 1 (पिन 2, 1 ए)
const int motor2Pin = 4; // एच-ब्रिज लेग 2 (पिन 7, 2 ए)
const int enablePin = 9; // एच-पुल सक्षम पिन
शून्य सेटअप ()
{1. आउटपुट के रूप में आपके द्वारा उपयोग किए जा रहे अन्य सभी पिन सेट करें:
पिनमोड (motor1Pin, OUTPUT);
पिनमोड (मोटर 2 पिन, आउटपूट);
पिनमोड (EnablePin, OUTPUT); // सेट सक्षम उच्च करें ताकि मोटर चालू हो सके:
digitalWrite (enablePin, HIGH);
}

शून्य लूप ()
{// मोटर को एक तरफ से मोड़ें
digitalWrite (motor1Pin, LOW); // सेट-एच के पुल 1 को कम करें
digitalWrite (motor2Pin, HIGH); // सेट-एच 2 एच-ब्रिज की उच्च देरी (1000); // और एक दूसरे के बाद दूसरे digitalWrite (motor1Pin, HIGH); // सेट हाई ब्रिज का 1 पैर
digitalWrite (motor2Pin, LOW); // सेट-एच 2 एच-ब्रिज कम देरी (1000);
// और अब सब फिर से
}

इमदादी

इसलिए, हमने रेंजफाइंडर के काम का पता लगाया। चलिए आगे बढ़ते हैं। हमारे पास एक रेंजफाइंडर है, आपको आगे और आस-पास दोनों को देखने की जरूरत है, ताकि आप जान सकें कि किसी चीज के मामले में कहां मोड़ना है। इन उद्देश्यों के लिए हम एक सर्वो (सर्वो, सर्वो, सर्वो) का उपयोग करेंगे।



इन खिलौनों का उपयोग मुख्य रूप से विमान मॉडलिंग में किया जाता है, लेकिन रोबोट के लिए भी, बहुत कुछ नहीं।
इस उपकरण को 0 से 180 डिग्री के कोणों से घुमाया जा सकता है। एक तीन-तार केबल मामले से आता है:

काला - GND
रेड - 5 वी
सफेद - संकेत

मोटर एक नियंत्रक द्वारा नियंत्रित किया जाता है (आप डरे नहीं हैं - आपको कुछ भी खरीदना नहीं है, यह पहले से ही सर्वो के अंदर है), जो एक बाहरी संकेत प्राप्त करता है, यह नियंत्रित करता है कि मोटर किसी दिए गए कोण से बदल जाएगा। इन उद्देश्यों के लिए, मोटर से नियंत्रक तक प्रतिक्रिया स्थापित की जाती है, जो एक चर अवरोधक है जो रोटेशन के कोण के आधार पर इसके प्रतिरोध को बदलता है। नियंत्रक स्वयं इनपुट पल्स लंबाई द्वारा नियंत्रित किया जाता है। आमतौर पर: 380 - 400 μs - 0 डिग्री, 2200 μs - 180 डिग्री। यहाँ Arduino के लिए एक सरल सर्वो नियंत्रण एल्गोरिथ्म है:

# डेफिन सर्वोपिन 2 // इस पैर पर हम अपने सर्वो (इसके सफेद तार) को जोड़ेंगे
शून्य सेटअप ()
{
पिनमोड (2, OUTPUT);
}

शून्य इमदादी_मोशन (इंट कोण) // इमदादी नियंत्रण समारोह
{
int time = 390 + 10 * कोण; // पल्स लंबाई में रोटेशन के दिए गए कोण को पुनर्गणना करें, जिसे // सर्वो को खिलाया जाता है
digitalWrite (सर्वो, उच्च); // सिग्नल चला गया है
देरीमाइक्रोसेकंड (समय); // दिए गए समय के लिए इसे पकड़ो
digitalWrite (सर्वो, LOW); // इसे बंद करें
देरीमाइक्रोसेकंड (20000-समय); // सर्वो को चालू करने का समय दें (20000 μs - 50 हर्ट्ज)
}

शून्य लूप ()
{

for (int i = 0; मैं <= 180; i ++)
{
सर्वो_मोशन (i); // स्क्रॉल सर्वो वन वे
देरी (10); // प्रत्येक डिग्री पर 10 मिलीसेकेंड की देरी से
}

for (int i = 180; i> = 0; i--)
{
सर्वो_मोशन (i); // फिर दूसरा तरीका
देरी (10);
}

}

लेकिन भविष्य में, हम सर्वो को नियंत्रित करने के लिए एक विशेष पुस्तकालय का उपयोग करेंगे, यहाँ इसका विवरण है:

www.arduino.cc/en/Reference/Servo

arduino.cc/en/Tutorial/Sweep

यह उदाहरण (2 लिंक) ठीक वैसा ही काम करता है जैसा कि ऊपर वर्णित कार्यक्रम। चित्रों, तस्वीरों, टिप्पणियों के साथ कोड का एक रंगीन विवरण है, इसलिए मुझे लगता है कि कोई विशेष कठिनाइयों नहीं होगी। मैं अपने आप को केवल कुछ टिप्पणियों तक सीमित करूंगा - जब इस कोड की जांच कर रहे हों, तो डिजिटल पोर्ट 9 पर सर्वो को फिर से व्यवस्थित करना न भूलें, या उस कोड में इस लाइन को ठीक करें:

myservo.attach (9); // सर्वो 9 को सर्वो ऑब्जेक्ट पर पिन 9 से जोड़ता है

और फिर कुछ भी काम नहीं करेगा। और आखिरी चीज जो मैं जोड़ना चाहूंगा - यह उदाहरण उपरोक्त लिंक पर उपलब्ध है, और "उदाहरण" टैब में Arduino के विकास के माहौल में।

सभा

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

arduino.cc/en/Guide/HomePage
freeduino.ru/arduino/index.html
arduino.ru

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

4 फीट - एच ब्रिज के इनपुट, प्रत्येक मोटर के लिए 2:
1 ए - 11
2 ए - 6
3 ए - 10
4 ए - 5

enablePin - 12

1,2EN और 3,4EN के लिए 1 पैर - उन्हें एक साथ रखें, क्योंकि हमें अभी भी अलग से दोनों मोटर्स की आवश्यकता नहीं है। सिद्धांत रूप में, सामान्य तौर पर, आप पुल के इन 2 पैरों को अरुडिनो से नहीं जोड़ सकते हैं, लेकिन बस उन्हें 5V लागू करें।

सोनार के लिए 2 पैर:
ट्रिग - ३
प्रतिध्वनि - २

सर्वो पैर:
सर्वो - -

यह सब, ऐसा लगता है। इसके अलावा, रोबोट की असेंबली के दौरान, मुझे एक समस्या का सामना करना पड़ा - रोबोट समय-समय पर बंद हो गया, अरुडिनो ने रिबूट किया। थोड़ा विचार करने के बाद, मैंने महसूस किया कि Arduino नैनो अपने मानक स्टेबलाइजर से इस पूरे सिस्टम (H-Bridge, सर्वो, सोनार) को चलाने में असमर्थ है। क्योंकि वोल्टेज स्टेबलाइजर 7805 (L7805, LM7805) मेरी सहायता के लिए आया था। डिवाइस का उपयोग करना आसान है, इसमें 3 पैर हैं: इनपुट (6 - 35 वी), जमीन, आउटपुट (~ 5 वी)। इंटरनेट पर हर जगह इसके लिए डेटशीट मिल सकती है। अपनी जमीन को मिलाकर, Arduino की भूमि के साथ और, तदनुसार, बैटरी के माइनस के साथ भी। मैंने ऐसा किया - Arduino से मैं केवल H- पुल, और बाकी सब (इमदादी, सोनार) को स्टेबलाइजर से खिलाता हूं। उसके बाद, रोबोट पूरी तरह से विफलताओं के बिना काम करना शुरू कर दिया। हां, महत्वपूर्ण नियम को मत भूलना - किसी भी योजना में पृथ्वी सभी तत्वों के लिए सामान्य होनी चाहिए! खैर, मोटरों के बारे में, मुझे लगता है कि यह समझ में आता है - हम बैटरी से पुल इनपुट तक वोल्टेज की आपूर्ति करते हैं - Vcc2। ठीक है, कनेक्शन का पता लगाओ, मैं तस्वीरों के साथ ऊपर बताऊंगा:

पूरी योजना:


वोल्टेज स्टेबलाइजर (संधारित्र स्थापित करने की आवश्यकता नहीं):


सोनार केबल:


एच - पुल:


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

प्रोग्रामिंग

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

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

परिवर्तनीय घोषणा:

सोनार एल्गोरिथ्म को लागू करने के लिए चर अहस्ताक्षरित int time_us = 0 है;
सोनार दूरी - अहस्ताक्षरित अंतर दूरी_सम = 0;
इस चर का उपयोग लूप में यह सुनिश्चित करने के लिए किया जाता है कि जब आप रोबोट चालू करते हैं, तो जगह में "चारों ओर" दिखाई देगा, और फिर जाएं -
अहस्ताक्षरित इंट सर्कल = 0;
सामने की निकटतम वस्तु की दूरी अहस्ताक्षरित int dist_f = 0 है;
बाईं ओर की निकटतम वस्तु की दूरी अहस्ताक्षरित int dist_l = 0 है;
दाईं ओर निकटतम ऑब्जेक्ट की दूरी अहस्ताक्षरित int dist_r = 0 है;
45 डिग्री के कोण पर निकटतम वस्तु की दूरी - अहस्ताक्षरित int dist_45 = 0;
135 डिग्री के कोण पर निकटतम वस्तु की दूरी - अहस्ताक्षरित int dist_135 = 0;

वह समय स्थिर (ms) जो रोबोट की गति के न्यूनतम चरण को परिभाषित करता है। प्रयोगात्मक रूप से चयनित। आंदोलन की गति और आपके रोबोट के सर्वो के रोटेशन की गति के आधार पर, आपको इसे बदलना पड़ सकता है। बाद में यह और स्पष्ट हो जाएगा कि इसकी आवश्यकता क्यों है -
अहस्ताक्षरित int t = 15;

कार्य:

सोनार () - सोनार एल्गोरिथ्म को लागू करता है, दूरी [सेमी] लौटाता है।
फॉरवर्ड (), बैक (), राइट (), लेफ्ट () हमारे मूल मोशन फंक्शन हैं।
मुख्य कार्य जो आंदोलन को लागू करता है

शून्य गति (चार डिमेशन, int prev_angle, int next_angle, इंट टाइम)
{
/ * यह फ़ंक्शन एक साथ मोटर्स और सर्वो के रोटेशन को नियंत्रित करता है।
char dimention - आंदोलन की दिशा
int prev_angle - पिछली सर्वो स्थिति
int next_angle - वह स्थिति जहां हम सर्वो को सेट करना चाहते हैं
int time - रोबोट के एक मूवमेंट का समय कदम * /

// वह मान जिससे आंदोलन के दौरान कोण बदलता है -
int a;
अगर (अगला_गंध> = prev_angle)
a = 15;
अन्यथा
a = -15;
अगर (डिमेशन == 'f')
{
// यदि आप कहते हैं कि आगे बढ़ें, तो
int i = prev_angle;
जबकि (i! = next_angle)
{
/ * जब तक हम सेट कोण तक नहीं पहुंचते, हम लूप में धीरे-धीरे सर्वो की वर्तमान स्थिति को एक * से बदल देंगे
i + = a; myservo.write (i); // और इस मान को सर्वो में पास करें
आगे (); // जिसके बाद हम आगे बढ़ते हैं
देरी (समय); // समय अंतराल के समय के दौरान
}
}

/ * बाएँ, दाएँ, पिछड़े और स्थिर खड़े रहने के लिए समान एल्गोरिथ्म * /

...

}

शून्य सामने_मिशन (इंट टाइम)
{
अगर ऑब्जेक्ट 45 और 135 डिग्री के कोण पर स्थित है, तो एक तरफ रोबोट का एक छोटा "टर्न" बाहर करने वाला फंक्शन
अगर (dist_45 <= 9)
{// यदि 45 डिग्री के कोण पर ऑब्जेक्ट की दूरी 9 सेमी से कम है, तो बाएं मुड़ें
बाएं ();
देरी (3 * समय); // तीन न्यूनतम अंतराल के दौरान
}
/ * दाईं ओर "मोड़" के लिए एक समान एल्गोरिथ्म * /

...

}
शून्य गति_बैक (इंट टाइम)
{
/ * रोबोट को 2 * समय के लिए पीछे की ओर ले जाएं, सर्वो के साथ 180 डिग्री के कोण से, 180 डिग्री के कोण से मुड़ें * /
गति ('बी', 180.90.2 * समय);
}
शून्य लूप ()
{
// हमारा मुख्य कार्य जो कार्य के अंतिम एल्गोरिथ्म को लागू करता है
यदि (वृत्त == 0)
{
// यदि रोबोट अभी चालू किया गया है, तो सर्वो को इसकी प्रारंभिक स्थिति पर सेट करें।
myservo.write (0); // और पक्षों पर "चारों ओर देखो"
dist_r = sonar ();
गति ('डब्ल्यू', 0.45, टी);
dist_45 = सोनार ();
गति ('डब्ल्यू', 45.90, टी);
dist_f = sonar ();
गति ('डब्ल्यू', 90,135, टी);
dist_135 = सोनार ();
गति ('डब्ल्यू', 135,180, टी);
dist_l = sonar (); } // हम अब यह कार्रवाई नहीं करेंगे
सर्कल ++; मैं
f (dist_f> = 25)
{// यदि सामने की निकटतम वस्तु 25 सेंटीमीटर से अधिक है
a: // हम आगे बढ़ते हैं, जबकि हम सर्वो को 180 से 135 डिग्री तक घुमाते हैं
गति ('एफ', 180,135, टी); // 135 डिग्री के कोण पर वस्तुओं से दूरी की माप करें
dist_135 = सोनार (); // यदि आवश्यक हो, तो एक मोड़ दें
front_motion (टी); // आगे भी इसी तरह, लेकिन विभिन्न मूल्यों के साथ
गति ('एफ', 135.90, टी);
dist_f = sonar ();
front_motion (टी);
गति ('एफ', 90.45, टी);
dist_45 = सोनार ();
front_motion (टी);
गति ('एफ', 45.0, टी);
dist_r = sonar ();
front_motion (टी);
गति ('एफ', 0.45, टी);
dist_45 = सोनार ();
front_motion (टी);
गति ('एफ', 45.90, टी);
dist_f = sonar ();
front_motion (टी);
गति ('एफ', 90,135, टी);
dist_135 = सोनार ();
front_motion (टी);
गति ('एफ', 135,180, टी);
dist_l = sonar (); front_motion (टी); // यदि सामने की दूरी अभी भी 25 सेंटीमीटर से अधिक है, तो वापस बिंदु 'ए' पर जाएं
अगर (dist_f> = 25)
गोटो ए;
}
अन्यथा
{// यदि नहीं
अगर (dist_f <5)
{// अगर रोबोट पहले से ही निकटतम वस्तु के करीब है, तो एक पिछड़े आंदोलन करें
गति_बैक (टी);
// एक नई दूरी मापें
dist_f = sonar ();
} // इस मामले में, हम उस दिशा में मुड़ते हैं जहां अधिक खाली स्थान है
अगर (dist_l> = dist_r || dist_135> dist_r)
{
गति ('एल', 180.90, टी);
dist_f = sonar ();
}
अगर (dist_l <dist_r)
{
गति ('आर', 180.90, टी);
dist_f = sonar ();
}
} // अगला, एक नया सर्कल
}

इस कार्यक्रम का पूरा संस्करण यहां डाउनलोड किया जा सकता है:
maxim.wf/arduino_code/Robot_compilation.pde

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






आपका ध्यान के लिए धन्यवाद!
मुझे किसी भी प्रश्न, सुझाव और टिप्पणी पर खुशी होगी।