Pan-Tilt Multi Servo Control: 11 lépés (képekkel)

2024 Szerző: John Day | [email protected]. Utoljára módosítva: 2024-01-30 09:43

Ebben az oktatóanyagban megvizsgáljuk, hogyan lehet több szervót vezérelni a Raspberry Pi Python használatával. Célunk egy PAN/TILT mechanizmus lesz egy kamera elhelyezésére (PiCam).

Itt láthatja, hogyan fog működni a végső projektünk:

Vezérlő szervo vezérlő hurok teszt:

1. lépés: BoM - Bill of Material

Fő részek:

1. Raspberry Pi V3 - 32,00 USD
2. 5 megapixeles 1080p érzékelő OV5647 mini kamera videomodul - 13,00 USD
3. TowerPro SG90 9G 180 fokos mikroszervó (2 X)- 4,00 USD
4. Mini pan/ billenő kamera platform vibrációgátló kamera tartó 2 szervóval (*) - 8,00 USD
5. Ellenállás 1K ohm (2X) - opcionális
6. Egyéb: fém alkatrészek, szalagok, stb.

(*) megvásárolhat egy teljes Pan/Tilt platformot a szervókkal, vagy sajátot építhet.

2. lépés: A PWM működése

A Raspberry Pi nem rendelkezik analóg kimenettel, de ezt szimulálhatjuk PWM (Pulse Width Modulation) módszerrel. Amit tenni fogunk, az az, hogy rögzített frekvenciájú digitális jelet állítunk elő, ahol megváltoztatjuk az impulzussorozat szélességét, amit "lefordítunk" "átlagos" kimeneti feszültségszintnek az alábbiak szerint:

Ezt az "átlagos" feszültségszintet használhatjuk a LED fényerejének szabályozására, például:

Megjegyezzük, hogy itt nem a frekvencia számít, hanem a "Duty Cycle", vagyis a pulzus "magas" ideje és a hullámperiódus közötti hányados. Tegyük fel például, hogy 50 Hz -es impulzusfrekvenciát generálunk a Raspberry Pi GPIO egyikén. A (p) periódus a frekvencia fordítottja vagy 20 ms (1/f) lesz. Ha azt szeretnénk, hogy a LED -ek "félig" világosak legyenek, akkor 50%-os üzemi ciklussal kell rendelkeznünk, ami azt jelenti, hogy "impulzus" 10 ms -ig "magas" lesz.

Ez az elv nagyon fontos lesz számunkra a szervo pozíciónk szabályozásához, miután a "Duty Cycle" meghatározza a szervo pozíciót az alábbiak szerint:

Szervo

3. lépés: A Hw telepítése

A szervókat külső 5 V -os tápegységhez csatlakoztatják, és az adatcsapjuk (esetemben a sárga vezetékeik) a Raspberry Pi GPIO -hoz csatlakoznak az alábbiak szerint:

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

Ne felejtse el összekapcsolni a GND -ket ==> Raspberry Pi - szervók - külső tápegység)

Opcióként 1K ohmos ellenállást rendelhet a Raspberry Pi GPIO és a kiszolgáló adatbeviteli tűje között. Ez megvédi az RPi -t szervo probléma esetén.

4. lépés: Szervokalibrálás

Az első dolog, amit meg kell tennie, hogy megerősítse a szervók fő jellemzőit. Esetemben Power Pro SG90 -et használok.

Adatlapjából megfontolhatjuk:

• Tartomány: 180o
• Tápegység: 4,8V (külső 5VDC USB tápegységként jól működik)
• Működési frekvencia: 50Hz (időszak: 20 ms)
• Impulzusszélesség: 1 ms és 2 ms között

Elméletileg a szervó rajta lesz

• Kezdeti pozíció (0 fok), ha 1 ms -os impulzust alkalmaznak az adatterminálra
• Semleges helyzet (90 fok), ha az adatterminálra 1,5 ms impulzust adnak
• Végső helyzet (180 fok), ha 2 ms -os impulzust alkalmaznak az adatterminálra

A szervo pozíció Python használatával történő programozásához nagyon fontos lesz tudni a fenti pozíciók "Duty Cycle" levelező ciklusát, végezzünk néhány számítást:

• Kezdeti pozíció ==> (0 fok) Pulzusszélesség ==> 1ms ==> Üzemidő = 1ms/20ms ==> 2,0%
• Semleges helyzet (90 fok) Pulzusszélesség 1,5 ms ==> Üzemidő = 1,5 ms/20 ms ==> 7,5%
• Végső helyzet (180 fok) 2 ms impulzusszélesség ==> Üzemidő = 2 ms/20 ms ==> 10%

Tehát a terhelési ciklusnak 2 és 10 %között kell változnia.

Teszteljük a szervókat egyenként. Ehhez nyissa meg a Raspberry terminált, és indítsa el a Python 3 shell -szerkesztőjét "sudo" néven (mivel "szuper felhasználónak" kell lennie a GPIO -k kezeléséhez):

sudo python3

A Python Shell -en

