Servo MG996R con Arduino: torque, consumo, alimentación y código

El servo MG996R es el servo de referencia para los trabajos pesados en proyectos con Arduino, gracias a sus engranajes metálicos y a un torque de hasta 11 kg·cm a 6 V. Con sus 55 gramos levanta el hombro de un brazo robótico, abre una tapa pesada o mueve un soporte pan-tilt para cámara. Pero esa fuerza tiene un precio: cuando trabaja con carga, el MG996R consume hasta 2,5 A. Por eso no puedes conectarlo sin más al pin de 5V del Arduino como harías con un SG90; necesita una fuente externa de 5–6 V, GND común y un condensador cerca del servo. Si te saltas estas reglas, el servo vibra, el Arduino se reinicia una y otra vez e incluso el ordenador puede desactivar el puerto USB.

En esta guía aprenderás a interpretar el torque y el consumo del MG996R con números reales, a elegir la fuente de alimentación adecuada, a usar el rango de 500–2500 µs con la librería Servo para encontrar los límites de tu propio servo y a evitar las vibraciones y los reinicios. Después pasaremos al código para ESP32 y Raspberry Pi Pico, al módulo PCA9685 que controla 16 servos con dos cables, a la elección de servos para un brazo robótico y a la comparación con el SG90 y el MG90S.

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

El MG996R es una versión mejorada del antiguo MG995 de TowerPro: su placa de control y sus engranajes rediseñados centran mejor y dejan menos holgura. Dentro de la carcasa hay un pequeño motor DC, una caja reductora metálica que reduce 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 gestiona todo. La placa lee cada 20 ms (50 Hz) el ancho del pulso que llega por el cable de señal, compara el ángulo pedido con el que indica el potenciómetro y gira el motor hasta que la diferencia desaparece. Un pulso de unos 1500 µs corresponde a la posición central; los pulsos más cortos giran el eje hacia un lado y los más largos hacia el otro. La banda muerta de 5 µs de la hoja de datos indica que el servo no reacciona a cambios menores. Explicamos el funcionamiento general de los servos en ¿Qué es un servomotor?.

¿Qué significa el torque? Cómo leer bien el valor en kg·cm

El torque (o par) es la capacidad del servo para girar una carga a cierta distancia de su eje, y se mide como fuerza × distancia. 11 kg·cm significa que puede sostener 11 kg a 1 cm del eje o 1,1 kg a 10 cm; si la distancia se duplica, la carga que puede mover se reduce a la mitad. Para pasarlo a newton metro, multiplica por 0,098: 11 kg·cm ≈ 1,08 N·m. El detalle clave es este: el valor de la hoja de datos es el torque de bloqueo, el límite en el que el eje se detiene, la corriente llega al máximo y el servo se calienta. En uso continuo, no pasar de la mitad de ese valor mantiene el servo frío, reduce las vibraciones y alarga la vida de los engranajes.

La tabla solo tiene en cuenta la carga del extremo. En un mecanismo real también suman el peso del propio brazo, los otros servos montados en él y la pinza; tienes que multiplicar la masa de cada pieza por su distancia al eje y sumarlo todo. Por ejemplo, si un brazo de 15 cm lleva en su extremo una pinza de 150 g y un objeto de 100 g, solo esas dos piezas suman 0,25 × 15 = 3,75 kg·cm; con el peso del brazo el total puede llegar a 5 kg·cm. Eso queda justo por debajo de la mitad del torque de bloqueo del MG996R a 6 V, así que es la elección correcta. Encontrarás el cálculo de torque pieza a pieza, con un ejemplo, en la guía del brazo robótico con Arduino.

Corriente: ¿por qué el MG996R no se alimenta desde el pin de 5V del Arduino?

