Componentes · 11 min de leitura

L9110S com Arduino: driver duplo de motor e controle de velocidade por PWM

Como ligar o driver de motor L9110S ao Arduino? Pinagem, controle de sentido e de velocidade por PWM, o limite de 800 mA, exemplos de carrinho robô e ventoinha, além de código para Uno, ESP32 e Pico.

O L9110S é um módulo driver de motor de dois canais, do tamanho da ponta de um dedo e muito barato, que permite controlar ao mesmo tempo o sentido e a velocidade de dois pequenos motores CC. A dupla L9110S e Arduino é uma das combinações mais práticas para carrinhos robô em miniatura movidos a pilha, pequenas ventoinhas, barquinhos de brinquedo e projetos com hélice. O módulo traz dois chips L9110S, e cada um consegue acionar um motor com cerca de 800 mA de corrente contínua por canal, na faixa de 2,5–12 V.

Um pino do Arduino não fornece corrente suficiente para acionar um motor diretamente: um pino do Uno entrega no máximo 20–40 mA, enquanto um pequeno motor amarelo com redução puxa muitas vezes isso na partida. Para mudar o sentido de giro, você também precisa inverter o sentido da corrente que passa pelo motor. Neste artigo você vai conhecer a pinagem do L9110S, a tabela-verdade, o controle de velocidade por PWM e o limite de corrente, e vai escrever código para um carrinho robô com Arduino Uno, uma ventoinha controlada por potenciômetro com ESP32 e MicroPython no Raspberry Pi Pico. Na última seção vamos esclarecer quando o L9110S pode substituir o L298N e quando não pode.

Módulo driver de motor de dois canais L9110S
Módulo L9110S: duas pontes H, uma barra de 6 pinos de entrada (B-IA, B-IB, GND, VCC, A-IA, A-IB) e bornes com parafuso para dois motores.

O que é o L9110S e como ele funciona?

Dentro do L9110S há uma ponte H formada por quatro chaves. Quando as chaves abrem e fecham em pares diagonais, a corrente passa pelo motor em um sentido ou no outro, e o motor gira para frente ou para trás. Cada ponte H tem dois pinos de entrada (IA e IB) e dois de saída (OA e OB). Coloque IA em HIGH e IB em LOW e o motor gira para um lado; inverta e ele gira para o outro. Se você aplicar um sinal PWM em uma dessas duas entradas, a tensão média que o motor recebe muda, e é assim que você ajusta a velocidade. O chip também tem diodos de proteção contra os picos de tensão reversa que o motor gera ao parar ou mudar de sentido, então não é preciso adicionar um diodo externo. O módulo não tem alimentação lógica separada nem regulador de 5 V: a tensão que você aplica no pino VCC alimenta tanto os chips quanto os motores.

CaracterísticaValor
Chip driver2 × L9110S (um por motor)
Canais2 motores CC ou 1 pequeno motor de passo bipolar
Tensão de alimentação (VCC)2,5–12 V
Corrente contínuaCerca de 800 mA por canal
Corrente de picoCerca de 1,5 A por curtos períodos
Entrada lógicaCompatível com 3,3 V e 5 V
Controle de velocidadePWM nos pinos de entrada (sem pino enable separado)
ProteçãoDiodos de roda livre integrados
TamanhoCerca de 3 × 2,5 cm, poucos gramas

Pinagem e tabela-verdade do L9110S

PinoFunção
B-IAEntrada 1 do motor B (aceita PWM)
B-IBEntrada 2 do motor B (aceita PWM)
GNDGND comum (negativo da bateria e GND do microcontrolador)
VCCAlimentação do motor e do chip, 2,5–12 V
A-IAEntrada 1 do motor A (aceita PWM)
A-IBEntrada 2 do motor A (aceita PWM)
MOTOR A / MOTOR BBornes com parafuso de dois polos onde os motores são ligados
A-IAA-IBMotor A
HIGHLOWGira para frente
LOWHIGHGira para trás
LOWLOWPara
HIGHHIGHPara
PWMLOWPara frente, velocidade definida pelo ciclo de trabalho
LOWPWMPara trás, velocidade definida pelo ciclo de trabalho

