Motor DC, servomotor y motor paso a paso: diferencias y usos

La diferencia entre un motor DC, un servomotor y un motor paso a paso cabe en una frase: el motor DC gira de forma continua y rápida mientras le das corriente, el servo va al ángulo que le pides y se queda ahí, y el motor paso a paso gira en pasos pequeños y contables. Así que si tienes que mover una rueda, eliges un motor DC; para abrir una tapa 90 grados, un servo; para mover una pieza con una precisión de una décima de milímetro, un motor paso a paso. En cualquier proyecto con Arduino, ESP32 o Raspberry Pi Pico en el que algo tenga que moverse, te encontrarás con uno de estos tres.

En esta guía comparamos qué hay dentro de cada motor, datos reales de velocidad, par y precisión de posición de modelos populares (motor TT, SG90, MG996R, 28BYJ-48, NEMA 17), qué driver necesita cada uno (L298N, señal PWM, ULN2003, A4988), cuánta corriente consumen y cuál se usa en cada proyecto. Al final encontrarás código para Arduino, ESP32 y Pico que mueve los tres a la vez, una breve introducción a los motores sin escobillas (BLDC) y los ESC, y los errores más habituales.

Respuesta corta: los tres motores en una tabla

La fila más importante de la tabla es la de realimentación. Un servo sabe dónde está gracias a su potenciómetro interno, y cuando algo lo empuja vuelve a su posición. Un motor paso a paso no sabe dónde está; tú solo cuentas cuántos pasos ha dado, y esa cuenta es correcta mientras el motor no se sobrecargue y no pierda pasos. Un motor DC no tiene ni idea de cuánto ha girado; si necesitas la posición, tienes que añadir un encoder a su eje. Qué motor elijas depende en gran medida de si tu proyecto necesita esa información.

¿Cómo funciona un motor DC?

Casi todos los motores DC de los proyectos de hobby son motores DC con escobillas. Dentro tienen imanes fijos y una bobina que gira (el rotor); las escobillas de carbón y el colector de láminas de cobre invierten el sentido de la corriente a medida que el rotor gira, de modo que nunca deja de girar. Tiene dos cables: si aplicas tensión gira, si inviertes los cables gira al revés. La tensión fija la velocidad y la corriente que consume fija el par. Mientras gira, en las bobinas se genera una tensión opuesta llamada fuerza contraelectromotriz que limita la corriente; cuando el eje se bloquea, esa tensión desaparece y la corriente se dispara hasta la corriente de bloqueo (stall).

Un motor DC pequeño sin reductora gira a miles de rpm pero tiene muy poco par; por eso los robots siempre usan motorreductores. La reductora 1:48 del motor TT baja unas 12.000 rpm en el eje del motor a 250 rpm en la rueda y multiplica el par unas 48 veces (sin contar las pérdidas de los engranajes). La velocidad la cambias con PWM y el sentido con un puente H; tienes los detalles en Control de motores DC con L298N. El punto débil del motor DC es la posición: el mismo valor PWM da una velocidad distinta según la tensión de la batería y la carga, así que la orden "avanza 2 segundos" recorre una distancia diferente cada vez. Si necesitas una distancia exacta, se añade un encoder a la rueda.

¿Cómo funciona un servomotor?

Un servomotor es en realidad un sistema completo metido en una caja pequeña: un motor DC, un tren de engranajes que reduce la velocidad y aumenta el par, un potenciómetro unido al eje de salida y una placa de control. El Arduino no le envía al servo un ángulo directamente, sino un pulso a 50 Hz (cada 20 ms); la anchura del pulso indica la posición deseada. La placa compara esa consigna con la posición real que lee del potenciómetro y mueve el motor en esa dirección hasta que la diferencia es cero. Esto se llama control en lazo cerrado, y por eso el servo se resiste cuando intentas girarlo con la mano.

