Componentes · 15 min de lectura

Servo MG90S Arduino: diferencias con SG90, conexión y calibración

Cómo usar el servo MG90S con Arduino: engranajes metálicos vs SG90, torque de 2,2 kg·cm, colores de cables, calibración 500–2400 µs y código Uno, ESP32, Pico.

El servo MG90S es un microservo del mismo tamaño que el SG90 pero con engranajes metálicos: con un cuerpo de 13,4 gramos da un torque de bloqueo de 1,8 kg·cm a 4,8 V y 2,2 kg·cm a 6 V, y aguanta golpes, choques del brazo y giros accidentales a mano mucho mejor que el SG90 de engranajes plásticos. Usar el servo MG90S con Arduino es igual de fácil que un SG90: los mismos tres cables, la misma librería Servo y la misma señal de 50 Hz. Las diferencias están en los detalles: consume un poco más de corriente, su rango de pulsos cambia de una unidad a otra y, si quieres ángulos exactos, hay que calibrarlo.

En esta guía compararás las especificaciones del MG90S con las del SG90 y el MG996R y verás los colores de los cables y la conexión con Arduino Uno, ESP32 y Raspberry Pi Pico. Después aprenderás cómo el rango de pulsos de 500–2400 µs se convierte en un ángulo, cómo encontrar los límites de tu propio servo desde el Monitor Serie y cómo corregir el error de ángulo con una calibración de tres puntos. Las últimas secciones tratan el cálculo de una fuente de alimentación aparte, el control desde el celular con un ESP32, el código MicroPython para la Pico y qué articulaciones de un brazo robótico le quedan bien al MG90S.

Microservo MG90S de engranajes metálicos
MG90S: las mismas medidas que el SG90, engranajes metálicos y tres cables marrón, rojo y naranja.

¿Qué es el servo MG90S y cómo funciona?

Dentro del MG90S hay un pequeño motor DC, una caja reductora de engranajes metálicos que baja la velocidad del motor y multiplica su torque, un potenciómetro que mide el ángulo del eje de salida y una placa de control que lo coordina todo. Cada 20 ms (50 Hz) la placa mide el ancho del pulso que llega por el cable de señal, lo compara con el ángulo que marca el potenciómetro y mueve el motor hasta que la diferencia desaparece. Un pulso de unos 1500 µs significa la posición central; con pulsos más cortos el eje gira hacia un lado y con pulsos más largos hacia el otro. La banda muerta de 5 µs de la hoja de datos es la mitad de los 10 µs del SG90, así que el MG90S responde a cambios de pulso más pequeños y sostiene la posición con más precisión. Explicamos desde cero cómo funcionan los servos en ¿Qué es un servomotor?.

CaracterísticaValor
Voltaje de trabajo4,8–6 V
Torque de bloqueo1,8 kg·cm (4,8 V), 2,2 kg·cm (6 V) ≈ 0,18–0,22 N·m
Velocidad (por 60°)0,10 s (4,8 V), 0,08 s (6 V)
Corriente en reposoUnos 5–10 mA (eje quieto, sin carga)
Corriente en movimientoUnos 120–250 mA (sin carga)
Corriente de bloqueoUnos 0,7–1 A
Banda muerta5 µs
RecorridoUnos 180° con 500–2400 µs (varía entre unidades)
Señal50 Hz (periodo de 20 ms), posición según el ancho del pulso
EngranajesMetálicos, rodamiento en el eje de salida
Peso y medidas13,4 g, 22,8 × 12,2 × 28,5 mm
CableUnos 25 cm; marrón GND, rojo positivo, naranja señal
Temperatura de trabajo0–55 °C

MG90S vs SG90: engranajes, torque y corriente

Por fuera los dos servos son casi idénticos: los agujeros de montaje, el ancho del cuerpo y los brazos (horns) son compatibles, así que puedes poner un MG90S directamente en un soporte diseñado para el SG90. La verdadera diferencia está adentro. Los engranajes plásticos del SG90 se saltan dientes y se rompen cuando el brazo choca o el eje se fuerza a mano; los metálicos del MG90S casi siempre aguantan el mismo golpe sin daño. A 6 V el torque sube de 1,8 a 2,2 kg·cm y la velocidad baja a 0,08 segundos por 60 grados. A cambio, el MG90S pesa unos 4,4 gramos más, consume un poco más de corriente en bloqueo y suele costar dos o tres veces lo que un SG90. Los engranajes metálicos también pueden tener un pequeño juego: en un brazo de precisión se nota como uno o dos grados de holgura cuando la carga cambia de dirección.

