Pan-Tilt Multi Servo Kontrol: 11 Adım (Resimlerle)

2024 Yazar: John Day | [email protected]. Son düzenleme: 2024-01-30 13:20

Bu eğitimde, bir Raspberry Pi üzerinde Python kullanarak birden fazla servoyu nasıl kontrol edeceğinizi keşfedeceğiz. Amacımız bir kamerayı (PiCam) konumlandırmak için bir PAN/TILT mekanizması olacak.

Burada nihai projemizin nasıl çalışacağını görebilirsiniz:

Kontrol Servo Kontrol döngüsü testi:

Adım 1: Malzeme Listesi - Malzeme Listesi

Ana parçalar:

1. Ahududu Pi V3 - 32,00 ABD Doları
2. 5 Megapiksel 1080p Sensör OV5647 Mini Kamera Video Modülü - US$ 13.00
3. TowerPro SG90 9G 180 derece Mikro Servo (2 X)- 4,00 ABD Doları
4. Mini Pan/Tilt Kamera Platformu Titreşim Önleyici Kamera Montajı w/ 2 Servo (*) - 8,00 ABD Doları
5. Direnç 1K ohm (2X) - Opsiyonel
6. Çeşitli: metal parçalar, bantlar vb (Pan/Tilt mekanizmanızı oluşturacaksanız)

(*) servolarla birlikte eksiksiz bir Pan/Tilt platformu satın alabilir veya kendinizinkini oluşturabilirsiniz.

Adım 2: PWM Nasıl Çalışır?

Raspberry Pi'nin analog çıkışı yoktur, ancak bunu bir PWM (Darbe Genişliği Modülasyonu) yaklaşımı kullanarak simüle edebiliriz. Yapacağımız şey, darbe dizisi genişliğini değiştireceğimiz, aşağıda gösterildiği gibi "ortalama" çıkış voltajı seviyesi olarak "çevrilecek" olan sabit frekanslı bir dijital sinyal oluşturmaktır:

Bu "ortalama" voltaj seviyesini bir LED parlaklığını kontrol etmek için kullanabiliriz, örneğin:

Burada önemli olanın frekansın kendisi değil, "Görev Döngüsü", yani darbenin "yüksek" olduğu zamanın dalga periyoduna bölünmesi arasındaki ilişki olduğuna dikkat edin. Örneğin, Raspberry Pi GPIO'larımızdan birinde 50 Hz'lik bir darbe frekansı üreteceğimizi varsayalım. Periyot (p), frekansın tersi veya 20ms (1/f) olacaktır. LED'imizin "yarı" parlak olmasını istiyorsak, Görev Döngüsünün %50 olması gerekir, bu da 10ms için "Yüksek" olacak bir "darbe" anlamına gelir.

Bu prensip, "Görev Döngüsü" servo pozisyonunu aşağıda gösterildiği gibi tanımladığında, servo pozisyonumuzu kontrol etmek için bizim için çok önemli olacaktır:

Servo

3. Adım: Donanım Kurulumu

Servolar, veri pinlerinin (benim durumumda sarı kabloları) Raspberry Pi GPIO'ya aşağıdaki gibi bağlanmasıyla harici bir 5V kaynağına bağlanacaktır:

• GPIO 17 ==> Yatırma Servosu
• GPIO 27 ==> Pan Servo

GND'leri birbirine bağlamayı unutmayın ==> Raspberry Pi - Servolar - Harici Güç Kaynağı)

Opsiyonel olarak Raspberry Pi GPIO ile Server data giriş pini arasında 1K ohm'luk bir direnç olabilir. Bu, bir servo sorunu olması durumunda RPi'nizi koruyacaktır.

Adım 4: Servo Kalibrasyonu

Yapmanız gereken ilk şey, servolarınızın ana özelliklerini doğrulamaktır. Benim durumumda, bir Power Pro SG90 kullanıyorum.

Veri sayfasından şunları düşünebiliriz:

• Aralık: 180o
• Güç Kaynağı: 4.8V (USB güç kaynağı olarak harici 5VDC iyi çalışıyor)
• Çalışma frekansı: 50Hz (Süre: 20 ms)
• Darbe genişliği: 1 ms'den 2 ms'ye

Teorik olarak, servo üzerinde olacak

• Veri terminaline 1 ms'lik bir darbe uygulandığında Başlangıç Konumu (0 derece)
• Veri terminaline 1,5 ms'lik bir darbe uygulandığında Nötr Konum (90 derece)
• Veri terminaline 2 ms'lik bir darbe uygulandığında Son Konum (180 derece)

Python kullanarak bir servo pozisyonu programlamak için yukarıdaki pozisyonlar için ilgili "Görev Döngüsü" nü bilmek çok önemli olacaktır, hadi biraz hesaplama yapalım:

• Başlangıç Konumu ==> (0 derece) Darbe genişliği ==> 1ms ==> Görev Döngüsü = 1ms/20ms ==> %2,0
• Nötr Konum (90 derece) 1,5 ms darbe genişliği ==> Görev Döngüsü = 1,5 ms/20 ms ==> %7,5
• Son Konum (180 derece) 2 ms darbe genişliği ==> Görev Döngüsü = 2 ms/20 ms ==> %10

Bu nedenle Görev Döngüsü %2 ila %10 aralığında değişmelidir.

