Guías · 13 min de lectura

Proyectos con servomotores Arduino: 15 ideas, SG90 y MG996R

Proyectos con servomotores Arduino: radar, brazo robótico, cerradura, seguidor solar y comedero; cómo elegir SG90, MG90S o MG996R, alimentarlos y usar PCA9685.

Los proyectos con servomotores son la forma más fácil de hacer que algo se mueva de verdad con Arduino: con un solo cable le indicas un ángulo, el servo va hasta ahí y se queda quieto. En esta guía reunimos 15 proyectos con servomotores y Arduino, desde el radar ultrasónico hasta el brazo robótico, pasando por la cerradura con tarjeta, el seguidor solar y el comedero automático para mascotas. Para cada proyecto vas a encontrar en una sola tabla qué servo elegir, cuántos hacen falta, si conviene controlarlos directamente desde Arduino o con un driver PCA9685, y cómo alimentarlos.

Antes de ir a los proyectos veremos las diferencias entre el SG90, el MG90S y el MG996R, cómo elegir la fuente de alimentación según la cantidad de servos y cuántos servos puede manejar a la vez un Arduino Uno, un ESP32 o una Raspberry Pi Pico. Después vienen plantillas de código ya compiladas para el radar, el brazo robótico y el seguidor solar, listas para usar. Si eres nuevo con los servos, te recomendamos leer primero ¿Qué es un servomotor?.

Microservo SG90 con su cable de tres colores
Microservo SG90: 9 gramos, unos 1,8 kg·cm de torque; cable marrón GND, rojo positivo y naranja de señal.

¿Qué servo elegir: SG90, MG90S o MG996R?

Lo primero que hay que mirar al elegir un servo es el torque: se expresa en kg·cm e indica cuántos kilos puede levantar a 1 cm del eje. Cuanto más largo es el brazo, menos carga levanta en la misma proporción; un SG90 de 1,8 kg·cm apenas sostiene 300 gramos en la punta de un brazo de 6 cm, y no de forma continua. Lo segundo es el material de los engranajes: los de plástico se barren cuando se fuerzan y los metálicos aguantan los golpes. Lo tercero es la corriente: un servo grande necesita una fuente grande. En la práctica, el SG90 sirve para tapas livianas y para girar sensores, el MG90S para mecanismos chicos que trabajan seguido o con esfuerzo, y el MG996R para el hombro de un brazo robótico y tapas pesadas.

ModeloTorqueEngranajesCorriente de bloqueoAlimentación recomendadaProyecto típico
SG901,8 kg·cm (4,8 V)Plástico650-750 mA5 VRadar, pan-tilt, tapa pequeña
MG90S1,8-2,2 kg·cmMetálicos0,7-1 A5-6 VCerradura, pinza, robot araña
MG996R9,4-11 kg·cmMetálicos, doble rodamiento2,5 A (6 V)6 V, 3 A por servoHombro de brazo robótico, cortina, tapa pesada
FS90R (360°)1,5 kg·cmPlásticohasta 800 mA5 VRuedas, base giratoria
Servomotor MG996R de engranajes metálicos con sus accesorios
MG996R: engranajes metálicos y hasta 11 kg·cm de torque; ideal para brazos robóticos y mecanismos pesados, pero siempre con fuente externa.

Tabla de alimentación: ¿cuántos servos y cuánta corriente?

En los proyectos con servos, la mayoría de los problemas no vienen del código sino de la alimentación. En el instante en que arranca, el servo pide un pico de corriente; si el pin 5V del Arduino, que viene del USB, no lo aguanta, el voltaje cae, la placa se reinicia y el servo tiembla. La regla es simple: un solo SG90 con poca carga puede funcionar desde el pin 5V del Arduino; para más, alimenta los servos con una fuente externa de 5-6 V, une el negativo de la fuente con el GND del Arduino y agrega un capacitor de 470-1000 µF en la línea de los servos. Para elegir la fuente, suma las corrientes de movimiento de los servos y deja al menos un 50 % de margen.

