მარტივი და ჭკვიანი რობოტული მკლავი არდუინოს გამოყენებით !!!: 5 ნაბიჯი (სურათებით)

2024 ავტორი: John Day | [email protected]. ბოლოს შეცვლილი: 2024-01-30 10:19

ამ სასწავლო ინსტრუქციაში მე გავაკეთებ მარტივ რობოტულ მკლავს. რომელიც კონტროლდება სამაგისტრო ხელის გამოყენებით. მკლავი დაიმახსოვრებს მოძრაობებს და თანმიმდევრობით ითამაშებს. კონცეფცია არ არის ახალი. მე მივიღე იდეა "მინი რობოტული მკლავისგან -სტოპერპიკის" მიერ, მინდოდა ამის გაკეთება დიდი ხნის განმავლობაში, მაგრამ მაშინ მე სრულიად არაფრისმთქმელი ვიყავი და არ მქონდა არანაირი ცოდნა პროგრამირების შესახებ. ახლა მე საბოლოოდ ვაშენებ ერთს, ვინახავ მარტივად, იაფად და გაგიზიარებთ ყველას.

ასე რომ დავიწყოთ ….

ნაბიჯი 1: ის, რაც დაგჭირდებათ:-

აქ არის ნივთების ჩამონათვალი, რაც დაგჭირდებათ:-

1. სერვო ძრავები x 5 ბმული აშშ-სთვის:- https://amzn.to/2OxbSH7 ბმული ევროპისთვის:-

2. პოტენომეტრები x 5 (მე გამოვიყენე 100k.) ბმული აშშ-სთვის:- https://amzn.to/2ROjhDMLink ევროპისთვის:-

3. არდუინო გაერო. (თქვენ ასევე შეგიძლიათ გამოიყენოთ Arduino Nano) ბმული აშშ-სთვის:- https://amzn.to/2DBbENW ბმული ევროპისთვის:-

4. პურის დაფა. (მე ვთავაზობ ამ ნაკრს) ბმული აშშ-სთვის:- https://amzn.to/2Dy86w4 ბმული ევროპისთვის:-

5. ბატარეა. (სურვილისამებრ, მე ვიყენებ 5 ვ ადაპტერს)

6. მუყაო/ხე/მზის დაფა/აკრილის რაც არის ხელმისაწვდომი ან ადვილი მოსაპოვებელი.

ასევე დაგჭირდებათ Arduino IDE დაყენებული.

ნაბიჯი 2: ხელის დამზადება:-

აქ მე გამოვიყენე Popsicle ჩხირები მკლავის გასაკეთებლად. თქვენ შეგიძლიათ გამოიყენოთ ნებისმიერი მასალა, რომელიც თქვენთვის ხელმისაწვდომია. და თქვენ შეგიძლიათ სცადოთ სხვადასხვა მექანიკური დიზაინი, რომ გახადოთ უკეთესი მკლავი. ჩემი დიზაინი არ არის ძალიან სტაბილური.

მე უბრალოდ ორმაგი ცალმხრივი ლენტი გამოვიყენე, რათა სერვოები გამეკეთებინა Popsicle ჯოხზე და დამაგრებულიყო ხრახნების გამოყენებით.

სამაგისტრო მკლავისთვის მე დავამატე პოტენომეტრები ყურძნის ჩხირებზე და გავაკეთე ხელი.

სურათების მითითება მოგცემთ უკეთეს იდეას.

მე ყველაფერი მაქვს დამონტაჟებული A4 ზომის ტილოს დაფაზე, რომელიც გამოიყენება როგორც ბაზა.

ნაბიჯი 3: კავშირის დამყარება:-

ამ ნაბიჯში ჩვენ გავაკეთებთ ყველა საჭირო კავშირს, იხილეთ სურათები ზემოთ.

• პირველ რიგში დააკავშირეთ ყველა სერვისი კვების ბლოკის პარალელურად (წითელი მავთული +ve და შავი ან ყავისფერი მავთულები Gnd– თან)
• შემდეგ შეაერთეთ სიგნალის მავთულები, ანუ ყვითელი ან ნარინჯისფერი მავთულები არდუინოს PWM პინთან.
• ახლა შეაერთეთ პოტენომეტრები +5v და Gnd არდუინოს პარალელურად.
• შეაერთეთ შუა ტერმინალი ardunio– ს ანალოგიურ პინთან.