“Para frente” e “para trás” aqui são apenas nomes; o sentido real de giro depende da ordem em que você liga os fios do motor no borne. Se um motor girar para o lado errado, basta trocar os dois fios dele em vez de mexer no código. Como o módulo não tem pinos ENA/ENB como o L298N, você aplica PWM em uma das duas entradas para controlar a velocidade. Se faltarem pinos PWM, dá para manter uma entrada fixa em HIGH e aplicar PWM na outra, mas aí a lógica fica invertida: quanto maior o ciclo de trabalho, mais o motor desacelera, porque o motor para quando as duas entradas estão em HIGH. Por isso, o método mais limpo é reservar dois pinos PWM por motor.

Ligação do L9110S: Arduino Uno, ESP32 e Pico

Pino do L9110SArduino UnoESP32Raspberry Pi Pico
A-IAD5GPIO 25GP16
A-IBD6GPIO 26GP17
B-IAD9GPIO 32GP18
B-IBD10GPIO 33GP19
VCCPositivo da bateria (ex.: 4×AA, 6 V)Positivo da bateria (ex.: 4×AA, 6 V)Positivo da bateria (ex.: 4×AA, 6 V)
GNDGND (comum com o negativo da bateria)GND (comum com o negativo da bateria)GND (comum com o negativo da bateria)
Cursor do potenciômetro (opcional)A0GPIO 34GP26
Nunca alimente os motores pelo pino 5V do Arduino e não se esqueça de ligar o GND do módulo ao GND do microcontrolador. A corrente repentina que o motor puxa na partida derruba a linha de 5V; a placa reinicia e, no ESP32, aparece o erro de brownout. Sem um GND comum, o sinal PWM perde a referência e o motor não gira ou se comporta de forma aleatória. Ligar VCC e GND invertidos queima os chips L9110S na hora.

Escolha uma alimentação próxima da tensão nominal do seu motor. Para motores amarelos TT com redução e micromotores N20, 4 pilhas AA (cerca de 6 V) são um ótimo começo. Duas células Li-Ion 18650 em série fornecem 7,4 V (8,4 V com carga completa); motores de 6 V aguentam, mas esquentam mais e se desgastam mais rápido, então é uma boa ideia limitar a velocidade máxima com PWM. Soldar um capacitor eletrolítico de 100 µF na linha VCC do módulo, perto do borne, e um capacitor cerâmico de 100 nF entre os dois terminais de cada motor reduz muito o ruído do motor que chega ao microcontrolador. Para estimar a duração da bateria, você pode usar a calculadora de autonomia da bateria: um robô que puxa 450 mA no total de pilhas AA de 2000 mAh dura aproximadamente 2000 / 450 ≈ 4,4 horas; na prática, um pouco menos.

Passo a passo: carrinho robô com L9110S (Arduino Uno)

  1. Monte os dois motores CC com redução no chassi; ligue o motor esquerdo ao borne MOTOR A e o direito ao MOTOR B.
  2. Ligue os pinos A-IA e A-IB do módulo aos pinos D5 e D6 do Uno, e B-IA e B-IB aos pinos D9 e D10; os quatro suportam PWM.
  3. Ligue o positivo do suporte de 4×AA ao pino VCC do módulo e o negativo ao GND.
  4. Crie o GND comum ligando o pino GND do módulo ao pino GND do Uno com um jumper.
  5. Alimente o Uno pelo USB e carregue o código abaixo; no primeiro teste, deixe as rodas suspensas, fora do chão.
  6. Se um motor girar para o lado errado, troque os dois fios desse motor no borne.
