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

2024 Författare: John Day | [email protected]. Senast ändrad: 2024-01-30 12:46

I denna handledning kommer vi att utforska hur du styr flera servon med Python på en Raspberry Pi. Vårt mål kommer att vara en PAN/TILT -mekanism för att placera en kamera (en PiCam).

Här kan du se hur vårt slutliga projekt kommer att fungera:

Control Servo Control loop test:

Steg 1: BoM - materialräkning

Huvuddelar:

1. Raspberry Pi V3 - 32,00 US $
2. 5 megapixlar 1080p sensor OV5647 minikamera videomodul - 13,00 US $
3. TowerPro SG90 9G 180 grader Micro Servo (2 X)- 4,00 US $
4. Mini Pan/ Tilt Camera Platform Anti -Vibration Camera Mount w/ 2 Servos (*) - 8,00 US $
5. Motstånd 1K ohm (2X) - Valfritt
6. Diverse: metalldelar, band, etc. (om du konstruerar din Pan/Tilt -mekanism)

(*) kan du köpa en komplett Pan/Tilt -plattform med servon eller bygga din egen.

Steg 2: Hur PWM fungerar

Raspberry Pi har ingen analog utgång, men vi kan simulera detta med en PWM -metod (Pulse Width Modulation). Vad vi kommer att göra är att generera en digital signal med en fast frekvens, där vi kommer att ändra pulstågets bredd, vad som kommer att "översättas" som en "genomsnittlig" utspänningsnivå enligt nedan:

Vi kan använda denna "genomsnittliga" spänningsnivå för att styra en LED -ljusstyrka till exempel:

Observera att det som spelar roll här är inte själva frekvensen, utan "Duty Cycle", det är förhållandet mellan tiden då pulsen är "hög" dividerat med vågperioden. Anta till exempel att vi kommer att generera en 50Hz pulsfrekvens på en av våra Raspberry Pi GPIO. Perioden (p) kommer att vara invers av frekvens eller 20 ms (1/f). Om vi vill att vår LED med en "halv" ljus, måste vi ha en Duty Cycle på 50%, det betyder en "puls" som kommer att vara "Hög" i 10ms.

Denna princip kommer att vara mycket viktig för oss att kontrollera vår servoposition när "Duty Cycle" kommer att definiera servopositionen enligt nedan:

Servo

Steg 3: Installera Hw

Servon kommer att anslutas till en extern 5V -strömförsörjning, med datapinnen (i mitt fall, deras gula ledningar) ansluten till Raspberry Pi GPIO enligt nedan:

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

Glöm inte att ansluta GND: erna ==> Raspberry Pi - Servos - Extern strömförsörjning)

Du kan som tillval ha ett motstånd på 1K ohm mellan Raspberry Pi GPIO och Server data input pin. Detta skulle skydda din RPi vid ett servoproblem.

Steg 4: Servokalibrering

Det första du ska göra är att bekräfta de viktigaste egenskaperna hos dina servon. I mitt fall använder jag en Power Pro SG90.

Från databladet kan vi överväga:

• Räckvidd: 180o
• Strömförsörjning: 4,8V (extern 5VDC som USB -strömförsörjning fungerar bra)
• Arbetsfrekvens: 50Hz (period: 20 ms)
• Pulsbredd: från 1 ms till 2 ms

I teorin kommer servon att vara på sin

• Utgångsläge (0 grader) när en puls på 1 ms appliceras på dess dataterminal
• Neutral position (90 grader) när en puls på 1,5 ms appliceras på dess dataterminal
• Slutlig position (180 grader) när en puls på 2 ms appliceras på dess dataterminal

För att programmera en servoposition med Python är det mycket viktigt att känna till korrespondenten "Duty Cycle" för ovanstående positioner, låt oss göra en beräkning:

• Utgångsläge ==> (0 grader) Pulsbredd ==> 1ms ==> Driftscykel = 1ms/20ms ==> 2,0%
• Neutral position (90 grader) Pulsbredd på 1,5 ms ==> Driftscykel = 1,5 ms/20 ms ==> 7,5%
• Slutställning (180 grader) Pulsbredd på 2 ms ==> Driftcykel = 2ms/20ms ==> 10%

