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