Pan-Tilt Multi Servo Control: Hatua 11 (na Picha)

2024 Mwandishi: John Day | [email protected]. Mwisho uliobadilishwa: 2024-01-30 12:54

Kwenye mafunzo haya, tutachunguza jinsi ya kudhibiti servos nyingi kwa kutumia Python kwenye Raspberry Pi. Lengo letu litakuwa utaratibu wa PAN / TILT kuweka kamera (PiCam).

Hapa unaweza kuona jinsi mradi wetu wa mwisho utafanya kazi:

Dhibiti mtihani wa kitanzi cha Udhibiti wa Servo:

Hatua ya 1: BoM - Muswada wa Nyenzo

Sehemu kuu:

1. Raspberry Pi V3 - US $ 32.00
2. Megapixels 5 1080p Sensor OV5647 Moduli ya Video ya Kamera Mini - US $ 13.00
3. TowerPro SG90 9G digrii 180 Micro Servo (2 X) - US $ 4.00
4. Mini Pan / Tilt Jukwaa la Kamera ya Kupambana na Vibration Kamera Mount w / 2 Servos (*) - US $ 8.00
5. Resistor 1K ohm (2X) - Hiari
6. Miscellaneous: sehemu za chuma, bendi, nk (ikiwa utaunda utaratibu wako wa Pan / Tilt)

(*) unaweza kununua jukwaa kamili la Pan / Tilt na servos au ujenge yako mwenyewe.

Hatua ya 2: Jinsi PWM inavyofanya kazi

Raspberry Pi haina pato la analog, lakini tunaweza kuiga hii, kwa kutumia njia ya PWM (Pulse Width Modulation). Tutafanya ni kutengeneza ishara ya dijiti na masafa ya kudumu, ambapo tutabadilisha upana wa treni ya kunde, nini "kitatafsiriwa" kama kiwango cha wastani cha "pato" kama inavyoonyeshwa hapa chini:

Tunaweza kutumia kiwango hiki cha "wastani" kudhibiti mwangaza wa LED kwa mfano:

Kumbuka kuwa la muhimu hapa sio masafa yenyewe, lakini "Mzunguko wa Ushuru", huo ndio uhusiano kati ya wakati ambao mimbari ni "juu" imegawanywa na kipindi cha mawimbi. Kwa mfano, tuseme kwamba tutazalisha mzunguko wa mapigo ya 50Hz kwenye moja ya Raspberry Pi GPIO yetu. Kipindi (p) kitabadilisha mzunguko au 20ms (1 / f). Ikiwa tunataka kuwa na LED yetu iliyo na "nusu" angavu, lazima tuwe na Mzunguko wa Ushuru wa 50%, hiyo inamaanisha "pigo" ambalo litakuwa "Juu" kwa 10ms.

Kanuni hii itakuwa muhimu sana kwetu, kudhibiti msimamo wetu wa servo, mara tu "Mzunguko wa Ushuru" utafafanua msimamo wa servo kama inavyoonyeshwa hapa chini:

Servo

Hatua ya 3: Kufunga Hw

Servos zitaunganishwa na usambazaji wa 5V wa nje, ikiwa na pini yao ya data (kwa upande wangu, wiring yao ya manjano) unganisha kwenye Raspberry Pi GPIO kama ilivyo hapo chini:

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

Usisahau kuunganisha GNDs pamoja ==> Raspberry Pi - Servos - Ugavi wa Umeme wa Nje)

Unaweza kuwa kama chaguo, kipinzani cha 1K ohm kati ya Raspberry Pi GPIO na pini ya kuingiza data ya Seva. Hii italinda RPi yako ikiwa kuna shida ya servo.

Hatua ya 4: Upimaji wa Servos

Jambo la kwanza kufanya ni kudhibitisha sifa kuu za servos zako. Kwa upande wangu, ninatumia Power Pro SG90.

Kutoka kwa data yake, tunaweza kuzingatia:

• Masafa: 180o
• Ugavi wa Nguvu: 4.8V (5VDC ya nje kama usambazaji wa umeme wa USB hufanya kazi vizuri)
• Mzunguko wa kufanya kazi: 50Hz (Kipindi: 20 ms)
• Upana wa kunde: kutoka 1ms hadi 2ms

