Servomotores

01 · Punto de partida

Un lazo cerrado en una caja

En el tema 31 construimos un lazo de velocidad: encoder, comparación con el objetivo, corrección del PWM. Un servo es lo mismo, pero ya armado, para la posición angular. Por dentro tiene:

• un motor DC pequeño (tema 30),
• un reductor de engranajes (plástico o metal) que multiplica el par,
• un potenciómetro en el eje de salida, que mide el ángulo (en algunos servos, un sensor magnético),
• y una placa de control con un puente H, que compara la posición medida con la pedida y mueve el motor hasta que coinciden.

Desde afuera tiene solo tres cables: alimentación (rojo, 4,8 a 6 V), masa (marrón o negro) y señal (naranja o amarillo). La información no viaja como tensión ni como corriente, sino en el ancho de un pulso. Para el programa es una función irA(ángulo): no hay que medir nada ni calcular un PID. A cambio, no se puede leer en qué posición está realmente (un servo común no informa su posición), ni cambiar su control interno.

02 · Cómo se le dice a dónde ir

La señal de 50 Hz

El servo espera un pulso positivo cada 20 ms (50 Hz). La duración del pulso fija el ángulo:

• 1,0 ms → un extremo (0°)
• 1,5 ms → el centro (90°)
• 2,0 ms → el otro extremo (180°)

El pulso ocupa entre el 5 y el 10 % del período (7,5 % en el centro), y el resto del tiempo la línea está en bajo. Muchos servos (como el SG90) aceptan un rango más amplio, de unos 0,5 ms a 2,4 ms para recorrer los 180° completos, y la librería Servo de Arduino usa por defecto 544 µs a 2400 µs. La relación es lineal:

Cada modelo de servo tiene su rango real, y no todos recorren 180°. Si el rango de la librería es mayor que el del servo, las puntas del rango hacen que el servo empuje contra su tope mecánico; si es menor, no llega al extremo. Por eso se recomienda calibrar los pulsos mínimo y máximo de cada servo (con attach(pin, min, max) o writeMicroseconds) y limitar el ángulo por software.

Dos propiedades de la señal: el servo tiene una banda muerta (unos ±5 a ±10 µs), dentro de la cual no se mueve, para no vibrar por pequeñas variaciones; y es sensible al jitter (variación del ancho del pulso), que produce temblor visible. Una señal generada por software con interrupciones mal atendidas hace temblar al servo; por eso se prefieren timers de hardware.

03 · Cuántos ángulos distintos

Resolución y librerías

La resolución efectiva depende de cómo se genera el pulso:

• Servo.write(grados) (Arduino): recibe un entero, un paso por grado. Con el rango 544–2400 µs, un grado equivale a 1856 / 180 = 10,3 µs.
• Servo.writeMicroseconds(us): da un paso de 1 µs, o 0,097° con ese rango. Es la forma de mover fino.
• Controlador PCA9685 (16 canales por I2C, tema 33 de Microcontroladores): genera los pulsos con un contador de 12 bits en un período de 20 ms. Cada «tick» dura 20 000 / 4096 = 4,88 µs. Con un servo de 1000 a 2000 µs para 180°, un tick equivale a 0,88°.

Por ejemplo, con el PCA9685 y ese servo, para 90° (1500 µs) se programan 307 ticks (1499 µs, 89,82°); para 135° (1750 µs), 358 ticks (1748 µs, 134,65°); el error de cuantización llega a ±0,35°. Es una limitación del conversor, y la resolución mecánica real del servo suele ser comparable (la banda muerta y el juego de los engranajes llegan a un grado).

#include <Servo.h>

Servo servo;
const uint8_t PIN_SERVO = 9;
const uint16_t US_MIN = 500, US_MAX = 2400;          // calibrados para este servo
const float ANG_MIN = 10, ANG_MAX = 170;             // límites de software, dentro del recorrido mecánico

void irAImediato(float grados) {
    grados = constrain(grados, ANG_MIN, ANG_MAX);
    servo.writeMicroseconds(US_MIN + (grados / 180.0) * (US_MAX - US_MIN));
}

void setup() {
    servo.attach(PIN_SERVO, US_MIN, US_MAX);
    irAImediato(90);                                  // posición inicial conocida
}

