Pan-Tilt Multi Servo Control: 11 trinn (med bilder)

2024 Forfatter: John Day | [email protected]. Sist endret: 2024-01-30 11:24

På denne opplæringen vil vi utforske hvordan du kontrollerer flere servoer ved hjelp av Python på en Raspberry Pi. Målet vårt vil være en PAN/TILT -mekanisme for å plassere et kamera (en PiCam).

Her kan du se hvordan vårt siste prosjekt vil fungere:

Control Servo Control loop test:

Trinn 1: BoM - materialregning

Hoved deler:

1. Raspberry Pi V3 - 32,00 dollar
2. 5 megapiksler 1080p sensor OV5647 minikamera videomodul - USD 13,00
3. TowerPro SG90 9G 180 grader mikroservo (2 X)- 4,00 dollar
4. Mini Pan/ Tilt Camera Platform Anti -Vibration Camera Mount m/ 2 Servos (*) - 8,00 US $
5. Motstand 1K ohm (2X) - Valgfritt
6. Diverse: metalldeler, bånd, osv. (I tilfelle du konstruerer Pan/Tilt -mekanismen)

(*) kan du kjøpe en komplett Pan/Tilt -plattform med servoene eller bygge din egen.

Trinn 2: Hvordan PWM fungerer

Raspberry Pi har ingen analog utgang, men vi kan simulere dette ved å bruke en PWM (Pulse Width Modulation) tilnærming. Det vi skal gjøre er å generere et digitalt signal med en fast frekvens, der vi vil endre pulstogbredden, det som vil bli "oversatt" som et "gjennomsnittlig" utgangsspenningsnivå som vist nedenfor:

Vi kan bruke dette "gjennomsnittlige" spenningsnivået til å kontrollere en LED -lysstyrke, for eksempel:

Vær oppmerksom på at det som betyr noe her, ikke er frekvensen i seg selv, men "Duty Cycle", det er forholdet mellom tiden som pulsen er "høy" dividert med bølgetiden. Anta for eksempel at vi vil generere en 50Hz pulsfrekvens på en av våre Raspberry Pi GPIO. Perioden (p) vil være invers av frekvens eller 20 ms (1/f). Hvis vi vil at vår LED med en "halv" lys, må vi ha en driftssyklus på 50%, det betyr en "puls" som vil være "høy" i 10 ms.

Dette prinsippet vil være veldig viktig for oss, for å kontrollere servoposisjonen, når "Duty Cycle" vil definere servoposisjonen som vist nedenfor:

Servo

Trinn 3: Installere Hw

Servoene vil bli koblet til en ekstern 5V forsyning, med datapinnen (i mitt tilfelle, de gule ledningene) koblet til Raspberry Pi GPIO som nedenfor:

• GPIO 17 ==> Tilt Servo
• GPIO 27 ==> Pan Servo

Ikke glem å koble GND -ene sammen ==> Raspberry Pi - Servoer - ekstern strømforsyning)

Du kan som alternativ ha en motstand på 1K ohm mellom Raspberry Pi GPIO og Server data input pin. Dette vil beskytte din RPi i tilfelle et servoproblem.

Trinn 4: Kalibrering av servoer

Det første du må gjøre er å bekrefte hovedtrekkene til servoene dine. I mitt tilfelle bruker jeg en Power Pro SG90.

Fra databladet kan vi vurdere:

• Rekkevidde: 180o
• Strømforsyning: 4,8V (ekstern 5VDC som USB -strømforsyning fungerer fint)
• Arbeidsfrekvens: 50Hz (periode: 20 ms)
• Pulsbredde: fra 1 ms til 2 ms

I teorien vil servoen være på sin

• Startposisjon (0 grader) når en puls på 1 ms tilføres dataterminalen
• Nøytral posisjon (90 grader) når en puls på 1,5 ms tilføres dataterminalen
• Endelig posisjon (180 grader) når en puls på 2 ms tilføres dataterminalen

For å programmere en servoposisjon ved hjelp av Python vil det være veldig viktig å kjenne korrespondenten "Duty Cycle" for posisjonene ovenfor, la oss gjøre noen beregninger:

• Startposisjon ==> (0 grader) Pulsbredde ==> 1ms ==> Driftssyklus = 1ms/20ms ==> 2,0%
• Nøytral posisjon (90 grader) Pulsbredde på 1,5 ms ==> Driftssyklus = 1,5 ms/20 ms ==> 7,5%
• Sluttposisjon (180 grader) Pulsbredde på 2 ms ==> Driftssyklus = 2ms/20ms ==> 10%

Så Duty Cycle bør variere fra 2 til 10 %.

La oss teste servoene individuelt. For det, åpne Raspberry -terminalen og start Python 3 -skallredigereren som "sudo" (fordi du burde være en "superbruker" å håndtere med GPIO -er):

