Comparativa de drivers de motor: L298N, TB6612FNG y A4988
Comparativa de drivers L298N, L293D, L9110S, TB6612FNG y A4988: corriente, caída de tensión, rendimiento y compatibilidad 3,3 V para tu coche robot o motor paso a paso.
Al comparar drivers de motor, la primera pregunta es: ¿cuánta corriente consume tu motor, con qué tensión trabaja y a qué nivel lógico habla tu placa (5 V o 3,3 V)? Los cinco drivers más usados en electrónica de aficionado son L298N, L293D, L9110S, TB6612FNG y A4988. La respuesta corta: para un coche robot pequeño con batería, el TB6612FNG; para motores de 12 V y 1–2 A, el L298N; para el presupuesto más bajo, el L9110S; para mover cuatro motores con una sola placa sobre un Arduino Uno, el shield L293D; y para motores paso a paso bipolares como el NEMA 17, el A4988.
En esta guía veremos cuánta corriente entrega realmente cada driver, cuánta tensión pierde, cómo afecta eso a la batería y al calentamiento, y su compatibilidad con placas de 3,3 V como ESP32 y Raspberry Pi Pico. Después encontrarás códigos funcionales que mueven los mismos dos motores con Arduino, ESP32 y Pico, un ejemplo de motor paso a paso con A4988 y una tabla de selección por proyecto.