MontajeCorriente en movimiento (aprox.)Fuente recomendada
1 × SG90, carga ligera100-250 mAAlcanza el pin 5V del Arduino
2 × SG90 o MG90S0,3-0,6 AFuente externa de 5 V, 2 A
4 × MG90S (brazo robótico chico)0,6-1,2 AFuente externa de 5 V, 3 A
1 × MG996R0,5-0,9 A (2,5 A bloqueado)6 V, 3 A
6 × MG996R (brazo robótico grande)3-5,4 AFuente conmutada de 6 V, 10 A
12 × MG90S (robot araña)1,8-3,6 A5-6 V, 5 A, o LiPo 2S con BEC de 5 A
Nunca alimentes varios servos, ni un solo MG996R, desde el pin 5V del Arduino, y no intentes hacerlos andar con una pila de 9 V: esas pilas pequeñas no entregan la corriente de un servo y la placa se reinicia una y otra vez. Cuando uses una fuente externa, no olvides unir los GND; sin tierra común la señal se queda sin referencia y el servo se mueve al azar.

¿Controlar los servos directamente o con un PCA9685?

Manejar unos pocos servos directamente desde los pines del microcontrolador es lo más sencillo. La librería Servo del Arduino Uno usa el Timer1 para generar pulsos para hasta 12 servos, pero mientras tanto analogWrite deja de funcionar en los pines 9 y 10. El ESP32 dedica un canal PWM por hardware a cada servo y la Pico tiene 16 canales PWM. Cuando pasas de 5 o 6 servos, cuando los pulsos empiezan a temblar o cuando necesitas los pines para otras cosas, entra en juego el driver PCA9685: con solo dos pines I2C maneja 16 servos y, como genera los pulsos con su propio reloj, le quita trabajo al microcontrolador. Su configuración la explicamos en detalle en controlador de servos PCA9685.

PlataformaLibreríaServos directosOjo con
Arduino Uno / NanoServo (incluida)Hasta 12Usa el Timer1: analogWrite no funciona en D9 y D10
Arduino MegaServo (incluida)Hasta 48Con muchos servos igual necesitas fuente externa
ESP32ESP32ServoHasta 16GPIO 18, 19, 21, 22, 23, 25, 26, 27 son seguros; 34-39 solo entrada
Raspberry Pi Picomachine.PWM (MicroPython)Hasta 16Dos pines del mismo slice PWM comparten frecuencia; a 50 Hz no importa
PCA9685 (con cualquier placa)Adafruit PWM Servo Driver16 por placa, hasta 62 placas encadenadasLa potencia de los servos entra por el borne V+ de la placa

15 proyectos con servomotores: servo, cantidad y forma de control

#ProyectoServoCantidadControlNivel
1Control de ángulo con potenciómetroSG901DirectoPrincipiante
2Radar ultrasónicoSG901DirectoPrincipiante
3Tapa automática de bote de basuraMG90S1DirectoPrincipiante
4Comedero automático para mascotasMG90S o MG996R1DirectoIntermedio
5Cerradura con tarjeta o con claveMG90S1DirectoIntermedio
6Termómetro de aguja con servoSG901DirectoPrincipiante
7Cabeza giratoria del robot evasor de obstáculosSG901DirectoIntermedio
8Soporte pan-tilt para cámara con joystickSG902DirectoPrincipiante
9Seguidor solarMG90S2DirectoIntermedio
10Barrera de paso a nivel (maqueta)SG902DirectoPrincipiante
11Abridor de cortina o tapa por Wi-FiMG996R1Directo (ESP32)Intermedio
12Plataforma estabilizada con MPU6050MG90S2DirectoAvanzado
13Brazo robótico de escritorio de 4 ejesMG90S o SG904Directo o PCA9685Intermedio
14Brazo robótico de 6 ejesMG996R y MG90S6PCA9685Avanzado
15Robot araña cuadrúpedoMG90S12PCA9685Avanzado

