Control de motor servo con Arduino: Guía paso a paso

En este tutorial aprenderemos cómo funcionan los motores servo y cómo controlarlos con Arduino. Los servos son muy populares en proyectos Arduino por su facilidad de uso y excelente control de posición.

Son ideales para robótica, automatización, modelos RC, etc. Ya los he usado en muchos proyectos:

• Brazo Robot Arduino DIY con Control por Smartphone
• Robot Hexápodo Hormiga Arduino
• Aerodeslizador RC DIY basado en Arduino
• Robot SCARA | Cómo construir tu propio robot Arduino
• Réplica del Rover Perseverance de Marte – Proyecto Arduino

Puedes ver el vídeo o leer el tutorial escrito. Incluye varios ejemplos de uso, diagrama de conexiones, códigos y una guía para controlar múltiples servos con el driver PCA9685 PWM.

¿Qué es un motor servo?

Un motor servo es un sistema de lazo cerrado que usa retroalimentación de posición para controlar su movimiento y posición final. Existen muchos tipos, pero su característica principal es la capacidad de controlar con precisión la posición de su eje.

En servos industriales el sensor de posición suele ser un encoder de alta precisión, mientras que en servos RC o de hobby es normalmente un potenciómetro simple. La posición real capturada se retroalimenta al detector de error, donde se compara con la posición objetivo. Según el error, el controlador corrige la posición real para que coincida con la objetivo.

En este tutorial nos centraremos en los servos de hobby: explicaremos su funcionamiento y control con Arduino.

Los servos de hobby son actuadores pequeños para controlar juguetes RC (coches, barcos, aviones). También los usan estudiantes de ingeniería para prototipar robótica, brazos robóticos, robots bioinspirados, humanoides, etc.

¿Cómo funcionan los motores servo?

Dentro de un servo de hobby hay cuatro componentes principales: motor DC, caja de engranajes, potenciómetro y circuito de control. El motor DC es de alta velocidad y bajo par, pero la caja de engranajes reduce la velocidad a ~60 RPM y aumenta el par.

El potenciómetro va acoplado al engranaje final o eje de salida; al girar el motor, el potenciómetro gira generando un voltaje relacionado con el ángulo absoluto del eje. En el circuito de control, este voltaje se compara con el de la línea de señal. Si hay diferencia, el controlador activa un puente H integrado que hace girar el motor en la dirección necesaria hasta que ambas señales coincidan (error cero).

Un servo se controla enviando una serie de pulsos por la línea de señal. La frecuencia debe ser 50 Hz (un pulso cada 20 ms). El ancho del pulso determina la posición angular; estos servos suelen girar 180° (límites físicos de recorrido).

Generalmente: 1 ms = 0°, 1.5 ms = 90°, 2 ms = 180°. Pero los valores mín/máx pueden variar según marca (ej. 0.5 ms para 0° y 2.5 ms para 180°).

Servos RC / Hobby populares para proyectos Arduino

Hay muchos modelos y fabricantes. Las consideraciones principales al elegir son: par, voltaje de operación, consumo de corriente y tamaño.

Los dos modelos más populares entre makers son el SG90 Micro Servo y el MG996R.

Especificaciones SG90 Micro Servo:

Especificaciones MG996R:

Control de motor servo con Arduino

Pongamos a prueba lo anterior con un ejemplo práctico controlando un servo de hobby con Arduino. Usaré el MG996R, servo de alto par con engranajes metálicos y par de bloqueo de 10 kg-cm. Su alto par tiene un coste: corriente de bloqueo de 2.5 A. Corriente de trabajo 500-900 mA, voltaje 4.8-7.2V.

Estas corrientes indican que no podemos conectar este servo directamente a Arduino, sino que debemos usar una fuente de alimentación externa.

Diagrama de circuito

Esquema de conexiones para este ejemplo:

Conectamos el pin de control del servo a cualquier pin digital de Arduino, GND y positivo a fuente externa de 5V, y conectamos también el GND de Arduino al del servo.

Si usamos un servo más pequeño como el S90 Micro Servo, es posible alimentarlo directamente del pin 5V de Arduino.

El S90 consume ~100-200 mA sin carga, pero 500-700 mA en bloqueo. El pin 5V de Arduino entrega ~500 mA por USB, hasta 1A con conector barril.

Recomendación: aunque sea posible alimentar servos 9g directamente, para mayor estabilidad usa siempre fuente externa.

Componentes necesarios:

• Motor Servo MG996R ………………………….
• o S90 Micro Servo ………..……………………
• Placa Arduino …………………………………….
• Fuente DC 5V 2A …………………..…..

Código Arduino para control de servo

Veamos el código para controlar el servo. Es muy simple: definimos el pin, lo configuramos como salida, y en loop() generamos pulsos con la duración y frecuencia explicadas.

/* Control Servo - Generador tren pulsos 50Hz por Dejan, https://howtomechatronics.com */
#define servoPin 9