Servoları tek tek test edelim. Bunun için Raspberry terminalinizi açın ve Python 3 kabuk düzenleyicinizi "sudo" olarak başlatın (çünkü GPIO'larla başa çıkmak için "süper kullanıcı" olmalısınız):

sudo python3

Python Shell'de

>>

RPI. GPIO modülünü içe aktarın ve GPIO olarak adlandırın:

RPi. GPIO'yu GPIO olarak içe aktar

Hangi pin numaralandırma şemalarını kullanmak istediğinizi tanımlayın (BCM veya BOARD). Bu testi BOARD ile yaptım, bu yüzden kullandığım pinler fiziksel pinlerdi (GPIO 17 = Pin 11 ve GPIO 27 Pin 13). Bunları tespit etmek ve test sırasında hata yapmamak benim için kolaydı (Son programda BCM kullanacağım). Tercihinizden birini seçin:

GPIO.setmode(GPIO. BOARD)

Kullanmakta olduğunuz servo pinini tanımlayın:

tiltPin = 11

Bunun yerine, BCM şemasını kullandıysanız, son 2 komut şu şekilde değiştirilmelidir:

GPIO.setmode(GPIO. BCM)

tiltPin = 17

Şimdi bu pinin bir "output" olacağını belirtmeliyiz.

GPIO.setup(tiltPin, GPIO. OUT)

Ve bu pinde üretilen frekans ne olacak, servomuz için 50Hz olacak:

eğim = GPIO. PWM(tiltPin, 50)

Şimdi, ilk görev döngüsü olan pin üzerinde bir PWM sinyali oluşturmaya başlayalım ("0" olarak tutacağız):

eğim = başlangıç(0)

Artık servonuzun hareketini gözlemleyerek farklı görev döngüsü değerleri girebilirsiniz. %2 ile başlayalım ve ne olduğunu görelim (servonun "sıfır konumuna" gittiğini tahmin ediyoruz):

tilt. ChangeDutyCycle(2)

Benim durumumda servo sıfır konumuna gitti ama görev döngüsünü %3'e değiştirdiğimde servonun aynı konumda kaldığını ve %3'ün üzerindeki görev döngüleriyle hareket etmeye başladığını gözlemledim. Yani, %3 benim ilk konumum (o derece). Aynısı %10'da oldu, servom bu değerin üzerine çıktı ve %13'e ulaştı. Bu özel servo için sonuç şuydu:

• 0 derece ==> %3 görev döngüsü
• 90 derece ==> %8 görev döngüsü
• 180 derece ==> %13 görev döngüsü

Testlerinizi bitirdikten sonra PWM'yi durdurmalı ve GPIO'ları temizlemelisiniz:

eğim = dur()

GPIO.cleanup()

Yukarıdaki Terminal yazdırma ekranı, her iki servomun sonucunu gösterir (benzer sonuçlara sahiptir). Aralığınız farklı olabilir.

Adım 5: Bir Python Komut Dosyası Oluşturma

Servomuza gönderilecek olan PWM komutları son adımda gördüğümüz gibi "görev döngüleri" içindedir. Ancak genellikle, bir servoyu kontrol etmek için parametre olarak derece cinsinden "açı" kullanmalıyız. O halde görev döngüsünde bizim için daha doğal bir ölçü olan "açı"yı Pi'mizin anlayabileceği şekilde çevirmeliyiz.

Nasıl yapılır? Çok basit! Görev döngüsü aralığının %3 ila %13 arasında olduğunu ve bunun 0 ila 180 derece arasında değişen açılara eşdeğer olduğunu biliyoruz. Ayrıca, bu varyasyonların doğrusal olduğunu biliyoruz, bu nedenle yukarıda gösterildiği gibi orantılı bir şema oluşturabiliriz. bu nedenle, bir açı verildiğinde, karşılık gelen bir görev döngüsüne sahip olabiliriz:

görev döngüsü = açı/18 + 3

Bu formülü saklayın. Bir sonraki kodda kullanacağız.

Testleri yürütmek için bir Python betiği oluşturalım. Temel olarak, Python Shell'de daha önce yaptığımızı tekrarlayacağız:

zaman ithal uyku

RPi. GPIO'yu GPIO olarak içe aktar GPIO.setmode(GPIO. BCM) GPIO.setwarnings(False) def setServoAngle(servo, açı): pwm = GPIO. PWM(servo, 50) pwm.start(8) dutyCycle = açı / 18. + 3. pwm. ChangeDutyCycle(dutyCycle) sleep(0.3) pwm.stop() if _name_ == '_main_': import sys servo = int(sys.argv[1]) GPIO.setup(servo, GPIO. OUT) setServoAngle (servo, int(sys.argv[2])) GPIO.cleanup()

Yukarıdaki kodun özü setServoAngle(servo, angle) işlevidir. Bu fonksiyon, argüman olarak bir servo GPIO numarası ve servonun konumlandırılması gereken yere bir açı değeri alır. Bu fonksiyonun girişi "açı" olduğunda, daha önce geliştirilen formülü kullanarak onu yüzde olarak görev döngüsüne çevirmeliyiz.

Komut dosyası yürütüldüğünde, parametre, servo GPIO ve açı olarak girmelisiniz.

Örneğin:

sudo python3 açısıServoCtrl.py 17 45

Yukarıdaki komut, GPIO 17'ye bağlı servoyu "yükseklik"te 45 derece ile konumlandıracaktır. Pan Servo kontrolü için de benzer bir komut kullanılabilir ("azimut"ta 45 dereceye konum):

sudo python açısıServoCtrl.py 27 45

angleServoCtrl.py dosyası GitHub'dan indirilebilir

Adım 6: Pan-Tilt Mekanizması

"Pan" servosu kameramızı "yatay" ("azimut açısı") hareket ettirecek ve "Tilt" servomuz onu "dikey" (yükseklik açısı) hareket ettirecektir.

Aşağıdaki resim Pan/Tilt mekanizmasının nasıl çalıştığını gösterir:

Geliştirmemiz sırasında "aşırılıklara" gitmeyeceğiz ve Pan/Tilt mekanizmamızı sadece 30 ila 150 derece arasında kullanacağız. Bu aralık bir kamera ile kullanılmak için yeterli olacaktır.

Adım 7: Pan-Tilt Mekanizması - Mekanik Yapı

Şimdi 2 servomuzu Pan/Tilt mekanizması olarak monte edelim. Burada 2 şey yapabilirsiniz. Son adımda gösterildiği gibi bir Pan-Tilt platform mekanizması satın alın veya ihtiyaçlarınıza göre kendinizinkini oluşturun.

Bir örnek, yukarıdaki fotoğraflarda gösterildiği gibi, sadece servoları birbirine bağlayarak ve eski oyuncaklardan küçük metal parçalar kullanarak yaptığım bir örnek olabilir.

Adım 8: Elektrikli Pan/Tilt Montajı

Pan/Tilt mekanizmanızı kurduktan sonra, tam elektrik bağlantısı için fotoğrafları takip edin.

1. Pi'nizi kapatın.
2. Tüm elektrik bağlantılarını yapın.
3. İki kez kontrol edin.
4. Önce Pi'nizi açın.
5. Her şey yolundaysa, servolarınıza güç verin.

Bu eğitimde kameranın nasıl kurulacağını keşfetmeyeceğiz, bu bir sonraki eğitimde açıklanacak.

9. Adım: Python Komut Dosyası

Her iki servoyu aynı anda kontrol etmek için bir Python Script oluşturalım:

zamandan içe uyku

RPi. GPIO'yu GPIO olarak içe aktar GPIO.setmode(GPIO. BCM) GPIO.setwarnings(False) pan = 27 tilt = 17 GPIO.setup(tilt, GPIO. OUT) # beyaz => TILT GPIO.setup(pan, GPIO. OUT)) # gray ==> PAN def setServoAngle(servo, angle): assert angle >=30 ve angle 90 (orta nokta) ==> 150 setServoAngle(tilt, int(sys.argv[2])) # 30 ==> 90 (orta nokta) ==> 150 GPIO.cleanup()

Komut dosyası yürütüldüğünde, parametre olarak Pan açısı ve Tilt açısı girmelisiniz. Örneğin:

sudo python3 servoCtrl.py 45 120

Yukarıdaki komut, Pan/Tilt mekanizmasını 45 derecelik "azimut" (Pan açısı) ve 120 derecelik "yükseklik" (Tilt Açısı) ile konumlandıracaktır. Hiçbir parametre girilmezse, varsayılanın hem kaydırma hem de eğme açılarının 90 dereceye kadar ayarlanacağını unutmayın.

Aşağıda bazı testleri görebilirsiniz:

servoCtrl.py dosyası GitHub'ımdan indirilebilir.

Adım 10: Sunucuların Döngü Testi

Şimdi tüm servoları otomatik olarak test etmek için bir Python Komut Dosyası oluşturalım:

zamandan içe uyku

RPi. GPIO'yu GPIO olarak içe aktar GPIO.setmode(GPIO. BCM) GPIO.setwarnings(False) pan = 27 tilt = 17 GPIO.setup(tilt, GPIO. OUT) # beyaz => TILT GPIO.setup(pan, GPIO. OUT)) # gray ==> PAN def setServoAngle(servo, angle): assert angle >=30 and angle <= 150 pwm = GPIO. PWM(servo, 50) pwm.start(8) dutyCycle = açı / 18. + 3. pwm. ChangeDutyCycle(dutyCycle) sleep(0.3) pwm.stop() if _name_ == '_main_': i aralığında (30, 160, 15): setServoAngle(pan, i) setServoAngle(tilt, i) for i in aralık (150, 30, -15): setServoAngle(pan, i) setServoAngle(tilt, i) setServoAngle(pan, 100) setServoAngle(tilt, 90) GPIO.cleanup()

Program otomatik olarak her iki açıda 30 ila 150 derece arasında bir döngü yürütecektir.

Sonucun altında:

Sadece daha önce açıklandığı gibi PWM teorisini göstermek için bir osiloskop bağladım.

Yukarıdaki kod, servoTest.py GitHub'ımdan indirilebilir.

Adım 11: Sonuç

Her zaman olduğu gibi, umarım bu proje başkalarının heyecan verici elektronik dünyasına girmelerine yardımcı olabilir!

Ayrıntılar ve son kod için lütfen GitHub depomu ziyaret edin: RPi-Pan-Tilt-Servo-Control

Daha fazla proje için lütfen blogumu ziyaret edin: MJRoBot.org

Bir sonraki öğreticime bir bakışın altında:

Dünyanın güneyinden selamlar!

Bir sonraki talimatımda görüşürüz!

Teşekkürler, Marcelo