04 · Fuerza disponible

Torque y consumo

El torque de un servo se da en kg·cm (la fuerza en kilogramos que ejerce en un punto a 1 cm del eje); 1 kg·cm ≈ 0,098 N·m. Depende de la tensión de alimentación y se indica como torque de bloqueo (stall), el máximo antes de que el servo se detenga. Valores típicos aproximados: un SG90 de 9 g, 1,8 kg·cm con 4,8 V (2,2 con 6 V); un MG996R de 55 g, 9,4 kg·cm con 4,8 V (11 con 6 V).

Para saber si un servo alcanza, se calcula el torque que exige la carga: T = peso × distancia al eje. Un brazo de 4 cm que sostiene 0,3 kg exige 1,2 kg·cm: el 67 % del torque de bloqueo de un SG90. La regla práctica es no pasar del 50 % del torque de bloqueo en servicio continuo: cerca del límite, el servo se calienta, tiembla y se desgasta.

La corriente es proporcional al esfuerzo: un servo en reposo y sin carga toma unos 10 mA; al moverse, 100 a 300 mA; bloqueado, cerca de su corriente de bloqueo (unos 650 mA para un SG90, hasta 2,5 A para un MG996R). Un servo que «sostiene» una carga pesada o empuja contra su tope consume continuamente y se calienta, como el motor bloqueado del tema 30. Esa es la causa de los servos que zumban.

05 · La fuente

Alimentación y ruido

El error más frecuente: alimentar los servos desde el pin de 5 V de la placa. Un puerto USB entrega 500 mA como máximo y la placa comparte esa corriente con todo; un solo servo bloqueado puede superarlo y reiniciar el microcontrolador. Prácticas:

• Fuente propia para los servos (5 o 6 V, con corriente para el pico de todos los servos que se mueven a la vez), con masa común con el microcontrolador.
• Capacitor de 470 a 1000 µF en la alimentación de los servos, cerca de ellos, para los picos de arranque.
• Cables gruesos y cortos para la alimentación: la resistencia del cableado hunde la tensión con la corriente.
• Línea de señal alejada de los cables de potencia.

Un ejemplo con cuatro servos SG90 y una fuente de 5 V con 0,5 Ω de resistencia total de cableado: en reposo (10 mA cada uno) la tensión es de 4,98 V; los cuatro moviéndose a la vez (250 mA cada uno, 1 A) bajan la tensión a 4,50 V, por debajo del mínimo del servo (4,8 V) y de lo que necesita un regulador; los cuatro bloqueados (650 mA cada uno, 2,6 A) la dejan en 3,70 V: el sistema se reinicia. Con un solo servo bloqueado, 4,67 V. El dimensionamiento correcto toma el pico simultáneo, no el promedio.

06 · Cómo moverlo bien

Límites y movimiento suave

Tres cuidados de programación:

• Límites de software. Si se ordena un ángulo fuera del recorrido mecánico, el servo empuja contra el tope con todo su torque, consume la corriente de bloqueo y se estropea. Se limita el ángulo (constrain) dentro del rango seguro, con margen respecto de los topes.
• Posición inicial. Un servo no informa su posición. Al encender, el programa no sabe dónde está, y el primer pulso lo hace saltar a la posición ordenada a velocidad máxima, con un pico de corriente. Se arranca con una posición inicial segura y se mueve suavemente desde ahí.
• Movimiento suave. Si se ordena un cambio grande de golpe, el lazo interno lleva el motor a velocidad máxima: movimiento brusco, tirones en la estructura y un pico de corriente. Se evita avanzando el ángulo de a pasos pequeños, con una velocidad máxima (limitación de velocidad), de forma no bloqueante.

float actual = 90, objetivo = 90;                    // grados
const float VELOCIDAD = 90.0;                         // °/s máxima
const uint16_t T_PASO = 20;                           // ms, sincronizado con el frame de 20 ms
uint32_t tPaso = 0;

void irA(float grados) { objetivo = constrain(grados, ANG_MIN, ANG_MAX); }