El rango RC estándar es de 1–2 ms, pero la mayoría de los servos baratos como el SG90 necesitan unos 0,5–2,4 ms para los 180° completos, y la librería Servo de Arduino usa por defecto 544–2400 µs. La banda muerta del SG90, es decir, el cambio más pequeño al que responde, es de unos 10 µs, lo que equivale aproximadamente a 1°; por eso la precisión práctica de un servo ronda el grado. Un servo de rotación continua (FS90R) es un servo con la realimentación desactivada: controlas velocidad y sentido en lugar del ángulo, y se pierde la información de posición. Si necesitas más fuerza, el MG996R con engranajes metálicos es la opción estándar; para lo básico, consulta ¿Qué es un servomotor?

¿Cómo funciona un motor paso a paso?

Un motor paso a paso no tiene escobillas. Las bobinas de la carcasa se activan en un orden determinado y el rotor magnético da un solo paso hacia la siguiente bobina cada vez. Los motores híbridos más comunes tienen 200 pasos por vuelta, es decir, 1,8° por paso. Si envías un número de pulsos, da exactamente esos pasos; si los envías más rápido, gira más rápido. Mientras las bobinas tengan corriente, el motor queda bloqueado en su sitio; esto se llama par de retención. La diferencia clave: el motor paso a paso trabaja en lazo abierto. Si la carga supera su par, pierde pasos y el Arduino no se entera. Por eso las impresoras 3D llevan cada eje a un final de carrera al arrancar (homing).

Verás dos tipos de motor paso a paso. Los unipolares (28BYJ-48, 5 cables) tienen un cable común entre bobinas y se controlan con un simple array de transistores como el ULN2003. En los bipolares (NEMA 17, 4 cables) hay que invertir el sentido de la corriente en las bobinas; de eso se encargan drivers con limitación de corriente como el A4988, el DRV8825 o el TMC2209. Estos drivers también hacen micropasos: el A4988 divide cada paso completo en 16, lo que eleva los pasos por vuelta a 3200 y hace el movimiento mucho más silencioso y suave. Para más detalles, mira 28BYJ-48 y ULN2003 y driver de motor paso a paso A4988.

Velocidad, par y precisión: comparativa con cifras

El par suele darse en kg·cm: un motor de 1 kg·cm puede sostener una carga de 1 kg a 1 cm de su eje, pero solo 0,5 kg a 2 cm (1 kg·cm ≈ 0,098 N·m). Por ejemplo, un MG996R a 6 V da 11 kg·cm; en el extremo de un brazo de 15 cm sostiene en teoría 11 / 15 ≈ 0,73 kg. Pero ese es el par máximo en el momento del bloqueo, y el propio peso del brazo se suma a la carga. Una buena regla para que el motor dure es quedarse por debajo de la mitad de ese valor; en la práctica, en el extremo de ese brazo puedes llevar unos cientos de gramos.

En velocidad, el orden se invierte. El motor DC es con diferencia el más rápido. Un servo SG90 completa un movimiento de 180° en unos 0,3 segundos y no puede ir más deprisa. En el motor paso a paso el par cae al aumentar la velocidad, porque la corriente de la bobina no tiene tiempo de subir del todo en cada paso; un 28BYJ-48 empieza a perder pasos por encima de unas 15 rpm. Alimentar un NEMA 17 con A4988 a 24 V en lugar de 12 V da más par a alta velocidad, porque el driver limita la corriente de todos modos. En precisión, en cambio, gana el paso a paso: un NEMA 17 da 1,8° en paso completo y, sobre el papel, 0,1125° a 1/16 de micropaso. Un detalle: la reductora interna del 28BYJ-48 no es exactamente 1:64 sino de aproximadamente 1:63,68, así que una vuelta real son unos 2038 pasos y no 2048; en proyectos que giran sin parar, como los relojes, esa diferencia se acumula.

¿Qué driver necesita cada motor?

