1 ene. 2015

SERVOMOTORES


Los servos son un tipo especial de motor de c.c. que se caracterizan por su capacidad para posicionarse de forma inmediata en cualquier posición dentro de su intervalo de operación. Para ello, el servomotor espera un tren de pulsos que se corresponde con el movimiento a realizar. Están generalmente formados por un amplificador, un motor, un sistema reductor formado por ruedas dentadas y un circuito de realimentación, todo en un misma caja de pequeñas dimensiones. 

El servomotor tiene 3 cables, Alimentación , Masa y la señal.Los colores son los siguientes:

Rojo - Alimentación(Normalmente 5 V aunque pueden ser mas)
Negro o Marrón -Masa
Blanco o Naranja - Señal de control (pulso enviado al servomotor)

Básicamente un servomotor es un motor de corriente continua con un potenciometro que le permite saber la posición en la que se encuentra y así poder controlarla. 

Estos motores se usan sobre todo para realizar movimientos precisos y generalmente pueden moverse entre 0 y 180 grados.

También existe un tipo de servo que se llama de rotación continua, en ese caso el ancho del pulso no determina su posición, sino su velocidad al girar.

Para controlar el servomotor se le envía pulsos cada 20 ms es decir 50Hz. La anchura del pulso es lo que codifica el angulo de giro , es decir lo que se conoce como PWM, codificación por ancho de pulso. Esta anchura varia según el servomotor pero normalmente va entre 0.5 y 2.5 ms aunque pueden variar.
Dependiendo del tamaño del servo y su consumo es posible que no puedas alimentarlo desde tu placa arduino, en ese caso es necesario una fuente de 5V independiente para poder moverlo,en mi caso uso un microservo por lo que consume poca corriente y se puede alimentar directamente por el Arduino . Sobre el peso que pueden levantar se puede deducir con el par del servo. Normalmente los servos indican el par o torque que pueden realizar para un servo estándar suele ser 5kg/cm es decir puede mover 5kg a 1 cm de distancia. En caso de querer mover lo a 5 cm el servo solo podrá mover 1kg.

Para el control de este tipo de motores con ARDUINO utilizamos la libreria estándar de ARDUINO "Servo.h". A continuación vamos a explicar cada una de sus funciones:


Attach()

Descripción
Se utiliza para definir en que pin tenemos pinchado el control del servo.

Sintaxis
servo.attach(pin)
servo.attach(pin, min, max)

Parametros
servo: una variable de tipo Servo
pin: el número de pin con el que el servo está asociado

Los parámetros "min" y "max" son opcionales, y se usan para fijar el ancho del pulso mínimo y máximo del servo. De esta forma podemos fijar unos limites en los que no queremos que mueva, pero que por cuestiones mecánicas sí que podría hacerlo.

Por poner un ejemplo, supongamos que estamos controlando uno de los servos de un brazo robotico que a su vez pertenece a otro robot más grande. Lógicamente queremos poder moverlo con la mayor libertad posible, pero sabemos que si girase demasiado, podría chocar contra su chasis. Pues lo único que tendríamos que hacer es emplear "min" y "max" para establecer los ángulos que no debe superar para evitar que esto ocurra.

También se puede dar el caso de que el servo que tengamos, por la razones que sea, no tiene tanto grado de libertad como el que arduino permite por defecto. En este caso seria importante fijar con "min" y "max" los limites de nuestro servo, para evitar pedirle que vaya a extremos a los que no puede alcanzar.

Es importante evitar, en la medida de lo posible, lleva el servo hasta más allá de sus extremos, ya que esto hará que necesita más intensidad de corriente para funcionar.

Por defecto, Arduino fija en 544 el ancho del pulso para el angulo mínimo y en 2400 el ancho de pulso para el angulo mayor.

Ejemplo
  1. #include <Servo.h>  
  2. //Creamos una variable de tipo Servo para poder utilizar las funciones de la librería  
  3. servo servo;  
  4. void setup()   
  5. {   
  6.     //asociamos la variable "servo" al pin 9.   
  7.     servo.attach(9);  
  8. }   
  9. void loop() {}



Write()


Descripción
Coloca el servo en el angulo que queramos. Algunos angulos importantes son:

0 - > Un extremo
90 => Centro
180 => otro extremo.

En servos de rotación continua lo que hace es ajustar la velocidad a la que se mueve el servo.

0 => Velocidad máxima en una dirección
90 => Parado
180 = > Velocidad máxima en dirección contraria.

Sintaxis
servo.write(angulo)

Parametros
servo: una variable tipo Servo
angulo: el valor a escribir en el servo, de 0 a 180

