Componentes · 10 min de lectura

Controlador de motor L9110S con Arduino: PWM y velocidad

¿Cómo conectar el L9110S a Arduino? Pines, giro y control de velocidad PWM, límite de 800 mA, coche robot y ventilador con código para Uno, ESP32 y Pico.

El L9110S es un módulo controlador de motores de doble canal, del tamaño de la yema de un dedo y muy barato, que te permite controlar a la vez el sentido y la velocidad de dos pequeños motores DC. La pareja L9110S y Arduino es una de las soluciones más prácticas para mini coches robot con pilas, ventiladores pequeños, barquitos de juguete y proyectos con hélice. El módulo lleva dos chips L9110S; cada uno puede mover un motor con unos 800 mA continuos por canal, en un rango de 2,5–12 V.

Los pines de Arduino no pueden dar la corriente necesaria para mover un motor directamente: un pin del Uno da como máximo 20–40 mA, mientras que un pequeño motor amarillo con reductora consume decenas de veces más al arrancar. Además, para cambiar el sentido de giro hay que invertir la dirección de la corriente que pasa por el motor. En este artículo aprenderás los pines del módulo L9110S, su tabla de verdad, el control de velocidad con PWM y el límite de corriente; escribirás el código de un coche robot con Arduino Uno, un ventilador controlado con potenciómetro con ESP32 y MicroPython con Raspberry Pi Pico. En la última sección aclararemos cuándo el L9110S puede sustituir al L298N y cuándo no.

Módulo controlador de motores de doble canal L9110S
Módulo L9110S: dos puentes en H, cabecera de entrada de 6 pines (B-IA, B-IB, GND, VCC, A-IA, A-IB) y bornes de tornillo para dos motores.

¿Qué es el L9110S y cómo funciona?

Dentro del L9110S hay un puente en H formado por cuatro interruptores. Cuando los interruptores se abren y cierran en pares cruzados, la corriente atraviesa el motor en un sentido o en el contrario, y el motor gira hacia delante o hacia atrás. Cada puente en H tiene dos pines de entrada (IA e IB) y dos de salida (OA y OB). Si pones IA en HIGH e IB en LOW, el motor gira en un sentido; si inviertes los valores, gira en el otro. Si aplicas una señal PWM a una de esas dos entradas, cambia la tensión media que ve el motor y así regulas su velocidad. El chip también incluye diodos de protección contra los picos de tensión inversa que genera el motor al detenerse o cambiar de sentido, así que no necesitas añadir diodos externos. El módulo no tiene alimentación lógica separada ni regulador de 5 V: la tensión que das al pin VCC alimenta tanto los chips como los motores.

CaracterísticaValor
Chip controlador2 × L9110S (uno por motor)
Número de canales2 motores DC o 1 pequeño motor paso a paso bipolar
Tensión de alimentación (VCC)2,5–12 V
Corriente continuaUnos 800 mA por canal
Corriente picoUnos 1,5 A durante poco tiempo
Entrada lógicaCompatible con 3,3 V y 5 V
Control de velocidadPWM en los pines de entrada (no hay pin enable)
ProtecciónDiodos de rueda libre integrados
TamañoUnos 3 × 2,5 cm, pesa pocos gramos

Pines del L9110S y tabla de verdad

PinFunción
B-IAEntrada 1 del motor B (admite PWM)
B-IBEntrada 2 del motor B (admite PWM)
GNDMasa común (negativo de la batería y GND del microcontrolador)
VCCAlimentación de motores y chip, 2,5–12 V
A-IAEntrada 1 del motor A (admite PWM)
A-IBEntrada 2 del motor A (admite PWM)
MOTOR A / MOTOR BBornes de tornillo de dos terminales donde conectas los motores
A-IAA-IBMotor A
HIGHLOWGira hacia delante
LOWHIGHGira hacia atrás
LOWLOWParado
HIGHHIGHParado
PWMLOWAdelante, velocidad según el duty
LOWPWMAtrás, velocidad según el duty

"Adelante" y "atrás" son solo nombres; el sentido real de giro depende del orden en que conectes los cables al borne. Si el motor gira al revés, no te compliques con el código: intercambia sus dos cables. Como el módulo no tiene pines ENA/ENB como el L298N, la velocidad se controla aplicando PWM a una de las dos entradas. Si te faltan pines PWM, puedes dejar una entrada fija en HIGH y aplicar PWM a la otra; pero entonces la lógica se invierte: cuanto más sube el duty, el motor va más lento, porque con las dos entradas en HIGH el motor se detiene. Por eso lo más limpio es reservar dos pines PWM por motor.