En reposo y sin carga, el MG996R consume solo unos 10 mA (si sostiene una carga, el valor sube con ella), pero en movimiento sube a 0,5–0,9 A, y con el eje forzado y durante los primeros milisegundos de cada arranque se acerca a 2,5 A. Cuando un Arduino Uno se alimenta por USB, la corriente total que puedes sacar del pin de 5V está limitada por el fusible de 500 mA de la placa, y una parte la consume la propia placa. En el instante en que el servo arranca, la línea de 5 V cae de forma notable durante unos milisegundos, el procesador se vuelve inestable y la placa se reinicia. Además, el ordenador puede desactivar durante un tiempo un puerto USB que detecta un exceso de corriente.

Los cables también forman parte del problema. Los cables jumper finos y los contactos de la protoboard suman fácilmente 0,2 Ω. Si lo calculas con la ley de Ohm, con un pico de 2,5 A se pierden 2,5 × 0,2 = 0,5 V solo en el cableado: la fuente de 5 V llega al servo como 4,5 V, y el servo pierde fuerza y vibra. Además, los contactos de la protoboard están pensados para aproximadamente 1 A. Conecta los cables de alimentación del MG996R directamente a una clema o a una línea de distribución soldada en lugar de a la protoboard, y usa cable de 20–22 AWG.

Alimentación correcta: 5–6 V externos, GND común y condensador

1. Elige la fuente: Usa una fuente conmutada de 5 V o 6 V capaz de dar la corriente de la tabla anterior para tu número de servos. En proyectos portátiles funcionan bien 4 pilas AA de NiMH (4,8 V) o una LiPo 2S con un regulador reductor (UBEC) ajustado a 6 V.
2. Lleva el positivo solo al servo: Conecta el positivo de la fuente al cable rojo del MG996R; no lo conectes al pin de 5V del Arduino.
3. Une las masas: Conecta el negativo de la fuente tanto al cable marrón del servo como al pin GND del Arduino. La señal es una tensión medida respecto a GND, así que sin GND común el servo no entiende los pulsos.
4. Conecta la señal: Conecta el cable naranja al pin D9 del Arduino Uno (GPIO 18 en el ESP32, GP15 en la Pico).
5. Añade un condensador: Coloca un condensador electrolítico de 470–1000 µF / 16 V entre los cables de alimentación del servo, lo más cerca posible de él; la pata marcada con la franja va al negativo. Con varios servos, calcula unos 100 µF por servo.
6. Alimenta el Arduino por separado: Hazlo funcionar por USB o por el conector DC. Así las caídas de tensión que provoca el servo no llegan al procesador.

La librería Servo y el rango de 500–2500 µs

La librería Servo de Arduino viene incluida en el IDE. Cuando escribes servo.attach(9), la librería usa por defecto el rango 544–2400 µs y asigna write(0) y write(180) a esos dos extremos; muchos MG996R se quedan algo por debajo de 180 grados con ese rango. Para ampliarlo, escribe servo.attach(9, 500, 2500). Este detalle es importante porque writeMicroseconds() tampoco puede salirse de los límites indicados en attach: si escribes writeMicroseconds(2500) sin fijarlos, la librería recorta el valor a 2400 sin avisar. Además, write() interpreta los números menores de 544 como ángulos y los mayores como microsegundos.

En el Arduino Uno, la librería Servo admite hasta 12 servos y, como usa el Timer1, analogWrite no funciona en los pines 9 y 10 mientras haya un servo conectado. Además, el límite mecánico de cada MG996R es un poco distinto: la hoja de datos del fabricante indica unos 120 grados de giro con los pulsos estándar de 1000–2000 µs, y con el rango ampliado la mayoría se acerca a 180 grados. Un servo empujado más allá de su límite choca con su tope interno, consume la corriente de bloqueo, zumba y se calienta. Por eso lo primero es encontrar el rango de pulsos seguro de tu servo con el siguiente sketch.

