Guias · 13 min de leitura

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.

Módulo driver de motor L298N com dissipador
Módulo driver de motor L298N: dois canais, até 2 A, um grande dissipador de alumínio e um regulador de 5 V na placa.

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ísticaL298NL293DL9110STB6612FNGA4988
Tipo de motor2 CC ou 1 de passo bipolar2 CC ou 1 de passo bipolar2 CC2 CC ou 1 de passo bipolar1 de passo bipolar
Tensão do motor5–35 V (módulo)4,5–36 V2,5–12 V4,5–13,5 V (máximo absoluto 15 V)8–35 V
Corrente contínua (por canal)2 A (com dissipador)0,6 Acerca de 0,8 A1,2 Acerca de 1 A sem dissipador, 2 A com refrigeração
Corrente de pico3 A1,2 Acerca de 1,5 A3,2 A2 A
Tecnologia de chaveamentoTransistor bipolarTransistor bipolarTransistor (baixa saturação)MOSFETMOSFET + controle de corrente
Queda de tensãocerca de 2–3 Vcerca de 1,8–2,6 Vcerca de 1 Vcerca de 0,5 V (a 1 A)Controlado por corrente, não é problema
EficiênciaBaixaBaixaMédiaAltaAlta
Alimentação lógica5 V (regulador no módulo)4,5–7 V (VCC1)Compartilhada com a alimentação do motor2,7–5,5 V (VCC)3–5,5 V (VDD)
Compatibilidade com sinal de 3,3 VGeralmente funcionaAs entradas aceitam, alimentação lógica de 5 VTotalmente compatívelTotalmente compatívelTotalmente compatível
Preço (relativo)BaixoBaixoMuito baixoMédioBaixo

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:

DriverPerda de tensão típicaTensão que sobra para o motorPotência perdida como calor no driverEficiência aproximada
L298N1,8 V4,2 V1,08 W70%
L293D2,0 V4,0 V1,2 W67%
L9110S0,8 V5,2 V0,48 W87%
TB6612FNG0,3 V5,7 V0,18 W95%
Se você precisar usar um L298N, escolha uma alimentação do motor cerca de 2 V acima da tensão nominal do motor. Por exemplo, uma fonte de 8 V para motores de 6 V e de cerca de 14 V para motores de 12 V compensa a perda no driver. O TB6612FNG não precisa dessa correção.

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çãoPino do L298NPino do TB6612FNGArduino UnoESP32Raspberry Pi Pico
Velocidade do motor A (PWM)ENAPWMAD5GPIO 25GP16
Direção 1 do motor AIN1AIN1D4GPIO 26GP17
Direção 2 do motor AIN2AIN2D7GPIO 27GP18
Velocidade do motor B (PWM)ENBPWMBD6GPIO 13GP21
Direção 1 do motor BIN3BIN1D8GPIO 33GP19
Direção 2 do motor BIN4BIN2D9GPIO 32GP20
Standby / habilitaçãoNenhumSTBYD10GPIO 4GP22
Alimentação lógica+5V (saída do regulador)VCC5V3V33V3 (OUT)
Alimentação do motor+12VVMFonte externaFonte externaFonte externa
TerraGNDGNDGNDGNDGND
O erro mais comum é não ligar o GND da fonte do motor ao GND da placa; sem um GND comum, os sinais de direção e PWM perdem o sentido. O segundo grande erro é deixar o jumper 5V-EN colocado em um módulo L298N quando a alimentação passa de 12 V; o regulador da placa pode superaquecer e queimar. Se você estiver acima de 12 V, retire o jumper e alimente o pino +5V com o 5V do Arduino. E nunca alimente motores pelo pino 5V do Arduino.

Passo a passo: acionando dois motores CC com Arduino

  1. 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.
  2. Ligue o terminal negativo da fonte tanto ao GND do driver quanto ao GND do Arduino.
  3. 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.
  4. 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.
  5. 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.
  6. Carregue o código abaixo e faça o primeiro teste com as rodas fora do chão.
C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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.

MicroPython
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.

C++ (Arduino IDE)
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}
Nunca conecte nem desconecte o cabo do motor de passo com o A4988 energizado; o pico de tensão gerado na bobina pode destruir o driver na hora. Além disso, motores unipolares de 5 fios como o 28BYJ-48 não podem ser acionados diretamente por um A4988; use a placa ULN2003 que vem com eles.

Qual driver para qual projeto?

ProjetoDriver recomendadoPor 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 UnoShield L293D ou L298N4 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)A4988Limite de corrente e micropasso
Motor de passo 28BYJ-48Placa ULN2003Motor unipolar, compatível diretamente com 5 V
Mini bomba d'água de 6 V em um só sentidoMOSFET de nível lógico ou um canal do L9110SPonte H é desnecessária se o sentido nunca muda
Bomba reversível ou bomba peristálticaTB6612FNGInversão de sentido e PWM eficiente
Qualquer projeto com motor CC baseado em ESP32 ou PicoTB6612FNGTotal 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

ProblemaCausa provávelSolução
O Arduino reinicia quando o motor giraO motor é alimentado pelo 5V do Arduino ou a fonte é fracaUse uma fonte separada para o motor, una os GNDs, coloque um capacitor de 100–470 µF na alimentação
Os motores não respondemSem GND comum, ou STBY em LOW no TB6612FNGUna os GNDs, coloque o pino STBY em HIGH
A velocidade não muda, motor sempre no máximoJumper ENA/ENB colocado no L298NRetire o jumper, ligue ENA/ENB a um pino PWM
Motor muito lento e fraco com o L298NPerda de tensão de 2–3 V no driverAumente a tensão da fonte ou troque pelo TB6612FNG
Zumbido agudo vindo do motorFrequência do PWM na faixa audívelSuba o PWM para 20 kHz no ESP32 ou no Pico
Motor de passo vibra mas não giraPares de bobinas trocados ou Vref muito baixoEncontre os pares de bobinas com um multímetro, ajuste o Vref pela fórmula
O driver superaquece e desligaA corrente de travamento do motor passa do limite do driverEscolha um driver mais forte, adicione um dissipador, não force o motor
Antes de trabalhar com um motor novo, meça a resistência da bobina com um multímetro e estime a corrente de travamento com I = V / R. Por exemplo, um motor de 6 V com resistência de 5 ohm consome cerca de 1,2 A quando travado; nesse caso, o limite de 0,6 A do L293D é baixo demais, enquanto o TB6612FNG ou o L298N são adequados.

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.

Ver todos os projetos
Carrinho controlado por Bluetooth com L298N
AR-80Avançado
Premium

Carrinho controlado por Bluetooth com L298N

Transforme seu celular em um controle remoto e dirija seu próprio carrinho robô.

5.0(39)
66
Robô que desvia de obstáculos
AR-81Avançado
Premium

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.

5.0(38)
49
Uso do motor de passo
AR-67Intermediário
Premium

Uso do motor de passo

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

4.5(31)
42
Servo motor de 360 graus com motor de passo
AR-68Intermediário
Premium

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.

4.5(22)
33
Estação de irrigação inteligente
AR-83Avançado
Premium

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.

5.0(42)
57
Variação gradual do brilho do LED com PWM no ESP32
ES-8Iniciante

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.

4.8(36)
55
Raspberry Pi Pico: variação de brilho do LED com PWM (efeito de respiração)
PI-14Iniciante

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.

4