Kwa nadharia, servo itakuwa juu yake

• Nafasi ya Awali (digrii 0) wakati mapigo ya 1ms yanatumika kwenye terminal ya data yake
• Nafasi ya Neutral (digrii 90) wakati mapigo ya 1.5 ms yanatumika kwa terminal ya data yake
• Nafasi ya Mwisho (digrii 180) wakati mpigo wa 2 ms unatumika kwenye kituo chake cha data

Ili kupanga nafasi ya servo kutumia Python itakuwa muhimu sana kujua mwandishi "Mzunguko wa Ushuru" kwa nafasi zilizo hapo juu, wacha tufanye hesabu:

• Nafasi ya Awali ==> (0 digrii) Upana wa kunde
• Nafasi ya upande wowote (digrii 90) Upana wa kunde wa 1.5 ms ==> Mzunguko wa Ushuru = 1.5ms / 20ms ==> 7.5%
• Nafasi ya Mwisho (nyuzi 180) Upana wa kunde wa 2 ms ==> Mzunguko wa Ushuru = 2ms / 20ms ==> 10%

Kwa hivyo Mzunguko wa Ushuru unapaswa kutofautiana kwa anuwai ya 2 hadi 10%.

Wacha tujaribu servos mmoja mmoja. Kwa hilo, fungua kituo chako cha Raspberry na uzindue mhariri wako wa ganda la Python 3 kama "sudo" (kwa sababu yako unapaswa kuwa "mtumiaji mzuri" kushughulikia GPIOs):

Sudo python3

Kwenye ganda la Python

>>

Ingiza moduli ya RPI. GPIO na uiita GPIO:

kuagiza RPi. GPIO kama GPIO

Fafanua ni mipango gani ya nambari unayotaka kutumia (BCM au BODI). Nilifanya mtihani huu na BODI, kwa hivyo pini ambazo nilitumia zilikuwa pini za mwili (GPIO 17 = Pin 11 na GPIO 27 Pin 13). Ilikuwa rahisi kwangu kuwatambua na sio kufanya makosa wakati wa mtihani (Katika programu ya mwisho nitatumia BCM). Chagua moja ya upendeleo wako:

GPIO.setmode (GPIO. BOARD)

Fafanua pini ya servo ambayo unatumia:

TiltPin = 11

Ikiwa badala yake, umetumia mpango wa BCM, amri 2 za mwisho zinapaswa kubadilishwa na:

GPIO.setmode (GPIO. BCM)

TiltPin = 17

Sasa, lazima tueleze kwamba pini hii itakuwa "pato"

Kuanzisha kwa GPIO (TiltPin, GPIO. OUT)

Na, ni nini mzunguko unaozalishwa kwenye pini hii, ambayo kwa servo yetu itakuwa 50Hz:

tilt = GPIO. PWM (tiltPin, 50)

Sasa, wacha tuanze kutoa ishara ya PWM kwenye pini na mzunguko wa ushuru wa awali (tutaiweka "0"):

tilt = kuanza (0)

Sasa, unaweza kuingiza maadili tofauti ya mzunguko wa ushuru, ukiangalia mwendo wa servo yako. Wacha tuanze na 2% na tuone nini kinatokea (tunatazama kuwa servo huenda "nafasi ya sifuri"):

Tilt. ChangeDutyCycle (2)

Kwa upande wangu, servo ilikwenda kwenye nafasi ya sifuri lakini wakati nilibadilisha mzunguko wa ushuru kuwa 3% niliona kuwa servo ilikaa sawa, ikianza kusonga na mizunguko ya ushuru zaidi ya 3%. Kwa hivyo, 3% ndio msimamo wangu wa kwanza (digrii o). Vivyo hivyo ilitokea kwa 10%, servo yangu ilikwenda juu ya thamani hii, ikamalizia mwisho wake kwa 13%. Kwa hivyo kwa servo hii, matokeo yalikuwa:

• Digrii 0 ==> mzunguko wa ushuru wa 3%
• 90 digrii ==> mzunguko wa ushuru wa 8%
• Digrii 180 ==> mzunguko wa ushuru wa 13%

