Pan-Tilt Multi Servo Control: 11 stappe (met foto's)

2024 Outeur: John Day | [email protected]. Laas verander: 2024-01-30 07:27

In hierdie tutoriaal gaan ons ondersoek hoe u verskeie servo's kan beheer met behulp van Python op 'n Raspberry Pi. Ons doel is 'n PAN/TILT -meganisme om 'n kamera ('n PiCam) te posisioneer.

Hier kan u sien hoe ons finale projek sal werk:

Control Servo Control lustoets:

Stap 1: BoM - Staatsbrief

Belangrikste dele:

1. Framboos Pi V3 - US $ 32,00
2. 5 megapixels 1080p sensor OV5647 mini kamera videomodule - US $ 13,00
3. TowerPro SG90 9G 180 grade mikro-servo (2 x)- US $ 4,00
4. Mini -pan/ kantel -kamera -platform, teen -vibrasie -kamera, met 2 servo's (*) - 8,00 dollar
5. Weerstand 1K ohm (2X) - opsioneel
6. Diverse: metaaldele, bande, ens. (As u u Pan/Tilt -meganisme bou)

(*) u kan 'n volledige Pan/Tilt -platform met die servo's koop of u eie bou.

Stap 2: Hoe werk PWM

Die Raspberry Pi het geen analoog uitset nie, maar ons kan dit simuleer met behulp van 'n PWM (Pulse Width Modulation) benadering. Wat ons sal doen, is om 'n digitale sein met 'n vaste frekwensie te genereer, waar ons die wydte van die polsstrein sal verander, wat 'vertaal' sal word as 'n 'gemiddelde' uitsetspanningsvlak soos hieronder getoon:

Ons kan hierdie 'gemiddelde' spanningsvlak gebruik om 'n LED -helderheid te beheer, byvoorbeeld:

Let daarop dat die frekwensie self nie belangrik is nie, maar die "Duty Cycle", dit is die verband tussen die tyd dat die puls "hoog" is gedeel deur die golfperiode. Gestel byvoorbeeld dat ons 'n 50Hz -pulsfrekwensie sal genereer op een van ons Raspberry Pi GPIO. Die periode (p) sal die inverse van frekwensie of 20 ms (1/f) wees. As ons wil hê dat ons LED met 'n "half" helder moet wees, moet ons 'n insetsiklus van 50%hê, dit beteken 'n 'pols' wat 10 ms 'hoog' sal wees.

Hierdie beginsel is baie belangrik vir ons om ons servoposisie te beheer, sodra die 'Duty Cycle' die servoposisie sal definieer soos hieronder getoon:

Servo

Stap 3: Die installering van die Hw

Die servo's word gekoppel aan 'n eksterne 5V -toevoer, met hul datapennetjie (in my geval, hul geel bedrading) soos hieronder aan die Raspberry Pi GPIO gekoppel:

• GPIO 17 ==> Kantel servo
• GPIO 27 ==> Pan Servo

Moenie vergeet om die GND's aan mekaar te koppel nie ==> Raspberry Pi - Servos - eksterne kragbron)

U kan as opsie 'n weerstand van 1K ohm tussen Raspberry Pi GPIO en Server -data -invoerpen hê. Dit beskerm u RPi in geval van 'n servoprobleem.

Stap 4: Servokalibrasie

Die eerste ding om dit te doen, is om die hoofkenmerke van u servo's te bevestig. In my geval gebruik ek 'n Power Pro SG90.

Uit die datablad kan ons oorweeg:

• Bereik: 180o
• Kragtoevoer: 4.8V (eksterne 5VDC as 'n USB -voeding werk goed)
• Werkfrekwensie: 50Hz (tydperk: 20 ms)
• Pulswydte: van 1 ms tot 2 ms

In teorie sal die servo op sy

• Aanvanklike posisie (0 grade) wanneer 'n puls van 1 ms op die dataterminaal toegepas word
• Neutrale posisie (90 grade) wanneer 'n puls van 1,5 ms op die dataterminaal toegepas word
• Finale posisie (180 grade) wanneer 'n puls van 2 ms op die dataterminaal toegepas word

Om 'n servoposisie met Python te programmeer, is baie belangrik om die korrespondent "Duty Cycle" vir bogenoemde posisies te ken; laat ons 'n berekening doen:

• Aanvanklike posisie ==> (0 grade) Pulswydte ==> 1ms ==> Inloopsiklus = 1ms/20ms ==> 2,0%
• Neutrale posisie (90 grade) Pulswydte van 1.5 ms ==> Duty Cycle = 1.5ms/20ms ==> 7.5%
• Finale posisie (180 grade) Pulswydte van 2 ms ==> Duty Cycle = 2ms/20ms ==> 10%

Die dienssiklus moet dus wissel van 2 tot 10 %.

Kom ons toets die servo's individueel. Maak daarvoor u Framboos -terminale oop en begin u Python 3 -dopredakteur as 'sudo' (omdat u 'n 'supergebruiker' moet wees om met GPIO's te hanteer):

sudo python3

Op Python Shell

>>

Voer die RPI. GPIO -module in en noem dit GPIO:

voer RPi. GPIO in as GPIO

Definieer watter pen-nommeringskemas u wil gebruik (BCM of BOARD). Ek het hierdie toets met BOARD gedoen, so die penne wat ek gebruik het, was die fisiese penne (GPIO 17 = Pin 11 en GPIO 27 Pin 13). Dit was vir my maklik om dit te identifiseer en nie foute te maak tydens die toets nie (in die finale program sal ek BCM gebruik). Kies die een van u voorkeur:

GPIO.setmode (GPIO. BOARD)

Definieer die servo -pen wat u gebruik:

tiltPin = 11

As u eerder die BCM -skema gebruik het, moet die laaste 2 opdragte vervang word deur:

GPIO.setmode (GPIO. BCM)

tiltPin = 17

Nou moet ons spesifiseer dat hierdie pen 'n 'uitvoer' sal wees

GPIO.setup (tiltPin, GPIO. OUT)

En wat is die frekwensie wat op hierdie pen gegenereer word, wat vir ons servo 50Hz is:

kantel = GPIO. PWM (tiltPin, 50)

Laat ons nou 'n PWM -sein op die pen begin genereer met 'n aanvanklike dienssiklus (ons hou dit "0"):

kantel = begin (0)

Nou kan u verskillende waardes van die dienssiklus invoer, met inagneming van die beweging van u servo. Kom ons begin met 2% en kyk wat gebeur (ons sien dat die servo na 'nulposisie' gaan):

tilt. ChangeDutyCycle (2)

In my geval het die servo na 'n nul posisie gegaan, maar toe ek die dienssiklus na 3% verander, het ek opgemerk dat die servo in dieselfde posisie bly en begin beweeg met 'n insetsiklus van meer as 3%. Dus, 3% is my aanvanklike posisie (o grade). Dieselfde gebeur met 10%, my servo het bo hierdie waarde gestyg, met 'n hoogtepunt van 13%. Dus vir hierdie spesifieke servo was die resultaat:

• 0 graad ==> dienssiklus van 3%
• 90 grade ==> dienssiklus van 8%
• 180 grade ==> dienssiklus van 13%

Nadat u u toetse voltooi het, moet u die PWM stop en die GPIO's opruim:

kantel = stop ()

GPIO.cleanup ()

Bogenoemde Terminal -afdrukskerm toon die resultaat vir albei my servo's (met soortgelyke resultate). U reeks kan anders wees.

Stap 5: Skep 'n Python -script

Die PWM -opdragte wat na ons servo gestuur moet word, is in 'dienssiklusse', soos ons op die laaste stap gesien het. Maar gewoonlik moet ons 'hoek' in grade as 'n parameter gebruik om 'n servo te beheer. Ons moet dus 'hoek' omskakel, wat 'n meer natuurlike meting is vir ons in dienssiklus, soos verstaanbaar deur ons Pi.

Hoe om dit te doen? Baie eenvoudig! Ons weet dat die werksiklusreeks van 3% tot 13% strek en dat dit gelykstaande is aan hoeke wat wissel van 0 tot 180 grade. Ons weet ook dat die variasies lineêr is, sodat ons 'n proporsionele skema kan bou soos hierbo getoon. gegewe 'n hoek, kan ons 'n korrespondent -dienssiklus hê:

dutycycle = hoek/18 + 3

Hou hierdie formule. Ons sal dit in die volgende kode gebruik.

Kom ons maak 'n Python -script om die toetse uit te voer. Eintlik herhaal ons wat ons voorheen op Python Shell gedoen het:

van tyd af slaap invoer

voer RPi. GPIO in as GPIO GPIO.setmode (GPIO. BCM) GPIO.setwarnings (Onwaar) def setServoAngle (servo, hoek): pwm = GPIO. PWM (servo, 50) pwm.start (8) dutyCycle = hoek / 18. + 3. pwm. ChangeDutyCycle (dutyCycle) slaap (0.3) pwm.stop () as _name_ == '_main_': invoer sys servo = int (sys.argv [1]) GPIO.setup (servo, GPIO. OUT) setServoAngle (servo, int (sys.argv [2])) GPIO.cleanup ()

Die kern van bogenoemde kode is die funksie setServoAngle (servo, hoek). Hierdie funksie ontvang as argumente 'n servo GPIO -nommer en 'n hoekwaarde na waar die servo geplaas moet word. Sodra die invoer van hierdie funksie 'hoek' is, moet ons dit in persentasie omskakel in die werksiklus, volgens die formule wat voorheen ontwikkel is.

As die script uitgevoer word, moet u parameters, servo GPIO en hoek invoer.

Byvoorbeeld:

sudo python3 hoekServoCtrl.py 17 45

Bogenoemde opdrag plaas die servo wat op GPIO 17 gekoppel is, met 45 grade in 'hoogte'. 'N Soortgelyke opdrag kan gebruik word vir Pan Servo -beheer (posisie tot 45 grade in "azimut"):

sudo python hoekServoCtrl.py 27 45

Die lêer angleServoCtrl.py kan van my GitHub afgelaai word

Stap 6: Die pan-kantelmeganisme

Die "Pan" servo sal ons kamera "horisontaal" beweeg ("azimuthoek") en ons "Tilt" servo sal dit "vertikaal" (hoogtehoek) beweeg.

Die onderstaande prent wys hoe die Pan/Tilt -meganisme werk:

Tydens ons ontwikkeling gaan ons nie na 'uiterstes' nie, en ons sal ons Pan/Tilt -meganisme slegs van 30 tot 150 grade gebruik. Hierdie reeks is genoeg om saam met 'n kamera gebruik te word.

Stap 7: Die pan -kantelmeganisme - meganiese konstruksie

Laat ons nou ons 2 servo's saamstel as 'n Pan/Tilt -meganisme. U kan 2 dinge hier doen. Koop 'n Pan-Tilt-platformmeganisme soos op die laaste stap, of bou u eie volgens u behoeftes.

Een voorbeeld kan die een wees wat ek gebou het, en die servo's net aan mekaar vasgemaak en klein metaalstukke van ou speelgoed gebruik soos op die foto's hierbo getoon.

Stap 8: Elektriese pan/kantel -samestelling

Nadat u u Pan/Tilt -meganisme saamgestel het, volg die foto's vir 'n volledige elektriese verbinding.

1. Skakel jou Pi uit.
2. Doen alle elektriese verbindings.
3. Gaan dit dubbel na.
4. Skakel eers jou Pi aan.
5. As alles in orde is, skakel u servo's aan.

Ons sal nie in hierdie tutoriaal ondersoek hoe om die kamera op te stel nie; dit sal in die volgende handleiding verduidelik word.

Stap 9: The Python Script

Kom ons skep 'n Python -script om beide servo's gelyktydig te beheer:

van tyd af slaap invoer

voer RPi. GPIO in as GPIO GPIO.setmode (GPIO. BCM) GPIO.setwarnings (Onwaar) pan = 27 kantel = 17 GPIO.setup (kantel, GPIO. OUT) # wit => TILT GPIO.setup (pan, GPIO. OUT) # grys ==> PAN def setServoAngle (servo, hoek): bevestig hoek> = 30 en hoek 90 (middel punt) ==> 150 setServoAngle (kantel, int (sys.argv [2])) # 30 ==> 90 (middelste punt) ==> 150 GPIO.cleanup ()

As die script uitgevoer is, moet u as parameters, panhoek en kantelhoek invoer. Byvoorbeeld:

sudo python3 servoCtrl.py 45 120

Bogenoemde opdrag plaas die Pan/Tilt -meganisme met 45 grade in "azimut" (panhoek) en 120 grade "hoogte" (kantelhoek). Let daarop dat as daar geen parameters ingevoer word nie, die standaard beide pan- en kantelhoeke is ingestel tot 90 grade.

Hieronder kan u 'n paar toetse sien:

Die servoCtrl.py -lêer kan afgelaai word vanaf my GitHub.

Stap 10: lustoets van bedieners

Kom ons maak nou 'n Python Script om outomaties die hele reeks servo's te toets:

van tyd af slaap invoer

voer RPi. GPIO in as GPIO GPIO.setmode (GPIO. BCM) GPIO.setwarnings (Onwaar) pan = 27 kantel = 17 GPIO.setup (kantel, GPIO. OUT) # wit => TILT GPIO.setup (pan, GPIO. OUT) # grey ==> PAN def setServoAngle (servo, hoek): bevestig hoek> = 30 en hoek <= 150 pwm = GPIO. PWM (servo, 50) pwm.start (8) dutyCycle = hoek / 18. + 3. pwm. ChangeDutyCycle (dutyCycle) slaap (0.3) pwm.stop () as _name_ == '_main_': vir i in reeks (30, 160, 15): setServoAngle (pan, i) setServoAngle (kantel, i) vir i in reeks (150, 30, -15): setServoAngle (pan, i) setServoAngle (kantel, i) setServoAngle (pan, 100) setServoAngle (kantel, 90) GPIO.cleanup ()

Die program sal outomaties 'n lus van 30 tot 150 grade in beide hoeke uitvoer.

Onder die resultaat:

Ek het slegs 'n ossilloskoop gekoppel om die PWM -teorie te illustreer soos voorheen verduidelik.

Bogenoemde kode, servoTest.py, kan afgelaai word vanaf my GitHub.

Stap 11: Gevolgtrekking

Soos altyd, hoop ek dat hierdie projek ander kan help om die opwindende wêreld van elektronika te vind!

Besoek my GitHub-bewaarplek vir meer inligting en finale kode: RPi-Pan-Tilt-Servo-Control

Besoek my blog vir meer projekte: MJRoBot.org

Hieronder 'n blik op my volgende tutoriaal:

Groete uit die suide van die wêreld!

Sien jou in my volgende instruksies!

Dankie, Marcelo