Conexión del L9110S: Arduino Uno, ESP32 y Pico

Pin L9110SArduino UnoESP32Raspberry Pi Pico
A-IAD5GPIO 25GP16
A-IBD6GPIO 26GP17
B-IAD9GPIO 32GP18
B-IBD10GPIO 33GP19
VCCPositivo de la batería (p. ej. 4×AA, 6 V)Positivo de la batería (p. ej. 4×AA, 6 V)Positivo de la batería (p. ej. 4×AA, 6 V)
GNDGND (común con el negativo de la batería)GND (común con el negativo de la batería)GND (común con el negativo de la batería)
Pin central del potenciómetro (opcional)A0GPIO 34GP26
No alimentes nunca los motores desde el pin 5V de Arduino y no olvides unir el GND del módulo con el GND del microcontrolador. La corriente de arranque del motor hunde la línea de 5V; la placa se reinicia y en el ESP32 obtienes un error de brownout. Sin GND común la señal PWM pierde su referencia y el motor no gira o se comporta de forma aleatoria. Invertir VCC y GND quema los chips L9110S al instante.

Para la alimentación, elige una fuente cercana a la tensión nominal de tu motor. Para los motores amarillos TT con reductora y los micromotores N20, 4 pilas AA (unos 6 V) son un buen punto de partida. Dos pilas Li-Ion 18650 en serie dan 7,4 V (8,4 V a plena carga); los motores de 6 V lo soportan, pero se calientan y se desgastan antes, y en ese caso conviene limitar la velocidad máxima con PWM. Soldar un condensador electrolítico de 100 µF en la línea VCC del módulo, cerca del borne, y uno cerámico de 100 nF entre los dos terminales de cada motor reduce mucho el ruido del motor que afecta al microcontrolador. Para estimar la duración de la batería puedes usar la calculadora de duración de batería: con pilas AA de 2000 mAh, un robot que consume 450 mA en total dura aproximadamente 2000 / 450 ≈ 4,4 horas; en la práctica algo menos.

Paso a paso: coche robot con L9110S (Arduino Uno)

  1. Monta los dos motores DC con reductora en el chasis; conecta el motor izquierdo al borne MOTOR A y el derecho al borne MOTOR B.
  2. Conecta los pines A-IA y A-IB del módulo a D5 y D6 del Uno, y B-IA y B-IB a D9 y D10; los cuatro admiten PWM.
  3. Conecta el positivo del portapilas 4×AA al pin VCC del módulo y el negativo al pin GND.
  4. Une el pin GND del módulo con el GND del Uno mediante un cable puente para crear la masa común.
  5. Alimenta el Uno por USB y sube el código siguiente; en la primera prueba levanta las ruedas del suelo.
  6. Si algún motor gira al revés, intercambia sus dos cables en el borne.
Motor DC con reductora y juego de ruedas
Los motores amarillos TT con reductora son los más habituales en coches robot y el L9110S los mueve sin problemas dentro de su límite de corriente.
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}
Fragmento de códigoQué hace
setMotor(pinIA, pinIB, speed)Según el signo de la velocidad aplica PWM a una entrada y 0 a la otra; positivo es adelante, negativo atrás y 0 parado.
constrain(speed, -255, 255)Recorta los valores que superan el límite de analogWrite.
drive(left, right)Gestiona los dos motores a la vez; valores iguales van recto y signos opuestos hacen girar el coche sobre sí mismo.
bucle for (80 → 200)Arranque suave: reduce el pico de corriente y el patinaje de las ruedas.
drive(-150, 150)El motor izquierdo gira hacia atrás y el derecho hacia delante; el coche gira a la izquierda sobre su eje.
Muchos motorreductores pequeños no arrancan con valores de duty bajos; para vencer la fricción suele hacer falta un mínimo de 70–100 (30–40 %). Para encontrar el valor de arranque de tu motor, sube la velocidad desde 0 paso a paso, imprímela en el Monitor Serie y usa el valor en el que empieza a girar como velocidad mínima en tu código.

Control de velocidad con PWM: duty cycle y tensión media

