Uso de servomotores con Arduino. Servo SG90

En este tutorial se explicará el funcionamiento y características de un servomotor, Servo SG90, así como la conexión con la placa Arduino y su utilización

Un servomotor es un motor de corriente continua, diseñado para que se mueva en un ángulo fijo y mantenga esa posición hasta una nueva orden. Frecuentemente son utilizados en aeromodelismo y robótica, por la capacidad de moverse en ángulo.

En el mercado existe una gran variedad de servomotores, se diferencian por su tamaño, su fuerza, su velocidad y su presición. La principal característica de estos motores es el torque (su fuerza). Es recomendable elegir un servo con un par superior al que necesitamos, porque si lo sometemos a cargas superiores a su fuerza, corremos el riesgo de dañar la parte mecánica (engranajes), si son de plástico podrían ceder y terminar rompiéndose.

Todos los servos usados para robótica, tiene un conector de 3 cables. VCC (rojo), GND (marrón) y señal (naranja):

Librería servo de Arduino

El control de servos en Arduino es muy fácil porque hay disponible una librería completa para el control de los servomotores. La documentación completa la encontramos en su página oficial: Servo Library. Esta librería esta destinada a facilitar la comunicación de Arduino con los servomotores.

La mayoria de las placas Arduino soportan el uso de hasta 12 motores, el uso de la biblioteca desactiva la funcionalidad PWM en los pines 9 y 10. La Arduino Mega puede soportar hasta 48 motores y hasta 12 servos pueden ser utilizados sin interferir con la funcionalidad PWM, pero si se usan de 12 a 23 motores desactivará el PWM en los pines 11 y 12.

Expliquemos brevemente las funciones de la librería.

• attach(pin, min, max)

Vincula la variable Servo a un pin.

Sintaxis:

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

Pin: es la patilla a la que está conectada la señal de control del servo.

min: es el ancho del pulso en microsegundos que se corresponde con 0º. Por defecto se establece en 544.

max: es el ancho del pulso en microsegundos que se corresponde con 180º. Por defecto se establece en 2400.

• write(grados)

Hace girar el eje del servo un número de grados según se le indique (0º a 180º).

• writeMicroseconds(tiempo)

Indica la anchura de pulso (en microsegundos) al servo. Los parámetros para un servo estándar son de 1000 us para un desplazamiento total a la izquierda, 2000 para el tope a la derecha y 1500 para posicionarlo en medio. Si se quiere un control exacto, habrá que estudiar las hojas de datos de cada servo (del fabricante) para averiguar exactamente la correspondencia de valores entre microsegundos y posición. No es directamente proporcional (no se puede hacer una regla de tres). Lo mejor es hacer un estudio con un osciloscopio.

• read()

Lee la posición actual del servo y devuelve un valor entre 0 y 180.

• attached(Pin)

Verifica si la variable servo está unida al pin indicado, devuelve true o false.

• detach(pin)

Desvincula la variable servo del pin indicado.

Uno de los ejemplos típicos para aprender a utilizar la librería, es girar el motor de 0º a 180º y volver a colocarlo en su posición inicial.

Esquema para su montaje

El servo dispone de 3 cables, dos para su alimentación (GND y VCC) y uno de señal (Sig). Es recomendable utilizar una fuente de alimentación externa, Arduino puede proporcionar corriente suficiente para un servo pequeño como el SG90, sin embargo no dispone de la suficiente energía para actuar con un servo grande o varios servos pequeños.

Material necesario:

• Placa Arduino UNO o similar.
• Servo SG90.
• Cables.

Para el control del servo contectamos el cable amarillo (señal) al pin 2.

Código para girar el motor de 0º a 180º

#include "Servo.h"   // librería para poder controlar el servo

Servo servoMotor;   // Crea un objeto servo llamado servoMotor

void setup(){ 
  // Asociamos el servo a la patilla 2 del Arduino
  servoMotor.attach(2);
}
 
void loop(){
  // Desplazamos a la posición 0º
  servoMotor.write(0);
  delay(1000);  // Esperamos 1 segundo
  
  // Desplazamos a la posición 90º
  servoMotor.write(90);
  delay(1000);  // Esperamos 1 segundo
  
  // Desplazamos a la posición 180º
  servoMotor.write(180);
  delay(1000);  // Esperamos 1 segundo
}