CaracterísticaSG90MG90SMG996R
EngranajesPlásticoMetalMetal, doble rodamiento
Torque de bloqueo1,8 kg·cm (4,8 V)1,8 kg·cm (4,8 V), 2,2 kg·cm (6 V)9,4 kg·cm (4,8 V), 11 kg·cm (6 V)
Velocidad (por 60°)0,10 s (4,8 V)0,10 s (4,8 V), 0,08 s (6 V)0,17 s (4,8 V), 0,14 s (6 V)
Banda muerta10 µs5 µs5 µs
Peso9 g13,4 g55 g
Medidas22,2 × 11,8 × 31 mm22,8 × 12,2 × 28,5 mm40,7 × 19,7 × 42,9 mm
Voltaje de trabajo4,8–6 V4,8–6 V4,8–7,2 V
Corriente de bloqueoUnos 0,6–0,75 AUnos 0,7–1 A2,5 A (6 V)
Resistencia a golpesBaja, los dientes se rompen fácilBuenaMuy buena
Desde el pin 5V de ArduinoUn servo, carga ligeraUn servo, carga ligeraNo, siempre fuente externa
Uso típicoPrimeras pruebas, tapas ligerasMuñeca, pinza, pan-tilt, robots pequeñosHombro de brazo robótico, tapa pesada, dirección
SG90
SG90
MG90S
MG90S
MG996R
MG996R

Para elegir, primero calcula el torque que necesitas: el torque es el peso de la carga multiplicado por su distancia al eje. Una carga de 100 g a 5 cm del eje necesita 0,1 × 5 = 0,5 kg·cm. A 5 V el MG90S da unos 2 kg·cm, pero ese es el límite de bloqueo, donde el eje se detiene; en uso continuo, quedarte como máximo en la mitad, unos 1 kg·cm, mantiene el servo frío y alarga la vida de los engranajes. Con esta cuenta el MG90S lleva sin problema hasta 200 g en la punta de un brazo de 5 cm y hasta 100 g en la punta de uno de 10 cm. Si necesitas más de 1 kg·cm pasa al servo MG996R; si solo estás probando o mueves una pieza de pocos gramos, el SG90 alcanza.

Colores de los cables del MG90S y conexión

Los tres cables del MG90S siguen el código de colores de TowerPro. Algunos fabricantes usan otros colores, pero el orden casi siempre es el mismo, con el positivo en el centro. Si conectas el conector al revés, normalmente el servo no se daña, simplemente no funciona; igual corrígelo de inmediato, porque en ese caso la corriente de tierra del servo intenta pasar por el pin de señal del Arduino.

Cable (TowerPro)FunciónOtras marcasSe conecta a
MarrónGND (negativo)NegroNegativo de la fuente y GND del Arduino
RojoPositivo (4,8–6 V)Rojo5 V o positivo externo de 5–6 V
NaranjaSeñal (PWM)Amarillo o blancoUn pin digital de la placa
ConexiónArduino UnoESP32Raspberry Pi Pico
Naranja (señal)D9GPIO 18GP15
Rojo (positivo): un servo, carga ligeraPin 5VPin 5V (VIN), desde USBPin VBUS (5 V del USB)
Rojo (positivo): con carga o varios servosExterna 5–6 VExterna 5–6 VExterna 5–6 V
Marrón (GND)GND y negativo de la fuenteGND y negativo de la fuenteGND y negativo de la fuente
Potenciómetro (ejemplo Uno)Pata central a A0, extremos a 5V y GND——
Segundo servo (ejemplo Pico)——GP14
Nunca conectes el cable rojo a un pin de 3,3 V: el servo trabaja débil y fuerza el pequeño regulador de la placa. Alimenta un solo MG90S desde el pin 5V del Arduino solo para pruebas sin carga; cuando el servo se bloquea, una corriente cercana a 1 A supera el límite de 500 mA del USB y la placa se reinicia. Una batería LiPo 2S de 7,4 V pasa el límite de 6 V del MG90S; conectada directo puede quemar la placa de control. Si usas una fuente externa no olvides unir las tierras; explicamos por qué en ¿Qué es GND?.