void setup() {
  pinMode(servoPin, OUTPUT);
}

void loop() {
  // Un pulso cada 20ms
  digitalWrite(servoPin, HIGH);
  delayMicroseconds(1450); // Duración pulso en µs
  digitalWrite(servoPin, LOW);
  delayMicroseconds(18550); // 20ms - duración pulso
  // Duraciones: 600 - 0°; 1450 - 90°; 2300 - 180°
}

Tras pruebas, obtuve estos valores para mi servo: 0.6 ms = 0°, 1.45 ms = 90°, 2.3 ms = 180°.

Conecté un multímetro en serie y medí hasta 0.63 A en bloqueo. Este no es un TowerPro MG996R original, sino una réplica barata con peor rendimiento.

Veamos una forma más cómoda: la librería Servo de Arduino.

/* Control Servo usando librería Arduino Servo por Dejan, https://howtomechatronics.com */
#include <Servo.h>
Servo myservo; // Crea objeto servo

void setup() {
  myservo.attach(9, 600, 2300); // (pin, min, max en µs)
}

void loop() {
  myservo.write(0); delay(1000);
  myservo.write(90); delay(500);
  myservo.write(135); delay(500);
  myservo.write(180); delay(1500);
}

Incluimos la librería, definimos el objeto servo, y con attach() definimos el pin y los valores mín/máx de duración de pulso. Luego con write() establecemos la posición de 0 a 180°.

Control de múltiples motores servo con Arduino

La librería Servo soporta hasta 12 servos simultáneos en la mayoría de placas Arduino, y 48 con Arduino Mega. Controlar varios es tan fácil como uno solo.

Ejemplo para 5 servos:

/* Control múltiples servos con Arduino por Dejan, https://howtomechatronics.com */
#include <Servo.h>
Servo servo1, servo2, servo3, servo4, servo5;

void setup() {
  servo1.attach(8);
  servo2.attach(9);
  servo3.attach(10);
  servo4.attach(11);
  servo5.attach(12);
}

void loop() {
  // Todos a 0°
  servo1.write(0); servo2.write(0); servo3.write(0);
  servo4.write(0); servo5.write(0);
  delay(2000);
  // Todos a 90°
  servo1.write(90); servo2.write(90); servo3.write(90);
  servo4.write(90); servo5.write(90);
  delay(2000);
  // Todos a 180°
  servo1.write(180); servo2.write(180); servo3.write(180);
  servo4.write(180); servo5.write(180);
  delay(2000);
}

Creamos un objeto Servo por cada motor y definimos su pin. Podemos mover cada servo a cualquier posición independientemente.

Como ejemplo, en mi proyecto Arduino Ant Hexapod Robot usé Arduino MEGA para controlar 22 servos.

Arduino y driver PCA9685 PWM/Servo

Otra forma de controlar servos es usando el driver PCA9685. Es un driver PWM/servo de 16 canales, 12 bits, que se comunica por I2C. Tiene reloj integrado para mover 16 servos independientemente de Arduino.

¡Lo mejor! Podemos encadenar hasta 62 drivers en un solo bus I2C. Teóricamente, 992 servos controlados con solo dos pines I2C de Arduino. Los 6 pines de selección de dirección configuran direcciones I2C distintas para cada driver.

Esquema de conexiones (nuevamente, fuente externa para servos):

Componentes necesarios:

• Motor Servo MG996R ………………………….
• Driver PCA9685 PWM Servo ……………….
• Placa Arduino …………………………………….
• Fuente DC 5V 6A …………………..…..

Usaremos la librería PCA9685 (descargable de GitHub).

Código Arduino y PCA9685

/* Control Servo con Arduino y PCA9685 por Dejan, https://howtomechatronics.com
   Librería: https://github.com/NachtRaveVL/PCA9685-Arduino */
#include <Wire.h>
#include "PCA9685.h"

PCA9685 driver;
// Salidas PCA9685 = 12-bit = 4096 pasos
// 2.5% de 20ms = 0.5ms ; 12.5% de 20ms = 2.5ms
// 2.5% de 4096 = 102 pasos; 12.5% de 4096 = 512 pasos
PCA9685_ServoEvaluator pwmServo(102, 470); // (-90°, +90°)
// Segundo servo (ajuste distinto)
// PCA9685_ServoEvaluator pwmServo2(102, 310, 505); // (0°, 90°, 180°)

void setup() {
  Wire.begin();
  Wire.setClock(400000); // 100kHz, 400kHz, 1000kHz soportados
  driver.resetDevices(); // Reset software todos los PCA9685 en bus Wire
  driver.init(B000000);  // Pines dirección A5-A0 = B000000
  driver.setPWMFrequency(50); // Frecuencia 50Hz
}

void loop() {
  driver.setChannelPWM(0, pwmServo.pwmForAngle(-90));
  delay(1000);
  driver.setChannelPWM(0, pwmServo.pwmForAngle(0));
  delay(1000);
  driver.setChannelPWM(0, pwmServo.pwmForAngle(90));
  delay(1000);
}