void actualizarServo() {                              // se llama en cada vuelta del loop (tema 41)
    if (millis() - tPaso >= T_PASO) {
        tPaso += T_PASO;
        float maxPaso = VELOCIDAD * T_PASO / 1000.0;  // 1,8° por paso
        float dif = objetivo - actual;
        actual += constrain(dif, -maxPaso, maxPaso);
        irAImediato(actual);
    }
}

Es la misma rampa que usábamos con el motor DC (tema 30), pero para la posición. Si el programa necesita saber cuándo el servo llegó, como no hay realimentación, se estima por el tiempo que debería tardar (la velocidad máxima del modelo, por ejemplo 0,1 s por cada 60°) o se agrega un sensor aparte. Y si se quiere que deje de consumir y de temblar cuando no hace falta mantener la posición, se puede detach(), a costa de que el servo quede flojo y pueda moverse con la carga.

07 · Cuando el ángulo no importa

Servos de rotación continua

Un servo de rotación continua es un servo común con el potenciómetro desacoplado (o reemplazado por un divisor fijo): el controlador cree que está siempre en el centro y, por eso, no sabe cuándo llegó. Ahora el pulso ya no fija un ángulo sino la velocidad y el sentido:

• 1,5 ms: detenido (se ajusta con un pequeño tornillo para que no gire solo).
• Menos de 1,5 ms (por ejemplo 1,3 ms): gira en un sentido; cuanto más lejos del centro, más rápido.
• Más de 1,5 ms (1,7 ms): gira en el sentido contrario.

Se obtiene un motor con reductor y driver incluidos, que se controla con un solo pin y se usa en ruedas de robots pequeños. Lo que se pierde: no hay control de posición ni de velocidad medida (la velocidad depende de la carga y de la batería), y el punto de parada deriva con la temperatura. Para movimientos con medición, un motor DC con encoder (tema 31) es mejor; para robots didácticos simples, el servo de rotación continua es práctico.

08 · Más allá del servo básico

Digitales, de bus y varios servos

• Servos analógicos y digitales. La señal de entrada es la misma. La diferencia es interna: un servo digital actualiza su lazo de control a unos 300 Hz en lugar de 50 Hz, con lo que reacciona más rápido y sostiene mejor la posición, a cambio de mayor consumo y de ruido de alta frecuencia.
• Servos de bus (Dynamixel, Feetech, Lewansoul): se conectan en cadena por un bus serie, con un identificador cada uno; el programa puede leer la posición, la temperatura, la carga y la tensión, y configurar límites de torque. Son los de los robots articulados.
• Muchos servos. Generar 12 señales con los timers de un microcontrolador es posible pero incómodo; un PCA9685 entrega 16 canales con un solo bus I2C y libera al procesador de generar pulsos. Los servos que se mueven a la vez suman sus corrientes: conviene escalonar los arranques.

09 · Elegir

Comparación y elección

El servo es ideal para ángulos limitados y cargas moderadas (brazos pequeños, timones, tapas, cámaras orientables). Para giro continuo, precisión alta o cargas grandes, un motor DC con encoder o un paso a paso.

10 · Analogía con programación

Pulsos, torque, fuente y movimiento

Calculemos las cuatro cosas del tema: el ancho de pulso y la cuantización del PCA9685, el porcentaje de torque según la palanca, la tensión de la fuente con varios servos y el efecto de limitar la velocidad en una orden de 0° a 180°, con un modelo simplificado de servo (velocidad proporcional al error con un tope de 600°/s, corriente proporcional a la velocidad).

# ---- 1. Pulso según el ángulo y cuantización del PCA9685 (12 bits en 20 ms) ----
def ancho_us(angulo, minimo, maximo):
    return minimo + angulo / 180 * (maximo - minimo)


print("ángulo  544-2400  1000-2000  500-2500")
for a in (0, 45, 90, 135, 180):
    print(f"{a:6d}  {ancho_us(a, 544, 2400):8.0f}  {ancho_us(a, 1000, 2000):9.0f}  {ancho_us(a, 500, 2500):8.0f}")
print(f"Servo.write: {(2400 - 544) / 180:.1f} µs por grado; writeMicroseconds: {180 / (2400 - 544):.3f}° por µs")