El PWM consiste en aplicar al motor una tensión media encendiendo y apagando el pin cientos de veces por segundo. Por su inercia, el motor percibe esos pulsos rápidos como un valor medio. La tensión media se calcula aproximadamente con V_media = V_alimentación × duty / 255: con 6 V, analogWrite(pin, 150) equivale a unos 6 × 150 / 255 ≈ 3,5 V. En el Arduino Uno, los pines D5 y D6 generan PWM a unos 980 Hz y los D9 y D10 a unos 490 Hz; a estas frecuencias es normal oír un ligero zumbido del motor. En ESP32 y Pico puedes elegir la frecuencia tú mismo; alrededor de 1 kHz es un punto de partida seguro para el L9110S. Con frecuencias muy altas el chip genera más calor en cada conmutación y con frecuencias muy bajas el motor gira con tirones. Para más detalles consulta el artículo qué es el PWM.

Límite de corriente: ¿qué motores aguanta el L9110S?

El límite más importante del L9110S es la corriente continua de unos 800 mA por canal. Lo que debes vigilar no es la corriente del motor en vacío, sino la corriente de bloqueo (stall). Cuando el motor arranca o la rueda se atasca contra un obstáculo, solo la resistencia del bobinado limita la corriente y el motor consume el máximo. Puedes estimarla con la ley de Ohm: si la resistencia del bobinado medida con el polímetro es de 5 Ω y la alimentación de 6 V, la corriente de bloqueo es de unos 6 / 5 = 1,2 A. Este valor no da problemas en un arranque breve, pero si el coche choca contra una pared y se queda segundos con las ruedas bloqueadas, el chip se calienta rápido. Como el módulo no tiene disipador, lo más sano es no mantener mucho tiempo cargas continuas superiores a 500 mA por canal.

MotorCorriente típicaPara el L9110S
Motor N20 con micro reductora (6 V)30–100 mA en vacíoMuy adecuado
Motor amarillo TT con reductora (3–6 V)150–250 mA en vacío, cerca de 1 A bloqueadoAdecuado; evita bloqueos largos
Motor DC tipo 130 + hélice200–500 mAAdecuado (mini ventilador)
Ventilador de PC sin escobillas de 5 V100–250 mASolo en un sentido
Motor con reductora metálica de 12 V (25GA/37GA)2–5 A bloqueadoNo adecuado, necesita un controlador más potente
Motor RS-550 / 775De varios amperios a decenas de amperiosTotalmente inadecuado

L9110S con ESP32: velocidad y sentido del ventilador con potenciómetro

Los pines del ESP32 trabajan a 3,3 V y las entradas del L9110S detectan ese nivel sin problemas; no hace falta convertidor de nivel. En el ejemplo siguiente conectamos al borne MOTOR A un pequeño motor 130 con hélice. Con un potenciómetro con los extremos a 3V3 y GND y el pin central al GPIO 34, el ventilador está parado en la posición central; al girarlo hacia un lado sopla cada vez más rápido y hacia el otro aspira en sentido contrario. La pequeña zona muerta central evita que las lecturas fluctuantes del potenciómetro muevan el motor continuamente adelante y atrás. El código separa con #if la diferencia de LEDC entre las versiones 2.x y 3.x del core Arduino del ESP32; si quieres usar también el canal B, puedes añadir los GPIO 32 y 33 de la misma 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 y MicroPython con L9110S

Todos los pines GPIO de la Pico pueden generar PWM por hardware, así que tienes mucha libertad al elegir pines. En el ejemplo, el motor izquierdo va a GP16 y GP17 y el derecho a GP18 y GP19. El código define cada motor como una clase y recibe la velocidad en porcentaje (de -100 a 100), así no tienes que trabajar con el rango 0–65535 de duty_u16. Alimenta la Pico por USB y los motores con el portapilas conectado al VCC del módulo, y une los dos GND. Cuando detienes el programa con Ctrl+C en Thonny, el bloque KeyboardInterrupt para los motores de forma segura; sin él, el hardware PWM seguiría funcionando y tu coche podría caerse de la 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 o L298N? ¿Cuál usar y cuándo?

CaracterísticaMódulo L9110SMódulo L298N
Tensión del motor2,5–12 VAprox. 5–35 V
Corriente por canalUnos 800 mA continuosUnos 2 A continuos
Caída de tensión en el controladorBajaUnos 2 V o más
Control de velocidadPWM en los pines IA/IBPWM en los pines ENA/ENB
Pines de control necesarios46 (4 con jumpers)
Regulador de 5 V integradoNoSí (con alimentación de hasta 12 V)
Tamaño y pesoMuy pequeño, pocos gramosGrande, con disipador
Lógica de 3,3 VCompatibleNormalmente funciona

