Pan-Tilt Multi Servo Control: 11 passos (amb imatges)

2024 Autora: John Day | [email protected]. Última modificació: 2024-01-30 08:15

En aquest tutorial, explorarem com controlar diversos servos mitjançant Python en un Raspberry Pi. El nostre objectiu serà un mecanisme PAN / TILT per situar una càmera (una PiCam).

Aquí podeu veure com funcionarà el nostre projecte final:

Prova del bucle de control de Servo Control:

Pas 1: BoM: llista de materials

Parts principals:

1. Raspberry Pi V3: 32,00 dòlars EUA
2. Sensor de 5 megapíxels 1080p OV5647 Mòdul de vídeo de mini càmera: 13,00 dòlars EUA
3. Servo micro TowerPro SG90 9G de 180 graus (2 X): 4,00 dòlars EUA
4. Plataforma de càmera antivibració mini plataforma panoràmica / inclinable amb 2 servos (*): 8,00 dòlars EUA
5. Resistència 1K ohm (2X): opcional
6. Diversos: peces metàl·liques, bandes, etc. (per si construïu el mecanisme Pan / Tilt)

(*) podeu comprar una plataforma Pan / Tilt completa amb els servos o crear-ne la vostra.

Pas 2: Com funciona PWM

El Raspberry Pi no té cap sortida analògica, però ho podem simular mitjançant un enfocament PWM (Pulse Width Modulation). El que farem és generar un senyal digital amb una freqüència fixa, on canviarem l’amplada del tren d’impulsos, el que es traduirà com un nivell de voltatge de sortida “mitjà” com es mostra a continuació:

Podem utilitzar aquest nivell de voltatge "mitjà" per controlar la brillantor d'un LED, per exemple:

Tingueu en compte que el que importa aquí no és la freqüència en si, sinó el "Cicle de treball", que és la relació entre el temps en què el puls és "alt" dividit pel període d'ona. Per exemple, suposem que generarem una freqüència de pols de 50Hz en un dels nostres Raspberry Pi GPIO. El període (p) serà invers de freqüència o de 20 ms (1 / f). Si volem que el nostre LED amb un "mig" brillant, haurem de tenir un cicle de treball del 50%, això significa un "pols" que serà "alt" durant 10 ms.

Aquest principi serà molt important per a nosaltres per controlar la nostra posició del servo, una vegada que el "Cicle de treball" definirà la posició del servo com es mostra a continuació:

Servo

Pas 3: Instal·lació del Hw

Els servos es connectaran a un subministrament extern de 5V, i el seu pin de dades (en el meu cas, el seu cablejat groc) es connectarà a Raspberry Pi GPIO com es mostra a continuació:

• GPIO 17 ==> Servidor inclinat
• GPIO 27 ==> Pan Servo

No oblideu connectar els GND junts ==> Raspberry Pi - Servos - Font d'alimentació externa)

Podeu tenir com a opció una resistència d’1K ohm entre Raspberry Pi GPIO i el pin d’entrada de dades del servidor. Això protegiria el vostre RPi en cas de problema de servo.

Pas 4: Calibratge dels servos

El primer que heu de fer és confirmar les característiques principals dels vostres servos. En el meu cas, estic fent servir un Power Pro SG90.

A partir del seu full de dades, podem considerar:

• Abast: 180o
• Font d'alimentació: 4,8 V (5VDC extern com a font d'alimentació USB funciona bé)
• Freqüència de treball: 50Hz (període: 20 ms)
• Amplada de pols: d'1 ms a 2 ms

En teoria, el servo estarà a punt

• Posició inicial (0 graus) quan s'aplica un pols d'1 ms al terminal de dades
• Posició neutral (90 graus) quan s’aplica un pols d’1,5 ms al terminal de dades
• Posició final (180 graus) quan s'aplica un pols de 2 ms al terminal de dades

Per programar una posició servo amb Python serà molt important conèixer el corresponent "Cicle de treball" per a les posicions anteriors, fem un càlcul:

• Posició inicial ==> (0 graus) Amplada del pols ==> 1ms ==> Cicle de treball = 1ms / 20ms ==> 2,0%
• Posició neutral (90 graus) Amplada del pols d’1,5 ms ==> Cicle de treball = 1,5 ms / 20 ms ==> 7,5%
• Posició final (180 graus) Amplada de pols de 2 ms ==> Cicle de treball = 2ms / 20ms ==> 10%

Per tant, el cicle de treball ha de variar entre un 2 i un 10%.