Un pin de Arduino puede dar como máximo 40 mA, y el límite seguro ronda los 20 mA; hasta un pequeño motor TT consume unas 7 veces más en vacío y más de 70 veces más bloqueado. Además, la bobina de un motor genera un pico de tensión inversa en el instante en que se corta la corriente, capaz de destruir un pin sin protección. Por eso entre el motor y la placa siempre hay un driver: la placa solo envía pequeñas señales de control y la corriente del motor va directamente de la fuente de alimentación a través del driver. Dentro de los drivers hay transistores y diodos que absorben la tensión inversa. Para un ventilador o una bomba que solo giran en un sentido basta con un único MOSFET.

Consumo: ¿cuánta corriente gasta cada motor?

Los tres motores se comportan de forma muy distinta en cuanto a corriente, y debes elegir la fuente según eso. Un motor DC consume más corriente cuanto más carga tiene; al arrancar y cuando una rueda se atasca se acerca a su corriente de bloqueo. Dimensiona la fuente para ese pico, no para la corriente en vacío. Un servo consume muy poco en reposo, pero en cada movimiento produce picos de corriente cortos y bruscos: incluso un solo SG90 puede superar 0,5 A por un instante, y un MG996R llega a 2,5 A cuando se fuerza. Esos picos hacen caer la tensión y reinician el Arduino, o provocan un error de brownout en el ESP32. Por las bobinas de un motor paso a paso, en cambio, circula corriente aunque no se mueva en absoluto: un 28BYJ-48 consume 150–200 mA parado y se calienta. En proyectos con batería, si no necesitas par de retención, apagar las bobinas (poner en HIGH el pin EN del A4988) alarga mucho la autonomía.

• Usa una alimentación separada: No alimentes motores desde el pin 5V del Arduino. Un puerto USB da unos 500 mA y la placa ya gasta parte; salvo un único servo pequeño, cada motor necesita su propia fuente.
• Une las masas: El negativo de la fuente de los motores debe ir conectado al GND de la placa; si no, la señal de control no tiene referencia (consulta masa común).
• Añade condensadores: Pon un electrolítico de 470–1000 µF en la línea de alimentación de los servos, al menos 47 µF en la entrada VMOT del A4988 y un condensador cerámico de 100 nF en los bornes de un motor DC con escobillas. El primero evita caídas de tensión y el último reduce el ruido de las escobillas.
• Elige la fuente por la corriente de pico: Por ejemplo, un brazo robótico con 4 servos necesita una fuente de 5–6 V de al menos 3 A, y un coche con dos motores TT una batería que aguante 2 × 1,5 A. Puedes calcular cuánto durará la batería con la calculadora de autonomía de baterías.
• Baja la tensión correctamente: Si necesitas 5–6 V para los servos a partir de una batería de 7,4 V, usa un regulador conmutado como el LM2596; los reguladores lineales como el 7805 se calientan mucho con corrientes del orden del amperio.

Los tres motores en un mismo Arduino: paso a paso

La mejor forma de ver la diferencia es hacer funcionar los tres a la vez. En el circuito siguiente, un motor TT se controla con un L298N, un SG90 directamente desde un pin y un 28BYJ-48 con una placa ULN2003. La tabla de pines sirve para los tres códigos: Arduino Uno, ESP32 y Raspberry Pi Pico.

1. Quita el jumper ENA del L298N; conecta ENA, IN1 e IN2 a los pines de la tabla y el motor DC a los bornes OUT1 y OUT2. Lleva la alimentación del motor (por ejemplo, dos pilas 18650 en serie, 7,4 V) al borne de 12V.
2. Conecta el cable marrón del servo a GND, el rojo a una fuente separada de 5–6 V y el cable naranja de señal a D9.
3. Enchufa el conector blanco del 28BYJ-48 en la placa ULN2003, conecta IN1–IN4 a D10–D13 y alimenta el borne + de la placa con 5 V.
4. Une los negativos de todas las fuentes y el GND del Arduino.
5. Sube el código con el Arduino IDE; las librerías Servo y Stepper vienen con el IDE, así que no tienes que instalarlas.
6. Enciende las fuentes de los motores y observa cómo se comportan los tres motores uno tras otro.