Alimentación aparte: ¿cuántos servos y cuánta corriente?

Un MG90S consume 120–250 mA cuando se mueve sin carga, pero en los primeros milisegundos de cada arranque y cuando el eje se fuerza, la corriente salta a 0,7–1 A. Con más servos esos picos se suman. Ten en cuenta también los cables: los contactos de la protoboard y los cables jumper delgados suman fácilmente 0,2 Ω. Si lo calculas con la ley de Ohm, en un pico de 3,2 A de cuatro servos arrancando a la vez se pierden solo en los cables 3,2 × 0,2 = 0,64 V; los 5 V de la fuente llegan a los servos como 4,4 V, y los servos pierden fuerza y tiemblan. Repartir la alimentación de los servos con una bornera o una línea soldada en vez de la protoboard reduce mucho esa pérdida.

Cantidad de servosEn movimientoPeor caso (todos bloqueados)Fuente recomendada
10,12–0,25 AAprox. 1 A5V del Arduino en pruebas sin carga, 5 V 1 A con carga
2 (pan-tilt)0,25–0,5 A2 A5 V, 2 A
4 (brazo robótico pequeño)0,5–1 A4 A5 V, 3–4 A
60,75–1,5 A6 A5–6 V, 5 A y código que mueva los servos de a uno
16 (PCA9685)2–4 A16 AFuente conmutada de 5–6 V, 10 A o más
  1. Elige la fuente: usa un adaptador conmutado de 5 V o 4 pilas AA de NiMH (4,8 V). Las pilas alcalinas nuevas llegan a 1,6 V cada una, así que un portapilas de 4 puede dar 6,4 V, algo por encima del límite del MG90S.
  2. Lleva el positivo al servo: conecta el positivo de la fuente al cable rojo del servo; no lo conectes al pin 5V del Arduino.
  3. Une las tierras: conecta el negativo de la fuente tanto al cable marrón del servo como al pin GND del Arduino; sin tierra común el servo no lee bien los pulsos.
  4. Agrega un capacitor: pon un capacitor electrolítico de 470 µF / 16 V en la línea de alimentación de los servos, cerca de ellos; con varios servos suma unos 100 µF por servo. La pata marcada con la franja va al negativo.
  5. Conecta la señal: conecta el cable naranja al pin D9 del Uno y alimenta el Arduino por separado desde el USB o su jack DC.
Si tienes un adaptador de 12 V, con un módulo LM2596 puedes ajustar la salida a 5–6 V y alimentar sin problema hasta tres MG90S. En un proyecto con baterías calcula la autonomía con la calculadora de duración de batería; la corriente media de los servos puede variar diez veces según se muevan todo el tiempo o solo de vez en cuando.

El rango de pulsos de 500–2400 µs y la librería Servo

Con la librería Servo que viene con el IDE de Arduino, al escribir servo.attach(9) el rango por defecto es 544–2400 µs, y write(0) y write(180) se asignan a esos dos extremos. La mayoría de los MG90S necesitan para 0 grados un pulso más corto que 544 µs, así que con la configuración por defecto el servo se queda unos grados corto en un extremo. Indicar el rango con servo.attach(9, 500, 2400) lo soluciona. Este detalle importa porque writeMicroseconds() tampoco puede salirse de los límites dados en attach; sin ellos, los 500 µs que escribes se suben en silencio a 544. En el rango de 500–2400 µs un grado equivale a unos 1900 / 180 ≈ 10,6 µs. Como la banda muerta del MG90S es de 5 µs, con writeMicroseconds() puedes dar incluso pasos de medio grado.

Ánguloattach(9) por defecto (544–2400)attach(9, 500, 2400)Nota
0°544 µs500 µsEn el extremo cambia unos grados
45°1008 µs975 µs—
90°1472 µs1450 µsEl centro real suele estar entre 1450 y 1550 µs
135°1936 µs1925 µs—
180°2400 µs2400 µsRedúcelo si choca con el tope mecánico

