Pan-Tilt Multi Servo Control: 11 ნაბიჯი (სურათებით)

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

ამ გაკვეთილზე ჩვენ შევისწავლით როგორ გავაკონტროლოთ მრავალი სერვისი პითონის გამოყენებით Raspberry Pi– ზე. ჩვენი მიზანი იქნება PAN/TILT მექანიზმი კამერის დასაყენებლად (PiCam).

აქ შეგიძლიათ ნახოთ როგორ იმუშავებს ჩვენი საბოლოო პროექტი:

Control Servo Control loop ტესტი:

ნაბიჯი 1: BoM - Bill of Material

ძირითადი ნაწილები:

1. ჟოლო Pi V3 - 32,00 აშშ დოლარი
2. 5 მეგაპიქსელიანი 1080p სენსორი OV5647 მინი კამერის ვიდეო მოდული - 13,00 აშშ დოლარი
3. TowerPro SG90 9G 180 გრადუსიანი მიკრო სერვო (2 X)- 4.00 აშშ დოლარი
4. მინი პან/ დახრის კამერის პლატფორმა ანტი ვიბრაციული კამერა მთაზე 2 სერვისი (*) - 8.00 აშშ დოლარი
5. რეზისტორი 1K ohm (2X) - სურვილისამებრ
6. სხვადასხვა: ლითონის ნაწილები, ზოლები და სხვა (იმ შემთხვევაში, თუ თქვენ ააშენებთ თქვენს პან/დახრის მექანიზმს)

(*) შეგიძლიათ შეიძინოთ სრული Pan/Tilt პლატფორმა სერვოებთან ერთად ან ააწყოთ საკუთარი.

ნაბიჯი 2: როგორ მუშაობს PWM

Raspberry Pi– ს არ აქვს ანალოგური გამომუშავება, მაგრამ ამის სიმულაცია შეგვიძლია PWM (პულსის სიგანის მოდულაციის) მიდგომის გამოყენებით. რასაც ჩვენ გავაკეთებთ არის ციფრული სიგნალის გენერირება ფიქსირებული სიხშირით, სადაც ჩვენ შევცვლით პულსის მატარებლის სიგანეს, რაც იქნება "თარგმნილი" როგორც "საშუალო" გამომავალი ძაბვის დონე, როგორც ნაჩვენებია ქვემოთ:

ჩვენ შეგვიძლია გამოვიყენოთ ეს "საშუალო" ძაბვის დონე LED სიკაშკაშის გასაკონტროლებლად, მაგალითად:

გაითვალისწინეთ, რომ აქ მნიშვნელოვანია არა თავად სიხშირე, არამედ "მოვალეობის ციკლი", ეს არის კავშირი იმ დროს შორის, როდესაც პულსი "მაღალია" გაყოფილი ტალღის პერიოდზე. მაგალითად, დავუშვათ, რომ ჩვენ შევქმნით 50Hz პულსის სიხშირეს ჩვენს ერთ Raspberry Pi GPIO- ზე. პერიოდი (p) იქნება ინვერსიული სიხშირის ან 20ms (1/f). თუ ჩვენ გვინდა, რომ ჩვენი LED "ნახევრად" ნათელია, ჩვენ უნდა გვქონდეს Duty Cycle 50%, ეს ნიშნავს "პულსი", რომელიც იქნება "მაღალი" 10 ms.

ეს პრინციპი ჩვენთვის ძალიან მნიშვნელოვანი იქნება, რომ გავაკონტროლოთ ჩვენი სერვო პოზიცია, მას შემდეგ რაც "სამუშაო ციკლი" განსაზღვრავს სერვო პოზიციას, როგორც ეს ნაჩვენებია ქვემოთ:

სერვო

ნაბიჯი 3: Hw- ს დაყენება

სერვისები დაუკავშირდება გარე 5 ვ წყაროს, მათი მონაცემების პინი (ჩემს შემთხვევაში, მათი ყვითელი გაყვანილობა) დაუკავშირდება Raspberry Pi GPIO– ს, როგორც ქვემოთ:

• GPIO 17 ==> Tilt Servo
• GPIO 27 ==> პან სერვო

არ დაგავიწყდეთ GND– ების ერთმანეთთან დაკავშირება ==> Raspberry Pi - Servos - გარე კვების წყარო)

თქვენ შეგიძლიათ გქონდეთ როგორც ვარიანტი, 1K ომის რეზისტორი Raspberry Pi GPIO- ს და სერვერის მონაცემთა შეყვანის პინს შორის. ეს დაიცავს თქვენს RPi სერვო პრობლემის შემთხვევაში.

ნაბიჯი 4: სერვოსის კალიბრაცია

პირველი რაც თქვენ უნდა გააკეთოთ არის დაადასტუროთ თქვენი სერვისების ძირითადი მახასიათებლები. ჩემს შემთხვევაში, მე ვიყენებ Power Pro SG90- ს.

მისი მონაცემთა ცხრილიდან შეგვიძლია განვიხილოთ:

• დიაპაზონი: 180o
• კვების ბლოკი: 4.8V (გარე 5VDC როგორც USB კვების წყარო მუშაობს კარგად)
• სამუშაო სიხშირე: 50Hz (პერიოდი: 20 ms)
• პულსის სიგანე: 1 ms– დან 2 ms

თეორიულად, სერვო იქნება მასზე

• საწყისი პოზიცია (0 გრადუსი), როდესაც 1ms პულსი გამოიყენება მის მონაცემთა ტერმინალზე
• ნეიტრალური პოზიცია (90 გრადუსი), როდესაც პულსი 1.5 ms გამოიყენება მის მონაცემთა ტერმინალზე
• საბოლოო პოზიცია (180 გრადუსი) როდესაც 2 ms პულსი გამოიყენება მის მონაცემთა ტერმინალზე

პითონის გამოყენებით servo პოზიციის დასაპროგრამებლად ძალიან მნიშვნელოვანია იცოდეთ კორესპონდენტი "Duty Cycle" ზემოაღნიშნული პოზიციებისთვის, მოდით გავაკეთოთ გაანგარიშება:

• საწყისი პოზიცია ==> (0 გრადუსი) პულსის სიგანე ==> 1ms ==> სამუშაო ციკლი = 1ms/20ms ==> 2.0%
• ნეიტრალური პოზიცია (90 გრადუსი) პულსის სიგანე 1.5 ms ==> სამუშაო ციკლი = 1.5ms/20ms ==> 7.5%
• საბოლოო პოზიცია (180 გრადუსი) პულსის სიგანე 2 ms ==> Duty Cycle = 2ms/20ms ==> 10%

ამრიგად, სამუშაო ციკლი უნდა განსხვავდებოდეს 2 -დან 10 %-მდე.

მოდით შევამოწმოთ სერვოები ინდივიდუალურად. ამისათვის გახსენით თქვენი ჟოლოს ტერმინალი და გაუშვით თქვენი Python 3 shell რედაქტორი, როგორც "sudo" (თქვენს გამო უნდა იყოთ "სუპერ მომხმარებელი" GPIO– ებთან მუშაობისთვის):

sudo python3

პითონ შელზე

>>

იმპორტი RPI. GPIO მოდული და მას GPIO:

იმპორტი RPi. GPIO როგორც GPIO

განსაზღვრეთ რომელი პინ-ნუმერაციის სქემები გსურთ გამოიყენოთ (BCM ან BOARD). მე ეს ტესტი გავაკეთე BOARD– ით, ამიტომ პინები, რომლებიც მე გამოვიყენე, იყო ფიზიკური ქინძისთავები (GPIO 17 = Pin 11 და GPIO 27 Pin 13). ჩემთვის ადვილი იყო მათი იდენტიფიცირება და ტესტის დროს შეცდომების დაშვება (საბოლოო პროგრამაში გამოვიყენებ BCM). შეარჩიეთ თქვენთვის სასურველი ვარიანტი:

GPIO.setmode (GPIO. BOARD)

განსაზღვრეთ servo pin, რომელსაც თქვენ იყენებთ:

tiltPin = 11

თუ ამის ნაცვლად, თქვენ გამოიყენეთ BCM სქემა, ბოლო 2 ბრძანება უნდა შეიცვალოს შემდეგით:

GPIO.setmode (GPIO. BCM)

tiltPin = 17

ახლა ჩვენ უნდა დავაზუსტოთ, რომ ეს პინი იქნება "გამომავალი"

GPIO.setup (tiltPin, GPIO. OUT)

და რა სიხშირე იქნება გამომუშავებული ამ პინზე, ჩვენი სერვოსთვის იქნება 50 ჰც:

დახრა = GPIO. PWM (tiltPin, 50)

ახლა, დავიწყოთ PWM სიგნალის გენერირება პინზე პირველადი მოვალეობის ციკლით (ჩვენ შევინარჩუნებთ მას "0"):

დახრა = დაწყება (0)

ახლა თქვენ შეგიძლიათ შეიყვანოთ სხვადასხვა მოვალეობის ციკლის მნიშვნელობები, დააკვირდეთ თქვენი სერვოს მოძრაობას. დავიწყოთ 2% -ით და ვნახოთ რა ხდება (ჩვენ ვხედავთ, რომ სერვო მიდის "ნულოვან პოზიციაში"):

დახრა. ChangeDutyCycle (2)

ჩემს შემთხვევაში, სერვო გადავიდა ნულოვან პოზიციაზე, მაგრამ როდესაც მე შევცვალე სამუშაო ციკლი 3% –ზე, მე დავინახე, რომ სერვო დარჩა იმავე პოზიციაზე, დავიწყე მოძრაობა 3% –ზე მეტი მოვალეობის ციკლით. ასე რომ, 3% არის ჩემი საწყისი პოზიცია (o გრადუსი). იგივე მოხდა 10%–ით, ჩემი სერვო ამ მაჩვენებელზე მაღლა წავიდა და მისი ბოლო 13%–ს მიაღწია. ამ კონკრეტული სერვისისთვის, შედეგი იყო:

• 0 ხარისხი ==> სამუშაო ციკლი 3%
• 90 გრადუსი ==> სამუშაო ციკლი 8%
• 180 გრადუსი ==> სამუშაო ციკლი 13%

ტესტების დასრულების შემდეგ, თქვენ უნდა შეაჩეროთ PWM და გაწმინდოთ GPIO– ები:

დახრა = გაჩერება ()

GPIO.cleanup ()

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

ნაბიჯი 5: პითონის სკრიპტის შექმნა

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

Როგორ გავაკეთო ეს? Ძალიან მარტივი! ჩვენ ვიცით, რომ მოვალეობის ციკლის დიაპაზონი 3% -დან 13% -მდეა და ეს არის ეკვივალენტური კუთხეებისა, რომლებიც მერყეობს 0 -დან 180 გრადუსამდე. ასევე, ჩვენ ვიცით, რომ ეს ვარიაციები არის ხაზოვანი, ასე რომ ჩვენ შეგვიძლია ავაშენოთ პროპორციული სქემა, როგორც ზემოთ ნაჩვენებია. ასე რომ, კუთხის გათვალისწინებით, ჩვენ შეგვიძლია გვქონდეს შესაბამისი სამუშაო ციკლი:

მორიგე = კუთხე/18 + 3

შეინახეთ ეს ფორმულა. ჩვენ გამოვიყენებთ მას შემდეგ კოდში.

მოდით შევქმნათ პითონის სკრიპტი ტესტების შესასრულებლად. ძირითადად, ჩვენ გავიმეორებთ იმას, რაც ადრე გავაკეთეთ Python Shell– ზე:

დროიდან იმპორტი ძილის