1#include <Servo.h>
2#include <Stepper.h>
3
4// DC motor (L298N): ENA=5, IN1=7, IN2=8
5const int ENA = 5;                 // PWM; Servo kütüphanesi 9 ve 10'un PWM'ini kapatır / Servo library disables PWM on 9 and 10
6const int IN1 = 7;
7const int IN2 = 8;
8
9const int SERVO_PIN = 9;           // servo sinyali / servo signal
10Servo servo;
11
12const int STEPS_PER_REV = 2048;    // 28BYJ-48 tam tur / full revolution
13Stepper stepper(STEPS_PER_REV, 10, 12, 11, 13);   // sıra: IN1, IN3, IN2, IN4 / order: IN1, IN3, IN2, IN4
14
15void releaseStepper() {            // bobinleri bırak, boşta akım çekmesin / release coils, no idle current
16  for (int pin = 10; pin <= 13; pin++) {
17    digitalWrite(pin, LOW);
18  }
19}
20
21void setup() {
22  pinMode(ENA, OUTPUT);
23  pinMode(IN1, OUTPUT);
24  pinMode(IN2, OUTPUT);
25  servo.attach(SERVO_PIN);
26  stepper.setSpeed(10);            // devir/dakika, 28BYJ-48 için en fazla ~15 / RPM, max ~15 for 28BYJ-48
27}
28
29void loop() {
30  // 1) DC motor: hız ve yön, konum yok / speed and direction, no position
31  digitalWrite(IN1, HIGH);
32  digitalWrite(IN2, LOW);
33  analogWrite(ENA, 180);           // yaklaşık %70 güç / about 70% power
34  delay(2000);
35  analogWrite(ENA, 0);             // motoru serbest bırak / let the motor coast
36  delay(500);
37
38  // 2) Servo: açı ver, gidip orada kalsın / give an angle, it goes there and holds
39  servo.write(0);
40  delay(600);
41  servo.write(180);
42  delay(600);
43  servo.write(90);
44  delay(600);
45
46  // 3) Step motor: tam çeyrek tur ileri ve geri / exactly a quarter turn forward and back
47  stepper.step(STEPS_PER_REV / 4);   // 512 adım = 90° / 512 steps = 90°
48  delay(500);
49  stepper.step(-STEPS_PER_REV / 4);
50  releaseStepper();
51  delay(1000);
52}

Al ejecutar el código verás la diferencia con claridad: el motor DC gira dos segundos, pero su eje se detiene cada vez en un punto distinto. El servo salta a 0°, 180° y 90° y se resiste si intentas girarlo con la mano. El motor paso a paso avanza despacio exactamente un cuarto de vuelta y vuelve al mismo punto; después de llamar a releaseStepper() puedes girar su eje a mano sin esfuerzo. La función step() de la librería Stepper bloquea el código hasta que termina el movimiento; si quieres mover varios motores a la vez y con aceleración suave, pásate a la librería AccelStepper.

Motor DC, servo y paso a paso con ESP32

Los pines del ESP32 dan 3,3 V; las entradas del L298N y del ULN2003 reconocen ese nivel como HIGH, y los servos también funcionan con una señal de 3,3 V. Los motores siguen necesitando su propia alimentación. La diferencia está en el servo: la librería Servo estándar de Arduino no es compatible con el ESP32. O instalas la librería ESP32Servo o, como abajo, generas tú mismo la señal de 50 Hz con la unidad PWM por hardware del ESP32, LEDC. Como usamos dos frecuencias distintas, 1 kHz para el motor DC y 50 Hz para el servo, asignamos los canales a temporizadores separados (canales 0 y 2) con ledcAttachChannel; en algunas versiones del core, los canales vecinos comparten el mismo temporizador. El código es para el core Arduino del ESP32 3.x; en las versiones 2.x se usan ledcSetup y ledcAttachPin en su lugar. La librería Stepper funciona sin cambios en el ESP32; si estás empezando con esta placa, echa un vistazo a ¿Qué es el ESP32?