Los valores de la tabla son calculados; en un servo real el pulso para 90 grados puede ser 1500 o 1520 µs en lugar de 1450. Algunas hojas de datos dicen que 1000–2000 µs dan el recorrido completo, pero en la práctica con ese rango el MG90S solo gira 90–100 grados. Si llevas el pulso más allá del límite mecánico, el servo empuja contra su tope interno, zumba, consume corriente de bloqueo y se calienta; como los engranajes metálicos soportan ese esfuerzo en silencio, no notas el problema tan rápido como con un SG90. Por eso lo primero es medir los límites de tu propio servo.

Calibración del ángulo: encuentra los límites de tu MG90S

El código de abajo mueve el servo en pasos de 10 µs con los caracteres que escribes en el Monitor Serie. + alarga el pulso, - lo acorta y c vuelve al centro (1500 µs); con n guardas el valor actual como límite inferior y con x como límite superior. Después de cada guardado, el código imprime la línea attach lista para tus próximos programas. Para dar varios pasos a la vez escribe +++++ y presiona Enter; el servo avanza cinco pasos, es decir, 50 µs.

C++ (Arduino IDE)
1#include <Servo.h>
2
3const byte SERVO_PIN = 9;          // turuncu sinyal kablosu / orange signal wire
4const int STEP_US = 10;            // her + ya da - için 10 µs / 10 µs per + or -
5
6Servo servo;
7int pulseUs = 1500;                // ortadan başla / start at the center
8int minUs = 1000;                  // bulunacak alt sınır / lower limit to find
9int maxUs = 2000;                  // bulunacak üst sınır / upper limit to find
10
11void printPulse() {
12  Serial.print(F("Darbe / pulse: "));
13  Serial.print(pulseUs);
14  Serial.println(F(" us"));
15}
16
17void setup() {
18  Serial.begin(115200);
19  servo.writeMicroseconds(pulseUs);      // önce darbe, sonra attach / pulse first, then attach
20  servo.attach(SERVO_PIN, 500, 2500);    // geniş aralık: sınırı sen bulacaksın / wide range: you find the limits
21  Serial.println(F("+ / - : 10 us | c: 1500 us | n: min | x: max"));
22  printPulse();
23}
24
25void loop() {
26  if (!Serial.available()) return;
27  char key = Serial.read();
28  if (key == '+') pulseUs += STEP_US;
29  else if (key == '-') pulseUs -= STEP_US;
30  else if (key == 'c') pulseUs = 1500;
31  else if (key == 'n') minUs = pulseUs;    // alt sınırı kaydet / save the lower limit
32  else if (key == 'x') maxUs = pulseUs;    // üst sınırı kaydet / save the upper limit
33  else return;                             // Enter ve diğer tuşları yok say / ignore Enter and other keys
34
35  pulseUs = constrain(pulseUs, 500, 2500);
36  servo.writeMicroseconds(pulseUs);
37  printPulse();
38
39  if (key == 'n' || key == 'x') {          // hazır attach satırı / ready-made attach line
40    Serial.print(F("servo.attach(9, "));
41    Serial.print(minUs);
42    Serial.print(F(", "));
43    Serial.print(maxUs);
44    Serial.println(F(");"));
45  }
46}
  1. Conecta el servo sin carga, sube el código y abre el Monitor Serie a 115200 baudios.
  2. Escribe c y presiona Enter; el servo va a 1500 µs. Coloca el brazo del servo en el diente más cercano al centro de tu mecanismo.
  3. Ve hacia el extremo inferior con -. Cuando el servo ya no gire, zumbe o tiemble, regresa 3–4 pasos (30–40 µs) y escribe n.
  4. Haz lo mismo con + para el extremo superior y escribe x. Anota la línea servo.attach(9, MIN, MAX) que aparece en el Monitor Serie.
  5. Encuentra los 90 grados con un transportador dibujado en papel o impreso: guarda como US_90 el pulso con el que el brazo queda perfectamente vertical.