აქ ციფრული ქინძისთავები 3, 5, 6, 9 და 10 გამოიყენება სერვისების გასაკონტროლებლად

ანალოგიური ქინძისთავები A0- დან A4- მდე გამოიყენება პოტენციომეტრიდან შესასვლელად.

პინ 3 -თან დაკავშირებული სერვო კონტროლდება A0- სთან დაკავშირებული პოტენომეტრით

პინ 5 -თან დაკავშირებული სერვო კონტროლირებადი იქნება ქოთნით A1- ზე და ასე შემდეგ….

შენიშვნა:- მიუხედავად იმისა, რომ Servos არ მუშაობს arduino– ით, დარწმუნდით, რომ სერვოს Gnd დაუკავშირეთ arduino– ს, წინააღმდეგ შემთხვევაში ხელი არ იმუშავებს.

ნაბიჯი 4: კოდირება:-

ამ კოდის ლოგიკა საკმაოდ მარტივია, პოტენომეტრების მნიშვნელობები ინახება მასივში, შემდეგ ჩანაწერები იმოძრავებს for მარყუჟის გამოყენებით და სერვისები აკეთებენ ნაბიჯებს მნიშვნელობების მიხედვით. თქვენ შეგიძლიათ გაეცნოთ ამ გაკვეთილს, რომელიც მე გამოვიყენე მითითებისთვის "Arduino Potentiometer Servo Control & Memory"

კოდი:- (გადმოსაწერი ფაილი თანდართულია ქვემოთ.)

პირველ რიგში ჩვენ გამოვაცხადებთ ყველა საჭირო ცვლადს გლობალურად, ასე რომ ჩვენ შეგვიძლია გამოვიყენოთ ისინი მთელი პროგრამის განმავლობაში. ამისათვის სპეციალური ახსნა არ არის საჭირო

#ჩართეთ

// Servo Objects Servo Servo_0; სერვო სერვო_1; სერვო სერვო_2; სერვო სერვო_3; სერვო სერვო_4; // პოტენომეტრის ობიექტები int Pot_0; int Pot_1; int Pot_2; int pot_3; int Pot_4; // ცვლადი შესანახად Servo Position int Servo_0_Pos; int Servo_1_Pos; int Servo_2_Pos; int Servo_3_Pos; int Servo_4_Pos; // ცვლადი წინა პოზიციის მნიშვნელობების შესანახად int Prev_0_Pos; int Prev_1_Pos; int Prev_2_Pos; int წინა_3_ დადებითი; int წინა_4_ დადებითი; // ცვლადი მიმდინარე პოზიციის მნიშვნელობების შესანახად int Current_0_Pos; int მიმდინარე_1_ დადებითი; int მიმდინარე_2_ დადებითი; int მიმდინარე_3_ დადებითი; int მიმდინარე_4_ დადებითი; int Servo_Position; // ინახავს კუთხეს int Servo_Number; // ინახავს no servo int Storage [600]; // მასივი მონაცემების შესანახად (მასივის ზომის გაზრდა მოიხმარს მეტ მეხსიერებას) int ინდექსი = 0; // მასივის ინდექსი იწყება 0 პოზიციიდან char მონაცემები = 0; // ცვლადი მონაცემების შესანახად სერიული შეყვანისგან.

ახლა ჩვენ დავწერთ კონფიგურაციის ფუნქციას, სადაც დავაყენებთ ქინძისთავებს და მათ ფუნქციებს. ეს არის მთავარი ფუნქცია, რომელიც პირველად ასრულებს

ბათილად დაყენება ()