1#include <Servo.h>
2
3const byte SERVO_PIN = 9;          // turuncu sinyal kablosu / orange signal wire
4Servo servo;
5int pulseUs = 1500;                // orta konum / center position
6
7void setup() {
8  Serial.begin(115200);
9  servo.writeMicroseconds(pulseUs);      // önce darbe, sonra attach / pulse first, then attach
10  servo.attach(SERVO_PIN, 500, 2500);    // aralığı genişlet / widen the range
11  Serial.println(F("500-2500 arasi bir deger yaz / type a value between 500 and 2500"));
12}
13
14void loop() {
15  if (Serial.available()) {
16    long value = Serial.parseInt();             // yazılan sayıyı oku / read the typed number
17    while (Serial.available()) Serial.read();   // satır sonunu temizle / clear the line ending
18    if (value >= 500 && value <= 2500) {
19      int step = (value > pulseUs) ? 10 : -10;  // 10 µs adımlarla yavaşça git / move slowly in 10 µs steps
20      while (abs(value - pulseUs) >= 10) {
21        pulseUs += step;
22        servo.writeMicroseconds(pulseUs);
23        delay(5);
24      }
25      pulseUs = value;
26      servo.writeMicroseconds(pulseUs);
27      Serial.print(F("Darbe / pulse: "));
28      Serial.print(pulseUs);
29      Serial.println(F(" us"));
30    }
31  }
32}

1. Sube el sketch, abre el Monitor Serie a 115200 baudios y elige Nueva línea como final de línea.
2. Escribe 1500; el servo va al centro. Coloca en ese momento el brazo del servo de modo que apunte a la posición central de tu mecanismo.
3. Acércate al límite inferior bajando de 50 en 50 µs con valores como 1000, 800 y 700. Si el servo deja de moverse o empieza a zumbar, retrocede 30–50 µs desde el último valor y apunta ese número como MIN_US.
4. Haz lo mismo con el límite superior usando valores como 2000, 2200 y 2300 para encontrar MAX_US. Usarás estos dos números en los siguientes sketches.

Movimiento suave: código que reduce los picos de corriente y los tirones

Una sola orden como servo.write(160) lanza el servo hacia el objetivo a toda velocidad, recorriendo 60 grados en 0,14 segundos a 6 V. Mientras tanto, el motor consume casi su corriente de bloqueo, el mecanismo da un tirón y el objeto que sujeta puede caerse. Dividir el movimiento en pasos pequeños reduce tanto los picos de corriente como el golpe mecánico. El sketch siguiente avanza el servo 1 grado cada 15 ms (unos 67°/s) y, como usa millis(), mientras tanto puedes hacer otras cosas.

1#include <Servo.h>
2
3const byte SERVO_PIN = 9;
4const int MIN_US = 550;            // kalibrasyonda bulduğun alt sınır / lower limit from calibration
5const int MAX_US = 2450;           // kalibrasyonda bulduğun üst sınır / upper limit from calibration
6const byte STEP_MS = 15;           // derece başına süre: 15 ms ≈ 67°/sn / time per degree: 15 ms ≈ 67°/s
7
8const int POSES[] = {20, 160, 90, 45, 135};    // sırayla gidilecek açılar / angles to visit in order
9const byte POSE_COUNT = sizeof(POSES) / sizeof(POSES[0]);
10
11Servo servo;
12int current = 90;                  // şu anki açı / current angle
13int target = 90;                   // hedef açı / target angle
14byte poseIndex = 0;
15unsigned long lastStep = 0;
16unsigned long arrivedAt = 0;
17
18int angleToUs(int angle) {
19  return map(angle, 0, 180, MIN_US, MAX_US);   // açıyı darbeye çevir / angle to pulse width
20}
21
22void setup() {
23  servo.writeMicroseconds(angleToUs(current)); // önce konum, sonra attach / position first, then attach
24  servo.attach(SERVO_PIN, MIN_US, MAX_US);
25  arrivedAt = millis();
26}
27
28void loop() {
29  unsigned long now = millis();
30
31  // Hedefe 1 derecelik adımlarla yaklaş / approach the target in 1-degree steps
32  if (current != target && now - lastStep >= STEP_MS) {
33    lastStep = now;
34    current += (target > current) ? 1 : -1;
35    servo.writeMicroseconds(angleToUs(current));
36    if (current == target) arrivedAt = now;
37  }
38
39  // Hedefte 1 sn bekle, sonra sıradaki poza geç / wait 1 s at the target, then take the next pose
40  if (current == target && now - arrivedAt >= 1000) {
41    target = POSES[poseIndex];
42    poseIndex = (poseIndex + 1) % POSE_COUNT;
43  }
44
45  // Burada başka işler de yapılabilir / other tasks can run here too
46}

