Pan-Tilt Multi Servo Control: 11 Mga Hakbang (na may Mga Larawan)

2024 May -akda: John Day | [email protected]. Huling binago: 2024-01-30 13:14

Sa tutorial na ito, susuriin namin kung paano makontrol ang maraming servo gamit ang Python sa isang Raspberry Pi. Ang aming layunin ay magiging isang mekanismo ng PAN / TILT upang iposisyon ang isang camera (isang PiCam).

Makikita mo rito kung paano gagana ang aming panghuling proyekto:

Kontrolin ang pagsubok sa loop ng Control Servo:

Hakbang 1: BoM - Bill of Material

Pangunahing bahagi:

1. Raspberry Pi V3 - US $ 32.00
2. 5 Megapixels 1080p Sensor OV5647 Mini Camera Video Module - US $ 13.00
3. TowerPro SG90 9G 180 degree Micro Servo (2 X) - US $ 4.00
4. Mini Pan / Tilt Camera Platform Anti-Vibration Camera Mount w / 2 Servos (*) - US $ 8.00
5. Resistor 1K ohm (2X) - Opsyonal
6. Miscellaneous: mga bahagi ng metal, banda, atbp (kung sakaling maitatayo mo ang iyong mekanismo ng Pan / Tilt)

(*) Maaari kang bumili ng isang kumpletong platform ng Pan / Tilt sa mga servos o bumuo ng iyong sarili.

Hakbang 2: Paano Gumagana ang PWM

Ang Raspberry Pi ay walang analog output, ngunit maaari naming gayahin ito, gamit ang isang diskarte na PWM (Pulse Width Modulation). Ang gagawin namin ay upang makabuo ng isang digital signal na may isang nakapirming dalas, kung saan babaguhin namin ang lapad ng tren ng pulso, kung ano ang "isasalin" bilang isang "average" na antas ng boltahe ng output tulad ng ipinakita sa ibaba:

Maaari naming gamitin ang antas ng "average" na boltahe na ito upang makontrol ang isang LED brightness halimbawa:

Tandaan na ang mahalaga dito ay hindi ang dalas mismo, ngunit ang "Duty Cycle", iyon ang ugnayan sa pagitan ng oras na ang mga pulso ay "mataas" na hinati ng panahon ng alon. Halimbawa, ipagpalagay na bubuo kami ng isang 50Hz dalas ng pulso sa isa sa aming Raspberry Pi GPIO. Ang panahon (p) ay ang kabaligtaran ng dalas o 20ms (1 / f). Kung nais namin na ang aming LED na may isang "kalahati" na maliwanag, dapat kaming magkaroon ng isang Duty Cycle na 50%, nangangahulugan iyon ng isang "pulso" na "Mataas" para sa 10ms.

Ang prinsipyong ito ay magiging napakahalaga para sa amin, upang makontrol ang aming posisyon sa servo, kapag tinukoy ng "Duty Cycle" ang posisyon ng servo tulad ng ipinakita sa ibaba:

Servo

Hakbang 3: Pag-install ng Hw

Ang mga servos ay konektado sa isang panlabas na 5V supply, pagkakaroon ng kanilang data pin (sa aking kaso, ang kanilang dilaw na mga kable) na kumonekta sa Raspberry Pi GPIO tulad ng nasa ibaba:

• GPIO 17 ==> Ikiling ang Servo
• GPIO 27 ==> Pan Servo

Huwag kalimutan na ikonekta ang mga GND magkasama ==> Raspberry Pi - Servos - External Power Supply)

Maaari kang magkaroon bilang isang pagpipilian, isang risistor ng 1K ohm sa pagitan ng Raspberry Pi GPIO at pag-input ng data ng Server pin. Protektahan nito ang iyong RPi sakaling may problema sa servo.

Hakbang 4: Pagkalibrate ng Servos

Ang unang bagay na dapat gawin ito ay upang kumpirmahin ang pangunahing mga katangian ng iyong servos. Sa aking kaso, gumagamit ako ng isang Power Pro SG90.

Mula sa datasheet nito, maaari nating isaalang-alang ang:

• Saklaw: 180o
• Power Supply: 4.8V (panlabas na 5VDC bilang isang USB power supply ay gumagana ng maayos)
• Paggawa ng dalas: 50Hz (Panahon: 20 ms)
• Lapad ng pulso: mula 1ms hanggang 2ms

Sa teorya, ang servo ay magiging dito

