Calculando el movimiento del servo con Raspberry
En la Raspberry Pi es necesario entender como funciona un servomotor para poder controlarlo correctamente. Por eso he colocado los conceptos necesarios.
Frecuency (F, Hz o ciclos/s): frecuencia, cantidad de ondas o ciclos en un segundo.
Period (T, Hz -1 o s/ciclos): período, duración en segundos de cada ciclo.
El fabricante de un servo nos dice que usemos un T=20 ms, calcule la F=? y cada DutyCycle para los PW (1ms, 1,5ms, 2 ms).
Cáculos:
Si el T= 20 ms/ciclo, ¿cuál es la frecuencia?.
Pulse width (PW, s/ciclo en alto "HIGH") Ancho del pulso con la señal en alto "HIGH". Normalmente se habla en ms, pero para programar debemos usar la unidad en s, por ello se hacen las conversiones. (1s =1000 ms)
Un servo de rotación normal (180 grados) son los más comunes y económicos, tendrá tres anchos según lo que queramos hacer:
a) PW= 1ms mover a 0 grados
b) PW= 1,5 ms mover a 90 grados
c) PW= 2 ms mover a 180 grados
Nota1: se puede hacer ańgulos intermedios
Un servo de rotación continua (360 grados) algo más costosos, tendrá tres anchos según lo que queramos hacer
a) PW= 1ms girar en sentido horario
b) PW= 1,5 ms no moverse
c) PW= 2 ms girar en sentido antihorario
Nota 1: no puedes prácticamente escoger un ángulo solo la velocidad de giro, a menos que apagues los servos, pero deberás hacer muchas pruebas con velocidad y tiempo para hallar un ángulo, Son más recomendables para hacer vueltas, tipo rueda de coche.
Nota 2: los servos se miran desde abajo para ver la dirección del giro, ya que se usan en ruedas de robots y es más cómodo verlos desde abajo (punto de referencia). Ver Vídeo 3. BQ. Tutoriales bitbloq 7. Los Servos (en el tiempo 12:40).
Valores teóricos
DutyCycle (DC, % ): porcentaje del período que la señal debe estar en alto "HIGH".
Para calcularlo se usan estas fórmulas, según uses frecuencia o período.
DC= PW x F
DC= PW x T
Left
El 5% del tiempo el pulso estará en alto "HIGH" (1ms)
Middle
El 7,5% del tiempo el pulso estará en alto "HIGH" (1.5ms)
Right
El 10% del tiempo el pulso estará en alto "HIGH" (2ms)
NOTA; en los tres casos en ancho total siempre será 20 ms "PW" pulse width
Calibrado del servo continuo con su potenciómetro incorporado usando una placa Arduino (vídeo con una placa Arduino BQ). Pero nos da la idea)
Código Arduino para ser usado para probar y ajustar el sevo con una placa BQ Zum (BT-328). (10 s stop, 3 s giro horario, para 1 s, 3s giro antihorario)
Código de bloques desde Bitbloq |
Código visto desde Arduino, con anotaciones |
Código para copiar
/*nombre del archivo test_servo.ino */
/*La funcion es comprobar el funcionamiento del servo y poder calibrarlo utilizando el potenciometro del mismo*/
/*** Included libraries ***/
#include <Servo.h> /*libreria de arduino para manejar servomotores */
/*** Global variables and function definition ***/
Servo servo_continuo;/*indica a arduino que trabajara con un servo y se llamara servo_continuo */
/* En loop se indica lo que va a ser indefinidamente*/
/*** Setup ***/void setup()
{
servo_continuo.attach(5);/*nombreservo.attach(pin,min,max)
/*parametros */
/* pin=numero del pin */
/* min= duracion del pulso min, es el 0 grados, en este servo horario*/
/* max= duracion del pulso max es el 180 grados, en este servo antihorario*/
/* Si solo coloca un valor queda predeterminado min=1ms y max=2ms */
}
/*El sentido de los giros se ven desde abajo del servo */
/*Es bueno parar el servo ante de hacerlo girar en sentido inverso para */
/*no dañarlo*/
/*Colocar una fuente de poder solo para ellos consumen mucha energia */
/*** Loop ***/
void loop() {
servo_continuo.write(90);/*Posicion central, quieto*/
delay(10000);/*quieto 10 s para calibrar servo*/
servo_continuo.write(180);/*Girara en sentido antihorario*/
delay(3000);/* durante 3 s*/
/* cuida al servo de un cambio brusco direccion*/
servo_continuo.write(90);/*Posicion central, quieto*/
delay(1000);/* durante 1s*/
servo_continuo.write(0);/*Girara en sentido horario */
delay(3000);/* durante 3s*/
Probando un servo SM-S4303R con la placa arduino de BQ
Calibrado del servo continuo SM-S4303R con su potenciómetro incorporado usando la Raspberry
Hay que emitir un PW de 20 ms con la Raspberry a través de un pin GPIO. Para ello usaremos el lenguaje Python, para hacer un pequeño script que lo haga y testee el servo.
La función DutyCycle de 1,5 ms es el ideal para hacer este PW de 20 ms, usar el potenciómetro del servo y con un destornillador ajustaremos hasta que el servo no se mueva.
Calibrado del servo de 180 grados EMAX ES08A-II usando una Raspberry
Hay que hacer un estudio de los movimientos del servo para saber la relación lineal entre el DutyCycle y el ángulo del servo. Cada servo tiene una relación diferente. Quiere decir que si lo mandas a moverse 180 grados es muy probable que no lo haga correctamente. Por ello tendremos que hacer un procedimiento. Te voy a mostrar como se hace. Primero te muestro las conexiones y después la forma experimental.
Conexiones del servo a la Raspberry usando una fuente de alimentación externa y una tabla de prototipos
Importante
"La fuente de alimentación externa la emplearemos para alimentar el motor. Si bien podemos alimentar un pequeño dispositivo/sensor con la Pi, no es recomendable emplearla para darle corriente directamente a los servos y los motores en general, pues consumen mucha corriente y pueden hacer que nuestro sistema sea inestable (e incluso cargarse alguno de los pines de nuestra pi). Por ello, el único cable que conectaremos desde la Raspberry al servo será el cable que llevará la señal de control."
Servo alimentado por una fuente de alimentación (5VCC) distinta a la Raspberry |
Determinación experimental de la ecuación lineal entre el dutyCycle y el ángulo; usando un script de python
#servo_cambiar_dutycycle.py
#Programa para determinar el dutyCycle "DC" real de un servo
#Cada servo tendrá DC diferentes a los teóricos
# Los valores teoricos son para F=50 HZ, T=20ms (PW)
# DC= 5 % Grados=0
# DC= 7.5 % Grados= 90
# DC=10 % Grados=18
#Determinara los valores para usarse en la ecuacion lineal
#en el servo de 180 de grados
# estos valores son DC(y) y Grados (x
# m=(y2-y1)/(x2-x1)
# Y-Y0= m(X-X0)
############## configuraciones iniciales ######################
import RPi.GPIO as GPIO # cargar libreria que maneja los pines
GPIO.setmode(GPIO.BOARD)# establece la numeracion de los pines tipo fisico
servoPin=11
GPIO.setup(servoPin,GPIO.OUT) # establece que el pin sera de salida
import time # cargar la libreria que maneja el tiempo
pwm=GPIO.PWM(servoPin,50)
pwm.start(7.5)
time.sleep(1)
####################Calibracion ######################
for i in range (5,10):
dutyCycle=input("Valor de dutyCycle (5-10)Cuidado?") #meteremos un valor y mediremos su ángulo
DC=dutyCycle
pwm.ChangeDutyCycle(DC)
time.sleep(.1)
pwm.stop()
GPIO.cleanup()
exit()
#2 x ctrl+D para salir
Nota: el servo tiembla a pesar de darle un reposo en el loop, en pruebas con el servo de rotación continua no lo hace. Puede ser que es la frecuencia no es la adecuada, la calidad del servo o la programación.
Cáculos de la ecuación lineal
Valores obtenidos experimentalmente (ángulo, dutyCycle)
A(0;2.5), B(90;7), C(180;11.5)
Hallar la pendiente de la recta
m=(y2-y1)/(x2-x1)
m= (7-2.5)/(90-0)= 1/20
Determinar la ecuación de esa recta, escogiendo dos puntos (A,B)
Y-Y0= m(X-X0)
Y-2.5=1/20(X-0)
Y=1/20 x+2.5
DC=1/20 Angulo +2.5
Mover el servo al ángulo indicado utilizando la Raspberry Pi
#servo_cambiar_angulo.py
#Programa para modificar el ángulo a voluntad
##########configuraciones iniciales ######################
import RPi.GPIO as GPIO # cargar libreria que maneja los pines
GPIO.setmode(GPIO.BOARD)# establece la numeracion de los pines tipo fisico
servoPin=11
GPIO.setup(servoPin,GPIO.OUT) # establece que el pin sera de salida
import time # cargar la libreria que maneja el tiempo
pwm=GPIO.PWM(servoPin,50)
pwm.start(7)
############ loop ·##################
for i in range (0,180):
posicionDecidida=input("¿En que ángulo quieres el servo (0-180)?")
DC=1/20*(posicionDecidida)+2.5
pwm.ChangeDutyCycle(DC)
time.sleep(.1)
pwm.stop()
GPIO.cleanup()
exit()
#2 x ctrl+D para salir
Mover el servo en forma continua en la Raspberry Pi
#servo_movimiento_continuo.py
#El servo se movera lentamente desde 0 a 180
# y retornara en forma continua
##########configuraciones iniciales ######################
import RPi.GPIO as GPIO # cargar libreria que maneja los pines
import time # cargar la libreria que maneja el tiempo
GPIO.setmode(GPIO.BOARD)# establece la numeracion de los pines a tipo fisico
servoPin=11
GPIO.setup(servoPin,GPIO.OUT) # establece que el pin sera de salida
pwm=GPIO.PWM(servoPin,50) # genera un pulso de 50 Hz en el pin 11
pwm.start(7) # establece un pulso de DC de 7
############ loop ·##################
while (1):
for i in range (0,180):
DC=1./20.*(i)+2.5
pwm.ChangeDutyCycle(DC)
time.sleep(.08)
time.sleep(3)
for i in range (180,0,-1):
DC=1./20.*i+2.5
pwm.ChangeDutyCycle(DC)
time.sleep(.08) pwm.stop()
GPIO.cleanup()
exit() #ctrl+c para salir (interrumpir keyboard)
#ctrl+d para salir (interrumpir el programa)
Código Python basado en Paez.com. A modificar
No funciona da error RPIO import PWM
#movimiento_servos.py
#Este script movera el servo conectado al pin 2 físico (BOARD)
from RPIO import PWM #importar la libreria para PWM
import time #importar time para las pausas
servo=PWM.Servo() #initcializar la libreria de servo
servo.set_servo(2,1500) #centrar el servo
time.sleep(1)
for _i in range(10): #loop between -90 and 90 degrees
servo.set_servo(2,2500)
time.sleep(1)
servo.set_servo(2,600)
time.sleep(1)
servo.set_servo(2,1500)
time.sleep(1)
Código Phython basado en Paul McWhorter (este si me funciona)
#test_servo_2.py
#mover servo en python
###############configuraciones iniciales#############
import RPi.GPIO as GPIO # cargar libreria
import time # carga libreria del tiempo
GPIO.setmode(GPIO.BOARD)# establece la numeracion de los pines tipo fisico
ServoPin=11 # el pin 11 sera la variable 11
GPIO.setup(ServoPin,GPIO.OUT)# establece que el pin sera de salida
pwm=GPIO.PWM(11,50) # en el pin 11 el pulso sera de 50 Hz
pwm.start(7,5) #pulso medio , servo quieto(servo continuo) o a 90 grados (servo no continuo)
#movera el servo de un lado a otro en forma infinita ya que es un loop
while(1):
#en un sentido
for i in range(0,180): #parametro que cambia en la formula de 0 a 180
DC=1./18.*(i)+2 #relacion lineal entre DC y el angulo
pwm.ChangeDutyCycle(DC) #cambia el porcentaje del periodo con la señal en alto
time.sleep(.01) #cambia la velocidad del movimiento
#en el otro sentido
for i in range(180,0):
DC=1./18.*(i)+2
pwm.ChangeDutyCycle(DC)
time.sleep(.01)
pwm.stop() #para el servo
GPIO.cleanup()#limpia las configuraciones de los GPIO
Código Phython basado en Paul McWhorter (este si me funciona)
#servo_cambiar_angulo.py
#Programa para modificar el ángulo a voluntad
##########configuraciones iniciales ######################
import RPi.GPIO as GPIO # cargar libreria que maneja los pines
GPIO.setmode(GPIO.BOARD)# establece la numeracion de los pines tipo fisico
servoPin=11
GPIO.setup(servoPin,GPIO.OUT) # establece que el pin sera de salida
import time # cargar la libreria que maneja el tiempo
pwm=GPIO.PWM(servoPin,50)
pwm.start(7)
for i in range (0,180):
posicionDesidida=input("¿En que ángulo quieres el servo (0-180)?")
DC=0.05*(posicionDesidida)+3
pwm.ChangeDutyCycle(DC)
pwm.stop()
GPIO.cleanup()
exit()
#2 x ctrl+D para salir
Webgrafía
1.Controlar un servomotor con Raspberry Pi. fpaez.com. URL: http://fpaez.com/controlar-un-servomotor-con-raspberry-pi/
2.Como funciona un servo-motor (tutorial). El profe García. Canal Youtube. URL: https://www.youtube.com/watch?v=llNoXMyzjYw
3. Controlar un servo con Rasperry Pi (usando RPIO.PWM y DMA). Nociones.de. URL: https://www.nociones.de/controlar-un-servo-con-rasperry-pi-usando-rpio-pwm-y-dma/
4.Torreta automática. BQ España: URL: http://diwo.bq.com/torreta-automatica
5.Torreta automática. Repositorio Github URL: https://github.com/JavierIH/laserTower/tree/master/part
6.RPIO.PWM, PWM via DMA for the Raspberry Pi. URL: https://pythonhosted.org/RPIO/pwm_py.html
7.Raspberry Pi LESSON 27: Analog Voltages Using GPIO PWM in Python.Paul McWhorter. URL: http://www.toptechboy.com/raspberry-pi/raspberry-pi-lesson-27-analog-voltages-using-gpio-pwm-in-python.
8.Raspberry Pi Raspberry Pi LESSON 28: Controlling a Servo on Raspberry Pi with Python. Paul McWhorter. URL: http://www.toptechboy.com/raspberry-pi/raspberry-pi-lesson-28-controlling-a-servo-on-raspberry-pi-with-python/
9.Welcome to RPIO’s documentation!. URL: http://pythonhosted.org/RPIO/
En Desarrollo voy agregando cosas, si deseas participar en este proyecto, puedes hacerlo.
Comentarios
Publicar un comentario