Comparativo de drivers de motor: L298N, L293D, TB6612FNG, A4988
Comparativo entre L298N, L293D, L9110S, TB6612FNG e A4988: corrente, queda de tensão, eficiência e compatibilidade com 3,3 V, com indicações para carrinhos robô e motores de passo.
Ao comparar drivers de motor, as primeiras perguntas são: quanta corrente o seu motor consome, com qual tensão ele funciona e qual nível lógico (5 V ou 3,3 V) a sua placa usa? Os cinco drivers mais usados pelos hobbistas são o L298N, o L293D, o L9110S, o TB6612FNG e o A4988. A resposta curta: o TB6612FNG é o melhor para um carrinho robô pequeno alimentado por bateria, o L298N para motores de 12 V que consomem 1–2 A, o L9110S para o orçamento mais apertado, um shield L293D para acionar quatro motores com uma só placa no Arduino Uno e o A4988 para motores de passo bipolares como o NEMA 17.
Neste guia vamos ver quanta corrente cada driver realmente consegue fornecer, quanta tensão ele perde, o que essa perda causa na autonomia da bateria e no aquecimento e como ele se comporta com placas de 3,3 V, como o ESP32 e o Raspberry Pi Pico. Você também vai encontrar códigos que funcionam e acionam os mesmos dois motores com Arduino, ESP32 e Pico, um exemplo de motor de passo com o A4988 e uma tabela de escolha por projeto.