>>

Importálja az RPI. GPIO modult, és hívja GPIO -nak:

importálja az RPi. GPIO -t GPIO -ként

Határozza meg, hogy mely pin-számozási sémákat szeretné használni (BCM vagy BOARD). Ezt a tesztet a BOARD segítségével végeztem, így a használt csapokat a fizikai csapok használtam (GPIO 17 = 11 -es és GPIO 27 -es 13 -as tű). Könnyű volt számomra azonosítani őket, és nem hibázni a teszt során (Az utolsó programban a BCM -et fogom használni). Válassza ki a kívántat:

GPIO.setmode (GPIO. BOARD)

Határozza meg a használt szervotüskét:

tiltPin = 11

Ha ehelyett BCM sémát használt, akkor az utolsó 2 parancsot a következőre kell cserélni:

GPIO.setmode (GPIO. BCM)

tiltPin = 17

Most meg kell adnunk, hogy ez a pin "kimenet" lesz

GPIO.setup (tiltPin, GPIO. OUT)

És mi lesz ezen a csapon generált frekvencia, hogy a szervónk 50 Hz lesz:

tilt = GPIO. PWM (tiltPin, 50)

Most kezdjük el a PWM jel generálását a csapon egy kezdeti munkaciklus mellett (0 -ban tartjuk):

dőlés = indítás (0)

Most különböző teljesítményciklus -értékeket adhat meg, figyelve a szervó mozgását. Kezdjük 2% -kal, és nézzük meg, mi történik (látjuk, hogy a szervó "nulla helyzetbe" megy):

tilt. ChangeDutyCycle (2)

Esetemben a szervó nulla helyzetbe került, de amikor a működési ciklust 3% -ra változtattam, azt tapasztaltam, hogy a szervó ugyanabban a helyzetben maradt, és 3% -nál nagyobb terhelési ciklusokkal kezdett mozogni. Tehát 3% a kezdeti pozícióm (o fok). Ugyanez történt 10%-kal is, a szervóm meghaladta ezt az értéket, és 13%-kal tetézte a végét. Tehát ennek a szervónak az eredménye a következő volt:

• 0 fok ==> 3% -os munkaciklus
• 90 fok ==> 8% -os működési ciklus
• 180 fok ==> 13% -os üzemidő

A tesztek befejezése után le kell állítania a PWM -et, és meg kell tisztítania a GPIO -kat:

dőlés = megállás ()

GPIO.cleanup ()

A fenti terminál nyomtatási képernyő mindkét szervom eredményét mutatja (hasonló eredményekkel). A tartománya eltérő lehet.

5. lépés: Python -szkript létrehozása

A szervónknak küldendő PWM parancsok "működési ciklusokban" vannak, amint azt az utolsó lépésben láttuk. Általában azonban a "szöget" fokokban kell használni paraméterként egy szervó vezérléséhez. Tehát a "szöget", amely egy természetesebb mérés, nekünk kell átalakítanunk a működési ciklusban, amint azt a Pi érti.

Hogyan kell csinálni? Nagyon egyszerű! Tudjuk, hogy a munkaciklus tartománya 3% és 13% között mozog, és ez megfelel a 0 és 180 fok közötti szögeknek. Azt is tudjuk, hogy ezek a variációk lineárisak, ezért a fentiek szerint felépíthetünk egy arányos sémát. így adott szög esetén megfelelő működési ciklusunk lehet:

terhelési ciklus = szög/18 + 3

Tartsa meg ezt a képletet. A következő kódban használjuk.

Hozzunk létre egy Python szkriptet a tesztek végrehajtásához. Alapvetően megismételjük, amit korábban a Python Shell -en tettünk:

az idő alvó alvásból

RPi. GPIO importálása GPIO -ként GPIO GPIO.setmode (GPIO. BCM) GPIO.setwarnings (False) def setServoAngle (szervo, szög): pwm = GPIO. PWM (szervo, 50) pwm.start (8) dutyCycle = szög / 18. + 3. pwm. ChangeDutyCycle (dutyCycle) alvás (0.3) pwm.stop () if _name_ == '_main_': import sys servo = int (sys.argv [1]) GPIO.setup (servo, GPIO. OUT) setServoAngle (szervo, int (sys.argv [2]))) GPIO.cleanup ()

A fenti kód magja a setServoAngle (szervo, szög) függvény. Ez a függvény érvként kapja meg a szervo GPIO számot és a szög értékét a szervó elhelyezésének helyéhez. Ha ennek a függvénynek a bemenete "szög", akkor azt a korábban kifejlesztett képlet segítségével százalékosan kell átalakítanunk a munkaciklusra.

A parancsfájl végrehajtásakor paraméterként, szervo GPIO -ként és szögként kell megadni.

Például:

sudo python3 szögServoCtrl.py 17 45

A fenti parancs a GPIO 17 -hez csatlakoztatott szervót 45 fokos "magasságban" pozícionálja. Hasonló parancs használható a Pan Servo vezérléshez (45 fokos helyzetben "azimut"):

