Motores con Arduino: DC, servo y paso a paso, cómo conectarlos

Conectar un motor directamente a un pin de Arduino es la forma más rápida de reiniciar la placa o quemar el pin. Cada tipo de motor necesita su propio intermediario: un puente H, una señal de pulsos o un driver. En esta guía verás las diferencias entre motores DC, servos y paso a paso, qué driver usar con cada uno y cómo alimentarlo todo sin problemas.

En resumen

• Un pin de Arduino Uno da como mucho unos 20 mA recomendados: ningún motor se conecta directo.
• DC con puente H (mejor TB6612FNG que L298N), servo con señal de 50 Hz, paso a paso con driver tipo A4988 o DRV8825.
• Los motores van con fuente aparte y GND común con el Arduino.

Los tres tipos de motor

Por qué no se conectan directos a un pin

Hay tres motivos, y basta con uno:

1. Corriente: un pin del ATmega328P del Uno tiene un máximo absoluto de 40 mA, y lo recomendable es no pasar de 20 mA. Un motor DC pequeño arranca pidiendo cientos de mA.
2. Tensión inductiva: al cortar la corriente, la bobina del motor genera un pico de tensión que puede dañar el pin. Es el mismo problema que con los relés.
3. Ruido: las escobillas y los arranques provocan caídas en la alimentación que reinician el microcontrolador.

Si solo necesitas un sentido de giro, basta un MOSFET con diodo, como se explica en el transistor como interruptor. Para cambiar de sentido, necesitas un puente H.

Motores DC: el puente H

Un puente H son cuatro interruptores dispuestos de forma que la corriente puede atravesar el motor en un sentido o en el otro. El Arduino solo le dice el sentido (dos pines) y la velocidad (un pin PWM).

L298N frente a TB6612FNG

Por qué importa la caída: con un L298N alimentado a 6 V, al motor le pueden llegar unos 4 V. Pierdes velocidad y fuerza y el chip lo convierte en calor. Para motores pequeños de 3 a 12 V, el TB6612FNG es casi siempre mejor elección. El L298N tiene sentido con tensiones o corrientes que el TB6612FNG no admite.

Ejemplo con TB6612FNG

Conexión de un canal (A):

Arduino D5 (PWM) -> PWMA
Arduino D7       -> AIN1
Arduino D8       -> AIN2
Arduino 5V       -> VCC  (lógica)
Fuente motor +   -> VM
GND común        -> GND
5V o pin         -> STBY (a nivel alto para activar)
Motor            -> A01 y A02

const int PWMA = 5, AIN1 = 7, AIN2 = 8;

void setup() {
  pinMode(PWMA, OUTPUT);
  pinMode(AIN1, OUTPUT);
  pinMode(AIN2, OUTPUT);
}

void motor(int velocidad) {  // -255 a 255
  digitalWrite(AIN1, velocidad > 0);
  digitalWrite(AIN2, velocidad < 0);
  analogWrite(PWMA, abs(velocidad));
}

void loop() {
  motor(200);  delay(2000);
  motor(0);    delay(500);
  motor(-200); delay(2000);
  motor(0);    delay(500);
}

Cambiar de sentido a toda velocidad provoca picos fuertes. Para un momento en 0 antes de invertir, como en el ejemplo.

Servos: pulsos a 50 Hz

Un servo de modelismo lleva dentro un motor DC, una reductora, un potenciómetro y su propio control. Tú solo le mandas una señal de 50 Hz (un pulso cada 20 ms) cuya anchura indica la posición:

Los márgenes exactos cambian de un modelo a otro. La librería Servo se encarga de generar la señal; tienes el código y los detalles del PWM en la guía de PWM en Arduino y ESP32.

Lo que sí importa aquí es la alimentación. El cable de señal va al pin, pero el positivo del servo no debería ir al 5V del Arduino salvo que sea un microservo sin carga. Al moverse o forzarse, un servo puede pedir picos de varios cientos de mA, y si son varios, más de un amperio. Los síntomas de alimentarlos desde la placa son clásicos: temblores, movimientos erráticos y reinicios.