იმპორტი RPi. GPIO როგორც GPIO GPIO.setmode (GPIO. BCM) GPIO.setwarnings (false) def setServoAngle (servo, angle): pwm = GPIO. PWM (servo, 50) pwm.start (8) dutyCycle = angle / 18. + 3. pwm. ChangeDutyCycle (dutyCycle) ძილი (0.3) pwm.stop () თუ _name_ == '_main_': იმპორტი sys servo = int (sys.argv [1]) GPIO.setup (servo, GPIO. OUT) setServoAngle (servo, int (sys.argv [2])) GPIO.cleanup ()

ზემოთ მოყვანილი კოდის ბირთვია ფუნქცია setServoAngle (servo, კუთხე). ეს ფუნქცია იღებს არგუმენტებს, სერვო GPIO ნომერს და კუთხის მნიშვნელობას, სადაც უნდა იყოს სერვო განლაგებული. მას შემდეგ რაც ამ ფუნქციის შეყვანა არის "კუთხე", ჩვენ უნდა გადავაქციოთ პროცენტულად მოვალეობის ციკლზე, ადრე შემუშავებული ფორმულის გამოყენებით.

როდესაც სკრიპტი შესრულებულია, თქვენ უნდა შეიყვანოთ როგორც პარამეტრები, servo GPIO და კუთხე.

Მაგალითად:

sudo python3 angleServoCtrl.py 17 45

ზემოაღნიშნული ბრძანება განათავსებს სერვიოს GPIO 17 -თან დაკავშირებულს 45 გრადუსით "სიმაღლეზე". მსგავსი ბრძანება შეიძლება გამოყენებულ იქნას პან სერვო კონტროლისთვის (პოზიცია 45 გრადუსამდე "აზიმუტში"):

sudo python angleServoCtrl.py 27 45

ფაილის angleServoCtrl.py გადმოწერა შესაძლებელია ჩემი GitHub– დან

ნაბიჯი 6: პან-დახრის მექანიზმი

"Pan" servo გადაადგილდება "ჰორიზონტალურად" ჩვენს კამერაზე ("აზიმუტის კუთხე") და ჩვენი "Tilt" servo გადავა მას "ვერტიკალურად" (სიმაღლის კუთხე).

ქვემოთ მოყვანილი სურათი გვიჩვენებს, თუ როგორ მუშაობს Pan/Tilt მექანიზმი:

ჩვენი განვითარების პროცესში ჩვენ არ გადავალთ "უკიდურესობამდე" და გამოვიყენებთ ჩვენს Pan/Tilt მექანიზმს მხოლოდ 30 -დან 150 გრადუსამდე. ეს დიაპაზონი საკმარისი იქნება კამერისთვის გამოსაყენებლად.

ნაბიჯი 7: პან -დახრის მექანიზმი - მექანიკური კონსტრუქცია

მოდით ახლა, შევიკრიბოთ ჩვენი 2 სერვისი, როგორც Pan/Tilt მექანიზმი. აქ შეგიძლიათ გააკეთოთ 2 რამ. შეიძინეთ Pan-Tilt პლატფორმის მექანიზმი, როგორც ბოლო საფეხურზე ნაჩვენები, ან შექმენით თქვენი საკუთარი საჭიროებების შესაბამისად.

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

ნაბიჯი 8: ელექტრო პან/დახრის ასამბლეა

მას შემდეგ რაც შეიკრიბებით თქვენი Pan/Tilt მექანიზმი, მიჰყევით ფოტოებს სრული ელექტრული კავშირისთვის.

1. გამორთეთ თქვენი Pi.
2. შეასრულეთ ყველა ელექტრული კავშირი.
3. ორმაგად შეამოწმე.
4. პირველ რიგში ჩართეთ თქვენი Pi.
5. თუ ყველაფერი წესრიგშია, ჩართეთ სერვისები.

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

ნაბიჯი 9: პითონის სკრიპტი

მოდით შევქმნათ პითონის სკრიპტი ორივე სერვისის ერთდროულად გასაკონტროლებლად:

დროიდან იმპორტი ძილის