Baada ya kumaliza majaribio yako, lazima usimamishe PWM na usafishe GPIOs:

elekea = simama ()

Usafishaji wa GPIO ()

Skrini ya kuchapisha ya Kituo cha hapo juu inaonyesha matokeo ya servos zangu zote mbili (ambazo zina matokeo sawa). Masafa yako yanaweza kuwa tofauti.

Hatua ya 5: Kuunda Hati ya Python

Amri za PWM kutumwa kwa servo yetu ziko katika "mizunguko ya ushuru" kama tulivyoona kwenye hatua ya mwisho. Lakini kawaida, lazima tutumie "angle" kwa digrii kama parameta kudhibiti servo. Kwa hivyo, lazima tugeuze "angle" ambayo ni kipimo cha asili zaidi kwetu katika mzunguko wa wajibu kama inavyoeleweka na Pi yetu.

Jinsi ya kufanya hivyo? Rahisi sana! Tunajua kuwa masafa ya ushuru huanzia 3% hadi 13% na kwamba hii ni sawa na pembe ambazo zitatoka 0 hadi 180 digrii. Pia, tunajua kwamba tofauti hizo ni sawa, kwa hivyo tunaweza kuunda schema sawia kama inavyoonyeshwa hapo juu. kwa hivyo, kwa kupewa pembe, tunaweza kuwa na mzunguko wa wajibu wa mwandishi:

wajibu = pembeni / 18 + 3

Weka fomula hii. Tutatumia katika nambari inayofuata.

Wacha tuunde hati ya chatu kutekeleza vipimo. Kimsingi, tutarudia kile tulichofanya hapo awali kwenye ganda la Python:

kutoka wakati kuagiza kuagiza

ingiza RPi. GPIO kama GPIO GPIO.setmode (GPIO. BCM) + 3. pwm. ChangeDutyCycle (dutyCycle) kulala (0.3) pwm.stop () ikiwa _name_ == '_main_': ingiza sys servo = int (sys.argv [1]) GPIO.setup (servo, GPIO. OUT) setServoAngle (servo, int (sys.argv [2])) GPIO.safisha ()

Msingi wa nambari hapo juu ni kazi setServoAngle (servo, angle). Kazi hii inapokea kama hoja, nambari ya GPIO ya servo, na thamani ya pembe mahali ambapo servo lazima iwekwe. Mara tu pembejeo ya kazi hii ni "pembe", lazima tuibadilishe kuwa mzunguko wa ushuru kwa asilimia, kwa kutumia fomula iliyotengenezwa hapo awali.

Wakati hati inatekelezwa, lazima uingie kama vigezo, servo GPIO, na pembe.

Kwa mfano:

Sura ya python3ServoCtrl.py 17 45

Amri iliyo hapo juu itaweka servo iliyounganishwa kwenye GPIO 17 na digrii 45 katika "mwinuko". Amri kama hiyo inaweza kutumika kwa udhibiti wa Pan Servo (nafasi hadi digrii 45 katika "azimuth"):

Sura ya chatu ya sudoServoCtrl.py 27 45

Faili angleServoCtrl.py inaweza kupakuliwa kutoka kwa GitHub yangu

Hatua ya 6: Utaratibu wa Pan-Tilt

Servo ya "Pan" itahamia "usawa" kamera yetu ("pembe ya azimuth") na servo yetu ya "Tilt" itaisogeza "wima" (pembe ya mwinuko).

Picha hapa chini inaonyesha jinsi utaratibu wa Pan / Tilt unavyofanya kazi:

Wakati wa maendeleo yetu hatutaenda kwa "uliokithiri" na tutatumia mfumo wetu wa Pan / Tilt kutoka digrii 30 hadi 150 tu. Masafa haya yatatosha kutumiwa na kamera.

Hatua ya 7: Utaratibu wa Pan-Tilt - Ujenzi wa Mitambo

Wacha sasa, tusanyike huduma zetu 2 kama mfumo wa Pan / Tilt. Unaweza kufanya vitu 2 hapa. Nunua utaratibu wa jukwaa la Pan-Tilt kama ile iliyoonyeshwa kwenye hatua ya mwisho au jijengee mwenyewe kulingana na mahitaji yako.