TICK = 20000 / 4096
print(f"PCA9685: tick de {TICK:.2f} µs = {TICK / 1000 * 180:.2f}° con 1000-2000 µs")
print("ángulo  ticks   µs reales  ángulo real  error")
for a in (0, 45, 90, 135, 180):
    ticks = round(ancho_us(a, 1000, 2000) / TICK)
    real = ticks * TICK
    ang_real = (real - 1000) / 1000 * 180
    print(f"{a:6d}  {ticks:5d}  {real:9.1f}  {ang_real:11.2f}  {ang_real - a:+.2f}°")

# ---- 2. Torque de una palanca con un SG90 (1,8 kg·cm) ----
BLOQUEO, MASA = 1.8, 0.3
print()
for cm in (2, 3, 4, 5, 6):
    par = MASA * cm
    print(f"{cm} cm: {par:.2f} kg·cm = {100 * par / BLOQUEO:.0f} % del bloqueo")

# ---- 3. Fuente de 5 V con 0,5 Ω de cableado y 4 servos SG90 ----
print()
for descripcion, n, corriente in (("en reposo", 4, 0.01), ("moviéndose", 4, 0.25), ("bloqueados", 4, 0.65), ("1 bloqueado", 1, 0.65)):
    total = n * corriente
    print(f"{descripcion:12s}: {total:4.2f} A -> {5.0 - total * 0.5:.2f} V en los servos")


# ---- 4. Orden de 0° a 180° con distintas velocidades de comando ----
def mover(objetivo, velocidad_cmd, total=3.0):
    KP, VMAX, I_REPOSO, I_MOV, dt = 15.0, 600.0, 10.0, 250.0, 1e-3
    th = pico = energia = 0.0
    t95 = None
    for k in range(round(total / dt)):
        t = k * dt
        cmd = objetivo if velocidad_cmd == 0 else min(objetivo, velocidad_cmd * t)
        v = max(-VMAX, min(VMAX, KP * (cmd - th)))        # el lazo interno del servo
        th += v * dt
        corriente = I_REPOSO + (I_MOV - I_REPOSO) * abs(v) / VMAX
        pico = max(pico, corriente)
        energia += corriente * dt
        if t95 is None and th >= 0.95 * objetivo:
            t95 = t
    return t95, pico, energia


print()
print("orden               95 % del recorrido   pico de corriente   carga consumida")
for nombre, vel in (("salto directo", 0), ("600 °/s", 600), ("180 °/s", 180), ("90 °/s", 90)):
    t95, pico, energia = mover(180, vel)
    print(f"{nombre:18s}  {t95:14.3f} s  {pico:15.0f} mA  {energia:12.0f} mA·s")

Resultado: con 544–2400 µs, 90° son 1472 µs y cada grado vale 10,3 µs; con 1000–2000 µs son 1500 µs. El PCA9685 usa 205, 256, 307, 358 y 410 ticks para 0°, 45°, 90°, 135° y 180° (1000–2000 µs) y comete errores de hasta ±0,35° (90° pasa a 89,82°, 135° a 134,65°). Con el SG90 y 0,3 kg, el torque va del 33 % (2 cm) al 100 % (6 cm). Con cuatro SG90: 4,98 V en reposo, 4,50 V moviéndose y 3,70 V bloqueados (4,67 V con uno solo bloqueado). En el movimiento 0°→180°, el salto directo llega al 95 % en 0,332 s con un pico de 250 mA; limitando la velocidad a 180°/s, llega en 1,019 s con un pico de 82 mA; a 90°/s, en 1,966 s con 46 mA. La carga total consumida es la misma (102 mA·s): limitar la velocidad reparte la corriente en el tiempo, no la reduce.

11 · Exploración interactiva

El pulso, la carga y el movimiento

El primer instrumento muestra el pulso de 50 Hz para un ángulo, según el rango del servo y la forma de generarlo. El segundo calcula el torque que exige una palanca y la tensión que queda en una fuente compartida por varios servos. El tercero simula el movimiento con y sin limitación de velocidad. Los datos de los servos son valores típicos aproximados.

Recorrido guiado