Ejemplo
  1. #include <Servo.h>  
  2. //Creamos una variable servo para poder usar las funciones con ella.   
  3. Servo servo;  
  4. void setup()   
  5. {   
  6.     //Definimos el pin al que ira conectado el servo.   
  7.     servo.attach(9);  
  8.     //Movemos el servo al centro  
  9.     servo.write(90);  // coloca el servo en su posición central  
  10. }   
  11. void loop() {  
  12.     //Lo llevamos a un extremo  
  13.     servo.write(0);   
  14.     //Le damos tiempo a llegar a esa posicion  
  15.     delay(500):  
  16.     //Lo volvemos a centrar  
  17.     servo.write(90);  
  18.     //Le damos tiempo a llegar a esa posicion  
  19.     delay(500):  
  20.     //Lo llevamos al otro extremo  
  21.     servo.write(180);  

Es importante darle tiempo al servo para alcanzar la posición que deseamos. Si nos limitamos a mandarle ordenes para moverse sin darle tiempo a alcanzarlas el servo no se moverá.


WriteMicroseconds()


Descripción
Manda un pulso de un ancho de tantos microsegundos como le especifiquemos en el paréntesis, de esta forma el servo se colocará en un determinado punto.

Normalmente con un pulso de 1000 debería colocarse completamente a la izquierda, con uno de 2000 a la derecha y, como es lógico, en el punto medio debería estar centrado, es decir en unos 1500.

El problema es que no todos los fabricantes hacen sus servos de la misma manera, por lo que estos valores no aseguran esas posiciones, en otros los valores están entre 700 para un extremo y 2300, en otros en cualquier otro valor. La única forma de controlar el servo de esta manera de una manera fiable es consultar la documentación del fabricante ( si es que la facilita) o ir probando.

Si nos decidimos por este ultimo método, hay que ser cuidadosos, como ya se ha mencionado anteriormente en este mismo tutorial, intentar que un servo alcance una posición que se escapa a sus posibilidades drena mucha energía. Por lo que no es aconsejable.

Por todo lo antes mencionado la mejor opción no es emplear esta función para controlar la posición de un servo ya que hay otras opciones mejores y más precisas ( véase write()), aunque si podría ser una buena opción para controlar la velocidad de un servo de rotación continua.

Sintaxis
servo.writeMicroseconds(uS)

Parametros
uS: el valor del parámetro en microsegundos (int)

Ejemplo
  1. #include <Servo.h>  
  2. #include <Servo.h>   
  3. Servo servo;  
  4. void setup(){   
  5.     servo.attach(9);  
  6.     servo.writeMicroseconds(1500);  // coloca el servo en posición central  
  7. }   
  8. void loop() {} 

Read()


Descripción
Se utiliza para conocer el angulo en el que actualmente se encuentra el servo. Esto puede ser útil en casos en los que se necesita una alta precisión, podríamos mover el servo y utilizar read() para asegurarnos de que esta en ese punto antes de realizar el siguiente movimiento.

También puede emplearse para conocer la posición en la que se encuentra el servo antes de comenzar a utilizarlo.

Sintaxis
servo.read()

Parametros
El ángulo del servo, de 0 a 180 grados.

Ejemplo
  1. #include <Servo.h>  
  2. //Ejemplo del programa que se asegura de que el servo esta correctamente posicionado antes de comenzar a moverse.  
  3. Servo servo;  
  4. void setup(){  
  5.     servo.attach(9);  
  6. }  
  7. void loop() {  
  8. //Movemos el servo a una determinada posición.  
  9. servo.write(20);  
  10. delay(500);  
  11. //Antes de realizar el siguiente movimiento, nos aseguramos de que el servo esta en la posicion en la que deberia estar.  
  12. if(servo.read() == 20){  
  13.     servo.write(70);  
  14.     delay(500);  
  15. }  


Detach()


Descripción
Esta función es la contraria attach, es decir, desvincula un determinado pin con el control del servo. Esto puede ser útil si por ejemplo tenemos las salidas de Arduino multiplexadas. Cuando queramos utilizarlas para controlar el servo, hacemos un attach y cuando las usamos con otra finalidad las liberamos de este cometido.

Sintaxis
servo.detach()

Parametros
sin parametros

Ejemplo
  1. #include ≶Servo.h>  
  2. Servo servo;  
  3. void setup(){  
  4.     servo.attach(9);  
  5. }  
  6.   
  7. void loop() {  
  8.     //realizamos varios movimientos con el servo.  
  9.     servo.write(40);  
  10.     delay(500);  
  11.     servo.write(90);  
  12.     delay(500);  
  13.     servo.write(6);  
  14.     delay(500);  
  15.     servo.detach() ;  
  16.     //A partir de este momento, no podremos volver a usar "servo" hasta que no volvamos a relacionarlo con un pin mediante attach()  


Attached()


Descripción
Comprueba si tenemos fijado un pin para el control de un servo.

Esto puede ser útil realizarlo si a lo largo de nuestro programa hemos empleado reiteradamente las funciones attach() y detach(), para segurarnos de que hemos vuelto a crear la asociación antes de intentar controlar el servo.

Sintaxis
servo.attached()

Parametros
true (verdadero) si el servo está asociado al pin; false (falso) en otro caso.

Ejemplo
  1. #include <Servo.h>  
  2. Servo servo;  
  3. void setup()  
  4. {  
  5.     servo.attach(9);  
  6. }  
  7. void loop() {  
  8.     //Comprobamos que hay un pin asociado a la variable servo.  
  9.     if (servo.attached() == false){  
  10.         //Si lo hay, movemos el servo.  
  11.         servo.write(50);  
  12.     }  
  13.     else  
  14.     {  
  15.         //en caso contrario, primero lo asignamos y despues lo movemos.  
  16.         servo.attach(9);  
  17.         servo.write(50);  
  18.     }  

No hay comentarios:

Publicar un comentario