Proyectos con un servo (1-7)

  • 1. Control de ángulo con potenciómetro: el "hola mundo" de los servos. Conviertes el valor 0-1023 del potenciómetro a 0-180 grados con map() y se lo escribes al servo. El código y la conexión están en ¿Qué es un servomotor?; a partir de acá vas a usar la misma lógica en todos los proyectos.
  • 2. Radar ultrasónico: se pega un sensor HC-SR04 sobre un SG90, el servo barre entre 15 y 165 grados y la distancia de cada ángulo se envía por el puerto serie. En la computadora, Processing convierte esos datos en la clásica pantalla verde de radar. Los detalles están en radar con Arduino y el código, más abajo.
  • 3. Tapa automática de bote de basura: un HC-SR04 en el frente detecta cuando la mano está a menos de 20 cm, el servo abre la tapa y la cierra unos segundos después. Si la tapa es pesada, usa un MG90S de engranajes metálicos en vez del SG90; más detalles en bote de basura inteligente.
  • 4. Comedero automático para mascotas: el servo abre durante unos segundos la compuerta que está bajo el depósito de alimento a ciertas horas. La hora la da un módulo RTC y la porción, el tiempo que la compuerta queda abierta. En los comederos con tornillo sin fin el torque necesario sube, así que conviene un MG996R o un servo de 360 grados; mira comedero automático.
  • 5. Cerradura con tarjeta o con clave: cuando se acerca la tarjeta RFID correcta o se ingresa la clave correcta en el teclado matricial, el servo corre el pestillo. Como el pestillo tiene rozamiento, un MG90S de engranajes metálicos dura bastante más.
  • 6. Termómetro de aguja con servo: le pones una aguja al brazo del servo y detrás un cartón con una escala de 0 a 40 °C; la temperatura que mide el DHT11 se convierte en ángulo con map(). La misma idea sirve como indicador de humedad, de nivel de sonido o de cantidad de suscriptores.
  • 7. Cabeza giratoria del robot evasor de obstáculos: cuando el robot se detiene, el HC-SR04 montado sobre el servo mira a la izquierda y a la derecha, y el robot gira hacia el lado más libre. Este agregado tan simple lo hace mucho más inteligente que un robot con sensor fijo; mira robot evasor de obstáculos.

Proyectos con dos servos (8-12)

  • 8. Soporte pan-tilt para cámara con joystick: se montan dos SG90 uno sobre otro: el de abajo gira en horizontal (pan) y el de arriba en vertical (tilt). Los ejes X e Y del módulo joystick se asignan a cada servo; arriba puedes poner una cámara chica, un láser o un sensor.
  • 9. Seguidor solar: cuatro LDR miden de qué lado llega más luz y dos servos orientan el panel en horizontal y vertical hacia la dirección más iluminada. Como el viento fuerza el brazo del panel, conviene usar MG90S. Los detalles están en seguidor solar y el código para ESP32, más abajo.
  • 10. Barrera de paso a nivel: para una maqueta de tren o un proyecto escolar, dos SG90 bajan y suben las barreras, los LED rojos parpadean alternados y un buzzer da el aviso. La llegada del tren la detecta un sensor infrarrojo o un reed switch; bajar la velocidad del servo da un efecto muy realista.
  • 11. Abridor de cortina o tapa por Wi-Fi: el ESP32 corre un pequeño servidor web y, al tocar el botón en el celular, un MG996R mueve el cordón de la cortina o una rejilla de ventilación. Como es un MG996R, sí o sí necesitas una fuente externa de 6 V.
  • 12. Plataforma estabilizada con MPU6050: el acelerómetro MPU6050 mide la inclinación de la plataforma y dos servos la corrigen en sentido contrario para mantener la superficie horizontal. Es un gimbal sencillo que mantiene firme un vaso de agua o una cámara chica; para que reaccione rápido hacen falta MG90S y un buen filtro.