O que é um driver de motor e por que você precisa de um?
Um pino digital do Arduino fornece no máximo cerca de 20–40 mA. Até um pequeno motor TT com redução consome 150–250 mA em funcionamento e perto de 1 A quando travado. Ligar um motor direto em um pino queima o pino, e os picos de tensão reversa gerados pelo motor podem reiniciar o microcontrolador. Um driver de motor é um circuito de chaveamento que recebe o sinal fraco do microcontrolador e alimenta o motor a partir de uma fonte separada. No coração dos drivers de motor CC está a ponte H: ligar e desligar quatro chaves em pares diagonais inverte a polaridade nos terminais do motor, que então gira para frente ou para trás. A velocidade é ajustada com um sinal PWM, que liga e desliga as chaves milhares de vezes por segundo. Os drivers de motor de passo vão um passo além: energizam as bobinas em sequência limitando a corrente e giram o motor em ângulos precisos.
Os cinco drivers em resumo
- L298N: Uma ponte H dupla com transistores bipolares, antiga mas muito comum. Aguenta tensão alta (5–35 V no módulo) e chega a 2 A por canal, mas perde 2–3 V e esquenta muito. Para mais detalhes, veja controle de motor CC com o L298N.
- L293D: Um CI DIP de 16 pinos com 600 mA contínuos e 1,2 A de pico por canal, além de diodos de proteção internos. Ficou famoso pelo shield de motor L293D, feito para o Arduino Uno, que aciona quatro motores CC.
- L9110S: A opção mais barata e menor. Funciona de 2,5–12 V e fornece cerca de 800 mA por canal; não tem pino enable, então cada motor é controlado com dois pinos. Mais detalhes no artigo sobre o driver de motor L9110S.
- TB6612FNG: Uma ponte H moderna baseada em MOSFET. Fornece 1,2 A contínuos e 3,2 A de pico por canal, com resistência de condução de cerca de 0,5 ohm; por isso quase não esquenta e funciona bem com níveis lógicos a partir de 2,7 V.
- A4988: Não é um driver de motor CC, e sim um driver de motor de passo bipolar. Oferece tensão de motor de 8–35 V, limite de corrente ajustável e micropasso de até 1/16. A montagem é explicada passo a passo no artigo sobre o driver de motor de passo A4988.
Tabela comparativa: corrente, tensão, compatibilidade com 3,3 V e preço
| Característica | L298N | L293D | L9110S | TB6612FNG | A4988 |
|---|---|---|---|---|---|
| Tipo de motor | 2 CC ou 1 de passo bipolar | 2 CC ou 1 de passo bipolar | 2 CC | 2 CC ou 1 de passo bipolar | 1 de passo bipolar |
| Tensão do 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 |
| Corrente contínua (por canal) | 2 A (com dissipador) | 0,6 A | cerca de 0,8 A | 1,2 A | cerca de 1 A sem dissipador, 2 A com refrigeração |
| Corrente de pico | 3 A | 1,2 A | cerca de 1,5 A | 3,2 A | 2 A |
| Tecnologia de chaveamento | Transistor bipolar | Transistor bipolar | Transistor (baixa saturação) | MOSFET | MOSFET + controle de corrente |
| Queda de tensão | cerca de 2–3 V | cerca de 1,8–2,6 V | cerca de 1 V | cerca de 0,5 V (a 1 A) | Controlado por corrente, não é problema |
| Eficiência | Baixa | Baixa | Média | Alta | Alta |
| Alimentação lógica | 5 V (regulador no módulo) | 4,5–7 V (VCC1) | Compartilhada com a alimentação do motor | 2,7–5,5 V (VCC) | 3–5,5 V (VDD) |
| Compatibilidade com sinal de 3,3 V | Geralmente funciona | As entradas aceitam, alimentação lógica de 5 V | Totalmente compatível | Totalmente compatível | Totalmente compatível |
| Preço (relativo) | Baixo | Baixo | Muito baixo | Médio | Baixo |
Os valores de corrente da tabela são limites do datasheet; na prática, a zona segura fica em cerca de 70% deles. Por exemplo, os 2 A do L298N só são possíveis com um dissipador grande e boa circulação de ar; se você forçar um módulo sem dissipador acima de 1 A de forma contínua, o CI esquenta rápido e entra em proteção térmica. Para saber a necessidade real de um motor, não olhe a corrente de funcionamento, e sim a corrente de travamento: quando uma roda bate em um obstáculo, o motor consome essa corrente, e o driver precisa aguentá-la, pelo menos por pouco tempo. A coluna de preço é só uma ordem relativa: o L9110S costuma ser o módulo mais barato, enquanto o TB6612FNG custa um pouco mais, mas compensa com folga pela eficiência e pelo tamanho pequeno.
Queda de tensão e eficiência: por que o L298N esquenta tanto?
Nos drivers com transistores bipolares (L298N, L293D), a corrente passa por dois transistores antes de chegar ao motor, e cerca de 1–1,5 V se perde em cada um. Essa perda vira calor: a potência perdida é calculada por P = V_queda × I. No TB6612FNG, baseado em MOSFET, as chaves se comportam como um resistor e a perda é P = I² × R_on; para 0,5 ohm e 1 A, isso dá só 0,5 W. Em sistemas a bateria de baixa tensão, a diferença é enorme: perder 2 V de um pack de 6 V significa jogar fora um terço da potência do motor. Você pode refazer os cálculos para o seu motor com a calculadora da lei de Ohm e estimar a duração da bateria com a calculadora Autonomia da bateria. A tabela abaixo mostra valores típicos para alimentação de 6 V e corrente de motor de 0,6 A:
| Driver | Perda de tensão típica | Tensão que sobra para o motor | Potência perdida como calor no driver | Eficiência aproximada |
|---|---|---|---|---|
| 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% |
Compatibilidade com 3,3 V: qual driver usar com ESP32 e Raspberry Pi Pico?
Os pinos do ESP32 e do Pico têm saída de 3,3 V. Como a alimentação lógica (VCC) do TB6612FNG pode ser ligada direto em 3,3 V, ele é a combinação mais limpa com essas placas. As entradas lógicas do A4988 também funcionam de 3–5,5 V, e as entradas do L9110S leem um sinal de 3,3 V sem problemas. No L298N e no L293D, o limiar de nível alto na entrada é de pelo menos 2,3 V, então um sinal de 3,3 V funciona na maioria dos casos, mas a parte lógica do CI precisa de alimentação de 5 V, e trabalhar perto do limiar pode causar disparos falsos em ambientes com ruído. Resumindo: se você vai começar um projeto novo com ESP32 ou Pico, comece com o TB6612FNG; se já tem um L298N, muitas vezes ele também vai funcionar, mas nunca esqueça a ligação do GND comum.
Ligações: tabela de pinos do L298N e do TB6612FNG
| Função | Pino do L298N | Pino do TB6612FNG | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|---|---|
| Velocidade do motor A (PWM) | ENA | PWMA | D5 | GPIO 25 | GP16 |
| Direção 1 do motor A | IN1 | AIN1 | D4 | GPIO 26 | GP17 |
| Direção 2 do motor A | IN2 | AIN2 | D7 | GPIO 27 | GP18 |
| Velocidade do motor B (PWM) | ENB | PWMB | D6 | GPIO 13 | GP21 |
| Direção 1 do motor B | IN3 | BIN1 | D8 | GPIO 33 | GP19 |
| Direção 2 do motor B | IN4 | BIN2 | D9 | GPIO 32 | GP20 |
| Standby / habilitação | Nenhum | STBY | D10 | GPIO 4 | GP22 |
| Alimentação lógica | +5V (saída do regulador) | VCC | 5V | 3V3 | 3V3 (OUT) |
| Alimentação do motor | +12V | VM | Fonte externa | Fonte externa | Fonte externa |
| Terra | GND | GND | GND | GND | GND |
Passo a passo: acionando dois motores CC com Arduino
- Ligue a fonte do motor (por exemplo 7,4 V com duas células 18650 ou 9 V com 6×AA) à entrada de alimentação do motor no driver: +12V no L298N, VM no TB6612FNG.
- Ligue o terminal negativo da fonte tanto ao GND do driver quanto ao GND do Arduino.
- Se estiver usando um L298N, retire os jumpers de ENA e ENB; caso contrário, não dá para controlar a velocidade e o motor gira sempre na velocidade máxima.
- Ligue os pinos PWM em D5 e D6 e os pinos de direção em D4, D7, D8 e D9, como na tabela. No TB6612FNG, ligue STBY em D10 e VCC no 5V do Arduino.
- Conecte os terminais dos motores às saídas OUT1–OUT2 (A01–A02) e OUT3–OUT4 (B01–B02). Se um motor girar para o lado errado, inverta os fios ou inverta a direção no código.
- Carregue o código abaixo e faça o primeiro teste com as rodas fora do chão.
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}O legal deste código é que ele funciona com a mesma disposição de pinos tanto no L298N quanto no TB6612FNG; as tabelas lógicas dos dois drivers são quase idênticas. Quando um pino de direção está em HIGH e o outro em LOW, o motor gira; o valor PWM (0–255) define a velocidade. Quando os dois pinos de direção vão para HIGH, os terminais do motor ficam em curto e o motor freia com a própria tensão que gera, o que faz o robô parar em uma distância menor numa descida ou em alta velocidade. Os pinos D5 e D6 do Uno geram PWM de cerca de 980 Hz; um leve zumbido dos motores nessa frequência é normal. Com o L298N, você vai notar que o motor não gira com valores de PWM muito baixos (abaixo de cerca de 60), porque, depois da perda no driver, a tensão média que sobra para o motor não é suficiente para vencer o atrito.
ESP32 com TB6612FNG: PWM silencioso de 20 kHz
No ESP32, usar a unidade de PWM por hardware LEDC em vez de analogWrite permite escolher a frequência que você quiser. Como o TB6612FNG aceita PWM de até 100 kHz, subir a frequência para 20 kHz leva o sinal a uma faixa que o ouvido humano não escuta, e o zumbido do motor some por completo. O código abaixo compila tanto no core do Arduino para ESP32 2.x quanto no 3.x; as funções LEDC que mudam entre as versões ficam separadas por um bloco de compilação condicional. Não esqueça de ligar o pino VCC do TB6612FNG ao pino 3V3 do 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 e MicroPython com TB6612FNG
Todos os pinos GPIO do Pico geram PWM por hardware, e no MicroPython o ciclo de trabalho é informado como um número de 16 bits (0–65535). No exemplo abaixo, a velocidade é dada em porcentagem (de -100 a 100) e a função a converte em um valor duty_u16. Como GP16 e GP21 ficam em slices de PWM diferentes, a frequência de um motor não afeta a do outro. Ligue o pino VCC do TB6612FNG ao pino 3V3 (OUT) do Pico e o pino VM à fonte externa do motor; alimentar motores pelo pino VSYS do Pico faz a placa reiniciar por causa da corrente limitada que vem da 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 de passo: limite de corrente e ajuste de Vref
O L298N e o L293D também podem acionar um motor de passo bipolar com duas pontes H, mas, como não conseguem limitar a corrente, o motor fica fraco em tensão baixa ou superaquece em tensão alta. O A4988 mede continuamente a corrente da bobina e a mantém constante (acionamento chopper); assim, até um motor NEMA 17 de 2,8 V pode ser acionado com segurança e torque alto a partir de uma fonte de 12 V ou 24 V. O limite de corrente é ajustado no pequeno trimpot da placa, e a fórmula é: I_max = Vref / (8 × Rs). Rs é o resistor sensor de corrente da placa; muitas placas clone trazem a marcação R100 (0,1 ohm) e algumas R068 (0,068 ohm). Por exemplo, em uma placa de 0,1 ohm, para 1 A você precisa de Vref = 1 × 8 × 0,1 = 0,8 V; para deixar uma margem térmica, cerca de 0,56 V (70%) é um bom ponto de partida. O A4988 é controlado com apenas dois pinos: cada pulso no pino STEP é um passo e o pino DIR define a direção. Com MS1, MS2 e MS3 em LOW, ele funciona em passo completo, e um motor de 1,8 grau dá 200 passos por volta. Lembre-se de ligar SLEEP e RESET entre si e de colocar um capacitor de pelo menos 100 µF entre VMOT e 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}Qual driver para qual projeto?
| Projeto | Driver recomendado | Por quê? |
|---|---|---|
| Carrinho robô com 2 motores TT (a bateria) | TB6612FNG (L9110S para economizar) | Baixa perda, bateria dura mais, tamanho pequeno |
| Carrinho de 4 rodas com Arduino Uno | Shield L293D ou L298N | 4 motores com uma placa; no L298N, os 2 motores de cada lado são ligados em paralelo |
| Motor com redução de 12 V (1–2 A) | L298N (com dissipador) | Aguenta tensão e corrente altas; para motores maiores, passe para drivers MOSFET como o BTS7960 |
| Motor de passo NEMA 17 (impressora 3D, CNC, slider) | A4988 | Limite de corrente e micropasso |
| Motor de passo 28BYJ-48 | Placa ULN2003 | Motor unipolar, compatível diretamente com 5 V |
| Mini bomba d'água de 6 V em um só sentido | MOSFET de nível lógico ou um canal do L9110S | Ponte H é desnecessária se o sentido nunca muda |
| Bomba reversível ou bomba peristáltica | TB6612FNG | Inversão de sentido e PWM eficiente |
| Qualquer projeto com motor CC baseado em ESP32 ou Pico | TB6612FNG | Total compatibilidade com lógica de 3,3 V |
O exemplo da bomba é especialmente importante: em um sistema de irrigação a bomba sempre gira no mesmo sentido, então um único MOSFET canal N e um diodo de roda livre bastam; você encontra esse método no artigo Como usar MOSFET com Arduino. Em carrinhos robô, quanto menor a tensão da bateria, maior a vantagem de um driver MOSFET; um carrinho alimentado por duas baterias 18650 vai visivelmente andar mais rápido e funcionar por mais tempo com um TB6612FNG do que com um L298N.
Ideias de projetos com drivers de motor
- Carrinho robô controlado por Bluetooth: Acione dois motores pelo celular com um TB6612FNG ou L298N; os passos estão no artigo como fazer um carrinho robô.
- Robô que desvia de obstáculos: Um veículo que detecta um obstáculo à frente com um HC-SR04 e muda de direção; detalhes no artigo robô que desvia de obstáculos.
- Robô seguidor de linha: Neste projeto, que exige resposta rápida de PWM, a eficiência do TB6612FNG faz diferença; dê uma olhada no artigo robô seguidor de linha.
- Irrigação automática: Ligue a mini bomba quando a umidade do solo cair; as ligações de alimentação são explicadas no artigo mini bomba d'água.
- Seguidor solar: Gire um painel em direção à luz com um motor de passo ou um motor CC com redução; veja o artigo seguidor solar.
- Posicionamento preciso: Para um slider de câmera ou uma mesa giratória que gira em ângulos pequenos, comece com um motor de passo 28BYJ-48 e depois passe para o A4988 e o NEMA 17.
Erros comuns e como resolver
| Problema | Causa provável | Solução |
|---|---|---|
| O Arduino reinicia quando o motor gira | O motor é alimentado pelo 5V do Arduino ou a fonte é fraca | Use uma fonte separada para o motor, una os GNDs, coloque um capacitor de 100–470 µF na alimentação |
| Os motores não respondem | Sem GND comum, ou STBY em LOW no TB6612FNG | Una os GNDs, coloque o pino STBY em HIGH |
| A velocidade não muda, motor sempre no máximo | Jumper ENA/ENB colocado no L298N | Retire o jumper, ligue ENA/ENB a um pino PWM |
| Motor muito lento e fraco com o L298N | Perda de tensão de 2–3 V no driver | Aumente a tensão da fonte ou troque pelo TB6612FNG |
| Zumbido agudo vindo do motor | Frequência do PWM na faixa audível | Suba o PWM para 20 kHz no ESP32 ou no Pico |
| Motor de passo vibra mas não gira | Pares de bobinas trocados ou Vref muito baixo | Encontre os pares de bobinas com um multímetro, ajuste o Vref pela fórmula |
| O driver superaquece e desliga | A corrente de travamento do motor passa do limite do driver | Escolha um driver mais forte, adicione um dissipador, não force o motor |
Escolher o driver de motor certo depende de conhecer a corrente do seu motor, a tensão de alimentação e o nível lógico da sua placa. Com essas três informações, as tabelas acima levam você à placa certa em segundos, e agora você também sabe onde aquele L298N antigo da gaveta ainda pode ser útil. No app BlueGrays você pode explorar projetos de carrinho controlado por Bluetooth com L298N, robô que desvia de obstáculos, motor de passo e irrigação inteligente, com esquemas do circuito passo a passo e códigos prontos, e começar a montar na hora.
Perguntas frequentes
O L298N ou o TB6612FNG, qual é melhor?
Para motores alimentados por bateria que consomem menos de 1 A, o TB6612FNG é melhor; graças ao projeto com MOSFET, ele perde só cerca de 0,5 V e quase não esquenta. O L298N é preferido acima de 13,5 V e para motores que precisam de 1–2 A por canal. Resumindo: TB6612FNG para robôs pequenos, L298N para motores maiores de 12–24 V.
Por que o L298N esquenta tanto?
Como o L298N usa transistores bipolares, cerca de 2–3 V se perdem nele enquanto a corrente passa, e essa perda vira calor. Com 1 A, o driver gera cerca de 2 W de calor, e é por isso que ele vem com um dissipador grande. Para reduzir o aquecimento, você pode manter a corrente baixa ou trocar por um driver baseado em MOSFET.
Posso usar um L298N com ESP32?
Sim. As entradas do L298N aceitam pelo menos 2,3 V como nível alto, então o sinal de 3,3 V do ESP32 funciona na maioria dos casos. A parte lógica do módulo precisa ser alimentada com 5 V, e os GNDs do ESP32 e do driver precisam estar unidos. Para um projeto novo, porém, o TB6612FNG, totalmente compatível com 3,3 V, é a escolha mais segura.
Quantos ampères o L293D fornece?
O L293D fornece 600 mA contínuos e 1,2 A de pico por canal, e tem dois canais. Esses valores bastam para motores de brinquedo pequenos e robôs leves, mas com motores cuja corrente de travamento passa de 1 A o CI esquenta e entra em proteção térmica. Para correntes maiores, considere o L298N ou o TB6612FNG.
Qual driver devo usar para um motor de passo?
Para motores de passo bipolares de 4 fios, como o NEMA 17, use um A4988 ou outro driver semelhante com controle de corrente; você pode ajustar o limite de corrente pelo Vref e usar micropasso. Para motores unipolares de 5 fios, como o 28BYJ-48, a placa ULN2003 é a solução mais fácil. O L298N consegue acionar um motor de passo bipolar, mas é ineficiente porque não limita a corrente.
Preciso de um driver de motor para uma bomba d'água?
Se a bomba vai girar só em um sentido, você não precisa de um driver de motor com ponte H; um MOSFET de nível lógico, um diodo e um resistor bastam. Se quiser inverter a bomba ou ajustar a velocidade com PWM, pode usar um canal de um driver como o L9110S ou o TB6612FNG. Em qualquer caso, alimente a bomba com uma fonte separada, nunca por um pino do Arduino.
Projetos para montar depois desta leitura
Ver todos os projetos
Carrinho controlado por Bluetooth com L298N
Transforme seu celular em um controle remoto e dirija seu próprio carrinho robô.