Por los dientes del eje del servo, el brazo solo se puede colocar en saltos fijos, así que casi nunca queda justo en el centro y esos pocos grados de diferencia los corriges por software. Además, la relación entre pulso y ángulo de un servo no es perfectamente lineal: un mapeo de dos puntos que clava 0 y 180 grados puede desviarse 3–5 grados a mitad de recorrido. La calibración de tres puntos elimina ese error: usas los tres pulsos medidos para 0, 90 y 180 grados y llamas a la función map() por separado para cada mitad. El código de abajo usa este método para pasar al servo el ángulo leído de un potenciómetro conectado en A0.

C++ (Arduino IDE)
1#include <Servo.h>
2
3const byte SERVO_PIN = 9;          // turuncu kablo / orange wire
4const byte POT_PIN = A0;           // potansiyometre orta bacağı / potentiometer wiper
5
6// Kalibrasyonda ölçtüğün üç nokta / the three points you measured
7const int US_0 = 520;              // 0 derece / 0 degrees
8const int US_90 = 1480;            // korna tam dik / horn exactly upright
9const int US_180 = 2380;           // 180 derece / 180 degrees
10
11Servo servo;
12float smoothAngle = 90;            // süzülmüş açı / filtered angle
13int lastAngle = -1;
14
15int angleToUs(int angle) {
16  angle = constrain(angle, 0, 180);
17  if (angle <= 90) return map(angle, 0, 90, US_0, US_90);   // alt yarı / lower half
18  return map(angle, 90, 180, US_90, US_180);                // üst yarı / upper half
19}
20
21void setup() {
22  servo.writeMicroseconds(angleToUs(90));   // açılışta ortada başla / start centered
23  servo.attach(SERVO_PIN, US_0, US_180);
24}
25
26void loop() {
27  int target = map(analogRead(POT_PIN), 0, 1023, 0, 180);
28  smoothAngle += (target - smoothAngle) * 0.15;   // gürültüyü süz / filter the noise
29  int angle = (int)(smoothAngle + 0.5);
30  if (abs(angle - lastAngle) >= 2) {             // 2 derecelik ölü bant / 2-degree deadband
31    servo.writeMicroseconds(angleToUs(angle));
32    lastAngle = angle;
33  }
34  delay(15);
35}

Reemplaza US_0, US_90 y US_180 por tus propias medidas. angleToUs() mapea 0–90 entre los dos primeros puntos y 90–180 entre los dos últimos, así la posición en la que el brazo queda vertical es de verdad 90 grados. Usar writeMicroseconds() también evita que write() redondee a grados enteros. Las pocas cuentas de ruido en la lectura del potenciómetro se eliminan con un filtro sencillo de coeficiente 0,15 y una banda muerta de 2 grados; sin banda muerta el servo se mueve sin parar en su lugar. Las otras causas del temblor las vemos en detalle en servo que tiembla. En el Uno la librería Servo usa el Timer1, por eso con un servo conectado analogWrite() no funciona en los pines D9 y D10.

MG90S con ESP32: control desde el celular con un deslizador

En el ESP32 la librería Servo estándar de Arduino no funciona; instala la librería ESP32Servo desde el Gestor de librerías. Funciona con las versiones 2.x y 3.x del core ESP32, recibe el periodo con setPeriodHertz(50) y no acepta límites fuera de 500–2500 µs. La salida de señal del ESP32 es de 3,3 V y prácticamente todos los MG90S la leen sin problema. El código de abajo conecta el ESP32 a tu red Wi-Fi; abre la dirección IP que aparece en el Monitor Serie en un celular conectado a la misma red y verás un deslizador: en cuanto lo sueltas, el servo gira a ese ángulo.

