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?.

¿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.
| Modelo | Torque | Engranajes | Corriente de bloqueo | Alimentación recomendada | Proyecto típico |
|---|---|---|---|---|---|
| SG90 | 1,8 kg·cm (4,8 V) | Plástico | 650-750 mA | 5 V | Radar, pan-tilt, tapa pequeña |
| MG90S | 1,8-2,2 kg·cm | Metálicos | 0,7-1 A | 5-6 V | Cerradura, pinza, robot araña |
| MG996R | 9,4-11 kg·cm | Metálicos, doble rodamiento | 2,5 A (6 V) | 6 V, 3 A por servo | Hombro de brazo robótico, cortina, tapa pesada |
| FS90R (360°) | 1,5 kg·cm | Plástico | hasta 800 mA | 5 V | Ruedas, base giratoria |

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.
| Montaje | Corriente en movimiento (aprox.) | Fuente recomendada |
|---|---|---|
| 1 × SG90, carga ligera | 100-250 mA | Alcanza el pin 5V del Arduino |
| 2 × SG90 o MG90S | 0,3-0,6 A | Fuente externa de 5 V, 2 A |
| 4 × MG90S (brazo robótico chico) | 0,6-1,2 A | Fuente externa de 5 V, 3 A |
| 1 × MG996R | 0,5-0,9 A (2,5 A bloqueado) | 6 V, 3 A |
| 6 × MG996R (brazo robótico grande) | 3-5,4 A | Fuente conmutada de 6 V, 10 A |
| 12 × MG90S (robot araña) | 1,8-3,6 A | 5-6 V, 5 A, o LiPo 2S con BEC de 5 A |
¿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.
| Plataforma | Librería | Servos directos | Ojo con |
|---|---|---|---|
| Arduino Uno / Nano | Servo (incluida) | Hasta 12 | Usa el Timer1: analogWrite no funciona en D9 y D10 |
| Arduino Mega | Servo (incluida) | Hasta 48 | Con muchos servos igual necesitas fuente externa |
| ESP32 | ESP32Servo | Hasta 16 | GPIO 18, 19, 21, 22, 23, 25, 26, 27 son seguros; 34-39 solo entrada |
| Raspberry Pi Pico | machine.PWM (MicroPython) | Hasta 16 | Dos pines del mismo slice PWM comparten frecuencia; a 50 Hz no importa |
| PCA9685 (con cualquier placa) | Adafruit PWM Servo Driver | 16 por placa, hasta 62 placas encadenadas | La potencia de los servos entra por el borne V+ de la placa |
15 proyectos con servomotores: servo, cantidad y forma de control
| # | Proyecto | Servo | Cantidad | Control | Nivel |
|---|---|---|---|---|---|
| 1 | Control de ángulo con potenciómetro | SG90 | 1 | Directo | Principiante |
| 2 | Radar ultrasónico | SG90 | 1 | Directo | Principiante |
| 3 | Tapa automática de bote de basura | MG90S | 1 | Directo | Principiante |
| 4 | Comedero automático para mascotas | MG90S o MG996R | 1 | Directo | Intermedio |
| 5 | Cerradura con tarjeta o con clave | MG90S | 1 | Directo | Intermedio |
| 6 | Termómetro de aguja con servo | SG90 | 1 | Directo | Principiante |
| 7 | Cabeza giratoria del robot evasor de obstáculos | SG90 | 1 | Directo | Intermedio |
| 8 | Soporte pan-tilt para cámara con joystick | SG90 | 2 | Directo | Principiante |
| 9 | Seguidor solar | MG90S | 2 | Directo | Intermedio |
| 10 | Barrera de paso a nivel (maqueta) | SG90 | 2 | Directo | Principiante |
| 11 | Abridor de cortina o tapa por Wi-Fi | MG996R | 1 | Directo (ESP32) | Intermedio |
| 12 | Plataforma estabilizada con MPU6050 | MG90S | 2 | Directo | Avanzado |
| 13 | Brazo robótico de escritorio de 4 ejes | MG90S o SG90 | 4 | Directo o PCA9685 | Intermedio |
| 14 | Brazo robótico de 6 ejes | MG996R y MG90S | 6 | PCA9685 | Avanzado |
| 15 | Robot araña cuadrúpedo | MG90S | 12 | PCA9685 | Avanzado |
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.
Conexión común: Arduino Uno, ESP32 y Pico
| Cable del servo | Arduino Uno | ESP32 | Raspberry Pi Pico | Fuente externa de 5-6 V |
|---|---|---|---|---|
| Marrón / negro (GND) | GND | GND | GND | Negativo (-) |
| Rojo (V+) | 5V (solo un SG90) | No se conecta | No se conecta | Positivo (+) |
| Naranja / amarillo (señal) | D9 | GPIO 18 | GP15 | No se conecta |
| GND de la fuente | GND (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.
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.
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.
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.
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.
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.
Proyectos para hacer después de leer esto
Ver todos los proyectos
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.

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.

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

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.

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.

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.

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.
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