sudo python szögServoCtrl.py 27 45

A angleServoCtrl.py fájl letölthető a GitHub -ból

6. lépés: A Pan-Tilt mechanizmus

A "Pan" szervó "vízszintesen" mozgatja a kameránkat ("azimut szög"), a "Tilt" szervó pedig "függőlegesen" (magassági szög).

Az alábbi kép mutatja a Pan/Tilt mechanizmus működését:

Fejlődésünk során nem fogunk "szélsőségekbe" menni, és csak 30 és 150 fok között fogjuk használni a Pan/Tilt mechanizmust. Ez a tartomány elegendő lesz a kamerával való használatra.

7. lépés: A Pan -Tilt mechanizmus - mechanikai felépítés

Most szereljük össze a 2 szervónkat Pan/Tilt mechanizmusként. Itt 2 dolgot tehetsz. Vásároljon Pan-Tilt platformmechanizmust az utolsó lépésben látható módon, vagy építse meg saját igényeinek megfelelően.

Az egyik példa az általam épített, csak a szervókat egymáshoz rögzítve, és a régi játékok apró fémdarabjait használva, amint a fenti képeken látható.

8. lépés: Elektromos pan/billenő szerelés

Miután összeszerelte a Pan/Tilt mechanizmust, kövesse a fényképeket a teljes elektromos csatlakoztatáshoz.

1. Kapcsolja ki a Pi -t.
2. Végezze el az összes elektromos csatlakozást.
3. Ellenőrizze kétszer.
4. Először kapcsolja be a Pi -t.
5. Ha minden rendben van, kapcsolja be a szervókat.

Ebben az oktatóanyagban nem vizsgáljuk meg a kamera beállításának módját, ezt a következő oktatóanyagban ismertetjük.

9. lépés: A Python -szkript

Hozzunk létre egy Python -szkriptet mindkét szervó egyidejű vezérlésére:

az idő alvó alvásból

RPi. GPIO importálása GPIO GPIO.setmode (GPIO. BCM) GPIO.setwarnings (False) pan = 27 tilt = 17 GPIO.setup (tilt, GPIO. OUT) # white => TILT GPIO.setup (pan, GPIO. OUT) # szürke ==> PAN def setServoAngle (szervo, szög): érvényesítési szög> = 30 és szög 90 (középső pont) ==> 150 setServoAngle (tilt, int (sys.argv [2])) # 30 ==> 90 (középső pont) ==> 150 GPIO.cleanup ()

A szkript végrehajtásakor paraméterekként meg kell adnia a Pan szög és a döntési szög értékét. Például:

sudo python3 servoCtrl.py 45 120

A fenti parancs pozícionálja a Pan/Tilt mechanizmust 45 fokos "azimut" (pásztázási szög) és 120 fokos "magasság" (döntési szög) helyzetbe. Ne feledje, hogy ha nem ad meg paramétereket, akkor az alapértelmezett beállítás a 90 fokos dőlésszög és dőlésszög.

Az alábbiakban néhány tesztet láthat:

A servoCtrl.py fájl letölthető a GitHub -ból.

10. lépés: A kiszolgálók hurok tesztelése

Most hozzunk létre egy Python -szkriptet a szervók teljes skálájának automatikus teszteléséhez:

az idő behozatalából

RPi. GPIO importálása GPIO GPIO.setmode (GPIO. BCM) GPIO.setwarnings (False) pan = 27 tilt = 17 GPIO.setup (tilt, GPIO. OUT) # white => TILT GPIO.setup (pan, GPIO. OUT) # szürke ==> PAN def setServoAngle (szervo, szög): érvényesítési szög> = 30 és szög <= 150 pwm = GPIO. PWM (szervo, 50) pwm.start (8) dutyCycle = szög / 18. + 3. pwm. ChangeDutyCycle (dutyCycle) alvás (0.3) pwm.stop () if _name_ == '_main_': for i (30, 160, 15): setServoAngle (pan, i) setServoAngle (tilt, i) for i in tartomány (150, 30, -15): setServoAngle (pan, i) setServoAngle (tilt, i) setServoAngle (pan, 100) setServoAngle (dönthető, 90) GPIO.cleanup ()

A program mindkét szögben automatikusan végrehajt egy 30-150 fokos ciklust.

Az eredmény alatt:

Az oszcilloszkópot csak a PWM elmélet illusztrálására kötöttem, ahogyan azt korábban kifejtettük.

A fenti kód, a servoTest.py letölthető a GitHub -ból.

11. lépés: Következtetés

Mint mindig, remélem, hogy ez a projekt segíthet másoknak is eligazodni az elektronika izgalmas világában!

A részletekért és a végső kódért keresse fel a GitHub letéteményemet: RPi-Pan-Tilt-Servo-Control

További projektekért látogasson el a blogomra: MJRoBot.org

Alább egy pillantás a következő oktatóanyagomra:

Üdvözlet a világ déli részéről!

Találkozunk a következő tanításomban!

Köszönöm, Marcelo