C++ (Arduino IDE)
1#include <WiFi.h>
2#include <WebServer.h>
3#include <ESP32Servo.h>
4
5const char* ssid = "AgAdi";          // Wi-Fi adın / your Wi-Fi name
6const char* password = "Sifre123";   // Wi-Fi şifren / your Wi-Fi password
7const int SERVO_PIN = 18;            // turuncu kablo / orange wire
8const int MIN_US = 500;              // kalibrasyon değerlerin / your calibration values
9const int MAX_US = 2400;
10
11WebServer server(80);
12Servo servo;
13int currentAngle = 90;
14
15const char PAGE[] = R"rawliteral(<!DOCTYPE html><html><head>
16<meta name="viewport" content="width=device-width,initial-scale=1"><title>MG90S</title></head>
17<body style="font-family:sans-serif;text-align:center">
18<h2>MG90S: <span id="v">90</span>&deg;</h2>
19<input id="s" type="range" min="0" max="180" value="90" style="width:90%">
20<script>
21const s = document.getElementById('s'), v = document.getElementById('v');
22s.oninput = () => v.textContent = s.value;
23s.onchange = () => fetch('/set?a=' + s.value);
24</script></body></html>)rawliteral";
25
26void handleRoot() {
27  server.send(200, "text/html", PAGE);
28}
29
30void handleSet() {
31  if (server.hasArg("a")) {
32    currentAngle = constrain(server.arg("a").toInt(), 0, 180);   // 0–180 ile sınırla / clamp to 0–180
33    servo.write(currentAngle);
34  }
35  server.send(200, "text/plain", String(currentAngle));
36}
37
38void setup() {
39  Serial.begin(115200);
40  servo.setPeriodHertz(50);                  // 50 Hz servo sinyali / 50 Hz servo signal
41  servo.attach(SERVO_PIN, MIN_US, MAX_US);
42  servo.write(currentAngle);
43
44  WiFi.begin(ssid, password);
45  while (WiFi.status() != WL_CONNECTED) delay(300);
46  Serial.print(F("IP: "));
47  Serial.println(WiFi.localIP());            // bu adresi telefonda aç / open this address on your phone
48
49  server.on("/", handleRoot);
50  server.on("/set", handleSet);
51  server.begin();
52}
53
54void loop() {
55  server.handleClient();
56}

Cuando el ESP32 enciende el Wi-Fi consume por un instante hasta 250 mA; si la corriente de arranque del servo cae en la misma línea USB, la placa muestra "Brownout detector was triggered" y se reinicia. Alimenta el servo con una fuente de 5 V aparte y une las tierras; los detalles están en error brownout del ESP32. Para la señal sirven bien los GPIO 13, 18, 19, 23, 25, 26 y 27; no uses los GPIO 6–11, que van a la memoria flash, ni los 34–39, que son solo de entrada.

MG90S con Raspberry Pi Pico (MicroPython)

En la Raspberry Pi Pico no hace falta ninguna librería extra: configuras el PWM a 50 Hz y das el ancho del pulso en nanosegundos con duty_ns(). La pequeña clase MicroServo de abajo guarda los valores de calibración de cada servo y avanza de a un grado para un movimiento suave. En el ejemplo, la muñeca de un brazo robótico está en GP15 y la pinza en GP14. En la Pico estos dos pines comparten el mismo slice de PWM (slice 7) y por lo tanto la frecuencia; no hay problema porque ambos usan 50 Hz, pero si pones otro pin del mismo slice a 1 kHz para el brillo de un LED, el servo también se descontrola. Para dos servos usa una fuente externa de 5 V en lugar de VBUS y une las tierras.

MicroPython
1from machine import Pin, PWM
2import time
3
4class MicroServo:
5    def __init__(self, pin, min_us=500, max_us=2400):
6        self.pwm = PWM(Pin(pin))
7        self.pwm.freq(50)                  # 50 Hz = 20 ms periyot / 20 ms period
8        self.min_us = min_us               # bu servonun kalibrasyonu / this servo's calibration
9        self.max_us = max_us
10        self.angle = None
11
12    def write(self, angle):
13        angle = max(0, min(180, angle))   # 0–180 ile sınırla / clamp to 0–180
14        us = self.min_us + (self.max_us - self.min_us) * angle / 180
15        self.pwm.duty_ns(int(us * 1000))  # µs -> ns
16        self.angle = angle
17
18    def move_to(self, target, ms_per_degree=10):
19        if self.angle is None:            # ilk komut: doğrudan git / first command: go directly
20            self.write(target)
21            return
22        step = 1 if target > self.angle else -1
23        for a in range(int(self.angle), int(target) + step, step):
24            self.write(a)                 # derece derece ilerle / move degree by degree
25            time.sleep_ms(ms_per_degree)
26
27    def off(self):
28        self.pwm.duty_ns(0)               # sinyali kes, servo serbest / stop the signal, servo goes limp
29
30wrist = MicroServo(15, 520, 2380)        # bilek GP15 / wrist on GP15
31gripper = MicroServo(14, 600, 2300)      # kıskaç GP14, aynı PWM dilimi / gripper on GP14, same PWM slice
32
33wrist.write(90)
34gripper.write(20)
35time.sleep(1)
36
37while True:
38    gripper.move_to(70)                  # kıskacı kapat / close the gripper
39    wrist.move_to(150)
40    time.sleep(0.5)
41    wrist.move_to(30)
42    gripper.move_to(20)                  # kıskacı aç / open the gripper
43    time.sleep(1)