Proyectos con muchos servos: brazo robótico y robot araña (13-15)

  • 13. Brazo robótico de escritorio de 4 ejes: usa cuatro servos para la base, el hombro, el codo y la pinza. En brazos chicos de acrílico o impresos en 3D alcanza con MG90S, y los cuatro se pueden manejar directo desde el Uno; los servos deben alimentarse con una fuente externa de 5 V 3 A. Puedes agregar control manual con potenciómetros, joystick o movimientos que se graban y se reproducen; mira brazo robótico con Arduino.
  • 14. Brazo robótico de 6 ejes: en brazos metálicos más grandes se usan MG996R para la base, el hombro y el codo, y MG90S para la muñeca y la pinza. Manejar los seis servos con un PCA9685 simplifica el cableado; una fuente de 6 V 10 A y un código que mueva los servos de a uno, no todos juntos, reducen los picos de corriente. Para la carga del hombro revisa la tabla de torque del MG996R.
  • 15. Robot araña cuadrúpedo: con tres articulaciones por pata hacen falta 12 servos, y con esa cantidad el PCA9685 es casi obligatorio. Como el peso importa, se prefieren MG90S, y el robot se alimenta con una batería LiPo 2S y un BEC de 5 A. La caminata se arma con una tabla de poses que cambia en orden los ángulos de cada pata; la plantilla del brazo robótico de más abajo es un buen punto de partida.
En los robots con ruedas se usa un servo de rotación continua de 360 grados en lugar de uno normal: en vez del ángulo se controlan la velocidad y el sentido. Los detalles están en servo de 360 grados FS90R. Para proyectos de exhibición también se pueden mover 32 servos sincronizados con dos PCA9685; el proyecto de coreografía de servos en círculo de BlueGrays hace justamente eso.

Conexión común: Arduino Uno, ESP32 y Pico

Cable del servoArduino UnoESP32Raspberry Pi PicoFuente externa de 5-6 V
Marrón / negro (GND)GNDGNDGNDNegativo (-)
Rojo (V+)5V (solo un SG90)No se conectaNo se conectaPositivo (+)
Naranja / amarillo (señal)D9GPIO 18GP15No se conecta
GND de la fuenteGND (común)GND (común)GND (común)Negativo (-)

Código del proyecto 2: radar ultrasónico con Arduino

El servo va a D9, el TRIG del HC-SR04 a D10 y el ECHO a D11. El servo se detiene cada 2 grados, espera 30 ms y mide la distancia; el resultado sale por el puerto serie con el formato "ángulo,distancia". Ese formato lo puede leer directamente la pantalla de radar de Processing o el Serial Plotter del IDE de Arduino. El tiempo límite de 30 ms que se le pasa a pulseIn equivale a unos 5 metros; si no vuelve el eco, se escribe -1. La lógica del cálculo de distancia está en la guía del HC-SR04.

C++ (Arduino IDE)
1#include <Servo.h>
2
3const int SERVO_PIN = 9;     // servo sinyali / servo signal
4const int TRIG_PIN = 10;     // HC-SR04 TRIG
5const int ECHO_PIN = 11;     // HC-SR04 ECHO
6
7Servo radar;
8
9int readDistanceCm() {
10  digitalWrite(TRIG_PIN, LOW);
11  delayMicroseconds(2);
12  digitalWrite(TRIG_PIN, HIGH);                        // 10 µs tetik darbesi / 10 µs trigger pulse
13  delayMicroseconds(10);
14  digitalWrite(TRIG_PIN, LOW);
15  unsigned long us = pulseIn(ECHO_PIN, HIGH, 30000UL); // en fazla 30 ms (~5 m) / max 30 ms (~5 m)
16  if (us == 0) return -1;                              // yankı yok / no echo
17  return us * 0.0343 / 2;                              // µs -> cm
18}
19
20void scanTo(int angle) {
21  radar.write(angle);
22  delay(30);                                           // servo yerine otursun / let the servo settle
23  int d = readDistanceCm();
24  Serial.print(angle);                                 // "açı,mesafe" satırı / "angle,distance" line
25  Serial.print(',');
26  Serial.println(d);
27}
28
29void setup() {
30  Serial.begin(9600);
31  pinMode(TRIG_PIN, OUTPUT);
32  pinMode(ECHO_PIN, INPUT);
33  radar.attach(SERVO_PIN);
34}
35
36void loop() {
37  for (int a = 15; a <= 165; a += 2) scanTo(a);       // soldan sağa / left to right
38  for (int a = 165; a >= 15; a -= 2) scanTo(a);       // sağdan sola / right to left
39}

