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.

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ística | Valor |
|---|---|
| Chip driver | 2 × L9110S (um por motor) |
| Canais | 2 motores CC ou 1 pequeno motor de passo bipolar |
| Tensão de alimentação (VCC) | 2,5–12 V |
| Corrente contínua | Cerca de 800 mA por canal |
| Corrente de pico | Cerca de 1,5 A por curtos períodos |
| Entrada lógica | Compatível com 3,3 V e 5 V |
| Controle de velocidade | PWM nos pinos de entrada (sem pino enable separado) |
| Proteção | Diodos de roda livre integrados |
| Tamanho | Cerca de 3 × 2,5 cm, poucos gramas |
Pinagem e tabela-verdade do L9110S
| Pino | Função |
|---|---|
| B-IA | Entrada 1 do motor B (aceita PWM) |
| B-IB | Entrada 2 do motor B (aceita PWM) |
| GND | GND comum (negativo da bateria e GND do microcontrolador) |
| VCC | Alimentação do motor e do chip, 2,5–12 V |
| A-IA | Entrada 1 do motor A (aceita PWM) |
| A-IB | Entrada 2 do motor A (aceita PWM) |
| MOTOR A / MOTOR B | Bornes com parafuso de dois polos onde os motores são ligados |
| A-IA | A-IB | Motor A |
|---|---|---|
| HIGH | LOW | Gira para frente |
| LOW | HIGH | Gira para trás |
| LOW | LOW | Para |
| HIGH | HIGH | Para |
| PWM | LOW | Para frente, velocidade definida pelo ciclo de trabalho |
| LOW | PWM | Para 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 L9110S | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| A-IA | D5 | GPIO 25 | GP16 |
| A-IB | D6 | GPIO 26 | GP17 |
| B-IA | D9 | GPIO 32 | GP18 |
| B-IB | D10 | GPIO 33 | GP19 |
| VCC | Positivo da bateria (ex.: 4×AA, 6 V) | Positivo da bateria (ex.: 4×AA, 6 V) | Positivo da bateria (ex.: 4×AA, 6 V) |
| GND | GND (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) | A0 | GPIO 34 | GP26 |
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)
- Monte os dois motores CC com redução no chassi; ligue o motor esquerdo ao borne MOTOR A e o direito ao MOTOR B.
- 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.
- Ligue o positivo do suporte de 4×AA ao pino VCC do módulo e o negativo ao GND.
- Crie o GND comum ligando o pino GND do módulo ao pino GND do Uno com um jumper.
- Alimente o Uno pelo USB e carregue o código abaixo; no primeiro teste, deixe as rodas suspensas, fora do chão.
- Se um motor girar para o lado errado, troque os dois fios desse motor no borne.

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ódigo | O 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. |
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.
| Motor | Corrente típica | Para o L9110S |
|---|---|---|
| Micromotor N20 com redução (6 V) | 30–100 mA sem carga | Muito adequado |
| Motor amarelo TT com redução (3–6 V) | 150–250 mA sem carga, cerca de 1 A no travamento | Adequado; evite travamentos longos |
| Motor CC tipo 130 + hélice | 200–500 mA | Adequado (miniventoinha) |
| Ventoinha de computador sem escovas de 5 V | 100–250 mA | Adequado só em um sentido |
| Motor de 12 V com redução metálica (25GA/37GA) | 2–5 A no travamento | Não adequado, precisa de um driver mais forte |
| Motor RS-550 / 775 | De alguns ampères a dezenas de ampères | De 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.
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.
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ística | Módulo L9110S | Módulo L298N |
|---|---|---|
| Tensão do motor | 2,5–12 V | Cerca de 5–35 V |
| Corrente por canal | Cerca de 800 mA contínuos | Cerca de 2 A contínuos |
| Queda de tensão no driver | Baixa | Cerca de 2 V ou mais |
| Controle de velocidade | PWM nos pinos IA/IB | PWM nos pinos ENA/ENB |
| Pinos de controle necessários | 4 | 6 (4 com jumpers) |
| Regulador de 5 V integrado | Não tem | Sim (com alimentação de até 12 V) |
| Tamanho e peso | Muito pequeno, poucos gramas | Grande, com dissipador |
| Lógica de 3,3 V | Compatível | Geralmente 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
| Sintoma | Causa provável | Solução |
|---|---|---|
| O motor não gira de jeito nenhum | Falta GND comum ou não chega alimentação ao VCC | Ligue 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ó zumbe | O valor de duty está abaixo do limite de partida do motor | Aumente a velocidade mínima para algo em torno de 70–100 |
| O Arduino reinicia quando o motor parte | Os motores são alimentados pela mesma linha de 5V da placa | Use uma bateria separada para os motores e coloque um capacitor de 100 µF no VCC |
| Gira em um sentido, mas não no outro | Uma entrada está em um pino sem PWM ou um fio está sem contato | Ligue as quatro entradas em pinos PWM e confira os jumpers |
| O chip esquenta muito | A corrente do motor passa do limite de 800 mA ou o motor está travado | Use um motor menor, evite travamentos ou troque por um L298N |
| O ajuste de velocidade funciona ao contrário | Uma entrada está em HIGH e a outra em PWM | Deixe a entrada fixa em LOW ou subtraia o valor de duty de 255 |
| O motor gira por um instante quando o ESP32 liga | O pino escolhido gera sinal na inicialização | Use pinos que ficam quietos no boot, como GPIO 25, 26, 32 e 33 |
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.
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.

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.

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.

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…

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.

Uso do motor de passo
Um motor que gira passo a passo, exatamente o quanto você quer, como o ponteiro de um relógio.
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