MG90S en un brazo robótico: ¿para qué articulación sirve?

Los brazos robóticos pequeños de 4 ejes, de acrílico o impresos en 3D, suelen armarse con cuatro microservos, y ahí el MG90S dura mucho más que el SG90: cuando el brazo choca o alguien fuerza la pinza con la mano, lo primero que se rompe son los engranajes plásticos. En un brazo más grande, el MG90S solo se usa en las articulaciones del extremo. La cuenta es sencilla: multiplica el peso de cada pieza que va después de la articulación por su distancia al eje y suma todo. Una pinza de 40 g a 6 cm y un objeto de 50 g a 8 cm cargan el servo de la muñeca con 0,04 × 6 + 0,05 × 8 = 0,64 kg·cm, por debajo del límite seguro del MG90S de unos 1 kg·cm a 5 V.

ArticulaciónCarga típica¿Sirve el MG90S?
Base (giro)Baja si el peso del brazo descansa en un rodamientoSí en brazos pequeños, MG996R en los grandes
HombroLa más alta, 2–5 kg·cmSolo en brazos muy livianos; normalmente MG996R
CodoMedia, 1–3 kg·cmSí en brazos cortos
MuñecaBaja, 0,3–1 kg·cmSí, ideal
PinzaBaja, pero con riesgo de apretar sin pararSí; limita el ángulo de cierre según el objeto

El error más común en la pinza es mandar el servo más allá del ángulo en el que agarra el objeto. Como no puede llegar a la posición, el servo consume corriente de bloqueo todo el tiempo, se calienta y en pocos minutos el motor o la placa de control pueden dañarse. Ajusta el ángulo de cierre al punto en el que las mordazas apenas tocan el objeto o, después de agarrarlo, retrocede unos grados. Encuentras el cálculo completo del torque y cómo armar un brazo de 6 ejes en la guía de brazo robótico con Arduino; si quieres manejar más de seis servos con una sola placa, el controlador de servos PCA9685 te facilita el trabajo.

Ideas de proyectos con el MG90S

  • Soporte pan-tilt para cámara: gira un módulo ESP32-CAM en horizontal y vertical con dos MG90S; los engranajes metálicos aguantan las vibraciones.
  • Radar con Arduino: barre un sensor HC-SR04 de 0 a 180 grados con un MG90S y dibuja una pantalla de radar; el armado está en proyecto de radar con Arduino.
  • Bote de basura inteligente: un bote de basura inteligente que abre una tapa liviana cuando acercas la mano.
  • Comedero automático para mascotas: un comedero automático que abre y cierra una compuerta a horas fijas.
  • Robot evasor de obstáculos: un servo de cuello que gira el sensor de distancia a izquierda y derecha; mira la guía del robot evasor de obstáculos.
  • Mini seguidor solar: encuentra la dirección de la luz con dos LDR y orienta un panel pequeño con un MG90S; los detalles están en seguidor solar.
  • Trabajos con giro continuo: para una rueda o una cinta transportadora usa un servo de 360 grados en lugar del MG90S.

Errores comunes y cómo resolverlos