Conjunto de motor CC com redução e roda
Os motores amarelos TT com redução são os mais comuns em carrinhos robô, e o L9110S os aciona com folga dentro do seu limite de corrente.
C++ (Arduino IDE)
1// L9110S ile iki motorlu robot araba / Two-motor robot car with L9110S
2const int A_IA = 5;   // Sol motor girişi 1 (PWM) / left motor input 1 (PWM)
3const int A_IB = 6;   // Sol motor girişi 2 (PWM) / left motor input 2 (PWM)
4const int B_IA = 9;   // Sağ motor girişi 1 (PWM) / right motor input 1 (PWM)
5const int B_IB = 10;  // Sağ motor girişi 2 (PWM) / right motor input 2 (PWM)
6
7// hız: -255 tam geri, 0 dur, 255 tam ileri / speed: -255 full reverse, 0 stop, 255 full forward
8void setMotor(int pinIA, int pinIB, int speed) {
9  speed = constrain(speed, -255, 255);
10  if (speed > 0) {
11    analogWrite(pinIA, speed);   // ileri / forward
12    analogWrite(pinIB, 0);
13  } else if (speed < 0) {
14    analogWrite(pinIA, 0);       // geri / reverse
15    analogWrite(pinIB, -speed);
16  } else {
17    analogWrite(pinIA, 0);       // dur / stop
18    analogWrite(pinIB, 0);
19  }
20}
21
22void drive(int left, int right) {
23  setMotor(A_IA, A_IB, left);
24  setMotor(B_IA, B_IB, right);
25}
26
27void setup() {
28  pinMode(A_IA, OUTPUT);
29  pinMode(A_IB, OUTPUT);
30  pinMode(B_IA, OUTPUT);
31  pinMode(B_IB, OUTPUT);
32  drive(0, 0);
33  delay(2000);                   // tekerlekleri kaldırmak için süre / time to lift the wheels
34}
35
36void loop() {
37  for (int s = 80; s <= 200; s += 5) {   // yumuşak kalkış / soft start
38    drive(s, s);
39    delay(30);
40  }
41  delay(1500);                   // 200 hızla ileri / forward at speed 200
42  drive(0, 0);
43  delay(500);
44  drive(-160, -160);             // geri / reverse
45  delay(1000);
46  drive(0, 0);
47  delay(500);
48  drive(-150, 150);              // yerinde sola dön / spin left in place
49  delay(600);
50  drive(150, -150);              // yerinde sağa dön / spin right in place
51  delay(600);
52  drive(0, 0);
53  delay(2000);
54}
Trecho do códigoO que faz
setMotor(pinIA, pinIB, speed) (define o motor)Envia PWM para uma entrada e 0 para a outra conforme o sinal da velocidade; positivo é para frente, negativo para trás, 0 para.
constrain(speed, -255, 255) (limita o valor)Corta valores que ultrapassam a faixa do analogWrite.
drive(left, right) (aciona os dois motores)Controla os dois motores juntos; valores iguais vão em linha reta, sinais opostos giram o carrinho no lugar.
laço for (80 → 200)Partida suave: reduz o pico repentino de corrente e a patinação das rodas.
drive(-150, 150) (giro à esquerda)O motor esquerdo gira para trás e o direito para frente; o carrinho gira para a esquerda em torno do próprio eixo.
A maioria dos pequenos motores com redução não consegue começar a girar com valores baixos de ciclo de trabalho; para vencer o atrito, geralmente é preciso um limite inferior de 70–100 (30–40 por cento). Para descobrir o valor de partida do seu motor, aumente a velocidade a partir de 0 aos poucos, mostre o valor no Monitor Serial e coloque no código, como velocidade mínima, o valor em que o motor começa a girar.

Controle de velocidade por PWM: ciclo de trabalho e tensão média

O PWM aplica uma tensão média ao motor ligando e desligando o pino centenas de vezes por segundo. Graças à inércia, o motor percebe esses pulsos rápidos como uma média. Você pode calcular a tensão média aproximadamente com a fórmula V_méd = V_alim × duty / 255: com alimentação de 6 V, analogWrite(pin, 150) corresponde a cerca de 6 × 150 / 255 ≈ 3,5 V. No Arduino Uno, os pinos D5 e D6 geram PWM de cerca de 980 Hz e os pinos D9 e D10 de cerca de 490 Hz; é normal ouvir um leve zumbido do motor nessas frequências. No ESP32 e no Pico você mesmo escolhe a frequência; algo em torno de 1 kHz é um começo seguro para o L9110S. Em frequências muito altas o chip gera mais calor a cada chaveamento, enquanto em frequências muito baixas o motor gira aos trancos. Para mais detalhes, dê uma olhada no artigo O que é PWM.