1#include <Stepper.h>
2
3// ESP32 Arduino çekirdeği 3.x / ESP32 Arduino core 3.x
4const int ENA = 25;                // L298N hız (PWM) / L298N speed (PWM)
5const int IN1 = 26;
6const int IN2 = 27;
7const int SERVO_PIN = 18;          // servo sinyali / servo signal
8
9const int STEPS_PER_REV = 2048;
10Stepper stepper(STEPS_PER_REV, 19, 22, 21, 23);   // sıra: IN1, IN3, IN2, IN4 / order: IN1, IN3, IN2, IN4
11
12void motor(int speed) {            // -255 … 255
13  digitalWrite(IN1, speed > 0);
14  digitalWrite(IN2, speed < 0);
15  ledcWrite(ENA, abs(speed));
16}
17
18void servoWrite(int angle) {       // 0 … 180
19  int us = map(angle, 0, 180, 500, 2400);              // açı → darbe (µs) / angle → pulse (µs)
20  ledcWrite(SERVO_PIN, (uint32_t)us * 65535 / 20000);  // 20 ms içindeki pay / share of the 20 ms period
21}
22
23void setup() {
24  pinMode(IN1, OUTPUT);
25  pinMode(IN2, OUTPUT);
26  ledcAttachChannel(ENA, 1000, 8, 0);        // kanal 0: 1 kHz, 8 bit (0–255) / channel 0: 1 kHz, 8-bit
27  ledcAttachChannel(SERVO_PIN, 50, 16, 2);   // kanal 2, ayrı zamanlayıcı: 50 Hz, 16 bit / channel 2, separate timer: 50 Hz, 16-bit
28  stepper.setSpeed(10);                      // devir/dakika / RPM
29}
30
31void loop() {
32  motor(200);         delay(2000);   // DC: ileri / forward
33  motor(0);           delay(500);    // DC: dur / stop
34  servoWrite(0);      delay(600);    // servo: 0°
35  servoWrite(180);    delay(600);    // servo: 180°
36  servoWrite(90);     delay(600);    // servo: 90°
37  stepper.step(512);  delay(500);    // step: çeyrek tur / quarter turn
38  stepper.step(-512); delay(1000);
39}

Código MicroPython para la Raspberry Pi Pico

En la Pico, cualquier pin GP puede dar PWM. En MicroPython ajustas la velocidad del motor DC entre 0 y 65535 con duty_u16() y la anchura de pulso del servo en nanosegundos con duty_ns(). El motor paso a paso se hace girar escribiendo la secuencia de medio paso en cuatro pines, uno tras otro; en medio paso, una vuelta del 28BYJ-48 son 4096 pasos. Si eres nuevo con la Pico, empieza por ¿Qué es la Raspberry Pi Pico?