SíntomaCausa probableSolución
El servo se queda unos grados corto en un extremoEl rango por defecto de 544–2400 µsEscribe attach(9, 500, 2400) y calibra
Zumba y se calienta en el extremoEl pulso pasa el límite mecánicoRedúcelo a los valores MIN y MAX que encontraste
El Arduino se reinicia cuando el servo se mueveEl servo se alimenta del USB por el pin 5VFuente externa de 5 V, tierra común y capacitor de 470 µF
Tiembla estando quietoAlimentación débil, cables largos y delgados o ruido del potenciómetroCables gruesos, capacitor, filtro y banda muerta
No responde o se mueve al azarEl GND de la fuente externa no está unido al ArduinoConecta el negativo de la fuente al GND del Arduino
Hace clic con carga y el eje patinaSe rompió un diente o el tornillo del brazo está flojoCambia el juego de engranajes y aprieta el tornillo central
Mucho menos torque del esperado, el servo pesa 9 gCopia con engranajes plásticosPesa el servo: un MG90S original pesa unos 13–14 g
Al encender, el servo da un salto bruscoattach() envía 1500 µs como primer pulsoAntes de attach() da el pulso inicial con writeMicroseconds()
Si el servo no tiene que sostener una carga, corta la señal con servo.detach() cuando llegue a su posición; el servo se calla y casi no consume corriente. Pero sin señal también desaparece el torque de sujeción, así que no uses detach en las articulaciones del brazo que cargan peso. Girar el eje a la fuerza con la mano quizá no rompa los engranajes metálicos, pero castiga el motor y el potenciómetro internos; gira el brazo siempre con suavidad y con el servo apagado.

El MG90S es la elección correcta para cualquier proyecto que pida un servo más resistente y un poco más fuerte sin salirse del tamaño del SG90. Recuerda las reglas: fuente externa de 5 V para todo lo que no sea carga ligera, tierra común, un capacitor cerca del servo, un rango de pulsos que empieza en 500–2400 µs y se ajusta con la calibración, y un ángulo de cierre limitado en la pinza. En la app BlueGrays encontrarás control de servos con potenciómetro y joystick, una cerradura RFID con servo para ESP32 y una coreografía con 32 servos, cada uno con diagrama del circuito paso a paso y código listo para usar.

Preguntas frecuentes

¿Cuál es la diferencia entre el servo MG90S y el SG90?

Tienen el mismo tamaño y los mismos cables, pero el MG90S lleva engranajes metálicos y a 6 V da 2,2 kg·cm de torque, mientras que el SG90, con engranajes plásticos, ronda 1,8 kg·cm y se le rompen los dientes con facilidad en un golpe. El MG90S pesa unos 13,4 g frente a los 9 g del SG90 y en bloqueo consume un poco más de corriente. En el código no cambia nada: los dos funcionan con la misma librería Servo.

¿Cuánto peso levanta un servo MG90S?

El torque de bloqueo del MG90S es de 1,8 kg·cm a 4,8 V y 2,2 kg·cm a 6 V; o sea, a 1 cm del eje apenas sostiene unos 2 kg. Para uso continuo cuenta con la mitad del torque: unos 200 g en la punta de un brazo de 5 cm y unos 100 g en la punta de uno de 10 cm.

¿Puedo alimentar el MG90S desde el pin 5V del Arduino?

Para pruebas sin carga, un solo MG90S funciona desde el pin 5V del Arduino. Pero cuando el servo se fuerza, una corriente cercana a 1 A supera el límite de 500 mA del USB y el Arduino se reinicia. En proyectos con carga o varios servos usa una fuente externa de 5 V y une las tierras.

¿El MG90S gira 180 o 360 grados?

El MG90S estándar gira unos 180 grados; para el recorrido completo suele necesitar pulsos de 500–2400 µs y los límites cambian de una unidad a otra. También se venden versiones de giro continuo de 360 grados, pero en esas controlas velocidad y sentido, no el ángulo.

¿Por qué mi servo MG90S tiembla o zumba?

La causa más común es una alimentación débil: un servo alimentado por USB hace caer el voltaje al arrancar. Si zumba en los extremos, el rango de pulsos pasa el límite mecánico; redúcelo calibrando. Si tiembla al controlarlo con un potenciómetro, filtra la lectura y agrega una banda muerta de 1–2 grados.

¿El MG90S funciona con ESP32 y señal de 3,3 V?

Sí. La placa de control del MG90S lee sin problema una señal de 3,3 V; en el ESP32 basta con la librería ESP32Servo y en la Pico con la clase PWM de MicroPython. La alimentación del servo debe seguir siendo de 5 V; no lo alimentes desde el pin de 3,3 V.

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