Si mueves muchos servos, un módulo con PCA9685 genera hasta 16 señales por I2C y libera los temporizadores del Arduino.

Servo de rotación continua

Parece un servo, pero no tiene posición: el pulso de 1,5 ms lo para y los extremos marcan velocidad y sentido. Es un motor DC con reductora y control incluido.

Motores paso a paso

Un motor paso a paso avanza en pasos fijos; el NEMA 17 típico da 200 pasos por vuelta (1,8° por paso). Los bipolares tienen dos bobinas y cuatro cables. No se mueven con «encender y apagar»: hay que alimentar las bobinas en secuencia, y eso lo hace el driver.

A4988 frente a DRV8825

Los dos usan solo dos pines: STEP (cada pulso es un paso o micropaso) y DIR (sentido).

const int STEP = 3, DIR = 4;

void setup() {
  pinMode(STEP, OUTPUT);
  pinMode(DIR, OUTPUT);
}

void loop() {
  digitalWrite(DIR, HIGH);
  for (int i = 0; i < 200; i++) {   // una vuelta en paso completo
    digitalWrite(STEP, HIGH);
    delayMicroseconds(800);
    digitalWrite(STEP, LOW);
    delayMicroseconds(800);
  }
  delay(1000);
}

Para aceleraciones suaves, la librería AccelStepper evita que el motor pierda pasos al arrancar.

El límite de corriente es obligatorio

Estos drivers regulan la corriente de las bobinas, y el máximo se ajusta con el potenciómetro del módulo midiendo la Vref con un multímetro. Pasos:

1. Mira la corriente nominal del motor en su hoja de datos (por ejemplo, 1,5 A por fase).
2. Identifica las resistencias de sensado (Rs) del módulo: suelen estar marcadas como R050, R068 o R100 (0,05, 0,068 o 0,1 Ω).
3. Calcula la Vref con la fórmula de tu driver y empieza algo por debajo del máximo.
4. Con el driver alimentado, mide entre el potenciómetro y GND y ajusta.

En un A4988 con Rs de 0,1 Ω, para 1 A:

Vref = I × 8 × Rs = 1 × 8 × 0,1 = 0,8 V

El procedimiento con multímetro está detallado en calibrar los drivers (Vref).

Alimentación separada y GND común

La regla vale para los tres tipos:

• Los motores se alimentan de su propia fuente, dimensionada para la suma de corrientes.
• El Arduino puede ir por USB o por otra fuente.
• Los GND se unen. Sin masa común, la señal del Arduino no tiene referencia y el driver no la entiende o se comporta de forma errática.
• Pon un condensador electrolítico (100 µF o más) entre VM/VMOT y GND, cerca del driver. Absorbe los picos al conectar.

Fuente motores +  ->  VM / VMOT del driver
Fuente motores -  ->  GND del driver  ->  GND del Arduino
Arduino pines     ->  entradas de control del driver

Errores habituales

• Alimentar motores desde el 5V del Arduino. Reinicios y reguladores calientes.
• Olvidar el GND común. El motor no responde o lo hace a saltos.
• Desconectar un paso a paso con el driver alimentado. El pico de tensión puede destruir el driver al instante.
• No ajustar la Vref. Si es baja, pierde pasos; si es alta, el motor y el driver se sobrecalientan.
• Usar un L298N con 5 o 6 V. La caída interna deja al motor sin tensión.
• Invertir el sentido de golpe a plena velocidad. Para antes un instante.

Relacionados

• PWM explicado: ciclo de trabajo, analogWrite en Arduino y LEDC en ESP32
• El transistor como interruptor: NPN y MOSFET con Arduino y ESP32
• Cómo leer un datasheet: guía práctica con el regulador 7805