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.

¿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ística | Valor |
|---|---|
| Chip controlador | 2 × L9110S (uno por motor) |
| Número de canales | 2 motores DC o 1 pequeño motor paso a paso bipolar |
| Tensión de alimentación (VCC) | 2,5–12 V |
| Corriente continua | Unos 800 mA por canal |
| Corriente pico | Unos 1,5 A durante poco tiempo |
| Entrada lógica | Compatible con 3,3 V y 5 V |
| Control de velocidad | PWM en los pines de entrada (no hay pin enable) |
| Protección | Diodos de rueda libre integrados |
| Tamaño | Unos 3 × 2,5 cm, pesa pocos gramos |
Pines del L9110S y tabla de verdad
| Pin | Función |
|---|---|
| B-IA | Entrada 1 del motor B (admite PWM) |
| B-IB | Entrada 2 del motor B (admite PWM) |
| GND | Masa común (negativo de la batería y GND del microcontrolador) |
| VCC | Alimentación de motores y chip, 2,5–12 V |
| A-IA | Entrada 1 del motor A (admite PWM) |
| A-IB | Entrada 2 del motor A (admite PWM) |
| MOTOR A / MOTOR B | Bornes de tornillo de dos terminales donde conectas los motores |
| A-IA | A-IB | Motor A |
|---|---|---|
| HIGH | LOW | Gira hacia delante |
| LOW | HIGH | Gira hacia atrás |
| LOW | LOW | Parado |
| HIGH | HIGH | Parado |
| PWM | LOW | Adelante, velocidad según el duty |
| LOW | PWM | Atrá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 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 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) |
| GND | GND (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) | A0 | GPIO 34 | GP26 |
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)
- 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.
- 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.
- Conecta el positivo del portapilas 4×AA al pin VCC del módulo y el negativo al pin GND.
- Une el pin GND del módulo con el GND del Uno mediante un cable puente para crear la masa común.
- Alimenta el Uno por USB y sube el código siguiente; en la primera prueba levanta las ruedas del suelo.
- Si algún motor gira al revés, intercambia sus dos cables en el 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}| Fragmento de código | Qué 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. |
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.
| Motor | Corriente típica | Para el L9110S |
|---|---|---|
| Motor N20 con micro reductora (6 V) | 30–100 mA en vacío | Muy adecuado |
| Motor amarillo TT con reductora (3–6 V) | 150–250 mA en vacío, cerca de 1 A bloqueado | Adecuado; evita bloqueos largos |
| Motor DC tipo 130 + hélice | 200–500 mA | Adecuado (mini ventilador) |
| Ventilador de PC sin escobillas de 5 V | 100–250 mA | Solo en un sentido |
| Motor con reductora metálica de 12 V (25GA/37GA) | 2–5 A bloqueado | No adecuado, necesita un controlador más potente |
| Motor RS-550 / 775 | De varios amperios a decenas de amperios | Totalmente 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.
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.
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ística | Módulo L9110S | Módulo L298N |
|---|---|---|
| Tensión del motor | 2,5–12 V | Aprox. 5–35 V |
| Corriente por canal | Unos 800 mA continuos | Unos 2 A continuos |
| Caída de tensión en el controlador | Baja | Unos 2 V o más |
| Control de velocidad | PWM en los pines IA/IB | PWM en los pines ENA/ENB |
| Pines de control necesarios | 4 | 6 (4 con jumpers) |
| Regulador de 5 V integrado | No | Sí (con alimentación de hasta 12 V) |
| Tamaño y peso | Muy pequeño, pocos gramos | Grande, con disipador |
| Lógica de 3,3 V | Compatible | Normalmente 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íntoma | Causa probable | Solución |
|---|---|---|
| El motor no gira nada | No hay GND común o no llega alimentación a VCC | Conecta 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 zumba | El duty está por debajo del umbral de arranque del motor | Sube la velocidad mínima a 70–100 aproximadamente |
| Arduino se reinicia cuando arranca el motor | Los motores se alimentan desde la misma línea de 5V que la placa | Usa 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 otro | Una entrada está en un pin sin PWM o un cable no hace contacto | Conecta las cuatro entradas a pines PWM y revisa los jumpers |
| El chip se calienta mucho | La corriente del motor supera los 800 mA o el motor está bloqueado | Usa un motor más pequeño, evita el bloqueo o pasa al L298N |
| El control de velocidad funciona al revés | Una entrada en HIGH y la otra con PWM | Pon la entrada fija en LOW o resta el duty a 255 |
| En el ESP32 el motor gira un instante al arrancar | El pin elegido emite señal durante el arranque | Usa pines que permanecen en silencio al arrancar, como GPIO 25, 26, 32, 33 |
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.
Proyectos para hacer después de leer esto
Ver todos los proyectos
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…

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.

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.

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.

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.

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

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.

Uso del motor paso a paso
Un motor que gira paso a paso, justo lo que tú quieras, como la aguja de un reloj.
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