Provem els servos individualment. Per a això, obriu el terminal de Raspberry i llanceu el vostre editor de shell Python 3 com a "sudo" (perquè haureu de ser un "superusuari" per gestionar amb GPIO):

sudo python3

A Python Shell

>>

Importeu el mòdul RPI. GPIO i anomeneu-lo GPIO:

importar RPi. GPIO com a GPIO

Definiu els esquemes de numeració de pins que voleu utilitzar (BCM o BOARD). Vaig fer aquesta prova amb BOARD, de manera que els pins que vaig fer servir eren els pins físics (GPIO 17 = Pin 11 i GPIO 27 Pin 13). Em va ser fàcil identificar-los i no equivocar-me durant la prova (al programa final faré servir BCM). Trieu la que preferiu:

GPIO.setmode (GPIO. BOARD)

Definiu el servo pin que utilitzeu:

tiltPin = 11

Si, en canvi, heu utilitzat l'esquema BCM, les dues darreres ordres s'han de substituir per:

GPIO.setmode (GPIO. BCM)

tiltPin = 17

Ara, hem d'especificar que aquest pin serà una "sortida"

GPIO.setup (tiltPin, GPIO. OUT)

I, quina serà la freqüència generada en aquest pin, que per al nostre servo serà de 50Hz:

tilt = GPIO. PWM (tiltPin, 50)

Ara comencem a generar un senyal PWM al pin amb un cicle de treball inicial (el mantindrem "0"):

tilt = start (0)

Ara podeu introduir diferents valors del cicle de treball observant el moviment del vostre servo. Comencem amb un 2% i veiem què passa (veiem que el servo passa a la "posició zero"):

tilt. ChangeDutyCycle (2)

En el meu cas, el servo va passar a la posició zero, però quan vaig canviar el cicle de treball al 3% vaig observar que el servo es mantenia a la mateixa posició, començant a moure’s amb cicles de treball superiors al 3%. Per tant, el 3% és la meva posició inicial (o graus). El mateix va passar amb un 10%, el meu servo va superar aquest valor, superant el seu final en un 13%. Per tant, per a aquest servo en particular, el resultat va ser:

• 0 graus ==> cicle de treball del 3%
• 90 graus ==> cicle de treball del 8%
• 180 graus ==> cicle de treball del 13%

Després d’acabar les proves, heu d’aturar el PWM i netejar els GPIO:

tilt = stop ()

GPIO.cleanup ()

La pantalla d’impressió del terminal anterior mostra el resultat de les meves serves (amb resultats similars). El vostre abast pot ser diferent.

Pas 5: creació d'un script Python

Les ordres PWM que s'enviaran al nostre servo es troben en "cicles de treball" tal com vam veure a l'últim pas. Però normalment hem d’utilitzar “angle” en graus com a paràmetre per controlar un servo. Per tant, hem de convertir "angle" que sigui una mesura més natural per a nosaltres en el cicle de treball, tal com entén el nostre Pi.

Com fer-ho? Molt simple! Sabem que l’interval de cicle de treball va del 3% al 13% i que això equival a angles que oscil·laran entre 0 i 180 graus. A més, sabem que aquestes variacions són lineals, de manera que podem construir un esquema proporcional com es mostra més amunt. de manera que, donat un angle, podem tenir un cicle de treball corresponent:

duticicle = angle / 18 + 3

Conserveu aquesta fórmula. L’utilitzarem al següent codi.

Creem un script Python per executar les proves. Bàsicament, repetirem el que vam fer abans a Python Shell:

a partir del temps importació de son

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

El nucli del codi anterior és la funció setServoAngle (servo, angle). Aquesta funció rep com a arguments, un número servo GPIO i un valor d’angle cap a on s’ha de situar el servo. Un cop l’entrada d’aquesta funció és “angle”, l’hem de convertir en cicle de treball en percentatge, utilitzant la fórmula desenvolupada anteriorment.

Quan s'executa l'script, heu d'introduir com a paràmetres, servo GPIO i angle.

Per exemple:

sudo python3 angleServoCtrl.py 17 45

L'ordre anterior posicionarà el servo connectat a GPIO 17 amb 45 graus a "elevació". Es pot utilitzar una ordre similar per al control Pan Servo (posició a 45 graus en "azimut"):

sudo python angleServoCtrl.py 27 45

El fitxer angleServoCtrl.py es pot descarregar des del meu GitHub

Pas 6: el mecanisme Pan-Tilt