sudo python3

På Python Shell

>>

Importer RPI. GPIO -modulen og kall den GPIO:

importer RPi. GPIO som GPIO

Definer hvilke pin-nummereringsordninger du vil bruke (BCM eller BOARD). Jeg gjorde denne testen med BOARD, så pinnene jeg brukte var de fysiske pinnene (GPIO 17 = Pin 11 og GPIO 27 Pin 13). Var lett for meg å identifisere dem og ikke gjøre feil under testen (I det siste programmet vil jeg bruke BCM). Velg den du foretrekker:

GPIO.setmode (GPIO. BOARD)

Definer servostiften du bruker:

tiltPin = 11

Hvis du i stedet har brukt BCM -oppsett, bør de to siste kommandoene erstattes av:

GPIO.setmode (GPIO. BCM)

tiltPin = 17

Nå må vi spesifisere at denne pinnen vil være en "utgang"

GPIO.setup (tiltPin, GPIO. OUT)

Og hva vil frekvensen bli generert på denne pinnen, som for vår servo vil være 50Hz:

tilt = GPIO. PWM (tiltPin, 50)

La oss begynne å generere et PWM -signal på pinnen med en innledende driftssyklus (vi beholder det "0"):

tilt = start (0)

Nå kan du angi forskjellige driftssyklusverdier og observere bevegelsen til servoen din. La oss starte med 2% og se hva som skjer (vi ser at servoen går til "nullposisjon"):

tilt. ChangeDutyCycle (2)

I mitt tilfelle gikk servoen til nullstilling, men da jeg endret driftssyklusen til 3% så jeg at servoen ble i samme posisjon og begynte å bevege seg med driftssykluser som var større enn 3%. Så, 3% er min utgangsposisjon (o grader). Det samme skjedde med 10%, min servo gikk over denne verdien og toppet slutten på 13%. Så for denne spesielle servoen ble resultatet:

• 0 grad ==> driftssyklus på 3%
• 90 grader ==> driftssyklus på 8%
• 180 grader ==> driftssyklus på 13%

Etter at du er ferdig med testene dine, må du stoppe PWM og rydde opp i GPIO -er:

vippe = stopp ()

GPIO.cleanup ()

Terminalutskriftsskjermen ovenfor viser resultatet for begge servoene mine (som har lignende resultater). Rekkevidden din kan være annerledes.

Trinn 5: Opprette et Python -script

PWM -kommandoene som skal sendes til servoen vår er i "duty cycles" slik vi så på det siste trinnet. Men vanligvis må vi bruke "vinkel" i grader som en parameter for å kontrollere en servo. Så vi må konvertere "vinkel" som er en mer naturlig måling for oss i driftssyklus, slik det er forståelig for Pi -en vår.

Hvordan gjøre det? Veldig enkelt! Vi vet at driftssyklusområdet går fra 3% til 13%, og at dette tilsvarer vinkler som vil variere fra 0 til 180 grader. Vi vet også at disse variasjonene er lineære, så vi kan konstruere et proporsjonalt skjema som vist ovenfor. så, gitt en vinkel, kan vi ha en korrespondentdriftssyklus:

dutyycle = vinkel/18 + 3

Behold denne formelen. Vi vil bruke den i neste kode.

La oss lage et Python -skript for å utføre testene. I utgangspunktet vil vi gjenta det vi gjorde før på Python Shell:

fra tid av importer søvn

importer RPi. GPIO som GPIO GPIO.setmode (GPIO. BCM) GPIO.setwarnings (False) def setServoAngle (servo, vinkel): pwm = GPIO. PWM (servo, 50) pwm.start (8) dutyCycle = vinkel / 18. + 3. pwm. ChangeDutyCycle (dutyCycle) sleep (0.3) pwm.stop () hvis _name_ == '_main_': import sys servo = int (sys.argv [1]) GPIO.setup (servo, GPIO. OUT) setServoAngle (servo, int (sys.argv [2])) GPIO.cleanup ()

Kjernen i koden ovenfor er funksjonen setServoAngle (servo, vinkel). Denne funksjonen mottar som argumenter, et servo GPIO -nummer og en vinkelverdi til hvor servoen må plasseres. Når inngangen til denne funksjonen er "vinkel", må vi konvertere den til driftssyklus i prosent, ved å bruke formelen utviklet før.

Når skriptet er utført, må du angi som parametere, servo GPIO og vinkel.

For eksempel:

sudo python3 vinkel ServoCtrl.py 17 45

Kommandoen ovenfor vil plassere servoen som er koblet til GPIO 17 med 45 grader i "elevation". En lignende kommando kan brukes for Pan Servo -kontroll (posisjon til 45 grader i "azimut"):

sudo python -vinkel ServoCtrl.py 27 45