• Paunang Posisyon (0 degree) kapag ang isang pulso na 1ms ay inilapat sa terminal ng data nito
• Neutrisyon na Posisyon (90 degree) kapag ang isang pulso na 1.5 ms ay inilapat sa terminal ng data nito
• Pangwakas na Posisyon (180 degree) kapag ang isang pulso na 2 ms ay inilapat sa terminal ng data nito

Upang mai-program ang isang posisyon ng servo gamit ang Python ay magiging napakahalaga upang malaman ang tagbalita na "Duty Cycle" para sa mga posisyon sa itaas, gumawa tayo ng ilang pagkalkula:

• Paunang Posisyon ==> (0 degree) Lapad ng pulso ==> 1ms ==> Duty Cycle = 1ms / 20ms ==> 2.0%
• Neutrisyon na Posisyon (90 degree) Lapad ng pulso na 1.5 ms ==> Duty Cycle = 1.5ms / 20ms ==> 7.5%
• Pangwakas na Posisyon (180 degree) Lapad ng pulso na 2 ms ==> Duty Cycle = 2ms / 20ms ==> 10%

Kaya't ang Duty Cycle ay dapat na magkakaiba sa isang saklaw na 2 hanggang 10%.

Isa-isa nating subukan ang mga servo. Para doon, buksan ang iyong terminal ng Raspberry at ilunsad ang iyong editor ng shell ng Python 3 bilang "sudo" (dahil dapat kang maging isang "super user" upang mahawakan ang mga GPIO):

sudo python3

Sa Python Shell

>>

I-import ang RPI. GPIO module at tawagan itong GPIO:

i-import ang RPi. GPIO bilang GPIO

Tukuyin kung aling mga pin-numbering na iskema ang nais mong gamitin (BCM o BOARD). Ginawa ko ang pagsubok na ito sa BOARD, kaya ang mga pin na ginamit ko ay ang mga pisikal na pin (GPIO 17 = Pin 11 at GPIO 27 Pin 13). Madali para sa akin na kilalanin ang mga ito at hindi magkamali sa pagsubok (Sa huling programa gagamitin ko ang BCM). Piliin ang isa sa iyong kagustuhan:

GPIO.setmode (GPIO. BOARD)

Tukuyin ang servo pin na ginagamit mo:

ikilingPin = 11

Kung Sa halip, gumamit ka ng BCM scheme, ang huling 2 utos ay dapat mapalitan ng:

GPIO.setmode (GPIO. BCM)

ikilingPin = 17

Ngayon, dapat naming tukuyin na ang pin na ito ay magiging isang "output"

GPIO.setup (tiltPin, GPIO. OUT)

At, ano ang magiging dalas na nabuo sa pin na ito, na para sa aming servo ay magiging 50Hz:

ikiling = GPIO. PWM (tiltPin, 50)

Ngayon, magsimula tayong makabuo ng isang signal ng PWM sa pin na may paunang ikot ng tungkulin (panatilihin namin itong "0"):

ikiling = simulan (0)

Ngayon, maaari kang magpasok ng iba't ibang mga halaga ng cycle ng tungkulin, na sinusunod ang paggalaw ng iyong servo. Magsimula tayo sa 2% at tingnan kung ano ang mangyayari (nakikita namin na ang servo ay papunta sa "zero na posisyon"):

ikiling. ChangeDutyCycle (2)

Sa aking kaso, ang servo ay nagpunta sa zero na posisyon ngunit nang palitan ko ang cycle ng tungkulin sa 3% naobserbahan ko na ang servo ay nanatili sa parehong posisyon, nagsisimula nang lumipat sa mga cycle ng tungkulin na higit sa 3%. Kaya, 3% ang aking paunang posisyon (o degree). Ang parehong nangyari sa 10%, ang aking servo ay lumampas sa halagang ito, na natapos sa 13%. Kaya para sa partikular na servo na ito, ang resulta ay:

• 0 degree ==> cycle ng tungkulin na 3%
• 90 degree ==> cycle ng tungkulin na 8%
• 180 degree ==> cycle ng tungkulin na 13%

Matapos mong matapos ang iyong mga pagsubok, dapat mong ihinto ang PWM at linisin ang mga GPIO:

ikiling = itigil ()

GPIO.cleanup ()

Ipinapakita ng screen sa itaas ng print ng Terminal ang resulta para sa pareho ng aking mga servos (na may katulad na mga resulta). Ang iyong saklaw ay maaaring naiiba.