1. Con 544–2400 µs, 90° y Servo.write: 1472 µs, ciclo de trabajo 7,4 %. Cambiá el rango a 1000–2000: 1500 µs. Un mismo ángulo genera pulsos distintos según la calibración.
2. Con Servo.write, movés el ángulo 0,5° y el pulso no cambia: la función trunca a grados enteros. Pasá a writeMicroseconds: sigue el movimiento con pasos de 0,1°.
3. Con el PCA9685 y 1000–2000 µs: pedí 135° y el ángulo real queda en 134,65°. Es la cuantización de 4,88 µs por tick.
4. En el instrumento 2, SG90, 0,3 kg a 4 cm: 1,2 kg·cm, 67 % del bloqueo: exigido. Subí el brazo a 6 cm: 100 %, no sostiene. Pasá al MG996R: 13 % con el mismo brazo.
5. Con 4 servos SG90 y una fuente de 2 A con 0,5 Ω de cableado, la corriente estimada a 67 % de carga ronda los 440 mA por servo: la tensión cae a ~3,9 V y el sistema falla por baja tensión. Bajá la resistencia del cableado a 0,1 Ω y se recupera.
6. En el instrumento 3, un salto de 180° directo: 0,33 s y 250 mA de pico. Pasá a 180°/s: 1,0 s y 82 mA. A 90°/s: 2,0 s y 46 mA. La carga consumida no cambia, solo se reparte.
7. Reducí el salto a 30° con el salto directo: el pico baja a ~190 mA porque el servo no llega a su velocidad máxima, y dura apenas ~0,1 s. Los saltos grandes son los que más corriente piden.

12 · Método de trabajo

Cómo integrar un servo

1. Calculá el torque (peso × distancia) con margen: menos del 50 % del bloqueo.
2. Elegí el servo por torque, velocidad, tamaño, engranajes (plástico o metal) y tipo (analógico, digital, de bus).
3. Calibrá el rango de pulsos del servo y definí límites de software con margen respecto de los topes.
4. Alimentalo aparte, con masa común, con un capacitor de 470–1000 µF y cable corto; calculá el pico simultáneo de todos.
5. Arrancá en una posición inicial segura y mové con limitación de velocidad, sin bloquear el programa.
6. Usá writeMicroseconds o un controlador de más resolución si necesitás movimientos finos.
7. Vigilá el calor y el zumbido: un servo que zumba está exigido o empujando contra un tope.
8. Para giro continuo o posición precisa, pasá a un motor DC con encoder o a un paso a paso.

Si el servo tiembla, revisá el jitter de la señal, la fuente y el ruido; si zumba sin moverse, está contra un tope o sobrecargado; si el sistema se reinicia al moverlo, la fuente es insuficiente; si no llega a un extremo, el rango de pulsos es menor que el real.

13 · Comprensión

Confusiones frecuentes

14 · Práctica guiada

Predecí antes de comprobar

1. Pulso para un ángulo

¿Qué ancho de pulso corresponde a 120° con un rango de 1000–2000 µs? ¿Y con 544–2400 µs?

2. Ciclo de trabajo

¿Qué ciclo de trabajo tiene la señal con un pulso de 1,5 ms y qué frecuencia?

3. Resolución del PCA9685

Con 4096 ticks en 20 ms, ¿qué duración tiene un tick y cuántos ticks hay en un pulso de 1500 µs?

4. Torque

Un objeto de 0,5 kg está a 4 cm del eje. ¿Alcanza un SG90 (1,8 kg·cm)? ¿Y un MG996R (9,4 kg·cm)?

5. Movimiento suave

Se quiere mover un servo 90° a 45°/s con un paso cada 20 ms. ¿Cuántos grados avanza por paso y cuánto dura el movimiento?

6. Rotación continua

Un servo de rotación continua gira lentamente cuando se le ordena 1,5 ms. ¿Qué hacés? ¿Qué pulsos usás para ir en cada sentido?

15 · Síntesis

Ideas para recordar

¿Listo para el tema 33?

Antes de avanzar, calculá el pulso para 30° con el rango de Arduino, explicá por qué un servo sin límites de software puede dañarse y decidí qué fuente usarías para cuatro servos de 650 mA de bloqueo. Si podés justificar las tres respuestas, ya sabés manejar un servo.

En el próximo tema estudiamos los motores paso a paso: unipolares y bipolares, secuencias, microstepping y drivers A4988 y DRV8825.