Mfano mmoja unaweza kuwa ule ambao nilijenga, nikifunga tu servos moja hadi nyingine, na kutumia vipande vidogo vya chuma kutoka kwa vitu vya kuchezea vya zamani kama inavyoonyeshwa kwenye picha hapo juu.

Hatua ya 8: Mkutano wa Umeme wa Pan / Tilt

Mara baada ya kusanyiko lako la Pan / Tilt, fuata picha kwa unganisho kamili la umeme.

1. Zima Pi yako.
2. Fanya viunganisho vyote vya umeme.
3. Iangalie mara mbili.
4. Nguvu kwenye Pi yako kwanza.
5. Ikiwa kila kitu ni sawa, weka nguvu servos zako.

Hatutachunguza kwenye mafunzo haya jinsi ya kuweka kamera, hii itaelezewa kwenye mafunzo yanayofuata.

Hatua ya 9: Hati ya Python

Wacha tuunde Hati ya Python kudhibiti servos zote mbili kwa wakati mmoja:

kutoka wakati kuagiza kuagiza

Ingiza RPi. GPIO kama GPIO GPIO.setmode (GPIO. BCM) # kijivu ==> PAN def setServoAngle (servo, angle): assert angle> = 30 na angle 90 (katikati) ==> 150 setServoAngle (tilt, int (sys.argv [2])) # 30 ==> 90 (hatua ya kati) ==> 150 GPIO.cleanup ()

Wakati hati inatekelezwa, lazima uingie kama vigezo, pembe ya Pan na pembe ya Tilt. Kwa mfano:

Sura ya python3 servoCtrl.py 45 120

Amri iliyo hapo juu itaweka utaratibu wa Pan / Tilt na digrii 45 katika "azimuth" (Pan angle) na digrii 120 za "mwinuko" (Tilt Angle). Kumbuka kuwa ikiwa hakuna vigezo vilivyoingizwa, chaguomsingi itakuwa zote, pan na pembe za kuelekeza zilizowekwa hadi digrii 90.

Chini unaweza kuona majaribio:

Faili ya servoCtrl.py inaweza kupakuliwa kutoka kwa GitHub yangu.

Hatua ya 10: Mtihani wa Kitanzi wa Seva

Wacha sasa tuunde Hati ya Python kujaribu moja kwa moja anuwai kamili ya servos:

kutoka wakati kuagiza kuagiza

ingiza RPi. GPIO kama GPIO GPIO.setmode (GPIO. BCM) # kijivu ==> PAN def setServoAngle (servo, angle): assert angle> = 30 na angle <= 150 pwm = GPIO. PWM (servo, 50) pwm. anza (8) wajibu Mzunguko = angle / 18. + 3. pwm. ChangeDutyCycle (dutyCycle) lala (0.3) pwm.stop () ikiwa _name_ == '_main_': kwa mimi katika masafa (30, 160, 15): setServoAngle (pan, i) setServoAngle (tilt, i) kwa i in masafa (150, 30, -15): seti ServoAngle (pan, i) seti ServoAngle (tilt, i) setServoAngle (pan, 100) setServoAngle (tilt, 90) GPIO.cleanup ()

Programu hiyo itafanya kitanzi kiatomati kutoka digrii 30 hadi 150 kwa pembe zote mbili.

Chini ya matokeo:

Niliunganisha oscilloscope tu kuonyesha nadharia ya PWM kama ilivyoelezwa hapo awali.

Nambari iliyo hapo juu, servoTest.py inaweza kupakuliwa kutoka kwa GitHub yangu.

Hatua ya 11: Hitimisho

Kama kawaida, natumahi mradi huu unaweza kusaidia wengine kupata njia yao katika ulimwengu wa kusisimua wa umeme!

Kwa maelezo na nambari ya mwisho, tafadhali tembelea duka langu la GitHub: RPi-Pan-Tilt-Servo-Control

Kwa miradi zaidi, tafadhali tembelea blogi yangu: MJRoBot.org

Chini ya muhtasari wa mafunzo yangu yafuatayo:

Saludos kutoka kusini mwa ulimwengu!

Tukutane kwenye mafunzo yangu yafuatayo!

Asante, Marcelo