En resumen, si tus motores son de menos de 12 V y ninguno pasa mucho de 1 A ni siquiera bloqueado, el L9110S es la mejor opción: es más pequeño, más ligero y no gasta los aproximadamente 2 V que se pierden en los transistores bipolares del L298N. Esta diferencia se nota mucho en proyectos con batería: con un portapilas de 6 V, el L298N deja unos 4 V para el motor, mientras que el L9110S entrega al motor casi toda la tensión y tu coche va visiblemente más rápido. Por otro lado, para motores con reductora metálica de 12 V, chasis pesados, cargas continuas de más de 1 A o alimentaciones superiores a 12 V necesitas el L298N o controladores más modernos con MOSFET. Para una comparación detallada con alternativas como el TB6612FNG, consulta la comparativa de controladores de motor.

Ideas de proyectos con L9110S

  • Mini coche controlado por Bluetooth: con un módulo HC-05, llama a la función drive() según las letras que llegan del móvil.
  • Robot que esquiva obstáculos: añade un HC-SR04 delante y haz que retroceda y gire ante obstáculos a menos de 20 cm; los detalles están en el artículo del robot que esquiva obstáculos.
  • Robot seguidor de línea: sigue la línea negra con dos sensores TCRT5000; con motores N20 y L9110S sale un robot ligero y ágil.
  • Ventilador según la temperatura: sube gradualmente la velocidad del ventilador con PWM según la temperatura medida; la lógica la encuentras en el artículo de control de ventilador con Arduino.
  • Conducción tipo tanque con joystick: convierte los ejes X e Y de un joystick en velocidades de los motores izquierdo y derecho.
  • Coche controlado por Wi-Fi: envía órdenes de sentido y velocidad desde los botones de una página web en el ESP32.
  • Mini grúa o abridor de cortinas: enrolla una cuerda con un motor con reductora y detén el motor en los extremos con un final de carrera.

Errores comunes y cómo solucionarlos

SíntomaCausa probableSolución
El motor no gira nadaNo hay GND común o no llega alimentación a VCCConecta el GND del módulo al GND de la placa y mide VCC con el polímetro
A baja velocidad el motor no gira, solo zumbaEl duty está por debajo del umbral de arranque del motorSube la velocidad mínima a 70–100 aproximadamente
Arduino se reinicia cuando arranca el motorLos motores se alimentan desde la misma línea de 5V que la placaUsa una batería aparte para los motores y añade un condensador de 100 µF a VCC
Gira en un sentido pero no en el otroUna entrada está en un pin sin PWM o un cable no hace contactoConecta las cuatro entradas a pines PWM y revisa los jumpers
El chip se calienta muchoLa corriente del motor supera los 800 mA o el motor está bloqueadoUsa un motor más pequeño, evita el bloqueo o pasa al L298N
El control de velocidad funciona al revésUna entrada en HIGH y la otra con PWMPon la entrada fija en LOW o resta el duty a 255
En el ESP32 el motor gira un instante al arrancarEl pin elegido emite señal durante el arranqueUsa pines que permanecen en silencio al arrancar, como GPIO 25, 26, 32, 33
La primera vez que pruebes el robot recién montado, levanta siempre las ruedas del suelo y limita la velocidad a unos 150. Si hay un error de cableado, el coche no saldrá disparado de la mesa y podrás comprobar con calma la temperatura del chip. Si tras unos minutos de funcionamiento el chip está tan caliente que no se puede tocar, la corriente del motor es excesiva para el L9110S.

El L9110S es un controlador ligero, barato y eficiente para proyectos con pilas y motores pequeños; si conoces sus límites y lo combinas con el motor adecuado, funcionará mucho tiempo sin problemas. Cuando pases a motores más grandes, podrás seguir usando la misma lógica de sentido y PWM con el L298N. En la aplicación BlueGrays encontrarás proyectos como el coche controlado por Bluetooth, el robot que esquiva obstáculos y el control PWM con potenciómetro, con esquema de conexión y código paso a paso, y podrás adaptar fácilmente la conexión del L9110S de este artículo. La guía de cómo construir un coche robot con Arduino también te ayudará a elegir chasis, ruedas y batería.

Preguntas frecuentes

¿Cuántos amperios aguanta el L9110S?

El L9110S da unos 800 mA continuos por canal, con una corriente pico de unos 1,5 A durante poco tiempo. Como el módulo lleva dos chips, mueve dos motores cada uno con ese límite. Para que dure más, conviene mantener la corriente continua por motor por debajo de 500–600 mA.

¿Se puede mover un motor de 12 V con el L9110S?