Código del proyecto 13: brazo robótico con varios servos sin delay

En un brazo robótico todas las articulaciones tienen que moverse a la vez y con suavidad. Si le escribes a cada servo el ángulo final directamente con write(), los servos saltan a toda velocidad, el brazo se sacude y los picos de corriente crecen. La plantilla de abajo acerca cada articulación a su objetivo grado por grado con millis(); el arreglo STEP_MS define la velocidad de cada una. Agregando filas a la tabla POSES puedes escribir tu propia secuencia de movimientos, y la misma estructura te sirve para el pan-tilt, la barrera o el robot araña.

C++ (Arduino IDE)
1#include <Servo.h>
2
3// 4 eksenli robot kol: taban, omuz, dirsek, kıskaç / 4-axis robot arm: base, shoulder, elbow, gripper
4const byte JOINTS = 4;
5const byte PINS[JOINTS] = {3, 5, 6, 9};
6const unsigned int STEP_MS[JOINTS] = {15, 20, 20, 8};   // 1 derece için bekleme (ms) / wait per degree (ms)
7
8// Hareket sırası: her satır bir poz / move sequence: each row is a pose
9const int POSES[][JOINTS] = {
10  {90, 90, 90, 30},     // başlangıç / home
11  {40, 120, 60, 30},    // nesneye uzan / reach the object
12  {40, 120, 60, 90},    // kıskacı kapat / close the gripper
13  {140, 80, 100, 90},   // taşı / carry
14  {140, 80, 100, 30}    // bırak / release
15};
16const byte POSE_COUNT = sizeof(POSES) / sizeof(POSES[0]);
17
18Servo servos[JOINTS];
19int current[JOINTS], target[JOINTS];
20unsigned long lastStep[JOINTS];
21byte pose = 0;
22
23// Servoyu hedefe 1 derece yaklaştırır, delay kullanmaz / moves a servo 1 degree closer, no delay
24bool updateJoint(byte i) {
25  if (current[i] == target[i]) return true;            // hedefte / at target
26  if (millis() - lastStep[i] < STEP_MS[i]) return false;
27  lastStep[i] = millis();
28  current[i] += (target[i] > current[i]) ? 1 : -1;
29  servos[i].write(current[i]);
30  return current[i] == target[i];
31}
32
33void setup() {
34  for (byte i = 0; i < JOINTS; i++) {
35    current[i] = target[i] = POSES[0][i];
36    servos[i].write(current[i]);                       // attach öncesi başlangıç açısı / start angle before attach
37    servos[i].attach(PINS[i]);
38  }
39  delay(1000);
40}
41
42void loop() {
43  bool allDone = true;
44  for (byte i = 0; i < JOINTS; i++) {
45    if (!updateJoint(i)) allDone = false;              // hepsi aynı anda hareket eder / all move together
46  }
47  if (allDone) {                                       // poz tamam, sıradakine geç / pose reached, next one
48    delay(500);
49    pose = (pose + 1) % POSE_COUNT;
50    for (byte i = 0; i < JOINTS; i++) target[i] = POSES[pose][i];
51  }
52}