Så Duty Cycle bör variera med ett intervall på 2 till 10 %.

Låt oss testa servon individuellt. För det, öppna din Raspberry -terminal och starta din Python 3 -skalredigerare som "sudo" (på grund av att du borde vara en "superanvändare" att hantera med GPIO: er):

sudo python3

På Python Shell

>>

Importera RPI. GPIO -modulen och kalla den GPIO:

importera RPi. GPIO som GPIO

Definiera vilka pin-nummereringsscheman du vill använda (BCM eller BOARD). Jag gjorde detta test med BOARD, så stiften som jag använde var de fysiska stiften (GPIO 17 = Pin 11 och GPIO 27 Pin 13). Var lätt för mig att identifiera dem och inte göra misstag under testet (I det sista programmet kommer jag att använda BCM). Välj en av dina preferenser:

GPIO.setmode (GPIO. BOARD)

Definiera servostift som du använder:

tiltPin = 11

Om du istället har använt BCM -schema, bör de två sista kommandona ersättas med:

GPIO.setmode (GPIO. BCM)

tiltPin = 17

Nu måste vi ange att denna pin kommer att vara en "output"

GPIO.setup (tiltPin, GPIO. OUT)

Och vad blir frekvensen som genereras på denna pin, som för vår servo kommer att vara 50Hz:

tilt = GPIO. PWM (tiltPin, 50)

Låt oss nu börja generera en PWM -signal på stiftet med en initial driftcykel (vi behåller den "0"):

tilt = start (0)

Nu kan du ange olika driftscykelvärden och observera rörelsen hos din servo. Låt oss börja med 2% och se vad som händer (vi ser att servon går till "nolläge"):

tilt. ChangeDutyCycle (2)

I mitt fall gick servon till nolläge men när jag ändrade arbetscykeln till 3% såg jag att servon stannade i samma position och började röra sig med arbetscykler större än 3%. Så, 3% är min utgångsläge (o grader). Detsamma hände med 10%, min servo gick över detta värde och toppade 13%. Så för just denna servo blev resultatet:

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

När du har avslutat dina tester måste du stoppa PWM och städa GPIO: erna:

tilt = stopp ()

GPIO.cleanup ()

Ovanstående terminalutskriftsskärm visar resultatet för båda mina servon (som har liknande resultat). Ditt sortiment kan vara annorlunda.

Steg 5: Skapa ett Python -skript

PWM -kommandona som ska skickas till vår servo är i "arbetscykler" som vi såg på det sista steget. Men vanligtvis måste vi använda "vinkel" i grader som en parameter för att styra en servo. Så vi måste konvertera "vinkel" som är en mer naturlig mätning för oss i arbetscykeln, vilket är förståeligt för vår Pi.

Hur man gör det? Väldigt enkelt! Vi vet att driftscykelområdet går från 3% till 13% och att detta motsvarar vinklar som sträcker sig från 0 till 180 grader. Vi vet också att dessa variationer är linjära, så vi kan konstruera ett proportionellt schema som visas ovan. så med tanke på en vinkel kan vi ha en korrespondentens arbetscykel:

arbetscykel = vinkel/18 + 3

Behåll denna formel. Vi kommer att använda den i nästa kod.

Låt oss skapa ett Python -skript för att utföra testerna. I grund och botten kommer vi att upprepa det vi gjorde tidigare på Python Shell:

från tid importera sömn

importera 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) viloläge (0.3) pwm.stop () om _name_ == '_main_': import sys servo = int (sys.argv [1]) GPIO.setup (servo, GPIO. OUT) setServoAngle (servo, int (sys.argv [2])) GPIO.cleanup ()

Kärnan i ovanstående kod är funktionen setServoAngle (servo, vinkel). Denna funktion tar emot som argument, ett servo GPIO -nummer och ett vinkelvärde till var servon måste placeras. När ingången till denna funktion är "vinkel" måste vi konvertera den till arbetscykel i procent, med hjälp av formeln som utvecklats tidigare.

När skriptet körs måste du ange som parametrar, servo GPIO och vinkel.

Till exempel:

sudo python3 vinkelServoCtrl.py 17 45