Limite de corrente: quais motores o L9110S aguenta?

O limite mais importante do L9110S é de cerca de 800 mA de corrente contínua por canal. O valor a observar não é a corrente que o motor puxa sem carga, e sim a corrente de travamento (stall). Quando o motor dá a partida, ou quando uma roda bate em um obstáculo e para, só a resistência do enrolamento limita a corrente, e o motor puxa o máximo. Você pode estimar esse valor com a lei de Ohm: se a resistência do enrolamento medida com o multímetro for de 5 Ω e a alimentação de 6 V, a corrente de travamento fica em cerca de 6 / 5 = 1,2 A. Isso não é problema durante uma partida rápida, mas se o carrinho empurrar uma parede e ficar segundos com as rodas sem conseguir girar, o chip esquenta rápido. Como o módulo não tem dissipador, o ideal é não manter por muito tempo cargas contínuas acima de 500 mA por canal.

MotorCorrente típicaPara o L9110S
Micromotor N20 com redução (6 V)30–100 mA sem cargaMuito adequado
Motor amarelo TT com redução (3–6 V)150–250 mA sem carga, cerca de 1 A no travamentoAdequado; evite travamentos longos
Motor CC tipo 130 + hélice200–500 mAAdequado (miniventoinha)
Ventoinha de computador sem escovas de 5 V100–250 mAAdequado só em um sentido
Motor de 12 V com redução metálica (25GA/37GA)2–5 A no travamentoNão adequado, precisa de um driver mais forte
Motor RS-550 / 775De alguns ampères a dezenas de ampèresDe jeito nenhum

L9110S com ESP32: velocidade e sentido da ventoinha com potenciômetro

Os pinos do ESP32 trabalham em 3,3 V e as entradas do L9110S leem esse nível sem problemas; não é preciso conversor de nível lógico. No exemplo abaixo, ligamos um pequeno motor 130 com hélice ao borne MOTOR A. Com um potenciômetro com os terminais externos em 3V3 e GND e o cursor no GPIO 34, a ventoinha fica parada quando ele está no meio; gire para um lado e ela sopra cada vez mais rápido, gire para o outro e ela puxa o ar no sentido contrário. A pequena zona morta no meio impede que as leituras instáveis do potenciômetro fiquem empurrando o motor para frente e para trás o tempo todo. O código separa com #if a diferença do LEDC entre o core do Arduino para ESP32 2.x e 3.x; se quiser usar também o canal B, adicione os GPIO 32 e 33 da mesma forma.

C++ (Arduino IDE)
1// ESP32 + L9110S: potansiyometre ile fan hızı ve yönü / fan speed and direction with a potentiometer
2const int FAN_IA = 25;      // Motor A girişi 1 / Motor A input 1
3const int FAN_IB = 26;      // Motor A girişi 2 / Motor A input 2
4const int POT_PIN = 34;     // Potansiyometre orta ucu (ADC1) / potentiometer wiper (ADC1)
5const int PWM_FREQ = 1000;  // PWM frekansı (Hz) / PWM frequency (Hz)
6const int PWM_RES = 8;      // 8 bit: 0-255 / 8 bit: 0-255
7const int DEAD_ZONE = 40;   // ortadaki ölü bölge / dead zone around the middle
8
9void pwmBegin(int pin, int channel) {
10#if ESP_ARDUINO_VERSION_MAJOR >= 3
11  (void)channel;                          // 3.x kanalı kendisi seçer / 3.x picks the channel itself
12  ledcAttach(pin, PWM_FREQ, PWM_RES);
13#else
14  ledcSetup(channel, PWM_FREQ, PWM_RES);  // 2.x: önce kanal ayarı / 2.x: set up the channel first
15  ledcAttachPin(pin, channel);
16#endif
17}
18
19void pwmSet(int pin, int channel, int duty) {
20#if ESP_ARDUINO_VERSION_MAJOR >= 3
21  (void)channel;
22  ledcWrite(pin, duty);                   // 3.x: pin numarasıyla / 3.x: by pin number
23#else
24  (void)pin;
25  ledcWrite(channel, duty);               // 2.x: kanal numarasıyla / 2.x: by channel number
26#endif
27}
28
29void setFan(int speed) {
30  speed = constrain(speed, -255, 255);
31  if (speed >= 0) {
32    pwmSet(FAN_IA, 0, speed);   // üfle / blow
33    pwmSet(FAN_IB, 1, 0);
34  } else {
35    pwmSet(FAN_IA, 0, 0);       // ters yönde em / suck in reverse
36    pwmSet(FAN_IB, 1, -speed);
37  }
38}
39
40void setup() {
41  Serial.begin(115200);
42  analogReadResolution(12);     // 0-4095
43  pwmBegin(FAN_IA, 0);
44  pwmBegin(FAN_IB, 1);
45  setFan(0);
46}
47
48void loop() {
49  int raw = analogRead(POT_PIN);
50  int speed = map(raw, 0, 4095, -255, 255);
51  if (abs(speed) < DEAD_ZONE) speed = 0;  // ortada dur / stop in the middle
52  setFan(speed);
53  Serial.printf("ADC: %d  Hiz/Speed: %d\n", raw, speed);
54  delay(50);
55}