{Serial.begin (9600); // arduino– სა და IDE– ს შორის სერიული კომუნიკაციისთვის. // სერვო ობიექტები მიმაგრებულია PWM ქინძისთავებზე. Servo_0.atach (3); Servo_1.atach (5); Servo_2.attach (6); Servo_3. მიმაგრება (9); Servo_4. მიმაგრება (10); // სერვოები ინიციალიზაციისას დაყენებულია 100 პოზიციაზე. Servo_0. დაწერა (100); Servo_1. დაწერეთ (100); Servo_2. დაწერეთ (100); Servo_3. დაწერე (100); Servo_4. დაწერე (100); Serial.println ("დააჭირეთ 'R' ჩაწერას და 'P' სათამაშოდ"); }

ახლა ჩვენ უნდა წავიკითხოთ პოტენომეტრების მნიშვნელობები ანალოგური შეყვანის ქინძისთავების გამოყენებით და დავნიშნოთ ისინი სერვისების გასაკონტროლებლად. ამისათვის ჩვენ განვსაზღვრავთ ფუნქციას და დავარქმევთ მას Map_Pot ();, შეგიძლიათ დაასახელოთ ის რაც გსურთ, ეს არის მომხმარებლის მიერ განსაზღვრული ფუნქცია

ბათილია Map_Pot ()

{ / * სერვოები ბრუნავს 180 გრადუსზე, მაგრამ მისი შეზღუდვების გამოყენება არ არის კარგი იდეა, რადგანაც ის ხდის სერვოს გამუდმებით ზუზუნს რაც შემაშფოთებელია, ამიტომ ჩვენ ვზღუდავთ სერვოს გადაადგილებას შორის: 1-179 * / Pot_0 = analogRead (A0); // წაიკითხეთ შეყვანილი ქოთნიდან და შეინახეთ იგი ცვლადი ქოთანში_0. Servo_0_Pos = რუკა (Pot_0, 0, 1023, 1, 179); // რუქა servos 0 - დან 1023 - მდე Servo_0.write (Servo_0_Pos) მნიშვნელობის მიხედვით; // გადაიტანეთ სერვო იმ პოზიციაზე. Pot_1 = analogRead (A1); Servo_1_Pos = რუკა (Pot_1, 0, 1023, 1, 179); Servo_1. დაწერეთ (Servo_1_Pos); Pot_2 = analogRead (A2); Servo_2_Pos = რუკა (Pot_2, 0, 1023, 1, 179); Servo_2. დაწერეთ (Servo_2_Pos); Pot_3 = analogRead (A3); Servo_3_Pos = რუკა (Pot_3, 0, 1023, 1, 179); Servo_3. წერენ (Servo_3_Pos); Pot_4 = analogRead (A4); Servo_4_Pos = რუკა (Pot_4, 0, 1023, 1, 179); Servo_4. წერენ (Servo_4_Pos); }

ახლა ჩვენ დავწერთ მარყუჟის ფუნქციას:

ბათილი მარყუჟი ()

{Map_Pot (); // ფუნქცია ზარი წაკითხვის pot ღირებულებების ხოლო (Serial.available ()> 0) {data = Serial.read (); if (მონაცემები == 'R') Serial.println ("მოძრაობების ჩაწერა …"); if (მონაცემები == 'P') Serial.println ("ჩაწერილი მოძრაობების დაკვრა …"); } if (მონაცემები == 'R') // თუ 'R' არის შეყვანილი, დაიწყეთ ჩაწერა. {// შეინახეთ მნიშვნელობები ცვლადში Prev_0_Pos = Servo_0_Pos; წინა_1_პოზიცია = სერვო_1_პოზიცია; წინა_2_Pos = Servo_2_Pos; წინა_3_პოზიცია = სერვო_3_პოზიცია; წინა_4_პოზიცია = სერვო_4_პოზიცია; Map_Pot (); // რუქის ფუნქცია გაიხსენა შედარებისთვის თუ (abs (Prev_0_Pos == Servo_0_Pos)) // აბსოლუტური მნიშვნელობა მიიღება {Servo_0.write (Servo_0_Pos) შედარებისას; // თუ ღირებულებები ემთხვევა servo გადაადგილდება if (Current_0_Pos! = Servo_0_Pos) // თუ მნიშვნელობები არ ემთხვევა {Storage [Index] = Servo_0_Pos + 0; // მნიშვნელობა ემატება მასივის ინდექსს ++; // ინდექსის ღირებულება გაზრდილია 1} მიმდინარე_0_Pos = Servo_0_Pos; } /* ანალოგიურად ღირებულების შედარება ხდება ყველა სერვისისთვის, +100 ემატება ყოველ შესვლისთვის, როგორც დიფერენციალური მნიშვნელობა. */ if (abs (Prev_1_Pos == Servo_1_Pos)) {Servo_1. დაწერეთ (Servo_1_Pos); if (მიმდინარე_1_Pos! = Servo_1_Pos) {Storage [Index] = Servo_1_Pos + 100; ინდექსი ++; } მიმდინარე_1_Pos = Servo_1_Pos; } if (abs (Prev_2_Pos == Servo_2_Pos)) {Servo_2.write (Servo_2_Pos); თუ (მიმდინარე_2_Pos! = Servo_2_Pos) {შენახვა [ინდექსი] = Servo_2_Pos + 200; ინდექსი ++; } მიმდინარე_2_Pos = Servo_2_Pos; } if (abs (Prev_3_Pos == Servo_3_Pos)) {Servo_3.write (Servo_3_Pos); if (მიმდინარე_3_Pos! = Servo_3_Pos) {შენახვა [ინდექსი] = Servo_3_Pos + 300; ინდექსი ++; } მიმდინარე_3_Pos = Servo_3_Pos; } if (abs (Prev_4_Pos == Servo_4_Pos)) {Servo_4.write (Servo_4_Pos); if (მიმდინარე_4_Pos! = Servo_4_Pos) {შენახვა [ინდექსი] = Servo_4_Pos + 400; ინდექსი ++; } მიმდინარე_4_Pos = Servo_4_Pos; } / * მნიშვნელობები იბეჭდება სერიულ მონიტორზე, '\ t' არის მნიშვნელობების ჩვენებისათვის ცხრილის ფორმატში * / Serial.print (Servo_0_Pos); Serial.print ("\ t"); Serial.print (Servo_1_Pos); Serial.print ("\ t"); Serial.print (Servo_2_Pos); Serial.print ("\ t"); Serial.print (Servo_3_Pos); Serial.print ("\ t"); Serial.println (Servo_4_Pos); Serial.print ("ინდექსი ="); Serial.println (ინდექსი); დაგვიანება (50); } თუ (მონაცემები == 'P') // IF 'P' შეყვანილია, დაიწყეთ ჩაწერილი მოძრაობების დაკვრა. {for (int i = 0; i <ინდექსი; i ++) // გადაკვეთეთ მასივი მარყუჟისათვის {Servo_Number = Storage /100; // პოულობს სერვისის რაოდენობას Servo_Position = შენახვის % 100; // პოულობს servo switch- ის პოზიციას (Servo_Number) {case 0: Servo_0.write (Servo_Position); შესვენება; საქმე 1: Servo_1.write (Servo_Position); შესვენება; შემთხვევა 2: Servo_2.write (Servo_Position); შესვენება; შემთხვევა 3: Servo_3.write (Servo_Position); შესვენება; შემთხვევა 4: Servo_4.write (Servo_Position); შესვენება; } დაყოვნება (50); }}}

მას შემდეგ რაც კოდი მზად არის, ახლა ატვირთეთ იგი arduino დაფაზე

Smart arm მზად არის სამუშაოდ. ფუნქცია ჯერ კიდევ არ არის ისეთი გლუვი, როგორც სტოპერპიკის მიერ გაკეთებული.

თუ შეგიძლიათ კოდი გააუმჯობესოთ ან რაიმე შემოთავაზება გქონდეთ, გთხოვთ შემატყობინოთ კომენტარების განყოფილებაში.

ამის თქმით, მოდით გადავიდეთ ტესტირებაზე ….

ნაბიჯი 5: ტესტირება:-

კოდის დაფაზე წარმატებით ატვირთვის შემდეგ, გახსენით 'სერიული მონიტორი' შეგიძლიათ იხილოთ ინსტრუმენტების ვარიანტში. სერიული მონიტორის დაწყებისთანავე არდუინო გადატვირთულია. ახლა თქვენ შეგიძლიათ აკონტროლოთ რობოტული მკლავი სამაგისტრო ხელის გამოყენებით. მაგრამ არაფერი აღირიცხება.

ჩაწერის დასაწყებად, მონიტორში შეიყვანეთ 'R', შეგიძლიათ შეასრულოთ ის სვლა, რომლის ჩაწერაც გსურთ.

მოძრაობების დასრულების შემდეგ თქვენ უნდა შეიყვანოთ 'P', რათა ჩაწერილი მოძრაობები ითამაშოთ. სერვოები გააგრძელებენ მოძრაობების შესრულებას მანამ, სანამ დაფა არ არის გადატვირთული.