Kommandot ovan kommer att placera servon ansluten till GPIO 17 med 45 grader i "elevation". Ett liknande kommando kan användas för Pan Servo -kontroll (position till 45 grader i "azimut"):

sudo python vinkel ServoCtrl.py 27 45

Filen angleServoCtrl.py kan laddas ner från min GitHub

Steg 6: Pan-Tilt-mekanismen

"Pan" -servot kommer att flytta "horisontellt" vår kamera ("azimutvinkel") och vår "Tilt" -servo kommer att flytta den "vertikalt" (höjdvinkel).

Bilden nedan visar hur Pan/Tilt -mekanismen fungerar:

Under vår utveckling kommer vi inte att gå till "extrema" och vi kommer att använda vår Pan/Tilt -mekanism från endast 30 till 150 grader. Denna räckvidd kommer att räcka för att användas med en kamera.

Steg 7: Pan -Tilt -mekanismen - mekanisk konstruktion

Låt oss nu montera våra 2 servon som en Pan/Tilt -mekanism. Du kan göra 2 saker här. Köp en Pan-Tilt-plattformsmekanism som den som visas i det sista steget eller bygg din egen enligt dina behov.

Ett exempel kan vara det som jag byggde, bara spänna servon en till en annan och använda små metallbitar från gamla leksaker som visas på bilderna ovan.

Steg 8: Elektrisk pan/lutningsenhet

När du har monterat din Pan/Tilt -mekanism, följ bilderna för fullständig elektrisk anslutning.

1. Stäng av din Pi.
2. Gör alla elektriska anslutningar.
3. Dubbelkolla det.
4. Slå på din Pi först.
5. Om allt är OK, slå på dina servon.

Vi kommer inte att utforska på denna handledning hur man ställer in kameran, detta kommer att förklaras i nästa handledning.

Steg 9: Python -skriptet

Låt oss skapa ett Python -skript för att styra båda servon samtidigt:

från tid importera sömn

importera 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): hävda vinkel> = 30 och vinkel 90 (mittpunkt) ==> 150 setServoAngle (tilt, int (sys.argv [2])) # 30 ==> 90 (mittpunkt) ==> 150 GPIO.cleanup ()

När manuset körs måste du ange som parametrar, Panvinkel och Lutningsvinkel. Till exempel:

sudo python3 servoCtrl.py 45120

Kommandot ovan kommer att placera Pan/Tilt -mekanismen med 45 grader i "azimut" (Pan -vinkel) och 120 grader av "elevation" (Tilt Angle). Observera att om inga parametrar har angetts är standard både pan- och tiltvinklar inställda på 90 grader.

Nedan kan du se några tester:

ServoCtrl.py -filen kan laddas ner från min GitHub.

Steg 10: Looptest av servrar

Låt oss nu skapa ett Python -skript för att automatiskt testa hela utbudet av servon:

från tid importera sömn

importera 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): hävda vinkel> = 30 och vinkel <= 150 pwm = GPIO. PWM (servo, 50) pwm.start (8) dutyCycle = vinkel / 18. + 3. pwm. ChangeDutyCycle (dutyCycle) viloläge (0,3) pwm.stop () om _name_ == '_main_': för i i intervall (30, 160, 15): setServoAngle (pan, i) setServoAngle (tilt, i) för i in intervall (150, 30, -15): setServoAngle (pan, i) setServoAngle (tilt, i) setServoAngle (pan, 100) setServoAngle (tilt, 90) GPIO.cleanup ()

Programmet kör automatiskt en slinga från 30 till 150 grader i båda vinklarna.

Under resultatet:

Jag kopplade ett oscilloskop endast för att illustrera PWM -teorin som förklarats tidigare.

Ovanstående kod, servoTest.py kan laddas ner från min GitHub.

Steg 11: Slutsats

Som alltid hoppas jag att detta projekt kan hjälpa andra att hitta in i den spännande världen av elektronik!

För detaljer och slutkod, besök min GitHub-förvaring: RPi-Pan-Tilt-Servo-Control

För fler projekt, besök min blogg: MJRoBot.org

Nedan en glimt av min nästa handledning:

Hälsningar från södra världen!

Vi ses i min nästa instruerbara!

Tack, Marcelo