La función angleToUs() convierte el ángulo a un pulso entre los valores MIN_US y MAX_US que encontraste al calibrar; así 0 y 180 grados pasan a ser los extremos reales y seguros del servo. Un servo no recuerda su posición mientras está apagado y, en cuanto recibe el primer pulso, va a ese ángulo a toda velocidad. Llamar a writeMicroseconds() antes de attach() hace que la librería se salte su pulso por defecto de 1500 µs y envíe directamente tu ángulo inicial; si dejas el mecanismo en la misma postura inicial antes de apagarlo, el salto al encender casi desaparece. Ajusta la velocidad con STEP_MS: 30 ms da un movimiento lento y suave, 5 ms uno rápido pero brusco. Si quieres mover el servo con un potenciómetro, basta con convertir la lectura en ángulo y escribirla en la variable target.

Vibraciones y reinicios del Arduino: causas y soluciones

Control del MG996R con un ESP32

La librería Servo estándar de Arduino no funciona en el ESP32; instala la librería ESP32Servo desde el Gestor de librerías. Se usa casi igual: indicas el periodo con setPeriodHertz(50) y la librería no acepta límites fuera de 500–2500 µs. La salida de señal del ESP32 es de 3,3 V y la gran mayoría de los MG996R la reconocen sin problemas; si tu servo no responde o se comporta de forma inestable, añade un conversor de nivel lógico en la línea de señal. En el ejemplo siguiente, un potenciómetro conectado a GPIO 34 gira el servo. Como el ADC del ESP32 es de 12 bits, las lecturas van de 0 a 4095 y tienen algo de ruido; por eso el código filtra y usa una banda muerta.

1#include <ESP32Servo.h>
2
3const int SERVO_PIN = 18;          // servo sinyali / servo signal
4const int POT_PIN = 34;            // pot orta bacağı (ADC1) / pot wiper (ADC1)
5const int MIN_US = 500;            // ESP32Servo bu aralığın dışına çıkmaz / ESP32Servo stays within 500–2500
6const int MAX_US = 2500;
7
8Servo servo;
9float smooth = 0;                  // süzülmüş pot değeri / filtered pot value
10int lastAngle = -1;
11
12void setup() {
13  Serial.begin(115200);
14  ESP32PWM::allocateTimer(0);              // servo için zamanlayıcı ayır / reserve a timer for the servo
15  servo.setPeriodHertz(50);                // 50 Hz = 20 ms periyot / 20 ms period
16  servo.attach(SERVO_PIN, MIN_US, MAX_US);
17  smooth = analogRead(POT_PIN);
18}
19
20void loop() {
21  smooth += (analogRead(POT_PIN) - smooth) * 0.1;   // ADC gürültüsünü süz / filter ADC noise
22  int angle = map((int)smooth, 0, 4095, 0, 180);    // 12 bit ADC: 0–4095
23  if (abs(angle - lastAngle) >= 2) {                // ölü bant: titremeyi keser / deadband stops jitter
24    servo.write(angle);
25    lastAngle = angle;
26    Serial.println(angle);
27  }
28  delay(20);
29}

MG996R con la Raspberry Pi Pico (MicroPython)

En la Raspberry Pi Pico no necesitas ninguna librería extra: ajustas el PWM a 50 Hz y das el ancho de pulso en nanosegundos con duty_ns(); 500 µs son 500000 ns. La señal de la Pico también es de 3,3 V. No alimentes el servo desde el pin VBUS ni VSYS de la Pico; la corriente de esos pines viene del puerto USB del ordenador y el pico de corriente del MG996R reiniciará la Pico. Alimenta el servo con una fuente externa y une las masas. El código siguiente mueve el servo grado a grado, con suavidad, entre tres posiciones.

