En este tutorial aprenderás cómo funcionan los servomotores y cómo controlarlos con Arduino. ¡He incluido diagramas de conexión y varios ejemplos de código!
Los servomotores se usan a menudo en proyectos de robótica, pero también los puedes encontrar en coches RC, aviones, etc. Son muy útiles cuando necesitas un control preciso de posición y/o un alto par motor.
En la primera parte de este artículo, veremos el funcionamiento interno de un servo y qué tipo de señal de control utiliza. También explico las diferencias entre un servo estándar y uno continuo. A continuación, te mostraré cómo conectar un servomotor al Arduino.
Con el primer ejemplo de código, podrás controlar tanto la posición como la velocidad del servomotor. Después, veremos cómo controlar un servo con un potenciómetro y cómo modificar el código para controlar varios servos al mismo tiempo. Por último, al final del artículo, encontrarás las especificaciones y dimensiones de algunos de los servos más populares del mercado.
Materiales
Componentes de hardware
| SG90 micro servo | × 1 | Amazon |
| MG996R high-torque servo | × 1 | Amazon |
| Arduino Uno Rev3 | × 1 | Amazon |
| Jumper wires | × 15 | Amazon |
| Breadboard | × 1 | Amazon |
| 10 kΩ potentiometer (tipo breadboard) | × 1 | Amazon |
| USB cable type A/B | × 1 | Amazon |
| 5V power supply (opcional) | × 1 | Amazon |
Software
Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.
¿Cómo funciona un servomotor?
Un servo hobby estándar suele consistir en un pequeño motor eléctrico, un potenciómetro, electrónica de control y una caja de engranajes. La posición del eje de salida se mide constantemente mediante el potenciómetro interno y se compara con la posición objetivo establecida por el controlador (por ejemplo, el Arduino).
Según el error, la electrónica de control ajusta la posición real del eje de salida para que coincida con la posición objetivo. Esto se conoce como un sistema de control en lazo cerrado.
La caja de engranajes reduce la velocidad del motor, lo que aumenta el par en el eje de salida. La velocidad máxima del eje de salida suele ser alrededor de 60 RPM.
Control del servo
Los servos se controlan enviando una señal PWM (modulación por ancho de pulso) a la línea de señal del servo. El ancho de los pulsos determina la posición del eje de salida. Cuando envías al servo una señal con un ancho de pulso de 1,5 milisegundos (ms), el servo se moverá a la posición neutral (90 grados). Las posiciones mínimas (0 grados) y máximas (180 grados) suelen corresponder a un ancho de pulso de 1 ms y 2 ms respectivamente. Ten en cuenta que esto puede variar ligeramente entre diferentes tipos y marcas de servos (por ejemplo, 0,5 y 2,5 ms). Muchos servos solo giran unos 170 grados (o incluso solo 90), pero la posición media casi siempre está en 1,5 ms.
Para ajustar la posición mínima y máxima en el código, consulta la sección más abajo.
Los servos generalmente esperan un pulso cada 20 milisegundos o 50 Hz, pero muchos servos RC funcionan bien en un rango de 40 a 200 Hz.
Servo de 360 grados (continuo) vs servo de 180 grados (estándar)
La mayoría de los servos RC son del tipo de 180 grados, lo que significa que solo pueden girar en un rango de 0 a 180 grados. Sin embargo, también existen servos de rotación continua, conocidos como servos de 360 grados.
Los servos de rotación continua reaccionan de forma diferente a la señal de control que los servos estándar de 180 grados. Con un servo de rotación continua, no puedes controlar la posición exacta del eje de salida, solo la velocidad y la dirección. Un pulso de 1 ms hará que el servo gire a máxima velocidad en una dirección y un pulso de 2 ms a máxima velocidad en la otra. Un valor cercano a 1,5 ms detiene el motor.
Si tu servo se comporta de forma inesperada, puede que estés usando un servo continuo en lugar de uno estándar.
Para más información, echa un vistazo a nuestro tutorial Positional versus Continuous Servos.
¿Cómo conectar un servomotor al Arduino?
Conectar un servomotor es muy fácil porque solo necesitas conectar tres cables: alimentación, tierra y señal. El cable de alimentación suele ser rojo y debe conectarse a 5 V.
Un micro servo como el SG90 consume alrededor de 10 mA en reposo y entre 100 y 250 mA al girar, por lo que puedes alimentarlo directamente con la salida de 5 V del Arduino. Sin embargo, debes tener cuidado al usar varios servos o servos más grandes. Si tu(s) motor(es) consumen más de 300 mA, deberías usar una fuente de alimentación externa para evitar dañar el Arduino. Consulta el esquema más abajo para usar fuentes de alimentación externas.
El cable de tierra suele ser negro o marrón y debe conectarse al pin de tierra del Arduino. Cuando uses una fuente de alimentación separada, conecta el cable de tierra tanto al Arduino como a la fuente de alimentación.
El cable de señal suele ser amarillo, naranja o blanco y puede conectarse a cualquiera de los pines digitales del Arduino. En este caso, lo conecté al pin digital 9.
Las conexiones también se muestran en la tabla a continuación.
Conexiones del servomotor
| Servomotor | Arduino |
|---|---|
| Alimentación (rojo) | 5 V |
| Tierra (negro o marrón) | GND |
| Señal (amarillo, naranja o blanco) | Pin 9 |
Como mencioné antes, si usas servos grandes o varios servos, deberías usar una fuente de alimentación externa. Simplemente conecta la fuente de alimentación como se muestra en el diagrama de conexión a continuación. Asegúrate de conectar juntos el pin GND del Arduino y el de la fuente de alimentación.
También puedes usar esta configuración si tu servomotor requiere un voltaje diferente al que puede proporcionar el Arduino, por ejemplo, 6 V o más. La siguiente imagen muestra cómo usar una fuente de alimentación externa para alimentar el servo:
Conexiones para servomotor con fuente de alimentación externa
| Servomotor | Conexión |
|---|---|
| Alimentación (rojo) | Fuente de alimentación de 5 V |
| Tierra (negro o marrón) | Tierra de la fuente de alimentación y GND del Arduino |
| Señal (amarillo, naranja o blanco) | Pin 9 del Arduino |
Ejemplo de código para Arduino
Para controlar el servomotor usaremos la Servo.h biblioteca que viene preinstalada con el IDE de Arduino. Con el código de ejemplo a continuación, puedes controlar la posición exacta del servomotor e incluye código para barrer el brazo del servo automáticamente de un lado a otro.
Puedes subir el código de ejemplo a tu Arduino mediante el IDE de Arduino. A continuación, explicaré cómo funciona el código.
/* Servo motor with Arduino example code. Position and sweep. More info: https://www.makerguides.com/ */
// Include the servo library:
#include "Servo.h"
// Create a new servo object:
Servo myservo;
// Define the servo pin:
#define servoPin 9
void setup() {
// Attach the Servo variable to a pin:
myservo.attach(servoPin);
}
void loop() {
// Tell the servo to go to a particular angle:
myservo.write(90);
delay(1000);
myservo.write(180);
delay(1000);
myservo.write(0);
delay(1000);
// Sweep from 0 to 180 degrees:
for (int angle = 0; angle <= 180; angle += 1) {
myservo.write(angle);
delay(15);
}
// And back from 180 to 0 degrees:
for (int angle = 180; angle >= 0; angle -= 1) {
myservo.write(angle);
delay(15);
}
delay(1000);
}
Cómo funciona el código
El primer paso es incluir la biblioteca de Arduino requerida. También puedes encontrar esta biblioteca en Sketch > Include Library > Servo.
// Include the servo library: #include "Servo.h"
Luego, necesitas crear un nuevo objeto de la clase Servo. En este caso, llamé al servo ‘myservo’, pero puedes usar otros nombres. Ten en cuenta que también tendrás que cambiar el nombre del servo en el resto del código.
// Create a new servo object: Servo myservo;
Después, definí a qué pin del Arduino está conectado el servomotor.
// Define the servo pin: #define servoPin 9
La instrucción #define se usa para dar nombre a un valor constante. El compilador reemplazará cualquier referencia a esta constante con el valor definido cuando se compile el programa. Así que donde menciones servoPin, el compilador lo reemplazará con el valor 9 al compilar el programa.
En la sección setup del código, vinculamos el objeto servo que creamos al pin que controlará el servo. La función attach() también tiene dos parámetros opcionales, que explico en la sección más abajo.
void setup() {
// Attach the Servo variable to a pin:
myservo.attach(servoPin);
}
Control de ángulo/posición:
En la primera parte del loop, simplemente indicamos al servomotor que se mueva a un ángulo particular con la función write(). Ten en cuenta que necesitas un retardo entre los comandos para darle tiempo al servo a moverse a la posición establecida.
// Tell the servo to go to a particular angle: myservo.write(90); delay(1000); myservo.write(180); delay(1000); myservo.write(0); delay(1000);
Control de velocidad:
En la última parte del código, usé dos bucles for para barrer el servomotor de un lado a otro. Este fragmento de código también puede ser útil si quieres controlar la velocidad del servo. Cambiando el valor del retardo al final del bucle for, puedes ajustar la velocidad del brazo del servo.
// Sweep from 0 to 180 degrees:
for (int angle = 0; angle <= 180; angle += 1) {
myservo.write(angle);
delay(15);
}
// And back from 180 to 0 degrees:
for (int angle = 180; angle >= 0; angle -= 1) {
myservo.write(angle);
delay(15);
}
¿Por qué mi servo no gira los 0 – 180 grados completos?
Como mencioné en la introducción, el ángulo del eje de salida del servomotor está determinado por el ancho del pulso eléctrico aplicado al cable de control. Generalmente, un ancho de pulso de aproximadamente 1 ms (milisegundo) corresponde a la posición mínima, 2 ms a la posición máxima y 1,5 ms a 90° (posición neutral). Sin embargo, esto puede variar ligeramente entre marcas e incluso entre servos diferentes de la misma marca. Esto significa que tendrás que ajustar los valores mínimos y máximos en el código para que coincidan con el servo que estás usando.
La biblioteca Servo de Arduino facilita mucho ajustar el ángulo mínimo y máximo del servomotor especificando dos parámetros opcionales en la función attach(). En esta función, el primer parámetro es el número del pin al que está conectado el servo. El segundo parámetro es el ancho de pulso, en microsegundos (μs), correspondiente al ángulo mínimo (0 grados) del servomotor. El tercer parámetro es el ancho de pulso, en microsegundos, correspondiente al ángulo máximo (180 grados) del servomotor.
Por defecto, el ancho de pulso mínimo y máximo está configurado en 544 y 2400 microsegundos. Estos valores funcionan para la mayoría de los servos comunes, pero a veces hay que ajustarlos ligeramente.
Recomiendo ajustar los valores mínimo y máximo en pequeños incrementos (10-20 microsegundos) para evitar dañar el servo. Si el brazo del servo golpea los límites físicos del motor, aumenta el valor mínimo y disminuye el máximo.
#define servoPin 9
int min = 480;
int max = 2500;
Servo myservo;
void setup() {
myservo.attach(servoPin, min, max);
}
Controlar un servomotor con un potenciómetro y Arduino
Controlar la posición de un servomotor con un potenciómetro es muy fácil y puede ser muy útil si quieres ajustar la posición del motor manualmente. Como ves en el diagrama de conexión arriba, el servomotor está conectado igual que antes. La única diferencia es que usé una breadboard para distribuir la alimentación desde el Arduino.
El potenciómetro tiene tres pines, conecta los pines exteriores a 5 V y GND. El pin central del potenciómetro se conecta al pin analógico A0 del Arduino.
Ejemplo de código Arduino para servomotor con potenciómetro
El código de ejemplo a continuación te permite controlar un servomotor con un potenciómetro.
/* Servo motor with potentiometer and Arduino example code. More info: https://www.makerguides.com/ */
#include "Servo.h" // include the required Arduino library
#define servoPin 9 // Arduino pin for the servo
#define potPin A0 // Arduino pin for the potentiometer
int angle = 0; // variable to store the servo position in degrees
int reading = 0; // variable to store the reading from the analog input
Servo myservo; // create a new object of the servo class
void setup() {
myservo.attach(servoPin);
}
void loop() {
reading = analogRead(potPin); // read the analog input
angle = map(reading, 0, 1023, 0, 180); // map the input to a value between 0 and 180 degrees
myservo.write(angle); // tell the servo to go to the set position
delay(15); // wait 15 ms for the servo to reach the position
}
Observa que antes de las secciones setup y loop del código se añade una nueva variable reading y se define el pin de entrada del potenciómetro.
En la sección loop del código, leemos el valor del pin analógico A0 con la función analogRead().
reading = analogRead(potPin); // read the analog input
Las placas Arduino contienen un convertidor analógico a digital (ADC) de 10 bits, por lo que obtenemos un valor entre 0 y 1023 según la posición del potenciómetro.
Como el servomotor solo puede girar entre 0 y 180 grados, necesitamos escalar los valores con la función map(). Esta función remapea un número de un rango a otro.
angle = map(reading, 0, 1023, 0, 180); // map the input to a value between 0 and 180 degrees
Por último, escribimos el ángulo al servomotor:
myservo.write(angle); // tell the servo to go to the set position delay(15); // wait 15 ms for the servo to reach the position
Controlar múltiples servomotores
Controlar varios servos es tan fácil como controlar uno solo, pero a menudo me preguntan cómo modificar el código. Por eso he añadido un ejemplo sencillo a continuación.
Ten en cuenta que tendrás que usar una fuente de alimentación externa para alimentar los servos porque el Arduino no puede proporcionar suficiente corriente para todos los motores.
Para este ejemplo, simplemente usamos más pines del Arduino para los servos adicionales. Sin embargo, esto significa que estás limitado a 12 servos usando un Arduino Uno, y puede que no te queden suficientes pines para otros componentes.
Otra opción es usar uno o varios PCA9685 PWM/servo drivers. Este controlador te permite controlar 16 servos con solo 2 pines del Arduino usando I2C. Adafruit también los vende en forma de Arduino shield.
Como la configuración de estos controladores de servos es un poco más complicada, lo cubriré en un tutorial aparte.
Ejemplo de código Arduino con múltiples servos
Como ves en el ejemplo a continuación, solo tienes que crear más objetos de la clase Servo con nombres diferentes. Puedes dirigir cada servo usando el nombre correcto en las secciones setup y loop del código.
/* Arduino with multiple servos example code. More info: https://www.makerguides.com/ */
#include "Servo.h"
Servo servo1;
Servo servo2;
Servo servo3;
Servo servo4;
Servo servo5;
void setup()
{
servo1.attach(9);
servo2.attach(10);
servo3.attach(11);
servo4.attach(12);
servo5.attach(13);
}
void loop()
{
servo1.write(0);
servo2.write(0);
servo3.write(0);
servo4.write(0);
servo5.write(0);
delay(2000);
servo1.write(90);
servo2.write(90);
servo3.write(90);
servo4.write(90);
servo5.write(90);
delay(1000);
servo1.write(180);
servo2.write(180);
servo3.write(180);
servo4.write(180);
servo5.write(180);
delay(1000);
}
Especificaciones de servomotores
A continuación puedes encontrar las especificaciones de algunos de los servos más populares del mercado. El fabricante original de estos servos es Tower Pro Pte Ltd. pero modelos similares pueden comprarse en muchos otros proveedores también.
SG90 analog micro servo
Pinout
| Marrón | GND |
| Rojo | VCC |
| Amarillo | Señal (PWM) |
Especificaciones
| Voltaje de operación | 4.8 V |
| Peso | 9 g |
| Par de bloqueo | 1.8 kg/cm (4.8 V) |
| Tipo de engranaje | Juego de engranajes POM |
| Velocidad de operación | 0.12 s/60° (4.8 V) |
| Temperatura de operación | 0 – 55 °C |
| Costo | Check price |
Dimensiones
| A | 34.5 mm |
| B | 22.8 mm |
| C | 26.7 mm |
| D | 12.6 mm |
| E | 32.5 mm |
| F | 16 mm |
MG90S digital micro servo
Pinout
| Marrón | GND |
| Rojo | VCC |
| Amarillo | Señal (PWM) |
Especificaciones
| Voltaje de operación | 4.8 V |
| Peso | 13.4 g |
| Par de bloqueo | 1.8 kg/cm (4.8 V), 2.2 kg/cm (6.6 V) |
| Tipo de engranaje | Aluminio 6061-T6 |
| Velocidad de operación | 0.10 s/60° (4.8 V), 0.08 s/60° (6.0 V) |
| Temperatura de operación | 0 – 55 °C |
| Costo | Check price |
Dimensiones
| A | 32.5 mm |
| B | 22.8 mm |
| C | 28.4 mm |
| D | 12.4 mm |
| E | 32.1 mm |
| F | 18.5 mm |
MG996R high torque digital servo
Pinout
| Marrón | GND |
| Rojo | VCC |
| Amarillo | Señal (PWM) |
Especificaciones
| Voltaje de operación | 4.8 – 6.6 V |
| Consumo en reposo | 10 mA |
| Consumo sin carga | 170 mA |
| Consumo en bloqueo | 1400 mA |
| Peso | 55 g |
| Par de bloqueo | 9.4 kg/cm (4.8 V), 11 kg/cm (6.0 V) |
| Tipo de engranaje | Engranaje metálico |
| Velocidad de operación | 0.19 s/60° (4.8 V), 0.15 s/60° (6.0 V) |
| Temperatura de operación | 0 – 55 °C |
| Costo | Check price |
Dimensiones
| A | 42.7 mm |
| B | 40.9 mm |
| C | 37 mm |
| D | 20 mm |
| E | 54 mm |
| F | 26.8 mm |
Conclusión
En este tutorial te he mostrado cómo usar servomotores con Arduino. Vimos lo básico para controlar la posición y velocidad de los servos, cómo controlar un servo con un potenciómetro y cómo controlar varios servos al mismo tiempo.
Si quieres aprender más sobre otros tipos de motores, consulta los artículos a continuación:
- Positional versus Continuous Servos
- 28BYJ-48 Stepper Motor with ULN2003 Driver and Arduino Tutorial
- How to control a Stepper Motor with Arduino Motor Shield Rev3
- How to control a stepper motor with A4988 driver and Arduino
También tengo un artículo sobre How To Control Servo Motors using ESP32 si quieres trabajar con un microcontrolador ESP32 en su lugar.
Si tienes alguna pregunta, sugerencia o crees que falta algo en este tutorial, por favor deja un comentario abajo.