Hakbang 5: Lumilikha ng isang Python Script

Ang mga utos ng PWM na ipapadala sa aming servo ay nasa "duty cycle" tulad ng nakita natin sa huling hakbang. Ngunit kadalasan, dapat nating gamitin ang "anggulo" sa mga degree bilang isang parameter upang makontrol ang isang servo. Kaya, dapat nating baguhin ang "anggulo" na isang mas natural na pagsukat sa amin sa duty cycle na naiintindihan ng aming Pi.

Paano ito magagawa? Napakasimple! Alam namin na ang saklaw ng cycle ng tungkulin ay mula 3% hanggang 13% at ito ay katumbas ng mga anggulo na mula sa 0 hanggang 180 degree. Gayundin, alam namin na ang mga pagkakaiba-iba na iyon ay linear, kaya makakagawa kami ng proporsyonal na iskema tulad ng ipinakita sa itaas. sa gayon, binigyan ng isang anggulo, maaari kaming magkaroon ng isang cycle ng tungkulin sa sulat:

dutycycle = anggulo / 18 + 3

Panatilihin ang formula na ito. Gagamitin namin ito sa susunod na code.

Lumikha tayo ng isang script ng Python upang maisagawa ang mga pagsubok. Talaga, uulitin namin ang ginawa namin dati sa Python Shell:

mula sa oras mag-import ng pagtulog

i-import ang RPi. GPIO bilang GPIO GPIO.setmode (GPIO. BCM) GPIO.setwarnings (Maling) def setServoAngle (servo, anggulo): pwm = GPIO. PWM (servo, 50) pwm.start (8) dutyCycle = anggulo / 18. + 3. pwm. ChangeDutyCycle (dutyCycle) pagtulog (0.3) pwm.stop () kung _name_ == '_main_': import sys servo = int (sys.argv [1]) GPIO.setup (servo, GPIO. OUT) setServoAngle (servo, int (sys.argv [2])) GPIO.cleanup ()

Ang core ng code sa itaas ay ang function setServoAngle (servo, anggulo). Ang pagpapaandar na ito ay natatanggap bilang mga argumento, isang numero ng servo GPIO, at isang halaga ng anggulo kung saan dapat nakaposisyon ang servo. Kapag ang input ng pagpapaandar na ito ay "anggulo", dapat natin itong i-convert sa duty cycle sa porsyento, gamit ang pormulang binuo dati.

Kapag ang script ay naisakatuparan, dapat kang magpasok bilang mga parameter, servo GPIO, at anggulo.

Halimbawa:

sudo python3 angguloServoCtrl.py 17 45

Ang utos sa itaas ay iposisyon ang servo na konektado sa GPIO 17 na may 45 degree sa "taas". Ang isang katulad na utos ay maaaring magamit para sa Pan Servo control (posisyon sa 45 degree sa "azimuth"):

sudo python angguloServoCtrl.py 27 45

Maaaring mai-download ang anggulo ng fileServoCtrl.py mula sa aking GitHub

Hakbang 6: Ang Pan-Ikiling Mekanismo

Ang "Pan" servo ay lilipat "pahalang" ng aming camera ("azimuth anggulo") at ang aming "Ikiling" servo ay ilipat ito "patayo" (anggulo ng taas).

Ipinapakita ng larawan sa ibaba kung paano gumagana ang mekanismo ng Pan / Tilt:

Sa panahon ng aming pag-unlad hindi kami pupunta sa "labis na labis" at gagamitin namin ang aming mekanismo ng Pan / Tilt mula 30 hanggang 150 degree lamang. Ang saklaw na ito ay magiging sapat upang magamit sa isang camera.

Hakbang 7: Ang Pan-Ikiling Mekanismo - Konstruksyon sa Mekanikal

Ngayon, tipunin ang aming 2 servos bilang isang Pan / Tilt na mekanismo. Maaari kang gumawa ng 2 bagay dito. Bumili ng isang mekanismo ng platform ng Pan-Tilt bilang isang ipinakita sa huling hakbang o bumuo ng iyong sarili ayon sa iyong mga pangangailangan.

Ang isang halimbawa ay maaaring ang isa na itinayo ko, ang pagkakabitay lamang sa mga servo sa isa't isa, at paggamit ng maliliit na piraso ng metal mula sa mga lumang laruan tulad ng ipinakita sa mga larawan sa itaas.