La tensión máxima del módulo es de 12 V, así que en teoría puede mover un motor pequeño de 12 V. Sin embargo, la mayoría de los motores de 12 V consumen mucho más de 1 A al bloquearse y el chip se calienta al trabajar en el límite. Para motores de 12 V es más seguro un L298N o un controlador con MOSFET.

¿El L9110S funciona con ESP32 y 3,3 V?

Sí. Las entradas del L9110S detectan el nivel lógico de 3,3 V como HIGH, así que se puede conectar directamente al ESP32, a la Raspberry Pi Pico y a otras placas de 3,3 V. Solo tienes que dar la alimentación del motor aparte a VCC y unir los GND.

¿Es mejor el L9110S o el L298N?

En proyectos pequeños con pilas y motores pequeños, el L9110S es mejor: es más pequeño y ligero y no pierde unos 2 V como el L298N. Si la corriente del motor supera 1 A o necesitas más de 12 V de alimentación, elige el L298N.

¿Se puede mover un motor paso a paso con el L9110S?

Sí, los dos puentes en H del módulo pueden mover las dos bobinas de un pequeño motor paso a paso bipolar (4 cables) y la librería Stepper de Arduino funciona con esta conexión. La corriente de bobina no debe superar 800 mA. Para motores unipolares de 5 cables como el 28BYJ-48 es más adecuada la placa ULN2003.

¿Por qué se calienta tanto el L9110S?

La causa más habitual es que el motor consume una corriente cercana al límite del chip; sobre todo los motores con ruedas atascadas o con mucha carga se acercan a la corriente de bloqueo. Una tensión de alimentación superior a la nominal del motor también aumenta la corriente. Usa un motor más pequeño, limita la velocidad máxima con PWM o pasa a un controlador más potente.

Ver todos los proyectos
Coche controlado por Bluetooth con L298N
AR-80Avanzado
Premium

Coche controlado por Bluetooth con L298N

Convierte tu móvil en un mando y conduce tu propio coche robot. El Arduino recibe por un módulo Bluetooth las órdenes de una app de control remoto en el móvil y mueve las ruedas con un controlador de…

5.0(39)
66
Robot para evitar obstáculos
AR-81Avanzado
Premium

Robot para evitar obstáculos

¿Qué le parece construir un vehículo inteligente que encuentre su propio camino? El Robot Evitador de Obstáculos explora constantemente su entorno gracias al sensor ultrasónico que lleva delante.

5.0(38)
49
Brillo de LED con Potenciómetro en ESP32 (Analógico → PWM)
ES-13Intermedio
Premium

Brillo de LED con Potenciómetro en ESP32 (Analógico → PWM)

En este proyecto controlamos el brillo de un LED de forma analógica mediante un potenciómetro. El pin ADC del ESP32 lee la tensión de 0-3,3 V procedente del potenciómetro y este valor se convierte en una señal PWM (modulación por ancho de pulso) que se envía al LED. Al girar el potenciómetro, el LED se enciende y se apaga gradualmente. Con Arduino Core 3.0+ se usa directamente analogWrite(); en el ESP32-S2/S3, la resolución del ADC es de 12 bits.

4.5(19)
32
ESP32 LED Fade con PWM
ES-8Principiante

ESP32 LED Fade con PWM

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

4.8(36)
55
Raspberry Pi Pico PWM LED Fade (Efecto Respiración)
PI-14Principiante

Raspberry Pi Pico PWM LED Fade (Efecto Respiración)

¡El LED ya no solo parpadea — respira! Con el PWM (modulación por ancho de pulso) del Raspberry Pi Pico, el brillo sube y baja lentamente. Aprende la clase machine.PWM, duty_u16() (brillo de 16 bits 0–65535), la frecuencia PWM, bucles range() y salida tipo analógica. Base para mezcla de color RGB, control de motores, servos y buzzer.

4
Servocontrol con joystick
AR-60Intermedio
Premium

Servocontrol con joystick

Controla dos motores con un joystick, igual que si giraras una cámara de seguridad.

4.7(42)
58
Funcionamiento del servomotor con potenciómetro
AR-36Principiante
Premium

Funcionamiento del servomotor con potenciómetro

A medida que giras el mando del potenciómetro, el brazo del servomotor gira con él: un extremo del mando equivale a cero grados y el otro a media vuelta.

4.6(37)
53
Uso del motor paso a paso
AR-67Intermedio
Premium

Uso del motor paso a paso

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

4.5(31)
42