Robô que desvia de obstáculos
Que tal construir um veículo inteligente que encontra seu próprio caminho? O robô que desvia de obstáculos monitora o ambiente constantemente com o sensor ultrassônico na parte da frente.

Uso do motor de passo
Um motor que gira passo a passo, exatamente o quanto você quer, como o ponteiro de um relógio.

Servo motor de 360 graus com motor de passo
Ensine um motor de passo comum a ir até qualquer ângulo que você quiser, ao longo de uma volta completa.

Estação de irrigação inteligente
Um jardineiro que rega suas plantas sozinho para que elas não sequem enquanto você está de férias.

Variação gradual do brilho do LED com PWM no ESP32
Varie suavemente o brilho do LED de 0 ao máximo e do máximo a 0. Controlamos o PWM com analogWrite(), como no Arduino. A mesma sintaxe funciona sem problemas com ESP32 Arduino Core 3.0+. Basta definir o pino e usar pinMode e analogWrite.

Raspberry Pi Pico: variação de brilho do LED com PWM (efeito de respiração)
O LED não só pisca — ele respira! Com o PWM (modulação por largura de pulso) do Raspberry Pi Pico, o brilho do LED aumenta e diminui lentamente, como a luz de um MacBook em repouso. Aprenda a usar a classe machine.PWM, duty_u16() (brilho de 16 bits, de 0–65535), frequência PWM (freq(1000) — 1.000 ciclos de ligar/desligar por segundo, sem cintilação visível), laços com passos usando range() (crescentes e decrescentes) e saída semelhante à analógica em um pino digital.
Mais artigos
App BlueGrays
Monte este circuito passo a passo pelo celular
Esquema do circuito, código e lista de componentes em uma só tela. Mais de 500 projetos com Arduino, ESP32 e Pico prontos para montar.
Escaneie com seu celular
Aponte a câmera para o código para abrir a loja de aplicativos do seu celular.
ou abrir a loja