¿Qué es un driver de motor y por qué lo necesitas?
Un pin digital de Arduino da como máximo unos 20–40 mA; incluso un pequeño motorreductor TT consume 150–250 mA en marcha y casi 1 A cuando se bloquea (stall). Conectar el motor directamente al pin lo quema, y los picos de tensión inversa del motor reinician el microcontrolador. Un driver de motor es un circuito de conmutación que toma la señal débil del microcontrolador y alimenta el motor desde una fuente aparte. En el corazón de los drivers de motores DC hay un puente en H: al abrir y cerrar cuatro interruptores en pares cruzados se invierte la polaridad del motor y este gira hacia delante o hacia atrás. La velocidad se regula con una señal PWM que abre y cierra los interruptores miles de veces por segundo. Los drivers para motores paso a paso van un paso más allá: energizan las bobinas en secuencia limitando la corriente para girar el motor con ángulos precisos.
Los cinco drivers en breve
- L298N: puente en H con transistores bipolares, antiguo pero muy extendido, con dos canales. Soporta tensiones altas (5–35 V en el módulo) y llega a 2 A por canal, pero pierde 2–3 V y se calienta mucho. Más detalles en Control de motor DC con L298N.
- L293D: circuito integrado DIP de 16 pines; 600 mA continuos por canal, 1,2 A de pico y diodos de protección internos. Es famoso por el shield de motores L293D, hecho para Arduino Uno y capaz de mover cuatro motores DC.
- L9110S: la opción más barata y pequeña. Funciona entre 2,5 y 12 V y da unos 800 mA por canal; no tiene pin enable y cada motor se controla con dos pines. Más detalles en Driver de motor L9110S.
- TB6612FNG: puente en H moderno basado en MOSFET. Da 1,2 A continuos y 3,2 A de pico por canal, con una resistencia en conducción de unos 0,5 ohmios; por eso casi no se calienta y trabaja sin problemas con niveles lógicos desde 2,7 V.
- A4988: no es un driver de motor DC, sino de motores paso a paso bipolares. Ofrece tensión de motor de 8–35 V, límite de corriente ajustable y micropasos hasta 1/16. La puesta en marcha se explica paso a paso en Driver paso a paso A4988.
Tabla comparativa: corriente, tensión, compatibilidad 3,3 V y precio
| Característica | L298N | L293D | L9110S | TB6612FNG | A4988 |
|---|---|---|---|---|---|
| Tipo de motor | 2 DC o 1 paso a paso bipolar | 2 DC o 1 paso a paso bipolar | 2 DC | 2 DC o 1 paso a paso bipolar | 1 paso a paso bipolar |
| Tensión del motor | 5–35 V (módulo) | 4,5–36 V | 2,5–12 V | 4,5–13,5 V (máximo absoluto 15 V) | 8–35 V |
| Corriente continua (por canal) | 2 A (con disipador) | 0,6 A | aprox. 0,8 A | 1,2 A | aprox. 1 A sin disipador, 2 A con refrigeración |
| Corriente de pico | 3 A | 1,2 A | aprox. 1,5 A | 3,2 A | 2 A |
| Tecnología de conmutación | Transistor bipolar | Transistor bipolar | Transistor (baja saturación) | MOSFET | MOSFET + control de corriente |
| Caída de tensión | aprox. 2–3 V | aprox. 1,8–2,6 V | aprox. 1 V | aprox. 0,5 V (a 1 A) | Controlada por corriente, no es un problema |
| Rendimiento | Bajo | Bajo | Medio | Alto | Alto |
| Alimentación lógica | 5 V (regulador en el módulo) | 4,5–7 V (VCC1) | Común con la del motor | 2,7–5,5 V (VCC) | 3–5,5 V (VDD) |
| Compatibilidad con señal de 3,3 V | Suele funcionar | Las entradas la aceptan, la alimentación lógica es de 5 V | Totalmente compatible | Totalmente compatible | Totalmente compatible |
| Precio (relativo) | Bajo | Bajo | Muy bajo | Medio | Bajo |
Los valores de corriente de la tabla son los límites de las hojas de datos; en la práctica la zona segura ronda el 70 % de ellos. Por ejemplo, los 2 A del L298N solo son posibles con un disipador grande y buen flujo de aire; si fuerzas un módulo sin disipador por encima de 1 A continuo, el integrado se calienta rápido y entra en protección térmica. Para saber lo que necesita realmente un motor no mires la corriente de trabajo, sino la corriente de bloqueo (stall): es la que consume cuando la rueda se atasca contra un obstáculo, y el driver debe soportarla al menos un breve instante. La columna de precio es un orden relativo: el L9110S suele ser el módulo más barato, mientras que el TB6612FNG, aunque algo más caro, compensa de sobra la diferencia con su rendimiento y su tamaño reducido.
Caída de tensión y rendimiento: ¿por qué se calienta tanto el L298N?
En los drivers con transistores bipolares (L298N, L293D) la corriente pasa por dos transistores antes de llegar al motor y en cada uno se pierden aproximadamente 1–1,5 V. Esa pérdida se convierte en calor y se calcula con P = V_caída × I. En el TB6612FNG, con MOSFET, los interruptores se comportan como una resistencia y la pérdida es P = I² × R_on; con 0,5 ohmios y 1 A son solo 0,5 W. En sistemas de batería de baja tensión la diferencia es enorme: perder 2 V de un pack de 6 V es tirar a la basura un tercio de la potencia del motor. Puedes repetir los cálculos para tu motor con la calculadora de la ley de Ohm y estimar la autonomía con la calculadora de duración de batería. La tabla siguiente muestra valores típicos para una alimentación de 6 V y 0,6 A de corriente del motor:
| Driver | Caída de tensión típica | Tensión que llega al motor | Potencia disipada en el driver | Rendimiento aproximado |
|---|---|---|---|---|
| L298N | 1,8 V | 4,2 V | 1,08 W | 70 % |
| L293D | 2,0 V | 4,0 V | 1,2 W | 67 % |
| L9110S | 0,8 V | 5,2 V | 0,48 W | 87 % |
| TB6612FNG | 0,3 V | 5,7 V | 0,18 W | 95 % |
Compatibilidad con 3,3 V: ¿qué driver usar con ESP32 y Raspberry Pi Pico?
Los pines de ESP32 y Pico dan salida de 3,3 V. La alimentación lógica (VCC) del TB6612FNG se puede conectar directamente a 3,3 V, así que es la pareja más limpia para estas placas. La entrada lógica del A4988 también funciona entre 3 y 5,5 V, y las entradas del L9110S detectan sin problema una señal de 3,3 V. En el L298N y el L293D el umbral de nivel alto en las entradas es de al menos 2,3 V, por lo que una señal de 3,3 V suele funcionar, pero la parte lógica del integrado necesita alimentación de 5 V y trabajar cerca del umbral puede provocar disparos erróneos en entornos con ruido. En resumen: si empiezas un proyecto nuevo con ESP32 o Pico, empieza con el TB6612FNG; si ya tienes un L298N, lo más probable es que funcione, pero no olvides nunca la conexión de masa común.
Conexiones: tabla de pines del L298N y el TB6612FNG
| Función | Pin L298N | Pin TB6612FNG | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|---|---|
| Velocidad motor A (PWM) | ENA | PWMA | D5 | GPIO 25 | GP16 |
| Dirección 1 motor A | IN1 | AIN1 | D4 | GPIO 26 | GP17 |
| Dirección 2 motor A | IN2 | AIN2 | D7 | GPIO 27 | GP18 |
| Velocidad motor B (PWM) | ENB | PWMB | D6 | GPIO 13 | GP21 |
| Dirección 1 motor B | IN3 | BIN1 | D8 | GPIO 33 | GP19 |
| Dirección 2 motor B | IN4 | BIN2 | D9 | GPIO 32 | GP20 |
| Reposo / habilitación | No tiene | STBY | D10 | GPIO 4 | GP22 |
| Alimentación lógica | +5V (salida del regulador) | VCC | 5V | 3V3 | 3V3 (OUT) |
| Alimentación del motor | +12V | VM | Fuente externa | Fuente externa | Fuente externa |
| Masa | GND | GND | GND | GND | GND |
Paso a paso: mover dos motores DC con Arduino
- Conecta la fuente del motor (por ejemplo, 7,4 V con 2 celdas 18650 o 9 V con 6×AA) a la entrada de alimentación del motor del driver: +12V en el L298N, VM en el TB6612FNG.
- Conecta el polo negativo de la fuente tanto al GND del driver como al GND del Arduino.
- Si usas un L298N, quita los jumpers de ENA y ENB; si no, no podrás regular la velocidad y el motor siempre girará a tope.
- Conecta los pines PWM a D5 y D6 y los de dirección a D4, D7, D8 y D9, como en la tabla. En el TB6612FNG, conecta STBY a D10 y VCC al 5V del Arduino.
- Conecta los motores a las salidas OUT1–OUT2 (A01–A02) y OUT3–OUT4 (B01–B02). Si un motor gira al revés, intercambia los cables o invierte la dirección en el código.
- Sube el código siguiente y haz la primera prueba con las ruedas en el aire.
1// L298N ya da TB6612FNG ile iki DC motor / Two DC motors with L298N or TB6612FNG
2const int ENA = 5; // PWMA (PWM pini / PWM pin)
3const int IN1 = 4; // AIN1
4const int IN2 = 7; // AIN2
5const int ENB = 6; // PWMB (PWM pini / PWM pin)
6const int IN3 = 8; // BIN1
7const int IN4 = 9; // BIN2
8const int STBY = 10; // yalnız TB6612FNG / TB6612FNG only
9
10// hiz: -255 (tam geri) ... 255 (tam ileri) / speed: -255 (full reverse) ... 255 (full forward)
11void motorSur(int en, int inA, int inB, int hiz) {
12 hiz = constrain(hiz, -255, 255);
13 if (hiz > 0) {
14 digitalWrite(inA, HIGH);
15 digitalWrite(inB, LOW);
16 } else if (hiz < 0) {
17 digitalWrite(inA, LOW);
18 digitalWrite(inB, HIGH);
19 } else {
20 digitalWrite(inA, LOW); // dur / stop
21 digitalWrite(inB, LOW);
22 }
23 analogWrite(en, abs(hiz));
24}
25
26// Kısa devre freni: iki giriş HIGH / Short brake: both inputs HIGH
27void fren(int en, int inA, int inB) {
28 digitalWrite(inA, HIGH);
29 digitalWrite(inB, HIGH);
30 analogWrite(en, 255);
31}
32
33void setup() {
34 pinMode(ENA, OUTPUT);
35 pinMode(IN1, OUTPUT);
36 pinMode(IN2, OUTPUT);
37 pinMode(ENB, OUTPUT);
38 pinMode(IN3, OUTPUT);
39 pinMode(IN4, OUTPUT);
40 pinMode(STBY, OUTPUT);
41 digitalWrite(STBY, HIGH); // TB6612FNG'yi uyandır / wake up the TB6612FNG
42}
43
44void loop() {
45 motorSur(ENA, IN1, IN2, 180); // ileri / forward
46 motorSur(ENB, IN3, IN4, 180);
47 delay(2000);
48
49 fren(ENA, IN1, IN2); // fren / brake
50 fren(ENB, IN3, IN4);
51 delay(500);
52
53 motorSur(ENA, IN1, IN2, -180); // geri / reverse
54 motorSur(ENB, IN3, IN4, -180);
55 delay(2000);
56
57 motorSur(ENA, IN1, IN2, 180); // yerinde dönüş / spin in place
58 motorSur(ENB, IN3, IN4, -180);
59 delay(1000);
60
61 motorSur(ENA, IN1, IN2, 0); // dur / stop
62 motorSur(ENB, IN3, IN4, 0);
63 delay(1000);
64}Lo bueno del código es que funciona con la misma distribución de pines tanto en el L298N como en el TB6612FNG; la tabla lógica de ambos drivers es casi idéntica. Cuando uno de los pines de dirección está en HIGH y el otro en LOW, el motor gira; el valor PWM (0–255) determina la velocidad. Si se ponen ambos pines de dirección en HIGH, los terminales del motor se cortocircuitan y el motor se frena con su propia tensión generada; así el robot se detiene en menos distancia en una pendiente o a gran velocidad. Los pines D5 y D6 del Uno generan PWM a unos 980 Hz; es normal oír un leve zumbido en los motores a esa frecuencia. Con el L298N verás que con valores PWM muy bajos (por debajo de unos 60) el motor no gira, porque la tensión media que le queda tras la pérdida del driver no basta para vencer la fricción.
ESP32 con TB6612FNG: PWM silencioso a 20 kHz
En el ESP32, usar la unidad PWM por hardware LEDC en lugar de analogWrite te permite elegir la frecuencia. Como el TB6612FNG admite PWM de hasta 100 kHz, si subes la frecuencia a 20 kHz pasa a una zona que el oído humano no percibe y el zumbido del motor desaparece por completo. El código siguiente compila tanto con las versiones 2.x como 3.x del core Arduino para ESP32; las funciones LEDC que cambian según la versión se separan con un bloque de compilación condicional. No olvides conectar el pin VCC del TB6612FNG al pin 3V3 del ESP32.
1#include <Arduino.h>
2
3// ESP32 + TB6612FNG pinleri / ESP32 + TB6612FNG pins
4const int PWMA = 25, AIN1 = 26, AIN2 = 27;
5const int PWMB = 13, BIN1 = 33, BIN2 = 32;
6const int STBY = 4;
7
8const int PWM_FREQ = 20000; // 20 kHz: duyulmayan PWM / inaudible PWM
9const int PWM_RES = 8; // 0-255 çözünürlük / 0-255 resolution
10
11void pwmBaslat(int pin, int kanal) {
12#if ESP_ARDUINO_VERSION_MAJOR >= 3
13 ledcAttach(pin, PWM_FREQ, PWM_RES); // core 3.x
14 (void)kanal;
15#else
16 ledcSetup(kanal, PWM_FREQ, PWM_RES); // core 2.x
17 ledcAttachPin(pin, kanal);
18#endif
19}
20
21void pwmYaz(int pin, int kanal, int deger) {
22#if ESP_ARDUINO_VERSION_MAJOR >= 3
23 ledcWrite(pin, deger);
24 (void)kanal;
25#else
26 ledcWrite(kanal, deger);
27 (void)pin;
28#endif
29}
30
31// hiz: -255 ... 255 / speed: -255 ... 255
32void motor(int pwmPin, int kanal, int in1, int in2, int hiz) {
33 hiz = constrain(hiz, -255, 255);
34 digitalWrite(in1, hiz > 0 ? HIGH : LOW);
35 digitalWrite(in2, hiz < 0 ? HIGH : LOW);
36 pwmYaz(pwmPin, kanal, abs(hiz));
37}
38
39void setup() {
40 pinMode(AIN1, OUTPUT);
41 pinMode(AIN2, OUTPUT);
42 pinMode(BIN1, OUTPUT);
43 pinMode(BIN2, OUTPUT);
44 pinMode(STBY, OUTPUT);
45 digitalWrite(STBY, HIGH); // sürücüyü etkinleştir / enable the driver
46 pwmBaslat(PWMA, 0);
47 pwmBaslat(PWMB, 1);
48}
49
50void loop() {
51 for (int h = 0; h <= 255; h += 5) { // yumuşak hızlanma / soft acceleration
52 motor(PWMA, 0, AIN1, AIN2, h);
53 motor(PWMB, 1, BIN1, BIN2, h);
54 delay(30);
55 }
56 delay(1500);
57 motor(PWMA, 0, AIN1, AIN2, -200); // geri / reverse
58 motor(PWMB, 1, BIN1, BIN2, -200);
59 delay(1500);
60 motor(PWMA, 0, AIN1, AIN2, 0); // dur / stop
61 motor(PWMB, 1, BIN1, BIN2, 0);
62 delay(1000);
63}Raspberry Pi Pico y MicroPython con TB6612FNG
Todos los pines GPIO de la Pico pueden generar PWM por hardware y en MicroPython el ciclo de trabajo se indica con un número de 16 bits (0–65535). En el ejemplo siguiente la velocidad se introduce en porcentaje (de -100 a 100) y la función la convierte en un valor duty_u16. Como GP16 y GP21 están en slices PWM distintos, la frecuencia de un motor no afecta a la del otro. Conecta el pin VCC del TB6612FNG al pin 3V3 (OUT) de la Pico y el pin VM a la fuente externa del motor; alimentar el motor desde el pin VSYS de la Pico reiniciaría la placa por la corriente limitada que llega del USB.
1from machine import Pin, PWM
2import time
3
4stby = Pin(22, Pin.OUT, value=1) # sürücüyü uyandır / wake the driver
5
6pwma = PWM(Pin(16))
7pwma.freq(20000) # 20 kHz sessiz PWM / quiet PWM
8ain1 = Pin(17, Pin.OUT)
9ain2 = Pin(18, Pin.OUT)
10
11pwmb = PWM(Pin(21))
12pwmb.freq(20000)
13bin1 = Pin(19, Pin.OUT)
14bin2 = Pin(20, Pin.OUT)
15
16def motor(pwm, in1, in2, hiz): # hiz: -100 ... 100 / speed in percent
17 hiz = max(-100, min(100, hiz))
18 in1.value(1 if hiz > 0 else 0)
19 in2.value(1 if hiz < 0 else 0)
20 pwm.duty_u16(int(abs(hiz) * 65535 / 100))
21
22while True:
23 motor(pwma, ain1, ain2, 70) # ileri / forward
24 motor(pwmb, bin1, bin2, 70)
25 time.sleep(2)
26 motor(pwma, ain1, ain2, -70) # geri / reverse
27 motor(pwmb, bin1, bin2, -70)
28 time.sleep(2)
29 motor(pwma, ain1, ain2, 0) # dur / stop
30 motor(pwmb, bin1, bin2, 0)
31 time.sleep(1)A4988 para motores paso a paso: límite de corriente y ajuste de Vref
El L298N y el L293D también pueden mover un motor paso a paso bipolar con dos puentes en H, pero como no limitan la corriente, el motor se queda sin fuerza a baja tensión o se calienta en exceso a tensión alta. El A4988, en cambio, mide continuamente la corriente de la bobina y la mantiene constante (control chopper); así puedes mover con seguridad y con mucho par un motor NEMA 17 de 2,8 V con una fuente de 12 V o 24 V. El límite de corriente se ajusta con el pequeño potenciómetro de la placa y la fórmula es: I_max = Vref / (8 × Rs). Rs es la resistencia de medida de corriente de la placa; en muchas placas clónicas pone R100 (0,1 ohmios) y en algunas R068 (0,068 ohmios). Por ejemplo, en una placa de 0,1 ohmios, para 1 A el Vref debe ser 1 × 8 × 0,1 = 0,8 V; para dejar margen térmico, un 70 % de ese valor, unos 0,56 V, es un buen punto de partida. El A4988 se controla solo con dos pines: cada pulso en STEP es un paso y el pin DIR indica el sentido. Con MS1, MS2 y MS3 en LOW funciona a paso completo y un motor de 1,8 grados da 200 pasos por vuelta. No olvides unir SLEEP con RESET y poner un condensador de al menos 100 µF entre VMOT y GND.
1// A4988 ile NEMA 17 step motor / NEMA 17 stepper with A4988
2// MS1-MS3 LOW = tam adım, SLEEP ile RESET birbirine bağlı / MS1-MS3 LOW = full step, SLEEP tied to RESET
3const int DIR_PIN = 2;
4const int STEP_PIN = 3;
5const int ADIM_TUR = 200; // 1,8 derece motor / 1.8 degree motor
6
7void adimAt(int adim, bool yon, unsigned int bekleme) {
8 digitalWrite(DIR_PIN, yon ? HIGH : LOW);
9 for (int i = 0; i < adim; i++) {
10 digitalWrite(STEP_PIN, HIGH);
11 delayMicroseconds(bekleme);
12 digitalWrite(STEP_PIN, LOW);
13 delayMicroseconds(bekleme);
14 }
15}
16
17void setup() {
18 pinMode(DIR_PIN, OUTPUT);
19 pinMode(STEP_PIN, OUTPUT);
20}
21
22void loop() {
23 adimAt(ADIM_TUR, true, 800); // saat yönünde 1 tur / one turn clockwise
24 delay(1000);
25 adimAt(ADIM_TUR, false, 800); // ters yönde 1 tur / one turn counter-clockwise
26 delay(1000);
27}¿Qué driver para qué proyecto?
| Proyecto | Driver recomendado | ¿Por qué? |
|---|---|---|
| Coche robot con 2 motores TT (con batería) | TB6612FNG (L9110S si buscas ahorrar) | Poca pérdida, larga autonomía, tamaño pequeño |
| Coche de 4 ruedas con Arduino Uno | Shield L293D o L298N | 4 motores con una sola placa; en el L298N se conectan 2 motores en paralelo por cada lado |
| Motor reductor de 12 V (1–2 A) | L298N (con disipador) | Soporta alta tensión y corriente; para motores más grandes pasa a drivers MOSFET como el BTS7960 |
| Motor paso a paso NEMA 17 (impresora 3D, CNC, slider) | A4988 | Límite de corriente y micropasos |
| Motor paso a paso 28BYJ-48 | Placa ULN2003 | Motor unipolar, compatible directamente con 5 V |
| Minibomba de agua de 6 V de un solo sentido | MOSFET de nivel lógico o L9110S de un canal | Si no cambia el sentido, el puente en H sobra |
| Bomba reversible o bomba peristáltica | TB6612FNG | Cambio de sentido y PWM eficiente |
| Cualquier proyecto de motor DC con ESP32 o Pico | TB6612FNG | Compatibilidad total con lógica de 3,3 V |
El ejemplo de la bomba es especialmente importante: en un sistema de riego la bomba gira siempre en el mismo sentido, así que basta con un MOSFET de canal N y un diodo de rueda libre; encontrarás este método en Uso de MOSFET con Arduino. En los coches robot, cuanto más baja es la tensión de la batería, mayor es la ventaja del driver con MOSFET; un coche alimentado con dos pilas 18650 va visiblemente más rápido y funciona más tiempo con un TB6612FNG que con un L298N.
Ideas de proyectos con drivers de motor
- Coche robot controlado por Bluetooth: mueve dos motores desde el móvil con un TB6612FNG o un L298N; los pasos están en construcción de un coche robot.
- Robot evita obstáculos: un vehículo que detecta el obstáculo con un HC-SR04 y cambia de dirección; detalles en robot evita obstáculos.
- Robot seguidor de línea: en este proyecto, que exige respuesta PWM rápida, el rendimiento del TB6612FNG marca la diferencia; echa un vistazo a robot seguidor de línea.
- Riego automático: activa la minibomba cuando baja la humedad del suelo; las conexiones de alimentación se explican en minibomba de agua.
- Seguidor solar: orienta el panel hacia la luz con un motor paso a paso o un motor DC con reductor; mira sistema de seguimiento solar.
- Posicionamiento preciso: para un slider de cámara o una plataforma giratoria con ángulos pequeños, empieza con el motor paso a paso 28BYJ-48 y pasa después al A4988 y al NEMA 17.
Errores comunes y cómo solucionarlos
| Problema | Causa probable | Solución |
|---|---|---|
| El Arduino se reinicia cuando gira el motor | El motor se alimenta del 5V del Arduino o la fuente es débil | Usa una fuente de motor aparte, une los GND y añade un condensador de 100–470 µF a la alimentación |
| Los motores no reaccionan | No hay GND común o STBY está en LOW en el TB6612FNG | Une los GND y pon el pin STBY en HIGH |
| La velocidad no cambia, el motor siempre va a tope | Jumper de ENA/ENB puesto en el L298N | Quita el jumper y conecta ENA/ENB a un pin PWM |
| El motor va muy lento y sin fuerza con el L298N | Pérdida de 2–3 V en el driver | Aumenta la tensión de la fuente o pasa al TB6612FNG |
| Se oye un zumbido agudo en el motor | La frecuencia PWM está en la zona audible | Sube el PWM a 20 kHz en ESP32 o Pico |
| El motor paso a paso vibra pero no gira | Pares de bobinas mal emparejados o Vref demasiado bajo | Encuentra los pares de bobinas con el multímetro y ajusta Vref con la fórmula |
| El driver se calienta mucho y se apaga | La corriente de bloqueo del motor supera el límite del driver | Elige un driver más potente, añade disipador y no fuerces el motor |
Elegir bien el driver de motor pasa por conocer la corriente de tu motor, su tensión de alimentación y el nivel lógico de tu placa. Con esos tres datos, las tablas anteriores te llevan a la placa correcta en pocos segundos, y ya sabes dónde puede ser útil ese viejo L298N que tienes en el cajón. En la app BlueGrays puedes ver paso a paso, con esquemas de conexión y código listo, proyectos como el coche controlado por Bluetooth con L298N, el robot evita obstáculos, el motor paso a paso y el riego inteligente, y empezar a montarlos enseguida.
Preguntas frecuentes
¿Es mejor el L298N o el TB6612FNG?
Para motores con batería que consumen menos de 1 A, el TB6612FNG es mejor: gracias a su estructura MOSFET pierde solo unos 0,5 V y casi no se calienta. El L298N se prefiere con tensiones superiores a 13,5 V y motores que necesitan 1–2 A por canal. En resumen: TB6612FNG para robots pequeños y L298N para motores más grandes de 12–24 V.
¿Por qué se calienta tanto el L298N?
Como el L298N usa transistores bipolares, al pasar la corriente pierde unos 2–3 V y esa pérdida se convierte en calor. A 1 A el driver genera unos 2 W de calor, por eso viene con un disipador grande. Para reducir el calentamiento puedes mantener la corriente baja o pasar a un driver basado en MOSFET.
¿Se puede usar el L298N con ESP32?
Sí: como las entradas del L298N aceptan como nivel alto a partir de 2,3 V, la señal de 3,3 V del ESP32 suele funcionar. La parte lógica del módulo debe alimentarse con 5 V y los GND del ESP32 y del driver deben unirse siempre. En un proyecto nuevo, el TB6612FNG, totalmente compatible con 3,3 V, es una opción más segura.
¿Cuántos amperios da el L293D?
El L293D puede dar 600 mA continuos y 1,2 A de pico por canal, y tiene dos canales. Estos valores bastan para motores de juguete pequeños y robots ligeros, pero con motores cuya corriente de bloqueo supera 1 A el integrado se calienta y entra en protección térmica. Para más corriente conviene considerar el L298N o el TB6612FNG.
¿Qué driver usar para un motor paso a paso?
Para motores paso a paso bipolares de 4 cables como el NEMA 17 hay que usar un A4988 u otro driver con control de corriente similar; puedes ajustar el límite de corriente con Vref y usar micropasos. Para motores unipolares de 5 cables como el 28BYJ-48, la placa ULN2003 es la solución más sencilla. El L298N puede mover un paso a paso bipolar, pero al no limitar la corriente resulta ineficiente.
¿Necesito un driver de motor para una bomba de agua?
Si la bomba solo va a girar en un sentido, no hace falta un driver con puente en H; basta con un MOSFET de nivel lógico, un diodo y una resistencia. Si quieres invertir la bomba o regular su velocidad con PWM, puedes usar un canal de un driver como el L9110S o el TB6612FNG. En cualquier caso, alimenta la bomba desde una fuente aparte y no desde el pin del Arduino.
Proyectos para hacer después de leer esto
Ver todos los proyectos
Coche controlado por Bluetooth con L298N
Convierte tu móvil en un mando y conduce tu propio coche robot. El Arduino recibe por un módulo Bluetooth las órdenes de una app de control remoto en el móvil y mueve las ruedas con un controlador de…

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.

Uso del motor paso a paso
Un motor que gira paso a paso, justo lo que tú quieras, como la aguja de un reloj.

Construcción de servomotor de 360 grados a partir de motor paso a paso
Enséñale a un motor paso a paso normal a ir al ángulo que quieras, a lo largo de toda la vuelta.

Estación de riego inteligente
Un jardinero que riega solo tus plantas para que no se sequen mientras estás de vacaciones.

ESP32 LED Fade con PWM
Cambiar el brillo del LED suavemente de 0 a max, de max a 0. Controlamos PWM con analogWrite() como en Arduino - la misma sintaxis con ESP32 Arduino Core 3.0+ funciona sin problemas. Pin definición + pinMode + analogWrite es suficiente.

Raspberry Pi Pico PWM LED Fade (Efecto Respiración)
¡El LED ya no solo parpadea — respira! Con el PWM (modulación por ancho de pulso) del Raspberry Pi Pico, el brillo sube y baja lentamente. Aprende la clase machine.PWM, duty_u16() (brillo de 16 bits 0–65535), la frecuencia PWM, bucles range() y salida tipo analógica. Base para mezcla de color RGB, control de motores, servos y buzzer.
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

