გსურთ ისწავლოთ როგორ შექმნათ თქვენი საკუთარი რობოტი? არსებობს უამრავი სხვადასხვა სახის რობოტი, რომლის დამზადებაც თქვენ შეგიძლიათ. ადამიანების უმეტესობას სურს ნახოს რობოტი, რომელიც ასრულებს მარტივ ამოცანებს A წერტილიდან B წერტილში გადაადგილებისას. თქვენ შეგიძლიათ გააკეთოთ რობოტი სრულად ანალოგური კომპონენტებისგან ან იყიდოთ დამწყები ნაკრები ნულიდან! საკუთარი რობოტის შექმნა შესანიშნავი საშუალებაა ასწავლოთ საკუთარ თავს როგორც ელექტრონიკა, ასევე კომპიუტერული პროგრამირება.
ნაბიჯები
მე -6 ნაწილი 1: რობოტის აწყობა
ნაბიჯი 1. შეაგროვეთ თქვენი კომპონენტები
ძირითადი რობოტის შესაქმნელად დაგჭირდებათ რამდენიმე მარტივი კომპონენტი. თქვენ შეგიძლიათ იპოვოთ ამ კომპონენტების უმეტესობა, თუ არა ყველა, თქვენს ადგილობრივ ელექტრონიკის ჰობის მაღაზიაში, ან რამდენიმე ონლაინ საცალო ვაჭრობაში. ზოგიერთი ძირითადი ნაკრები შეიძლება შეიცავდეს ყველა ამ კომპონენტს. ეს რობოტი არ საჭიროებს შედუღებას:
- Arduino Uno (ან სხვა მიკროკონტროლერი)
- 2 უწყვეტი როტაციის სერვისი
- 2 ბორბალი, რომელიც ჯდება სერვოში
- 1 მბრუნავი როლიკერი
- 1 პატარა გამწოვი პურის დაფა (მოძებნეთ პურის დაფა, რომელსაც აქვს ორი დადებითი და უარყოფითი ხაზი თითოეულ მხარეს)
- დისტანციის სენსორი (ოთხი პინიანი კონექტორის კაბელით)
- 1 მინი ღილაკის ღილაკი
- 1 10kΩ რეზისტორი
- 1 USB A to B კაბელი
- გამოყოფილი თავების 1 ნაკრები
- 1 6 x AA ბატარეის დამჭერი 9V DC დენის ჯეკით
- 1 პაკეტი მხტუნავ მავთულხლართებს ან 22 ლიანდაგს შემაერთებელ მავთულს
- ძლიერი ორმხრივი ლენტი ან ცხელი წებო
ნაბიჯი 2. გადააბრუნეთ ბატარეის პაკეტი ისე, რომ ბრტყელი უკანა მხარე იყოს ზემოთ
თქვენ აშენებთ რობოტის სხეულს ბატარეის პაკეტის საფუძველზე.
ნაბიჯი 3. გაათანაბრეთ ორი სერვისი ბატარეის პაკეტის ბოლოს
ეს უნდა იყოს დასასრული, როდესაც ბატარეის მავთული ამოდის სერვოებიდან, რომელიც უნდა ეხებოდეს ძირს და თითოეული მათგანის მბრუნავი მექანიზმი უნდა იყოს მიმართული ბატარეის პაკეტის გვერდით. Servos უნდა იყოს სათანადოდ გასწორებული ისე, რომ ბორბლები პირდაპირ წავიდეს. სერვერების მავთულები უნდა ჩამოდიოდეს ბატარეის უკანა მხარეს.
ნაბიჯი 4. მიამაგრეთ servos თქვენი ფირზე ან წებოთი
დარწმუნდით, რომ ისინი მყარად არის მიმაგრებული ბატარეის პაკეტზე. სერვოების ზურგი უნდა იყოს გასწორებული ბატარეის უკანა ნაწილთან ერთად.
სერვოები უნდა აიღონ ბატარეის უკანა ნახევარი
ნაბიჯი 5. მიამაგრეთ პურის პერპენდიკულარულად ბატარეის პაკეტზე ღია სივრცე
ის ოდნავ უნდა ჩამოკიდეს ბატარეის წინა ნაწილზე და გაგრძელდება თითოეულ მხარეს. გაგრძელებამდე დარწმუნდით, რომ იგი საიმედოდ არის დამაგრებული. "A" რიგი უნდა იყოს ყველაზე ახლოს servos- თან.
ნაბიჯი 6. მიამაგრეთ არდუინოს მიკროკონტროლი სერვოების ზედა ნაწილზე
თუ თქვენ სწორად მიამაგრეთ სერვოები, უნდა იყოს ბრტყელი სივრცე, რომელიც მათ შეეხო. მიამაგრეთ არდუინოს დაფა ამ ბრტყელ სივრცეზე ისე, რომ არდუინოს USB და დენის კონექტორები უკანა მხარეს იყოს (დაფის მოშორებით). არდუინოს წინა მხარე ძლივს გადაფარავს პურის დაფას.
ნაბიჯი 7. განათავსეთ ბორბლები servos
მტკიცედ დააჭირეთ ბორბლებს სერვოს მბრუნავ მექანიზმზე. ამას შეიძლება დასჭირდეს მნიშვნელოვანი ძალა, რადგან ბორბლები შექმნილია იმისათვის, რომ მაქსიმალურად მჭიდროდ მოერგოს საუკეთესო წევას.
ნაბიჯი 8. მიამაგრეთ კასტერი პურის დაფის ბოლოში
თუ შასს გადაატრიალებთ, უნდა ნახოთ ცოტაოდენი დაფა, რომელიც გადადის ბატარეის კოლოფზე. მიამაგრეთ კასტერი ამ გაფართოებულ ნაჭერზე, საჭიროების შემთხვევაში გამოიყენეთ ამწეები. კასტერი მოქმედებს როგორც წინა ბორბალი, რაც საშუალებას აძლევს რობოტს ადვილად გადაუხვიოს ნებისმიერი მიმართულებით.
თუ თქვენ იყიდეთ ნაკრები, კასტერს შეიძლება მოყვეს რამდენიმე ამწეები, რომელთა გამოყენება შეგიძლიათ იმის უზრუნველსაყოფად, რომ კასტერი მიაღწევს მიწას. მე
ნაწილი 6 6: რობოტის გაყვანილობა
ნაბიჯი 1. დაარღვიე ორი 3 პინიანი სათაური
თქვენ იყენებთ მათ, რათა დააკავშიროთ სერვისები პურის დაფაზე. მიამაგრეთ ქინძისთავები სათაურის ქვემოთ ისე, რომ ქინძისთავები გამოვიდეს თანაბარ მანძილზე ორივე მხრიდან.
ნაბიჯი 2. ჩასვით ორი სათაური პინდის 1-3 და 6-8 ქინძისთავებში E დაფაზე
დარწმუნდით, რომ ისინი მტკიცედ არის ჩასმული.
ნაბიჯი 3. შეაერთეთ servo კაბელები სათაურებთან, მარცხენა მხარეს შავი კაბელით (ქინძისთავები 1 და 6)
ეს დააკავშირებს სერვისებს პურის დაფაზე. დარწმუნდით, რომ მარცხენა სერვერი უკავშირდება მარცხენა სათაურს და მარჯვენა სერვერი მარჯვენა სათაურს.
ნაბიჯი 4. შეაერთეთ წითელი ჯუმბერის მავთულები C2 და C7 ქინძისთავებიდან წითელი (პოზიტიური) სარკინიგზო ქინძისთავებისთვის
დარწმუნდით, რომ თქვენ იყენებთ წითელ სარკინიგზო ხაზს დაფის უკანა მხარეს (შასის დანარჩენ ნაწილთან უფრო ახლოს).
ნაბიჯი 5. შეაერთეთ შავი ჯუმბერის მავთულები B1 და B6 ქინძისთავებიდან ლურჯ (ადგილზე) სარკინიგზო ქინძისთავებზე
დარწმუნდით, რომ იყენებთ ცისფერ სარკინიგზო ხაზს დაფის უკანა მხარეს. ნუ შეაერთებთ მათ წითელ სარკინიგზო ქინძისთავებში.
ნაბიჯი 6. შეაერთეთ თეთრი ჯუმბერის მავთულები არდუინოს 12 და 13 ქინძისთავებიდან A3 და A8
ეს საშუალებას მისცემს არდუინოს გააკონტროლოს სერვოები და გადააბრუნოს ბორბლები.
ნაბიჯი 7. მიამაგრეთ სენსორი პურის დაფის წინა მხარეს
ის არ იკეტება პურის დაფაზე გარე კვების რელსებში, არამედ სამაგიეროდ პირველი რიგის ასოებით (J). დარწმუნდით, რომ განათავსეთ იგი ზუსტად ცენტრში, თითოეულ მხარეს თანაბარი რაოდენობის ქინძისთავებით.
ნაბიჯი 8. შეაერთეთ შავი ჯუმბერის მავთული პინიდან I14 პირველი სენსორის მარცხენა მხარეს მდებარე ლურჯი სარკინიგზო პინზე
ეს გააფუჭებს სენსორს.
ნაბიჯი 9. შეაერთეთ წითელი ჯუმბერის მავთული პინიდან I17 პირველი სენსორის მარჯვნივ არსებული წითელი სარკინიგზო პინზე
ეს აძლიერებს სენსორს.
ნაბიჯი 10. შეაერთეთ თეთრი ჯუმბერის მავთულები პინ I15– დან პინ 9 – ზე Arduino– ზე და I16– დან პინ 8 – მდე
ეს მიაწვდის ინფორმაციას სენსორიდან მიკროკონტროლერს.
მე -6 ნაწილი 3: დენის გაყვანილობა
ნაბიჯი 1. გადაატრიალეთ რობოტი მის მხარეს ისე, რომ დაინახოთ პაკეტში არსებული ბატარეები
ორიენტაცია გაუკეთეთ ისე, რომ ბატარეის პაკეტი გამოდის მარცხნივ ბოლოში.
ნაბიჯი 2. შეაერთეთ წითელი მავთული მეორე გაზაფხულზე მარცხნიდან ქვედადან
დარწმუნდით, რომ ბატარეის პაკეტი სწორად არის ორიენტირებული.
ნაბიჯი 3. შეაერთეთ შავი მავთული ბოლო გაზაფხულზე ქვედა-მარჯვენა
ეს ორი კაბელი ხელს შეუწყობს არდუინოს სწორი ძაბვის უზრუნველყოფას.
ნაბიჯი 4. შეაერთეთ წითელი და შავი მავთულები უკიდურესად მარჯვენა წითელ და ლურჯ ქინძისთავებზე, დაფაზე უკანა მხარეს
შავი კაბელი უნდა იყოს ჩართული ლურჯი სარკინიგზო ბუდეში 30 პინზე. წითელი კაბელი უნდა იყოს ჩართული წითელ სარკინიგზო პინში 30 პინზე.
ნაბიჯი 5. შეაერთეთ შავი მავთული GND პინიდან არდუინოზე უკანა ლურჯ სარკინიგზო ხაზთან
შეაერთეთ იგი პინ 28 -ში ლურჯ სარკინიგზო ხაზზე.
ნაბიჯი 6. შეაერთეთ შავი მავთული უკანა ლურჯი სარკინიგზოდან წინა ლურჯ სარკინიგზო ხაზზე თითოეული 29
არ დააკავშიროთ წითელი რელსები, რადგან თქვენ სავარაუდოდ დააზიანებთ არდუინოს.
ნაბიჯი 7. შეაერთეთ წითელი მავთული წინა წითელი სარკინიგზოდან პინ 30 -ში Arduino– ზე 5V პინზე
ეს უზრუნველყოფს არდუინოს ძალას.
ნაბიჯი 8. ჩადეთ ღილაკზე გადამრთველი მწკრივებს შორის უფსკრული 24-26 ქინძისთავებზე
ეს გადამრთველი საშუალებას მოგცემთ გამორთოთ რობოტი დენის გამორთვის გარეშე.
ნაბიჯი 9. შეაერთეთ წითელი მავთული H24– დან წითელ სარკინიგზო ხაზზე, სენსორის მარჯვნივ, მომდევნო ხელმისაწვდომ პინში
ეს გაააქტიურებს ღილაკს.
ნაბიჯი 10. გამოიყენეთ რეზისტორი H26 ლურჯ სარკინიგზო ხაზთან დასაკავშირებლად
შეაერთეთ იგი პინთან პირდაპირ შავი მავთულის გვერდით, რომელიც რამდენიმე ნაბიჯის წინ დააკავშირეთ.
ნაბიჯი 11. შეაერთეთ თეთრი მავთული G26– დან პინ 2 – ზე Arduino– ზე
ეს საშუალებას მისცემს Arduino– ს დაარეგისტრიროს ღილაკი.
მე -6 ნაწილი 4: Arduino პროგრამული უზრუნველყოფის დაყენება
ნაბიჯი 1. ჩამოტვირთეთ და ამოიღეთ Arduino IDE
ეს არის Arduino განვითარების გარემო და გაძლევთ საშუალებას დაპროგრამოთ ინსტრუქციები, რომლებიც შემდეგ შეგიძლიათ ატვირთოთ თქვენს Arduino მიკროკონტროლერზე. შეგიძლიათ უფასოდ გადმოწეროთ arduino.cc/en/main/software– დან. გადმოტვირთეთ გადმოწერილი ფაილი ორმაგი დაწკაპუნებით და გადაიტანეთ საქაღალდე შიგნით ადვილად მისაწვდომ ადგილას. თქვენ ნამდვილად არ დააინსტალირებთ პროგრამას. ამის ნაცვლად, თქვენ უბრალოდ გაუშვებთ მას მოპოვებული საქაღალდიდან arduino.exe ორმაგი დაწკაპუნებით.
ნაბიჯი 2. შეაერთეთ ბატარეის პაკეტი Arduino– სთან
შეაერთეთ ბატარეის უკანა ბუდე Arduino– ს კონექტორში, რომ მისცეთ მას ძალა.
ნაბიჯი 3. შეაერთეთ Arduino თქვენს კომპიუტერში USB- ის საშუალებით
Windows სავარაუდოდ არ აღიარებს მოწყობილობას.
ნაბიჯი 4. დააჭირეთ
⊞ Win+R და ტიპი devmgmt.msc.
ეს დაიწყებს მოწყობილობის მენეჯერს.
ნაბიჯი 5. დააწკაპუნეთ მარჯვენა ღილაკით "უცნობი მოწყობილობა" განყოფილებაში "სხვა მოწყობილობები" და აირჩიეთ "მძღოლის პროგრამული უზრუნველყოფის განახლება
" თუ თქვენ ვერ ხედავთ ამ ვარიანტს, ამის ნაცვლად დააწკაპუნეთ "თვისებები", აირჩიეთ "მძღოლი" ჩანართი და შემდეგ დააჭირეთ "მძღოლის განახლება".
ნაბიჯი 6. აირჩიეთ "დაათვალიერე ჩემი კომპიუტერი დრაივერის პროგრამული უზრუნველყოფისთვის
" ეს საშუალებას მოგცემთ აირჩიოთ მძღოლი, რომელიც მოყვა Arduino IDE– ს.
ნაბიჯი 7. დააწკაპუნეთ "დათვალიერებაზე" და გადადით საქაღალდეში, რომელიც ადრე ამოიღეთ
შიგნით ნახავთ "მძღოლების" საქაღალდეს.
ნაბიჯი 8. აირჩიეთ "მძღოლების" საქაღალდე და დააჭირეთ "OK"
" დაადასტურეთ, რომ გსურთ გააგრძელოთ, თუ გაფრთხილებული ხართ უცნობი პროგრამული უზრუნველყოფის შესახებ.
ნაწილი 6 -დან 6: რობოტის დაპროგრამება
ნაბიჯი 1. დაიწყეთ Arduino IDE IDE საქაღალდეში arduino.exe ფაილის ორჯერ დაწკაპუნებით
თქვენ დახვდებით ცარიელი პროექტით.
ნაბიჯი 2. ჩასვით შემდეგი კოდი, რომ თქვენი რობოტი წავიდეს პირდაპირ
ქვემოთ მოყვანილი კოდი გახდის თქვენს არდუინოს განუწყვეტლივ წინსვლას.
#მოიცავს // ეს პროგრამაში ამატებს "სერვოს" ბიბლიოთეკას // ქვემოთ იქმნება ორი servo ობიექტი Servo leftMotor; Servo rightMotor; void setup () {leftMotor.attach (12); // თუ თქვენ შემთხვევით გადართეთ პინ ნომრები თქვენს სერვისებზე, შეგიძლიათ შეცვალოთ ნომრები აქ მარჯვნივMotor.attach (13); } void loop () {leftMotor.write (180); // უწყვეტი ბრუნვით, 180 ეუბნება სერვას, რომ გადავიდეს სრული სიჩქარით "წინ". მარჯვენა მოტორ. ჩაწერა (0); // თუ ორივე 180 -ზეა, რობოტი წრეში წავა, რადგან სერვოები გადატრიალებულია. "0", ეუბნება მას სრული სიჩქარით გადაადგილება "უკან". }
ნაბიჯი 3. შექმენით და ატვირთეთ პროგრამა
დააწკაპუნეთ მარჯვენა ისრის ღილაკზე ზედა მარცხენა კუთხეში, რომ ააწყოთ და ატვირთოთ პროგრამა დაკავშირებულ არდუინოში.
შეიძლება დაგჭირდეთ რობოტის ამოღება ზედაპირზე, რადგან ის უბრალოდ გააგრძელებს წინსვლას პროგრამის ატვირთვის შემდეგ
ნაბიჯი 4. დაამატეთ kill switch ფუნქცია
დაამატეთ შემდეგი კოდი თქვენი კოდის "void loop ()" განყოფილებაში, რათა ჩართოთ kill switch, "write ()" ფუნქციების ზემოთ.
if (digitalRead (2) == HIGH) // ეს რეგისტრირდება, როდესაც ღილაკი დაჭერილია Arduino პინ 2 -ზე {while (1) {leftMotor.write (90); // "90" არის ნეიტრალური პოზიცია სერვოებისთვის, რაც მათ ეუბნება შეწყვიტონ მარჯვნივ შემობრუნება Motor.write (90); }}
ნაბიჯი 5. ატვირთეთ და შეამოწმეთ თქვენი კოდი
დამატებული kill გადამრთველის კოდით, შეგიძლიათ ატვირთოთ და გამოსცადოთ რობოტი. მან უნდა გააგრძელოს წინსვლა სანამ არ დააჭერთ გადამრთველს, ამ დროს ის შეწყვეტს მოძრაობას. სრული კოდი ასე უნდა გამოიყურებოდეს:
#მოიცავს // ქვემოთ იქმნება ორი servo ობიექტი Servo leftMotor; Servo rightMotor; void setup () {leftMotor.attach (12); rightMotor.attach (13); } void loop () {if (digitalRead (2) == HIGH) {while (1) {leftMotor.write (90); rightMotor.write (90); }} leftMotor.write (180); rightMotor.write (0); }
მე -6 ნაწილი 6 -დან: მაგალითი
ნაბიჯი 1. მიჰყევით მაგალითს
შემდეგი კოდი გამოიყენებს რობოტზე მიმაგრებულ სენსორს, რათა ის გადაუხვიოს მარცხნივ, როდესაც ის შეხვდება დაბრკოლებას. იხილეთ კომენტარებში კოდი დეტალებისთვის იმის შესახებ, თუ რას აკეთებს თითოეული ნაწილი. ქვემოთ მოყვანილი კოდი არის მთელი პროგრამა.
#ჩართეთ სერვო მარცხენაძრავი; Servo rightMotor; const int serialPeriod = 250; // ეს ზღუდავს გამომავალს კონსოლზე ყოველ 1/4 წამში ერთხელ ხელმოუწერელ დიდხანს SerialDelay = 0; const int loop პერიოდი = 20; // ეს ადგენს, რამდენად ხშირად ატარებს სენსორი კითხვას 20ms- მდე, რაც არის სიხშირე 50 Hz ხელმოუწერელი დიდი ხნის განმავლობაში LoopDelay = 0; // ეს ანიჭებს TRIG და ECHO ფუნქციებს არდუინოს ქინძისთავებს. შეცვალეთ რიცხვები აქ თუ სხვაგვარად დაუკავშირდით const int ultrasonic2TrigPin = 8; const int ულტრაბგერითი 2EchoPin = 9; int ულტრაბგერითი 2 მანძილი; int ულტრაბგერითი ხანგრძლივობა; // ეს განსაზღვრავს რობოტის ორ შესაძლო მდგომარეობას: წინსვლა ან მარცხნივ მოქცევა #განსაზღვრეთ DRIVE_FORWARD 0 #განსაზღვრეთ TURN_LEFT 1 int state = DRIVE_FORWARD; // 0 = მართვა წინ (DEFAULT), 1 = მოუხვიეთ მარცხნივ void setup () {Serial.begin (9600); // ამ სენსორის პინის კონფიგურაციები pinMode (ულტრაბგერითი 2TrigPin, OUTPUT); pinMode (ულტრაბგერითი 2EchoPin, INPUT); // ეს ანიჭებს ძრავებს Arduino ქინძისთავებს leftMotor.attach (12); rightMotor.attach (13); } void loop () {if (digitalRead (2) == HIGH) // ეს ამოიცნობს kill switch {while (1) {leftMotor.write (90); rightMotor.write (90); }} debugOutput (); // ეს ბეჭდავს გამართვის შეტყობინებებს სერიულ კონსოლში if (millis () - timeLoopDelay> = loopPeriod) {readUltrasonicSensors (); // ეს ავალებს სენსორს წაიკითხოს და შეინახოს გაზომილი მანძილები stateMachine (); timeLoopDelay = მილი (); }} void stateMachine () {if (state == DRIVE_FORWARD) // თუ დაბრკოლებები არ გამოვლენილა {if (ultrasonic2Distance> 6 || ultrasonic2Distance <0) // თუ რობოტის წინ არაფერია ულტრაბგერითი დისტანცია უარყოფითი იქნება ზოგიერთი ექოსკოპიისათვის, თუ არ არსებობს დაბრკოლება {// მართეთ მარჯვნივ rightMotor.write (180); leftMotor.write (0); } else // თუ ჩვენს წინ არის ობიექტი {state = TURN_LEFT; }} else if (მდგომარეობა == TURN_LEFT) // თუ რაიმე დაბრკოლება გამოვლინდა, მოუხვიეთ მარცხნივ {ხელმოუწერელი long timeToTurnLeft = 500; // 90 გრადუსზე დასაბრუნებლად დაახლოებით.5 წამი სჭირდება. თქვენ შეიძლება დაგჭირდეთ ამის მორგება, თუ თქვენი ბორბლები სხვა ზომისაა ვიდრე ხელმოუწერელი გრძელი turnStartTime = millis (); // დაზოგეთ ის დრო, როდესაც ჩვენ დავიწყეთ შემობრუნება ((millis ()-turnStartTime) <timeToTurnLeft) // დარჩით ამ მარყუჟში, სანამ დრო არ გასულა {/ TOTURLeft {/ მოუხვიეთ მარცხნივ, გახსოვდეთ, რომ როდესაც ორივე დაყენებულია "180"-ზე ის ბრუნდება რა rightMotor.write (180); leftMotor.write (180); } სახელმწიფო = DRIVE_FORWARD; }} void readUltrasonicSensors () {// ეს არის ულტრაბგერითი 2. შეიძლება დაგჭირდეთ ამ ბრძანებების შეცვლა, თუ სხვა სენსორს იყენებთ. digitalWrite (ultrasonic2TrigPin, HIGH); გადადება მიკრო წამი (10); // ინარჩუნებს ტრიგერის მაღალ დონეს მინიმუმ 10 მიკროწამი digitalWrite (ultrasonic2TrigPin, LOW); ultrasonic2Duration = pulseIn (ultrasonic2EchoPin, HIGH); ულტრაბგერითი 2 მანძილი = (ულტრაბგერითი 2 ხანგრძლივობა/2)/29; } // ქვემოთ მოცემულია კონსოლში შეცდომების გამართვისთვის. void debugOutput () {if ((millis () - timeSerialDelay)> serialPeriod) {Serial.print ("ultrasonic2Distance:"); Serial.print (ულტრაბგერითი 2 დისტანცია); Serial.print ("სმ"); Serial.println (); timeSerialDelay = მილი (); }}