Incluimos librerías, definimos objeto PCA9685. Con ServoEvaluator definimos duración de pulsos / salida PWM. La resolución es 12-bit (4096 pasos). Pulso mínimo 0.5 ms (0°) = 102 pasos; máximo 2.5 ms (180°) = 512 pasos. Ajusta según tu servo; yo usé 102-470 para 0-180°.

En setup(): reloj I2C, dirección del driver, frecuencia 50 Hz.

En loop(): setChannelPWM() y pwmForAngle() posicionan el servo.

Conecté un segundo servo y, como esperaba, no posicionaba igual (son copias baratas). No es problema: con instancias ServoEvaluator separadas configuramos salidas distintas por servo, ajustando también los 90° si no están centrados.

Control de muchos servos con Arduino y drivers PCA9685 encadenados

Ejemplo con múltiples drivers encadenados:

Conectamos drivers entre sí y soldamos pines de dirección apropiados. Esquema:

/* Control Servo con Arduino y PCA9685 por Dejan, https://howtomechatronics.com
   Librería: https://github.com/NachtRaveVL/PCA9685-Arduino */
#include <Wire.h>
#include "PCA9685.h"

PCA9685 driver;
// PCA9685 outputs = 12-bit = 4096 steps
// 2.5% of 20ms = 0.5ms ; 12.5% of 20ms = 2.5ms
// 2.5% of 4096 = 102 steps; 12.5% of 4096 = 512 steps
PCA9685_ServoEvaluator pwmServo(102, 470); // (-90deg, +90deg)
// Second Servo
PCA9685_ServoEvaluator pwmServo2(102, 310, 505); // (0deg, 90deg, 180deg)

void setup() {
  Wire.begin(); // Wire must be started first
  Wire.setClock(400000); // Supported baud rates are 100kHz, 400kHz, and 1000kHz
  driver.resetDevices(); // Software resets all PCA9685 devices on Wire line
  driver.init(B000000); // Address pins A5-A0 set to B000000
  driver.setPWMFrequency(50); // Set frequency to 50Hz
}

void loop() {
  driver.setChannelPWM(0, pwmServo.pwmForAngle(-90));
  delay(1000);
  driver.setChannelPWM(0, pwmServo.pwmForAngle(0));
  delay(1000);
  driver.setChannelPWM(0, pwmServo.pwmForAngle(90));
  delay(1000);
}

Creamos objetos PCA9685 separados por driver, definimos direcciones y frecuencia 50 Hz. Luego con setChannelPWM() y pwmForAngle() controlamos cualquier servo en cualquier driver.

Solución de problemas

El servo vibra y reinicia mi placa Arduino

Problema común con SG90 y MG996R: consumen mucha corriente bajo carga, causando reinicios en Arduino, especialmente si alimentas el servo del pin 5V de Arduino.

Solución: usa un condensador entre GND y 5V. Actúa como desacoplador, suministrando corriente extra al arrancar el motor DC.

El servo no recorre todo el rango 0-180°

Otro problema común. Como dijimos, 1 ms (o 0.5 ms) = 0°, 2 ms (o 2.5 ms) = 180°. Pero varía entre servos y fabricantes.

Solución: ajusta el ancho de pulso enviado. Con la librería Servo es fácil en attach():

myservo.attach(9, 600, 2300); // (pin, min, max en µs)

attach() acepta dos parámetros extra: ancho de pulso mínimo y máximo en microsegundos. Valores por defecto: 544 µs (0°) y 2400 µs (180°). Ajustándolos afinas el rango real.

Dimensiones y modelo 3D

He creado modelos 3D de los dos servos más populares: SG90 y MG996R. Descargables desde los enlaces.

SG90 Micro Servo

Modelo 3D: Descargar de Thangs.

Dimensiones:

MG996R Servo Motor

Modelo 3D MG996R: Descargar de Thangs.

Dimensiones:

Conclusión

Hemos cubierto casi todo sobre uso de servos con Arduino. Hay muchos fabricantes y modelos, cada uno con características únicas que pueden diferir de lo explicado.

Las posibilidades para robótica, automatización y proyectos RC son infinitas, pero elegir el modelo adecuado es crucial.

¡Espero que hayas disfrutado y aprendido! Pregunta en comentarios y revisa mi Colección de Proyectos Arduino.

Preguntas Frecuentes (FAQ)

Es muy fácil. El servo tiene 3 cables: dos para alimentación (GND y 5V) y el tercero es la línea de control que va a Arduino.

Podemos, pero tendremos problemas de potencia. Si el servo consume >500 mA, Arduino puede perder alimentación y reiniciarse. Mejor usar siempre fuente externa dedicada.

Con la librería Servo: hasta 12 servos en la mayoría de placas, hasta 48 en Arduino Mega. Siempre con fuente dedicada para los servos.