1from machine import Pin, PWM
2import time
3
4# DC motor (L298N): ENA=GP15, IN1=GP14, IN2=GP13
5ena = PWM(Pin(15))
6ena.freq(1000)
7in1 = Pin(14, Pin.OUT)
8in2 = Pin(13, Pin.OUT)
9
10# Servo: GP16, 50 Hz
11servo = PWM(Pin(16))
12servo.freq(50)
13
14# Step motor (ULN2003): IN1–IN4 = GP2–GP5
15coils = [Pin(n, Pin.OUT) for n in (2, 3, 4, 5)]
16SEQ = [(1,0,0,0), (1,1,0,0), (0,1,0,0), (0,1,1,0),
17       (0,0,1,0), (0,0,1,1), (0,0,0,1), (1,0,0,1)]   # yarım adım dizisi / half-step sequence
18
19def motor(speed):                    # -100 … 100
20    in1.value(speed > 0)
21    in2.value(speed < 0)
22    ena.duty_u16(int(abs(speed) * 655.35))
23
24def servo_angle(angle):              # 0 … 180
25    us = 500 + angle * 1900 // 180   # 500–2400 µs
26    servo.duty_ns(us * 1000)
27
28phase = 0                            # dizideki konum, çağrılar arasında korunur / position in the sequence, kept between calls
29
30def step(steps, delay_ms=2):         # yarım adımda 4096 adım = 1 tur / 4096 half-steps = 1 turn
31    global phase
32    d = 1 if steps > 0 else -1
33    for _ in range(abs(steps)):
34        phase = (phase + d) % 8
35        for pin, v in zip(coils, SEQ[phase]):
36            pin.value(v)
37        time.sleep_ms(delay_ms)
38    for pin in coils:
39        pin.value(0)                 # bobinleri bırak / release coils
40
41while True:
42    motor(70)                        # DC: %70 ileri / 70% forward
43    time.sleep(2)
44    motor(0)                         # DC: dur / stop
45    time.sleep(0.5)
46    for a in (0, 180, 90):           # servo: üç açı / three angles
47        servo_angle(a)
48        time.sleep(0.6)
49    step(1024)                       # step: çeyrek tur / quarter turn
50    time.sleep(0.5)
51    step(-1024)
52    time.sleep(1)

¿Qué motor para cada proyecto?

En algunos proyectos sirven los dos motores, y la elección depende de los detalles. En un coche robot, los motores DC bastan para las ruedas, pero si quieres que el coche avance exactamente 50 cm, o añades encoders o mueves las ruedas con motores paso a paso. En un brazo robótico, los servos son la vía más fácil; los brazos pesados y precisos usan motores paso a paso con reductoras en las articulaciones. En una impresora 3D es fácil calcular cuántos pasos necesita un eje por milímetro: con un motor de 200 pasos, micropasos de 1/16 y una polea GT2 de 20 dientes (paso de 2 mm) se obtiene 200 × 16 / (20 × 2) = 80 pasos/mm; con un husillo trapezoidal T8 de 8 mm de avance, el valor pasa a 200 × 16 / 8 = 400 pasos/mm. En proyectos que barren 0–180°, como un radar o un seguidor solar, el servo es a la vez la solución más barata y la más sencilla.

Breve introducción a los motores sin escobillas (BLDC) y los ESC

En el motor DC sin escobillas (BLDC) la estructura está invertida: los imanes van en la parte que gira y las bobinas en la carcasa fija. Al no tener escobillas ni colector, no hay rozamiento, chispas ni desgaste; el motor es más eficiente, más silencioso y dura mucho más. El precio es que ahora el sentido de la corriente lo tiene que cambiar un circuito electrónico en lugar de las escobillas. Por eso los motores BLDC tienen 3 cables y no giran si los conectas directamente a una batería. En los motores de modelismo la velocidad se indica con el valor KV: las rpm en vacío por cada voltio. Un motor de 1000 KV (por ejemplo, el A2212) con una LiPo de 3 celdas (11,1 V) gira en vacío a unas 11.100 rpm. Los drones, aviones RC, monopatines y patinetes eléctricos, ventiladores de ordenador y discos duros usan motores sin escobillas.

Para conectar un motor BLDC al Arduino necesitas un ESC (Electronic Speed Controller, variador electrónico de velocidad). El ESC convierte la tensión continua de la batería en pulsos trifásicos para el motor; los ESC sin sensores estiman la posición del rotor a partir de la fuerza contraelectromotriz de la bobina que no está alimentada. Lo bueno es que la entrada de control del ESC es igual que la de un servo: con pulsos a 50 Hz, 1000 µs significa parado y 2000 µs, acelerador a tope. La corriente del ESC (por ejemplo, 30 A) debe ser mayor que la corriente máxima que puede consumir el motor, y la mayoría de los ESC tienen una salida BEC que da 5 V. Por seguridad, el ESC quiere ver primero el acelerador al mínimo al encenderse; esto se llama armado (arming), y hasta recibir esa señal no hace girar el motor. En el código siguiente, el cable de señal del ESC va a D9 y el cursor del potenciómetro que hace de acelerador va a A0.

