Servomotores

¿Qué es un servomotor?
Un servomotor o “servo” es un motor electrónico de baja inercia al que se le puede controlar tanto la velocidad de giro como la posición dentro de su rango de operación.
El cuerpo de los servo motores está formado por un motor eléctrico, una caja reductora con engranajes y un circuito electrónico de control. Los servos motores son comúnmente utilizados en modelismo para controlar los sistemas de dirección, por ejemplo el timón de un barco o los alerones de un avión.
Los servos usan la modulación por ancho de pulsos (PWM) para controlar la posición del motor eléctrico."1

La desventaja es que consumen más energía que un servo motor analógico, por lo que se recomienda suministrarles  energía por un circuito alterno para no dañar la placa micro-controladora. Son muy usados en robótica.


Evolución de los soportes

I soporte

Bracket Pan/Tilt con dos servos. Creado con Freecad. Diseño original. Bracket Pan/Tilt, impreso en PLA se rompe con facilidad, hemos colocado bridas

II soporte
Me puse con el Freecad y después de muchas horas (que el programa no lo conozco bien todavía)  salió algo más feo "estéticamente" pero creo más fuerte estructuralmente.

Nuevo modelo. Bracket Pan/Tilt con dos servos de Chito. Creado con Freecad.

Después de 4 horas de impresión este es el resultado.

Características del servo de rotación continua Servos SM-S4303R

 
Voltaje: 4.8 – 6 V
Par de torsión: 3.3/5.1Kg.cm (4.8V/6V)
Velocidad: 43/54 rpm (4.8V/6V)
Peso: 20 g

El SM-S4303R es un servo de tamaño estándar que ha sido construido específicamente por SpringRC para una rotación continua. A 6 V, tiene una velocidad de rotación máxima de 54 RPM (sin carga) y puede producir hasta 51 on-in (5,1 kg-cm) de torque. Cuenta con dos rodamientos de bolas en el eje de salida para reducir la fricción, y ofrece un fácil acceso al potenciómetro de ajuste del punto de reposo. El servo se puede controlar mediante una conexión directa a una única línea de E / S del microcontrolador sin ningún tipo de electrónica adicional, lo que lo convierte en un gran actuador para proyectos de robótica para principiantes.

Giro
Sentido antihorario (ancho del pulso o señal mayor de 1.5 ms)
Punto de reposo el servo no se moverá si recibe una señal de  (1.5 ms)
Sentido horario (ancho del pulso o señal menor de 1.5 ms)

Velocidad
Más veloz a medida que el pulso se aleje más del valor de reposo

El servo de rotación continua SM-S4303R convierte los pulsos estándar de servo posicionamiento RC en una velocidad de rotación continua. El punto de reposo predeterminado es 1,5 ms, pero esto se puede ajustar usando un destornillador pequeño para girar el potenciómetro y conseguir que con este pulso se quede estático el motor. Los anchos de pulso por encima del punto de reposo dan como resultado una rotación en sentido contrario a las agujas del reloj, con una velocidad que aumenta a medida que aumenta el ancho de pulso; Los anchos de pulso por debajo del punto de reposo dan como resultado una rotación en el sentido de las agujas del reloj, con una velocidad que aumenta a medida que disminuye la anchura del impulso.

Características del servo de 180 grados ES08A-II

 
Algo de teoría. Cómo funciona un servomotor
La mayoría de los servos funcionan con un pulso de  entre 10 y 30 ms/ciclo de longitud (dependerá del fabricante) . Tomando 20 ms/ciclo (la media), equivalente a 50 Hz (ciclos/s). En Arduino es muy fácil con el comando nombreservo.writer(angulo) en raspberry hay que pensar mas. Aquí tenemos varios vídeos que te darán una explicación de como funcionan los servomotores.

 
Excelente la cantidad de proyectos que tiene este profesor colombiano (El profe García).
Video 1. El profe García. Como funciona un servomotor.

Vídeo 2. Como funciona un servomotor.

Vídeo 3. BQ. Tutoriales bitbloq 7. Los Servos.
BQ Maker también tiene excelentes vídeos. Este vídeo es más hacia las placas Arduino, pero funcionan.

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

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

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).

La microcontroladora emitirá  una onda de tipo cuadrada entre 0 y +5VCC "PWD" que según su características influirá en la posición del servo. Fuente Wikipedia. Pareciera que los grados están incorrectos, pero los servos se miran desde abajo.

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 atornillado ajustaremos  hasta que el servo no se mueva.

 Por desarrollar





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.

Te voy a mostrar como se hace.  Primero te muestro las conexiones y después la forma experimental.

Esquema eléctrico

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

 Conexiones del servo a la Raspberry usando una fuente de alimentación externa y una tabla de prototipos

Determinación experimental de la ecuación lineal entre el dutyCycle y el ángulo usando un script de python

 

Código python utilizado para generar el PMW (ancho de pulso modulado de F=50 Hz ,T=20 ms) para determinar la relació lineal entre el ángulo y su DutyCycle en forma experimental

#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.