იმპორტი RPi. GPIO როგორც GPIO GPIO.setmode (GPIO. BCM) GPIO.setwarnings (False) pan = 27 tilt = 17 GPIO.setup (tilt, GPIO. OUT) # white => TILT GPIO.setup (პან, GPIO. OUT) # ნაცრისფერი ==> PAN def setServoAngle (servo, angle): კუთხის დამტკიცება> = 30 და კუთხე 90 (შუა წერტილი) ==> 150 კომპლექტიServoAngle (დახრა, int (sys.argv [2])) # 30 ==> 90 (შუა წერტილი) ==> 150 GPIO.cleanup ()

როდესაც სკრიპტი შესრულებულია, თქვენ უნდა შეიყვანოთ როგორც პარამეტრები, პან კუთხე და დახრის კუთხე. Მაგალითად:

sudo python3 servoCtrl.py 45 120

ზემოაღნიშნული ბრძანება დააწესებს Pan/Tilt მექანიზმს 45 გრადუსით "აზიმუტში" (პან კუთხე) და 120 გრადუსი "ამაღლების" (დახრის კუთხე). გაითვალისწინეთ, რომ თუ პარამეტრი არ არის შეყვანილი, ნაგულისხმევი იქნება ორივე, პან და დახრის კუთხეები 90 გრადუსამდე.

ქვემოთ შეგიძლიათ ნახოთ რამდენიმე ტესტი:

ServoCtrl.py ფაილის გადმოწერა შესაძლებელია ჩემი GitHub– დან.

ნაბიჯი 10: სერვერების მარყუჟის ტესტი

მოდით ახლა შევქმნათ პითონის სკრიპტი სერვისების სრული სპექტრის ავტომატურად შესამოწმებლად:

დროიდან იმპორტი ძილის

იმპორტი RPi. GPIO როგორც GPIO GPIO.setmode (GPIO. BCM) GPIO.setwarnings (False) pan = 27 tilt = 17 GPIO.setup (tilt, GPIO. OUT) # white => TILT GPIO.setup (პან, GPIO. OUT) # ნაცრისფერი ==> PAN def setServoAngle (servo, კუთხე): კუთხის დამტკიცება> = 30 და კუთხე <= 150 pwm = GPIO. PWM (servo, 50) pwm.start (8) dutyCycle = angle / 18. + 3. pwm. ChangeDutyCycle (dutyCycle) ძილი (0.3) pwm.stop () თუ _name_ == '_ მთავარი_': i დიაპაზონში (30, 160, 15): დიაპაზონი (150, 30, -15): setServoAngle (ტაფა, i) კომპლექტიServoAngle (დახრა, i) კომპლექტიServoAngle (ტაფა, 100) კომპლექტიServoAngle (დახრა, 90) GPIO.cleanup ()

პროგრამა ავტომატურად შეასრულებს მარყუჟს 30 -დან 150 გრადუსამდე ორივე კუთხით.

შედეგის ქვემოთ:

მე შევაერთე ოსცილოსკოპი მხოლოდ PWM თეორიის საილუსტრაციოდ, როგორც ეს ადრე იყო განმარტებული.

ზემოთ მოყვანილი კოდი, servoTest.py შეიძლება გადმოწერილი იყოს ჩემი GitHub– დან.

ნაბიჯი 11: დასკვნა

როგორც ყოველთვის, ვიმედოვნებ, რომ ეს პროექტი სხვებს დაეხმარება იპოვონ გზა ელექტრონიკის ამაღელვებელ სამყაროში!

დეტალებისა და საბოლოო კოდისთვის ეწვიეთ ჩემს GitHub საცავს: RPi-Pan-Tilt-Servo-Control

მეტი პროექტისთვის ეწვიეთ ჩემს ბლოგს: MJRoBot.org

ქვემოთ ნაჩვენებია ჩემი შემდეგი გაკვეთილი:

სალუდო მსოფლიოს სამხრეთიდან!

შევხვდებით ჩემს შემდეგ ინსტრუქტაჟში!

Გმადლობთ, მარსელო