Llamar a write() antes de attach() evita que, al encender, el servo salte primero a 90 grados y después vaya a la pose inicial. Los servos están en D3, D5, D6 y D9; como la librería Servo puede usar cualquier pin digital, no hace falta que el pin tenga la marca PWM. Si el Arduino se reinicia cuando el brazo se mueve, el problema no es el código sino la alimentación; aplica la lista de control de la guía servo que tiembla.

Código del proyecto 9: seguidor solar con ESP32

En el ESP32 la librería Servo de Arduino no funciona; en su lugar tienes que instalar la librería ESP32Servo, que corre con el mismo código en los cores 2.x y 3.x. Cada una de las cuatro LDR va entre 3V3 y un pin analógico, y desde ese pin una resistencia de 10 kΩ a GND; con más luz, la lectura sube. Conectamos las LDR a los pines del ADC1 (32-35), porque los pines del ADC2 no se pueden leer con el Wi-Fi encendido. Si el panel gira para el lado contrario, tu montaje del servo es distinto; basta con intercambiar el 1 y el -1 en el código. Cómo se mide la luz con una LDR lo explicamos en sensor de luz LDR.

C++ (Arduino IDE)
1#include <ESP32Servo.h>
2
3const int PAN_PIN = 18;      // yatay servo / horizontal servo
4const int TILT_PIN = 19;     // dikey servo / vertical servo
5// LDR'ler ADC1 pinlerinde (Wi-Fi ile çakışmaz) / LDRs on ADC1 pins (no Wi-Fi conflict)
6const int LDR_TL = 32, LDR_TR = 33, LDR_BL = 34, LDR_BR = 35;
7const int TOLERANCE = 80;    // bu farkın altında hareket etme / ignore smaller differences
8
9Servo pan, tilt;
10int panAngle = 90, tiltAngle = 45;
11
12void setup() {
13  analogReadResolution(12);                 // 0-4095
14  pan.setPeriodHertz(50);                   // standart servo 50 Hz / standard servo 50 Hz
15  tilt.setPeriodHertz(50);
16  pan.attach(PAN_PIN, 500, 2400);           // darbe aralığı (µs) / pulse range (µs)
17  tilt.attach(TILT_PIN, 500, 2400);
18  pan.write(panAngle);
19  tilt.write(tiltAngle);
20}
21
22void loop() {
23  int tl = analogRead(LDR_TL), tr = analogRead(LDR_TR);
24  int bl = analogRead(LDR_BL), br = analogRead(LDR_BR);
25  int top = (tl + tr) / 2, bottom = (bl + br) / 2;
26  int left = (tl + bl) / 2, right = (tr + br) / 2;
27
28  // Daha aydınlık tarafa 1 derece dön / turn 1 degree toward the brighter side
29  if (abs(left - right) > TOLERANCE) panAngle += (left > right) ? 1 : -1;
30  if (abs(top - bottom) > TOLERANCE) tiltAngle += (top > bottom) ? 1 : -1;
31  panAngle = constrain(panAngle, 5, 175);
32  tiltAngle = constrain(tiltAngle, 10, 90);
33
34  pan.write(panAngle);
35  tilt.write(tiltAngle);
36  delay(25);
37}

Servo con Raspberry Pi Pico (MicroPython)

En la Pico no hace falta ninguna librería extra: con machine.PWM generas una señal de 50 Hz y le das el ancho de pulso en nanosegundos. La función set_angle() de abajo convierte 0-180 grados al rango de 500-2400 µs; si tu servo zumba en los extremos, achica esos límites. Los pines de la Pico entregan 3,3 V y el SG90, el MG90S y el MG996R funcionan bien con ese nivel de señal, pero la alimentación del servo tiene que venir igual de VBUS (5 V del USB) o de una fuente externa. Aplicando la misma función a una lista de objetos PWM puedes llevar a la Pico todos los proyectos de arriba.