1from machine import Pin, PWM
2import time
3
4MIN_NS = 500000                   # 500 µs = 0 derece / 0 degrees
5MAX_NS = 2500000                  # 2500 µs = 180 derece / 180 degrees
6
7servo = PWM(Pin(15))              # turuncu kablo GP15'e / orange wire to GP15
8servo.freq(50)                    # 50 Hz servo sinyali / 50 Hz servo signal
9
10def write_angle(angle):
11    angle = max(0, min(180, angle))                           # 0–180 ile sınırla / clamp to 0–180
12    servo.duty_ns(MIN_NS + (MAX_NS - MIN_NS) * angle // 180)  # açıyı darbeye çevir / angle to pulse
13
14def move_slow(start, end, ms_per_degree=15):
15    step = 1 if end > start else -1
16    for a in range(start, end + step, step):  # 1 derecelik adımlar / 1-degree steps
17        write_angle(a)
18        time.sleep_ms(ms_per_degree)
19
20write_angle(90)                   # ortadan başla / start at the center
21time.sleep(1)
22
23while True:
24    move_slow(90, 170)
25    time.sleep(1)
26    move_slow(170, 10)
27    time.sleep(1)
28    move_slow(10, 90)
29    time.sleep(1)

16 servos con un PCA9685: muchos MG996R con dos cables

Cuando el número de servos crece, o cuando trabajas con librerías que desactivan las interrupciones, el módulo PCA9685 te facilita la vida. Esta placa es un generador PWM de 16 canales y 12 bits que se comunica con el Arduino por I2C usando solo los cables SDA y SCL. Como genera los pulsos con su propio reloj, la señal no tiembla aunque el procesador esté ocupado con otras tareas. Su dirección por defecto es 0x40; cambiando la dirección con los puentes de soldadura A0–A5 de la placa puedes conectar 62 placas al mismo bus, es decir, 992 servos en teoría. A 50 Hz, el periodo de 20 ms se divide en 4096 pasos y cada paso equivale a unos 4,9 µs: 500 µs son unos 102 pasos y 2500 µs unos 512.

1#include <Wire.h>
2#include <Adafruit_PWMServoDriver.h>
3
4Adafruit_PWMServoDriver pca = Adafruit_PWMServoDriver(0x40);   // varsayılan adres / default address
5
6const byte SERVO_COUNT = 16;
7const uint16_t MIN_US = 500;       // kalibrasyonla daralt / narrow it after calibration
8const uint16_t MAX_US = 2500;
9
10uint16_t angleToUs(float angle) {
11  return MIN_US + (uint16_t)(angle * (MAX_US - MIN_US) / 180.0);
12}
13
14void setup() {
15  pca.begin();
16  pca.setOscillatorFrequency(27000000);   // kartın gerçek saatine yakın / close to the real board clock
17  pca.setPWMFreq(50);                     // servolar için 50 Hz / 50 Hz for servos
18  delay(10);
19  for (byte ch = 0; ch < SERVO_COUNT; ch++) {
20    pca.writeMicroseconds(ch, angleToUs(90));   // hepsini ortala / center them all
21    delay(200);                                 // sırayla başlat: akım darbesini dağıt / one by one: spread the current surge
22  }
23}
24
25void loop() {
26  // Dalga: her servo komşusundan biraz geride / wave: each servo slightly behind its neighbour
27  float t = millis() / 1000.0;
28  for (byte ch = 0; ch < SERVO_COUNT; ch++) {
29    float angle = 90 + 40 * sin(t * 2.0 - ch * 0.4);   // 50–130° arası / between 50° and 130°
30    pca.writeMicroseconds(ch, angleToUs(angle));
31  }
32  delay(20);
33}

Para usar el sketch, instala la librería Adafruit PWM Servo Driver desde el Gestor de librerías. La línea setOscillatorFrequency(27000000) es importante: sobre el papel, el reloj interno del PCA9685 es de 25 MHz, pero en realidad varía entre unos 23 y 27 MHz, y los ejemplos de Adafruit usan 27 MHz. Sin este ajuste, los pulsos que fijas con writeMicroseconds() pueden desviarse unos pocos puntos porcentuales. Arrancar los servos uno a uno, con 200 ms de separación, evita que los 16 consuman la corriente de arranque a la vez. Si cada servo tiene límites distintos, convierte MIN_US y MAX_US en arrays de 16 elementos y calibra cada canal. El sketch también funciona sin cambios en el ESP32, porque allí la librería Wire usa por defecto GPIO 21 y 22.

MG996R, SG90 y MG90S: comparación

La carga y la longitud del brazo deciden. Si vas a girar una pieza de pocos gramos o solo quieres experimentar, el SG90 basta. Si quieres el mismo tamaño con engranajes metálicos resistentes a los golpes, elige el MG90S. Si el torque necesario supera 1 kg·cm, por ejemplo para llevar 100 g en el extremo de un brazo de 10 cm, pasa al MG996R. El MG996R tiene unas cinco veces el torque del SG90, pero es más lento, seis veces más pesado y consume entre tres y cuatro veces más corriente, así que planifica la alimentación y el montaje mecánico en consecuencia. Si 11 kg·cm tampoco te bastan, mira servos más grandes de la clase de 20 kg·cm, como el DS3218.

Elegir servos para un brazo robótico

• Base: MG996R. No cargues todo el peso del brazo sobre el eje del servo; pon un rodamiento en la base para que el servo solo tenga que girarlo.
• Hombro: Es la articulación más exigida. Usa un MG996R; si el brazo mide más de 20 cm, añade un servo de la clase de 20 kg·cm o un contrapeso.
• Codo: MG996R. Llevar el servo pesado a la altura del hombro y mover el codo con una varilla de empuje reduce la carga del hombro.
• Muñeca y giro de muñeca: Un MG90S es suficiente; poner aquí un MG996R solo añade peso que el hombro tiene que cargar.
• Pinza: SG90 o MG90S. Ajusta el ángulo de cierre al punto en que los dedos apenas tocan el objeto; un servo que sigue intentando apretar consume la corriente de bloqueo.
• Montaje: Coloca un brazo metálico en el eje de 25 dientes del MG996R y fíjalo con el tornillo central; los brazos de plástico se desgastan enseguida con este torque.

Ideas de proyectos con el MG996R

• Brazo robótico: Un brazo de 6 servos con MG996R en la base, el hombro y el codo y MG90S en la muñeca y la pinza; el montaje está en la guía del brazo robótico.
• Cámara pan-tilt: Gira un módulo ESP32-CAM en horizontal y vertical con dos MG996R.
• Seguidor solar: Detecta de dónde viene la luz con cuatro LDR y orienta un pequeño panel hacia el sol con un MG996R; detalles en el artículo del seguidor solar.
• Papelera inteligente: Una papelera inteligente que abre una tapa pesada al acercar la mano.
• Cerradura con tarjeta: Abre un pestillo con un MG996R cuando el RFID RC522 lee la tarjeta correcta.
• Grúa con joystick: Una pequeña grúa o excavadora que se mueve en dos ejes con un joystick.
• Tracción continua: Una rueda lenta pero potente con la versión de 360 grados del MG996R; la diferencia se explica en el artículo del servo de 360 grados.

Bien alimentado, el MG996R es un motor robusto y barato que se encarga sin esfuerzo de trabajos que los servos pequeños no pueden hacer. Recuerda las reglas: fuente externa de 5–6 V, GND común, un condensador cerca del servo, un rango de pulsos calibrado y movimientos suaves, y un PCA9685 cuando aumente el número de servos. En la app BlueGrays encontrarás proyectos como el control de servos con potenciómetro y joystick, una cerradura RFID con ESP32 y servo y una coreografía de 32 servos, cada uno con su esquema paso a paso y el código listo para usar.