1#include <Servo.h>
2
3Servo esc;                         // ESC bir servo gibi sürülür / an ESC is driven like a servo
4const int POT_PIN = A0;            // gaz potansiyometresi / throttle potentiometer
5
6void setup() {
7  esc.attach(9, 1000, 2000);       // 1000–2000 µs aralığı / 1000–2000 µs range
8  esc.writeMicroseconds(1000);     // en düşük gaz: ESC'yi kur (arming) / minimum throttle: arm the ESC
9  delay(3000);                     // bip seslerini bekle / wait for the beeps
10}
11
12void loop() {
13  int throttle = map(analogRead(POT_PIN), 0, 1023, 1000, 2000);   // pot → gaz / pot → throttle
14  esc.writeMicroseconds(throttle);
15  delay(20);                       // bir servo periyodu / one servo period
16}

Errores frecuentes y soluciones

• El Arduino se reinicia cuando arranca el motor: El motor o el servo se alimentan desde el pin 5V de la placa. Usa una fuente separada, une las masas y añade un condensador grande a la alimentación.
• El servo tiembla o da saltos: La fuente es débil, los cables son finos y largos o la masa no es común. Conecta el servo a una fuente de 5–6 V que dé al menos 1 A.
• Con un servo, la velocidad del motor DC no cambia: En el Uno, ENA está en el pin 9 o 10, y la librería Servo desactiva el PWM de esos pines. Mueve ENA al 3, 5, 6 u 11.
• El motor DC no gira con valores PWM bajos, solo zumba: No hay potencia suficiente para vencer el rozamiento estático. Arranca el motor un instante con un valor alto y luego baja la velocidad, o mantén el valor mínimo en torno a 80–100. Ten en cuenta también la caída de tensión de unos 2 V del L298N.
• El motor paso a paso vibra pero no gira: El orden de las bobinas es incorrecto o la velocidad es demasiado alta. Para el 28BYJ-48 usa el orden Stepper(2048, IN1, IN3, IN2, IN4) y mantén la velocidad por debajo de 15 rpm.
• El motor paso a paso pierde pasos: La carga es demasiado pesada, la aceleración demasiado brusca o el límite de corriente del A4988 demasiado bajo. Ajusta Vref con la fórmula I = Vref / (8 × Rcs), donde Rcs es la resistencia de medida de corriente de la placa, y usa una aceleración suave con AccelStepper.
• Se ha quemado el A4988: Se conectó o desconectó el cable del motor con el driver alimentado, Vref estaba demasiado alto o faltaba el condensador en VMOT. Conecta siempre el motor con la alimentación apagada.
• El ESC no hace girar el motor y pita sin parar: Al encender no recibió la señal de acelerador mínimo. Asegúrate de que setup() envía writeMicroseconds(1000) y espera unos segundos; si hace falta, calibra el ESC como indica su manual.

En resumen, el motor DC significa velocidad, el servo ángulo y el motor paso a paso posición; si combinas el motor adecuado con el driver adecuado, tienes medio proyecto resuelto. Empezar con un SG90 y un motor TT y pasar después al paso a paso es la forma más fácil de aprender los tres. En la app BlueGrays encontrarás proyectos de uso del servomotor, control de un servo con potenciómetro, uso del motor paso a paso, un servo de 360 grados hecho con un motor paso a paso, un coche controlado por Bluetooth con L298N y un robot que esquiva obstáculos, todos paso a paso con esquema del circuito y código.