Raspberry Pi Pico e MicroPython com o L9110S

Todo pino GPIO do Pico gera PWM por hardware, então você tem bastante liberdade para escolher os pinos. No exemplo, o motor esquerdo está em GP16 e GP17 e o direito em GP18 e GP19. O código define cada motor como uma classe e recebe a velocidade em porcentagem (-100 a 100), assim você não precisa lidar com a faixa de 0–65535 do duty_u16. Alimente o Pico pelo USB e os motores pelo pack de baterias ligado ao VCC do módulo, e una os dois GNDs. Quando você para o programa com Ctrl+C no Thonny, o bloco KeyboardInterrupt para os motores com segurança; sem ele, o hardware PWM continua funcionando e seu carrinho pode sair andando da mesa.

MicroPython
1from machine import Pin, PWM
2import time
3
4class Motor:
5    def __init__(self, pin_ia, pin_ib, freq=1000):
6        self.ia = PWM(Pin(pin_ia))       # IA girişi / IA input
7        self.ib = PWM(Pin(pin_ib))       # IB girişi / IB input
8        self.ia.freq(freq)
9        self.ib.freq(freq)
10        self.stop()
11
12    def speed(self, percent):            # -100 geri ... 100 ileri / -100 reverse ... 100 forward
13        percent = max(-100, min(100, percent))
14        duty = int(abs(percent) * 65535 // 100)
15        if percent > 0:
16            self.ia.duty_u16(duty)
17            self.ib.duty_u16(0)
18        elif percent < 0:
19            self.ia.duty_u16(0)
20            self.ib.duty_u16(duty)
21        else:
22            self.stop()
23
24    def stop(self):
25        self.ia.duty_u16(0)
26        self.ib.duty_u16(0)
27
28left = Motor(16, 17)    # A-IA = GP16, A-IB = GP17
29right = Motor(18, 19)   # B-IA = GP18, B-IB = GP19
30
31def drive(l, r, ms):
32    left.speed(l)
33    right.speed(r)
34    time.sleep_ms(ms)
35
36try:
37    while True:
38        for s in range(30, 81, 5):       # yumuşak kalkış / soft start
39            drive(s, s, 40)
40        drive(80, 80, 1500)              # ileri / forward
41        drive(0, 0, 500)
42        drive(-60, -60, 1000)            # geri / reverse
43        drive(0, 0, 500)
44        drive(-60, 60, 600)              # yerinde sola dön / spin left in place
45        drive(0, 0, 2000)
46except KeyboardInterrupt:
47    left.stop()                          # Ctrl+C ile güvenli dur / safe stop on Ctrl+C
48    right.stop()

L9110S ou L298N? Qual usar?

CaracterísticaMódulo L9110SMódulo L298N
Tensão do motor2,5–12 VCerca de 5–35 V
Corrente por canalCerca de 800 mA contínuosCerca de 2 A contínuos
Queda de tensão no driverBaixaCerca de 2 V ou mais
Controle de velocidadePWM nos pinos IA/IBPWM nos pinos ENA/ENB
Pinos de controle necessários46 (4 com jumpers)
Regulador de 5 V integradoNão temSim (com alimentação de até 12 V)
Tamanho e pesoMuito pequeno, poucos gramasGrande, com dissipador
Lógica de 3,3 VCompatívelGeralmente funciona

Resumindo: se seus motores trabalham abaixo de 12 V e nenhum deles passa muito de 1 A mesmo no travamento, o L9110S é a melhor escolha: é menor, mais leve e não desperdiça os cerca de 2 V perdidos nos transistores bipolares do L298N. Essa diferença é bem perceptível em projetos a bateria: com um pack de 6 V, o L298N deixa uns 4 V para o motor, enquanto o L9110S entrega a maior parte da alimentação ao motor e seu carrinho fica visivelmente mais rápido. Por outro lado, para motores de 12 V com redução metálica, chassis pesados, cargas contínuas acima de 1 A ou alimentação acima de 12 V, você precisa do L298N ou de drivers mais modernos com MOSFET. Para uma comparação detalhada com alternativas como o TB6612FNG, veja o artigo comparação de drivers de motor.

Ideias de projetos com o L9110S

  • Minicarro controlado por Bluetooth: com um módulo HC-05, chame a função drive() conforme as letras que chegam do celular.
  • Robô que desvia de obstáculos: coloque um HC-SR04 na frente e monte um robô que dá ré e vira quando há um obstáculo a menos de 20 cm; os detalhes estão no artigo robô que desvia de obstáculos.
  • Robô seguidor de linha: siga uma linha preta com dois sensores TCRT5000; motores N20 e o L9110S resultam em um robô leve e ágil.
  • Ventoinha controlada pela temperatura: aumente a velocidade da ventoinha aos poucos com PWM conforme a temperatura medida; a lógica está no artigo controle de ventoinha com Arduino.
  • Direção de tanque com joystick: transforme os eixos X e Y do joystick nas velocidades dos motores esquerdo e direito.
  • Carrinho controlado por Wi-Fi: envie comandos de sentido e velocidade pelos botões de uma página web servida pelo ESP32.
  • Miniguindaste ou abridor de cortina: enrole um fio com um motor com redução; pare o motor nos pontos extremos com uma chave de fim de curso.

Erros comuns e como resolver

SintomaCausa provávelSolução
O motor não gira de jeito nenhumFalta GND comum ou não chega alimentação ao VCCLigue o GND do módulo ao GND da placa e meça o VCC com o multímetro
Em baixa velocidade o motor não gira, só zumbeO valor de duty está abaixo do limite de partida do motorAumente a velocidade mínima para algo em torno de 70–100
O Arduino reinicia quando o motor parteOs motores são alimentados pela mesma linha de 5V da placaUse uma bateria separada para os motores e coloque um capacitor de 100 µF no VCC
Gira em um sentido, mas não no outroUma entrada está em um pino sem PWM ou um fio está sem contatoLigue as quatro entradas em pinos PWM e confira os jumpers
O chip esquenta muitoA corrente do motor passa do limite de 800 mA ou o motor está travadoUse um motor menor, evite travamentos ou troque por um L298N
O ajuste de velocidade funciona ao contrárioUma entrada está em HIGH e a outra em PWMDeixe a entrada fixa em LOW ou subtraia o valor de duty de 255
O motor gira por um instante quando o ESP32 ligaO pino escolhido gera sinal na inicializaçãoUse pinos que ficam quietos no boot, como GPIO 25, 26, 32 e 33
Ao testar pela primeira vez um robô recém-montado, sempre deixe as rodas suspensas e limite a velocidade a cerca de 150. Se houver erro de ligação, o carrinho não dispara da mesa e você consegue conferir a temperatura do chip com calma. Se depois de alguns minutos funcionando o chip estiver quente demais para tocar, a corrente do motor é demais para o L9110S.

O L9110S é um driver leve, barato e eficiente para projetos a bateria com motores pequenos; se você conhecer os limites dele e combiná-lo com o motor certo, ele vai funcionar sem problemas por muito tempo. Quando partir para motores maiores, pode continuar usando a mesma lógica de sentido e PWM com o L298N. No app BlueGrays você encontra esquemas do circuito e códigos passo a passo de projetos como carrinho controlado por Bluetooth, robô que desvia de obstáculos e controle PWM com potenciômetro, e pode adaptar facilmente a eles a ligação do L9110S mostrada aqui. O guia como fazer um carrinho robô com Arduino também vai ajudar na escolha do chassi, das rodas e da bateria.

Perguntas frequentes

Quantos ampères o L9110S aguenta?

O L9110S fornece cerca de 800 mA de corrente contínua por canal, com pico de curta duração de cerca de 1,5 A. Como o módulo tem dois chips, ele aciona dois motores separadamente, cada um com esse limite. Para uma vida longa, uma boa regra é manter a corrente contínua por motor abaixo de 500–600 mA.

O L9110S consegue acionar um motor de 12 V?

A tensão máxima de alimentação do módulo é 12 V, então, em teoria, dá para acionar um pequeno motor de 12 V. Mas a maioria dos motores de 12 V puxa bem mais de 1 A no travamento, e um chip trabalhando no limite esquenta. Para motores de 12 V, um L298N ou um driver com MOSFET é uma escolha mais segura.

O L9110S funciona com o ESP32 e 3,3 V?

Sim. Os pinos de entrada do L9110S leem o nível lógico de 3,3 V como HIGH, então você pode ligá-lo diretamente ao ESP32, ao Raspberry Pi Pico e a outras placas de 3,3 V. Basta fornecer a alimentação dos motores separadamente no VCC e unir os GNDs.

Qual é melhor, o L9110S ou o L298N?

Para projetos a bateria com motores pequenos, o L9110S é melhor: é menor e mais leve e não perde cerca de 2 V como o L298N. Se a corrente do motor passar de 1 A ou você precisar de alimentação acima de 12 V, escolha o L298N.

O L9110S consegue acionar um motor de passo?

Sim, as duas pontes H do módulo conseguem acionar as duas bobinas de um pequeno motor de passo bipolar (4 fios), e a biblioteca Stepper do Arduino funciona com essa ligação. A corrente da bobina não pode passar de 800 mA. Para motores unipolares de 5 fios, como o 28BYJ-48, uma placa ULN2003 é mais indicada.

Por que o L9110S esquenta tanto?

A causa mais comum do aquecimento é o motor puxar corrente perto do limite do chip; motores com rodas travadas ou carga pesada, em especial, chegam perto da corrente de travamento. Uma tensão de alimentação maior que a tensão nominal do motor também aumenta a corrente. Use um motor menor, limite a velocidade máxima com PWM ou passe para um driver mais potente.

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
Brilho do LED com potenciômetro no ESP32 (analógico → PWM)
ES-13Intermediário
Premium

Brilho do LED com potenciômetro no ESP32 (analógico → PWM)

Neste projeto, controlamos o brilho de um LED de forma analógica com um potenciômetro. O pino ADC do ESP32 lê a tensão de 0-3,3V do potenciômetro e converte esse valor em um sinal PWM (modulação por largura de pulso), enviado ao LED. Assim, ao girar o potenciômetro, o brilho do LED aumenta e diminui gradualmente. Com Arduino Core 3.0+, você pode usar analogWrite() diretamente; no ESP32-S2/S3, a resolução do ADC é fixada em 12 bits.

4.5(19)
32
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
Controle de servos com joystick
AR-60Intermediário
Premium

Controle de servos com joystick

Controle dois motores com um joystick, como ao girar uma câmera de segurança. Empurre a alavanca para os lados e o servo motor inferior gira lentamente; mova para cima ou para baixo e o servo…

4.7(42)
58
Uso de servo motor com potenciômetro
AR-36Iniciante
Premium

Uso de servo motor com potenciômetro

Conforme você gira o botão do potenciômetro, o braço do servo motor gira junto: uma extremidade do botão corresponde a zero grau, e a outra, a meia volta.

4.6(37)
53
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