Filen angleServoCtrl.py kan lastes ned fra min GitHub

Trinn 6: Pan-Tilt-mekanismen

"Pan" -servoen vil bevege kameraet vårt horisontalt ("azimutvinkel") og "Tilt" -servoen flytte det "vertikalt" (høydevinkel).

Bildet nedenfor viser hvordan Pan/Tilt -mekanismen fungerer:

Under utviklingen vil vi ikke gå til "ekstremer", og vi vil bare bruke Pan/Tilt -mekanismen fra 30 til 150 grader. Dette området vil være nok til å brukes med et kamera.

Trinn 7: Pan -Tilt -mekanismen - mekanisk konstruksjon

La oss nå montere våre 2 servoer som en Pan/Tilt -mekanisme. Du kan gjøre 2 ting her. Kjøp en Pan-Tilt-plattformsmekanisme som den som ble vist på det siste trinnet, eller bygg din egen i henhold til dine behov.

Ett eksempel kan være det jeg bygde, bare binde servoene til hverandre og bruke små metallstykker fra gamle leker som vist på bildene ovenfor.

Trinn 8: Elektrisk pan/tilt -enhet

Når du har montert Pan/Tilt -mekanismen, følger du bildene for full elektrisk tilkobling.

1. Slå av Pi.
2. Gjør alle elektriske tilkoblinger.
3. Dobbeltsjekk det.
4. Slå på Pi først.
5. Hvis alt er i orden, slå på servoene dine.

Vi vil ikke utforske på denne opplæringen hvordan du setter opp kameraet, dette vil bli forklart i neste opplæring.

Trinn 9: Python -skriptet

La oss lage et Python -script for å kontrollere begge servoene samtidig:

fra tid av importer søvn

importer RPi. GPIO som GPIO GPIO.setmode (GPIO. BCM) GPIO.setwarnings (False) pan = 27 tilt = 17 GPIO.setup (tilt, GPIO. OUT) # white => TILT GPIO.setup (pan, GPIO. OUT) # grå ==> PAN def setServoAngle (servo, vinkel): hev vinkel> = 30 og vinkel 90 (midtpunkt) ==> 150 setServoAngle (tilt, int (sys.argv [2])) # 30 ==> 90 (midtpunkt) ==> 150 GPIO.cleanup ()

Når skriptet er utført, må du angi som parametere, Panvinkel og Tiltvinkel. For eksempel:

sudo python3 servoCtrl.py 45120

Kommandoen ovenfor vil plassere Pan/Tilt -mekanismen med 45 grader i "azimut" (Pan -vinkel) og 120 grader "elevation" (Tilt Angle). Vær oppmerksom på at hvis ingen parametere er angitt, vil standarden være både panorering og vippevinkler satt opp til 90 grader.

Nedenfor ser du noen tester:

ServoCtrl.py -filen kan lastes ned fra min GitHub.

Trinn 10: Sløyfetest av servere

La oss nå lage et Python -script for å automatisk teste hele spekteret av servoer:

fra tid av importer søvn

importer RPi. GPIO som GPIO GPIO.setmode (GPIO. BCM) GPIO.setwarnings (False) pan = 27 tilt = 17 GPIO.setup (tilt, GPIO. OUT) # white => TILT GPIO.setup (pan, GPIO. OUT) # grå ==> PAN def setServoAngle (servo, vinkel): hev vinkel> = 30 og vinkel <= 150 pwm = GPIO. PWM (servo, 50) pwm.start (8) dutyCycle = vinkel / 18. + 3. pwm. ChangeDutyCycle (dutyCycle) søvn (0,3) pwm.stop () hvis _name_ == '_main_': for i i område (30, 160, 15): setServoAngle (pan, i) setServoAngle (tilt, i) for i in område (150, 30, -15): setServoAngle (pan, i) setServoAngle (tilt, i) setServoAngle (pan, 100) setServoAngle (tilt, 90) GPIO.cleanup ()

Programmet vil automatisk kjøre en sløyfe fra 30 til 150 grader i begge vinkler.

Under resultatet:

Jeg koblet bare til et oscilloskop for å illustrere PWM -teorien som forklart tidligere.

Koden ovenfor, servoTest.py kan lastes ned fra min GitHub.

Trinn 11: Konklusjon

Som alltid håper jeg at dette prosjektet kan hjelpe andre å finne veien inn i den spennende elektronikkverdenen!

For detaljer og siste kode, vennligst besøk mitt GitHub-depot: RPi-Pan-Tilt-Servo-Control

For flere prosjekter, vennligst besøk bloggen min: MJRoBot.org

Nedenfor et glimt av min neste opplæring:

Hilsener fra den sørlige verden!

Se deg i min neste instruerbare!

Takk skal du ha, Marcelo