El servo "Pan" mourà "horitzontalment" la nostra càmera ("angle d'azimut") i el nostre servo "Tilt" la mourà "verticalment" (angle d'elevació).

La imatge següent mostra com funciona el mecanisme Pan / Tilt:

Durant el nostre desenvolupament no anirem a "extrems" i utilitzarem el nostre mecanisme Pan / Tilt només de 30 a 150 graus. Aquest abast serà suficient per utilitzar-lo amb una càmera.

Pas 7: el mecanisme Pan-Tilt: construcció mecànica

Ara, muntem els nostres 2 servos com a mecanisme Pan / Tilt. Aquí podeu fer dues coses. Compreu un mecanisme de plataforma Pan-Tilt com el que es mostra a l'últim pas o creeu-lo segons les vostres necessitats.

Un exemple pot ser el que vaig construir, només lligant els servos entre si i fent servir petites peces metàl·liques de joguines antigues, tal com es mostra a les fotos anteriors.

Pas 8: conjunt elèctric Pan / Tilt

Un cop tingueu muntat el mecanisme Pan / Tilt, seguiu les fotos per obtenir una connexió elèctrica completa.

1. Apagueu el Pi.
2. Feu totes les connexions elèctriques.
3. Comproveu-ho de nou.
4. Enceneu primer el vostre Pi.
5. Si tot està bé, alimenteu els servos.

No explorarem en aquest tutorial com configurar la càmera, això s'explicarà al proper tutorial.

Pas 9: l'escriptura Python

Creem un script Python per controlar ambdós servos simultàniament:

a partir del temps importació de son

importar RPi. GPIO com a GPIO GPIO.setmode (GPIO. BCM) GPIO.setwarnings (False) pan = 27 tilt = 17 GPIO.setup (tilt, GPIO. OUT) # white => TILT GPIO.setup (pan, GPIO. OUT) # gris ==> PAN def setServoAngle (servo, angle): assert angle> = 30 i angle 90 (punt mig) ==> 150 setServoAngle (inclinació, int (sys.argv [2])) # 30 ==> 90 (punt mig) ==> 150 GPIO.cleanup ()

Quan s'executa l'script, heu d'introduir com a paràmetres, angle de panoràmica i angle d'inclinació. Per exemple:

sudo python3 servoCtrl.py 45 120

L'ordre anterior posicionarà el mecanisme Pan / Tilt amb 45 graus en "azimut" (angle Pan) i 120 graus "elevació" (angle Tilt Angle). Tingueu en compte que si no s’introdueixen paràmetres, els valors predeterminats seran els dos, els angles de panoràmica i d’inclinació configurats fins a 90 graus.

A continuació podeu veure algunes proves:

El fitxer servoCtrl.py es pot descarregar des del meu GitHub.

Pas 10: prova de bucle de servidors

Ara creem un script Python per provar automàticament tota la gamma de servos:

a partir del temps importació de son

importar RPi. GPIO com a GPIO GPIO.setmode (GPIO. BCM) GPIO.setwarnings (False) pan = 27 tilt = 17 GPIO.setup (tilt, GPIO. OUT) # white => TILT GPIO.setup (pan, GPIO. OUT) # gray ==> PAN def setServoAngle (servo, angle): assert angle> = 30 i angle <= 150 pwm = GPIO. PWM (servo, 50) pwm.start (8) dutyCycle = angle / 18. + 3. pwm. ChangeDutyCycle (dutyCycle) sleep (0.3) pwm.stop () if _name_ == '_main_': per a l'interval (30, 160, 15): setServoAngle (panoràmica, i) setServoAngle (inclinació, i) per a i interval (150, 30, -15): setServoAngle (panoràmica, i) setServoAngle (inclinació, i) setServoAngle (panoràmica, 100) setServoAngle (inclinació, 90) GPIO.cleanup ()

El programa executarà automàticament un bucle de 30 a 150 graus en ambdós angles.

A sota del resultat:

Vaig connectar un oscil·loscopi només per il·lustrar la teoria PWM, tal com s’ha explicat anteriorment.

El codi anterior, servoTest.py es pot descarregar des del meu GitHub.

Pas 11: Conclusió

Com sempre, espero que aquest projecte pugui ajudar els altres a endinsar-se en l’apassionant món de l’electrònica.

Per obtenir més informació i el codi final, visiteu el dipòsit de GitHub: RPi-Pan-Tilt-Servo-Control

Per obtenir més projectes, visiteu el meu bloc: MJRoBot.org

A continuació, un cop d'ull al meu següent tutorial:

Saluts del sud del món!

Ens veiem a la meva propera instrucció!

Gràcies, Marcelo