MicroPython
1from machine import Pin, PWM
2import time
3
4servo = PWM(Pin(15))         # GP15 sinyal / GP15 signal
5servo.freq(50)               # 50 Hz = 20 ms periyot / 20 ms period
6
7def set_angle(angle, min_us=500, max_us=2400):
8    angle = max(0, min(180, angle))                 # 0-180 arası sınırla / clamp to 0-180
9    us = min_us + (max_us - min_us) * angle / 180   # açı -> darbe (µs) / angle -> pulse (µs)
10    servo.duty_ns(int(us * 1000))                   # µs -> ns
11
12while True:
13    for a in range(0, 181, 2):                      # 0 -> 180 derece / degrees
14        set_angle(a)
15        time.sleep_ms(15)
16    for a in range(180, -1, -2):                    # 180 -> 0 derece / degrees
17        set_angle(a)
18        time.sleep_ms(15)

Errores comunes en proyectos con servomotores

  • El Arduino se reinicia cuando se mueve el servo: los servos se alimentan del pin 5V que viene del USB. Usa fuente externa, GND común y un capacitor de 470-1000 µF.
  • El servo zumba y se calienta en los extremos: al ir a 0 o 180 grados choca contra el tope mecánico. Reduce el rango a 5-175 grados o calibra los límites de pulso en attach().
  • El servo tiembla: alimentación débil, cables largos y finos o ruido en el potenciómetro. Usa cable grueso, filtra la lectura y agrega una zona muerta que ignore los cambios chicos.
  • analogWrite no funciona en D9 y D10: en el Uno la librería Servo usa el Timer1. Pasa el PWM de LED o motores a D3, D5, D6 o D11.
  • El brazo no levanta la carga: el torque se divide por el largo del brazo. Acorta el brazo, aligera la carga o sube un escalón de servo (de SG90 a MG90S, de MG90S a MG996R).
  • Se rompieron los engranajes de plástico: el mecanismo traba el servo o giraste el brazo a mano a la fuerza. Donde haya esfuerzo continuo usa servos de engranajes metálicos y no lo gires con la mano.
Antes de cerrar el proyecto en una caja, corre el código sin el brazo del servo puesto y, con la orden de 90 grados activa, coloca el brazo de modo que quede al centro. Así el mecanismo tiene el mismo recorrido hacia los dos lados y el servo no choca contra el tope en la primera prueba.

Una vez que entiendes cómo funcionan, los servomotores te abren la puerta a proyectos sin límite: las mismas pocas líneas de código mueven tanto un radar como un brazo robótico. Si quieres armar varios de estos proyectos paso a paso, en la app BlueGrays encontrarás el control de servo con potenciómetro, el servo con joystick, el servo con ESP32, la cerradura con RFID y servo, el robot evasor de obstáculos y la coreografía de 32 servos en círculo, con sus diagramas de conexión y su código.

Preguntas frecuentes

¿Qué proyectos se pueden hacer con un servomotor?

Con un servomotor puedes hacer todo lo que tenga que ir a un ángulo y quedarse ahí: radar, brazo robótico, cerradura, seguidor solar, comedero automático, soporte pan-tilt para cámara y robots caminantes son los ejemplos más populares. Con servos de 360 grados también se arman robots pequeños con ruedas.

¿Cuántos servos se pueden conectar a un Arduino?

La librería Servo del Arduino Uno maneja directamente hasta 12 servos y la del Mega hasta 48. Casi siempre el límite lo pone la fuente de alimentación, no la cantidad de pines. Para más de 5 o 6 servos conviene un driver PCA9685, que maneja 16 por placa y cientos si se encadenan.

¿Compro un SG90 o un MG996R?

Para tapas livianas, girar sensores y brazos chicos alcanza con un SG90. Para cargas pesadas, el hombro de un brazo robótico o mecanismos que trabajan forzados necesitas el MG996R, de engranajes metálicos y hasta 11 kg·cm de torque, pero pide una fuente externa capaz de dar 3 A por servo.

¿Se puede alimentar un servo desde el pin 5V del Arduino?

