Servomotores

Simplificándolo mucho, y si entrar en grandes detalles, un servomotor es un motor que cuenta con un circuito de control que nos permite colocarlo en una posición determinada.
La posición en la que se colocará dependerá del ancho del pulso que enviemos al circuito de control
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.

Conexión

Por lo general, los servos tienen 3 cables. Dos de ellos son para la alimentación, y el tercero es el cable por el que mandaremos la señal desde Arduino para que el servo se mueva o se coloque en una determinada posición.
Para hacer esto,necesitamos un pulso PWM, por lo que tenemos que asegurarnos de conectar el cable de señal a una salida de arduino que pueda realizar esta función, como por ejemplo el pin 9 en el que lo hemos colocado para todos los ejemplos y esquemas de este tutorial.

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)

Parámetros

• 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 ángulo mínimo y en 2400 el ancho de pulso para el ángulo mayor.

Ejemplo

1
2
3
4
5
6
7
8
9

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

Write()

Descripción

Coloca el servo en el ángulo que queramos. Algunos ángulos 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)

Parámetros

• servo: una variable tipo Servo
• ángulo: el valor a escribir en el servo, de 0 a 180

Ejemplo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

#include <Servo.h>
//Creamos una variable servo para poder usar las funciones con ella.
Servo servo;
void setup()
{
//Definimos el pin al que ira conectado el servo.
servo.attach(9);
//Movemos el servo al centro
servo.write(90); // coloca el servo en su posición central
}
void loop() {
//Lo llevamos a un extremo
servo.write(0);
//Le damos tiempo a llegar a esa posición
delay(500):
//Lo volvemos a centrar
servo.write(90);
//Le damos tiempo a llegar a esa posición
delay(500):
//Lo llevamos al otro extremo
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á.

WriteMicrosecons

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)

Parámetros

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

Ejemplo

1
2
3
4
5
6
7

#include <Servo.h>
Servo servo;
void setup(){
servo.attach(9);
servo.writeMicroseconds(1500); // coloca el servo en posición central
}
void loop() {}

Read

Se utiliza para conocer el ángulo 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()

Parámetros

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

Ejemplo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

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

Detach

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

Parámetros

sin parámetros

Ejemplo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

#include <Servo.h>
Servo servo;
void setup(){
servo.attach(9);
}
 
void loop() {
//realizamos varios movimientos con el servo.
servo.write(40);
delay(500);
servo.write(90);
delay(500);
servo.write(6);
delay(500);
servo.detach() ;
//A partir de este momento, no podremos volver a usar "servo" hasta que no volvamos a relacionarlo con un pin mediante attach()
}

Attached

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 asegurarnos de que hemos vuelto a crear la asociación antes de intentar controlar el servo.

Sintaxis

servo.attached()

Parámetros

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

Ejemplo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

#include <Servo.h>
Servo servo;
void setup()
{
servo.attach(9);
}
void loop() {
//Comprobamos que hay un pin asociado a la variable servo.
if (servo.attached() == false){
//Si lo hay, movemos el servo.
servo.write(50);
}
else
{
//en caso contrario, primero lo asignamos y después lo movemos.
servo.attach(9);
servo.write(50);
}
}

2 respuestas a “Servomotores”

1. Gabriel Romero dice:

   25 octubre, 2016 a las 11:27 pm

   como suavizar el movimiento del servo para que no de saltos o vibre gracias

   Responder
   • crakernano dice:

     27 octubre, 2016 a las 9:12 am

     Hola Gabriel,

     si lo que quieres es que el servo se mueva hasta la posición que tu le indiques de forma fluida el truco es está en ir enviando la posición ángulo a ángulo usando un bucle:

      // Iremos desde los 0 grados hasta 180 de grado en grado
       for(pos = 0; pos < 180; pos += 1){   
                                         
         myservo.write(pos);//En cada vuelta del bucle le indicamos que se mueva 1 grado más 
         delay(15);//Esperamos 15 ms para que le de tiempo a llegar a la posición antes 
       } 
     

     De esta forma en lugar de decirle "estas en 0, vete a 180" para que lo haga de golpe lo que hacemos es que en cada vuelta del bucle le pedimos que avance 1 grado más hasta llegar a la posición que queremos. El resultado de esto es un movimiento fluido, sin saltos ni vibración.

     Responder

Este sitio usa Akismet para reducir el spam. Aprende cómo se procesan los datos de tus comentarios.