En la cabecera del programa incluimos la librería Servo.h que contiene las funciones necesarias para controlar el servo. Lo primero que hacemos es crear un objeto «servo» que hemos llamado servoMotor.

#include "Servo.h"
Servo servoMotor;

En el bloque setup indicamos el pin que hemos conectado a nuestro servo.

void setup(){
  servoMotor.attach(2);
}

En el bloque loop con la instrucción servoMotor.write() indicamos en qué ángulo queremos posicionar nuestro servo motor: 0º, 90ª y 180º.

void loop(){
  servoMotor.write(0);
  delay(1000);

  servoMotor.write(90);
  delay(1000);

  servoMotor.write(180);
  delay(1000);
}

Girando grado a grado nuestro servomotor

Si lo que pretendemos es que nuestro servo haga un barrido desde 0 a 180º y viceversa, podemos conseguirlo utilizando dos bucles for:

#include "Servo.h"  // librería para poder controlar el servo

Servo servoMotor;   // Crea un objeto servo llamado servoMotor

void setup(){ 
  Serial.begin(9600);
  // Asociamos el servo a la patilla 2 del Arduino
  servoMotor.attach(2);
  servoMotor.write(0); // Inicializamos al ángulo 0 el servomotor
}
 
void loop(){
  // giro de 0 a 180º
  for (int i = 0; i <= 180; i++){
    servoMotor.write(i);
    Serial.print("Angulo:  ");
    Serial.println(i);
    delay(30);
  }
 // giro de 180 a 0º
  for (int i = 179; i > 0; i--){
    servoMotor.write(i);
    Serial.print("Angulo:  ");
    Serial.println(i);
    delay(30);
  }
}

Control de un servomotor a través de un potenciómetro

Material necesario:

• Placa Arduino UNO o similar.
• Servo SG90.
• Potenciómetro.
• Cables.

Para esto realizaremos las siguientes conexiones:

Es recomendable utilizar una fuente de alimentación externa, puesto que podemos dañar el servo. La alimentación del motor puede ser la misma que la de Arduino siempre y cuando la fuente soporte la potencia del servo y sea de 5V. Los 5V del USB solo soportan un servo SG90, más servos o de otro tipo necesitarían usar una fuente externa.

Una vez realizadas las conexiones subimos el programa:

/* Controlar el ángulo de rotación con un potenciómetro. */
#include "Servo.h"  // librería para poder controlar el servo

Servo servoMotor;   // Crea un objeto servo llamado servoMotor

const int pinPotenc = 0;
const int pinServo = 2;
const int pulsoMin = 650;   // pulso para girar el servo a 0º
const int pulsoMax = 2550;  // pulso para girar el servo a 180º

int valor;
int angulo;

void setup() {
  Serial.begin(9600);
  servoMotor.attach(pinServo, pulsoMin, pulsoMax);
}

void loop() {
  valor = analogRead(pinPotenc);
  angulo = map(valor, 0, 1023, 0, 180);
  servoMotor.write(angulo);
  Serial.print("Angulo:  ");
  Serial.println(angulo);
  delay(20);
}

Como se observa en el código, en la función loop(), se hace la lectura del potenciómetro que está conectado al pin A0 (hay que recordar que es un pin digital y como tal nos dará valores entre 0 y 1023). Utilizamos la instrución map() para adaptarlo a valores de 0° a 180° y enviarlo al servomotor.

Una vez cargado el programa, el servo debe moverse cada vez que movamos el potenciómetro, y el monitor serial debería mostrar el ángulo aplicado en cada momento al servomotor.

Si la posición del servomotor no coincide con el ángulo correspondiente, es porque el ancho del pulso que maneja la librería no coincide con los del servo, para corregirlo es necesario indicarle el ancho de pulso mínimo (para 0°) y el máximo (para 180°), la única modificación sería en la siguiente línea:

servoMotor.attach(9,900,2100);  // estos valores no son fijos, debemos buscar unos valores óptimos

Deben cambiar los valores 900 y 2100 hasta lograr nuestros valores correctos.