Hakbang 8: Electrical Pan / Tilt Assembly

Kapag napagsama mo na ang iyong mekanismo ng Pan / Tilt, sundin ang mga larawan para sa buong koneksyon sa elektrisidad.

1. Patayin ang iyong Pi.
2. Gawin ang lahat ng mga koneksyon sa kuryente.
3. I-double check ito.
4. Lakas muna sa Pi mo.
5. Kung OK ang lahat, bigyan ng lakas ang iyong mga servo.

Hindi namin tuklasin ang tutorial na ito kung paano i-set-up ang camera, ipapaliwanag ito sa susunod na tutorial.

Hakbang 9: Ang Python Script

Lumikha tayo ng isang Python Script upang makontrol ang parehong servos nang sabay-sabay:

mula sa oras mag-import ng pagtulog

i-import ang RPi. GPIO bilang GPIO GPIO.setmode (GPIO. BCM) GPIO.setwarnings (Mali) pan = 27 ikiling = 17 GPIO.setup (ikiling, GPIO. OUT) # puti => TILT GPIO.setup (pan, GPIO. OUT) # grey ==> PAN def setServoAngle (servo, anggulo): igiit angulo> = 30 at angulo 90 (gitnang punto) ==> 150 setServoAngle (ikiling, int (sys.argv [2])) # 30 ==> 90 (gitnang punto) ==> 150 GPIO.cleanup ()

Kapag ang script ay naisakatuparan, dapat kang magpasok bilang mga parameter, anggulo ng Pan at anggulo ng Ikiling. Halimbawa:

sudo python3 servoCtrl.py 45 120

Ang utos sa itaas ay iposisyon ang mekanismo ng Pan / Tilt na may 45 degree sa "azimuth" (Pan anggulo) at 120 degree ng "taas" (Tilt Angle). Tandaan na kung walang mga parameter na naipasok, ang default ay pareho, i-pan at ikiling ang mga anggulo na naka-set up sa 90 degree.

Sa ibaba makikita mo ang ilang mga pagsubok:

Maaaring ma-download ang file na servoCtrl.py mula sa aking GitHub.

Hakbang 10: Loop Test ng Mga Servers

Lumikha tayo ngayon ng isang Python Script upang awtomatikong subukan ang buong saklaw ng mga servos:

mula sa oras mag-import ng pagtulog

i-import ang RPi. GPIO bilang GPIO GPIO.setmode (GPIO. BCM) GPIO.setwarnings (Mali) pan = 27 ikiling = 17 GPIO.setup (ikiling, GPIO. OUT) # puti => TILT GPIO.setup (pan, GPIO. OUT) # grey ==> PAN def setServoAngle (servo, anggulo): igiit angulo> = 30 at angulo <= 150 pwm = GPIO. PWM (servo, 50) pwm.start (8) dutyCycle = anggulo / 18. + 3. pwm. ChangeDutyCycle (dutyCycle) pagtulog (0.3) pwm.stop () kung _name_ == '_main_': para sa ako sa saklaw (30, 160, 15): setServoAngle (pan, i) setServoAngle (ikiling, i) para sa i in saklaw (150, 30, -15): setServoAngle (pan, i) setServoAngle (ikiling, i) setServoAngle (pan, 100) setServoAngle (ikiling, 90) GPIO.cleanup ()

Ang programa ay awtomatikong isagawa ang isang loop mula 30 hanggang 150 degree sa parehong mga anggulo.

Sa ibaba ng resulta:

Kumonekta lamang ako ng isang oscilloscope upang ilarawan ang teorya ng PWM tulad ng ipinaliwanag dati.

Ang code sa itaas, ang servoTest.py ay maaaring ma-download mula sa aking GitHub.

Hakbang 11: Konklusyon

Tulad ng nakasanayan, inaasahan kong ang proyekto na ito ay maaaring makatulong sa iba na mahanap ang kanilang mga paraan sa kapanapanabik na mundo ng electronics!

Para sa mga detalye at pangwakas na code, mangyaring bisitahin ang aking deposito sa GitHub: RPi-Pan-Tilt-Servo-Control

Para sa higit pang mga proyekto, mangyaring bisitahin ang aking blog: MJRoBot.org

Sa ibaba ng isang sulyap ng aking susunod na tutorial:

Saludos mula sa timog ng mundo!

Kita tayo sa susunod kong turo!

Salamat, Marcelo