Solo un SG90 con poca carga. Si conectas más servos o uno grande, los picos de corriente bajan el voltaje y el Arduino se reinicia. Usa una fuente externa de 5-6 V y conecta su GND al GND del Arduino.

¿Por qué tiembla mi servomotor?

La causa más común es una alimentación insuficiente; le siguen la falta de GND común, el ruido en la lectura del potenciómetro y que el servo choque contra su tope mecánico. Una fuente externa, un capacitor, filtrar la lectura y reducir el rango a 5-175 grados resuelven la mayoría de los casos.

¿Cómo se controla un servo con el ESP32?

En el ESP32 se usa la librería ESP32Servo en lugar de la librería Servo estándar; los comandos attach(pin, 500, 2400) y write(ángulo) son los mismos que en Arduino. Elige pines que puedan ser salida, como GPIO 18, 19 o 25, y alimenta el servo desde una fuente de 5 V, no desde el pin de 3,3 V del ESP32.

Ver todos los proyectos
Uso del servomotor
AR-35Principiante
Premium

Uso del servomotor

El brazo de un pequeño servomotor gira por turnos a tres posiciones: al principio del todo, justo al centro y al final del todo, esperando dos segundos en cada parada.

4.7(48)
67
Funcionamiento del servomotor con potenciómetro
AR-36Principiante
Premium

Funcionamiento del servomotor con potenciómetro

A medida que giras el mando del potenciómetro, el brazo del servomotor gira con él: un extremo del mando equivale a cero grados y el otro a media vuelta.

4.6(37)
53
Servocontrol con joystick
AR-60Intermedio
Premium

Servocontrol con joystick

Controla dos motores con un joystick, igual que si giraras una cámara de seguridad.

4.7(42)
58
Servomotor ESP32 (control mediante potenciómetro)
ES-16Intermedio
Premium

Servomotor ESP32 (control mediante potenciómetro)

En este proyecto controlamos un servomotor SG90 mediante un potenciómetro. Ajustamos el ángulo del servo asignando el valor analógico leído en el potenciómetro al rango de 0 a 180 grados. La biblioteca ESP32Servo genera señales de servo en los GPIO adecuados del ESP32 que admiten salida; en este proyecto se utiliza GPIO 18. Este es un método de control básico para brazos robóticos, cardanes de cámara y mecanismos de puertas automáticas.

4.3(29)
42
Cerradura RFID ESP32 (RC522 + servo + OLED + zumbador + LED)
ES-35Avanzado
Premium

Cerradura RFID ESP32 (RC522 + servo + OLED + zumbador + LED)

Construimos una cerradura inteligente con un ESP32, un módulo RFID RC522, un servo SG90, una pantalla OLED SSD1306, un zumbador activo y 2 LED. Al pasar una tarjeta, su UID se compara con las autorizadas definidas en el código; si coincide, el servo abre (LED verde + 2 pitidos cortos) y vuelve a cerrar a los 5 segundos. Con una tarjeta no autorizada se enciende el LED rojo, suenan 3 pitidos rápidos y la OLED muestra su UID.

4.8(9)
16
Coreografía de servos en círculo - Patrones animados con 32 servos
AR-97Avanzado
Premium

Coreografía de servos en círculo - Patrones animados con 32 servos

Un proyecto de animación visual con 32 servomotores dispuestos en círculo sobre un Arduino Mega. Los servos se gestionan en un único array, se conectan a los pines 22–53 del Mega y muestran cuatro secuencias de movimiento: una vibración caótica en ángulos aleatorios, un barrido sincronizado, una ola que recorre el círculo y una aguja de brújula que oscila de lado a lado.

4.5(40)
62
Robot para evitar obstáculos
AR-81Avanzado
Premium

Robot para evitar obstáculos

¿Qué le parece construir un vehículo inteligente que encuentre su propio camino? El Robot Evitador de Obstáculos explora constantemente su entorno gracias al sensor ultrasónico que lleva delante.

5.0(38)
49