Tira LED RGB con Arduino y MOSFET: controla 12 V paso a paso
Cómo controlar una tira LED RGB de 12 V con Arduino: MOSFET IRLZ44N, PWM de tres canales, degradado de color, potenciómetro, fuente y código para ESP32 y Pico.
Controlar una tira LED RGB con Arduino consiste en manejar los canales rojo, verde y azul de una tira 5050 de 12 V no direccionable con tres señales PWM independientes para conseguir el color que quieras. Los pines de Arduino no soportan los amperios que consume la tira ni los 12 V, así que se coloca un MOSFET por canal: Arduino solo envía una señal de 5 V a la puerta del MOSFET y es este quien soporta la corriente real. Así puedes controlar metros de tira con un microcontrolador pequeño y con total seguridad.
En esta guía verás cómo es una tira 5050 por dentro, cómo elegir el MOSFET correcto, cómo hacer las conexiones y calcular la fuente. Después mezclarás colores con Arduino Uno, harás un degradado suave basado en millis() y elegirás color y brillo con potenciómetros, y ejecutarás el mismo circuito con la unidad LEDC del ESP32 y el PWM de MicroPython en la Raspberry Pi Pico. También verás la diferencia con la WS2812B y, al final, los errores más comunes con sus soluciones.
¿Qué es una tira LED RGB y cómo funciona?
En una tira RGB no direccionable, cada encapsulado SMD 5050 contiene tres chips LED: rojo, verde y azul. La tira se forma conectando en paralelo segmentos de 12 V, cada uno con tres LED y una resistencia limitadora por color; la tensión directa de tres LED en serie es de unos 6–9 V según el color y la resistencia absorbe el resto. La tira tiene cuatro terminales: el positivo común (+12V) y R, G y B. Es decir, es de ánodo común: para que un color se encienda, tienes que llevar su línea a GND. Toda la tira muestra el mismo color a la vez; no puedes encender cada LED de un color distinto. El color lo determina el ciclo de trabajo PWM de cada canal: con rojo y verde al máximo ves amarillo, y con los tres al máximo, una luz casi blanca.
| Característica | Tira de 30 LED/m | Tira de 60 LED/m |
|---|---|---|
| Tipo de LED | 5050 SMD (5,0 × 5,0 mm, 3 chips) | 5050 SMD (5,0 × 5,0 mm, 3 chips) |
| Tensión de trabajo | 12 V DC | 12 V DC |
| Potencia (blanco total) | Unos 7,2 W/m | Unos 14,4 W/m |
| Corriente (blanco total) | Unos 0,6 A/m | Unos 1,2 A/m |
| Corriente por canal | Unos 0,2 A/m | Unos 0,4 A/m |
| Intervalo de corte | Cada 3 LED (10 cm) | Cada 3 LED (5 cm) |
| Terminales | +12V, R, G, B | +12V, R, G, B |
Diferencia entre tira RGB y WS2812B
Ambas tiras dan luz RGB, pero su lógica de control es totalmente distinta. La tira no direccionable es como una lámpara: cambias el brillo de los tres canales y ajustas el color de toda la tira. En una tira WS2812B NeoPixel, cada LED lleva un pequeño chip controlador y con una sola línea de datos puedes enviar un color distinto a cada LED. La siguiente tabla te ayudará a decidir cuál elegir:
| Característica | Tira RGB de 12 V (5050) | Tira WS2812B |
|---|---|---|
| Control | Toda la tira de un color | Cada LED de un color |
| Alimentación | 12 V (también hay versiones de 24 V) | 5 V |
| Cableado | 4 hilos: +12V, R, G, B | 3 hilos: 5V, DIN, GND |
| Circuito de potencia | Un MOSFET por canal | No hace falta, basta un pin de datos |
| Código | analogWrite / PWM | Biblioteca FastLED o Adafruit NeoPixel |
| Corriente (60 LED/m, blanco total) | Unos 1,2 A/m (12 V) | Unos 3,6 A/m (5 V) |
| Caída de tensión | Hasta 5 m normalmente no hay problema | En tiras largas hay que alimentar por varios puntos |
| Efectos | Color fijo, degradado, respiración | Luz en movimiento, arcoíris, animaciones |
| Precio | Barata | Más cara |
¿Por qué hace falta un MOSFET y cuál elegir?
Un pin del Arduino Uno está pensado para dar unos 20 mA (límite absoluto de 40 mA), mientras que un solo canal de una tira de 5 metros y 60 LED/m puede consumir 2 A. Además, la tira funciona a 12 V. Un MOSFET de canal N resuelve esto como interruptor del lado bajo: el Drain va a la línea de color de la tira, el Source a GND, y la tensión aplicada en la Gate abre y cierra el MOSFET. Lo crítico es elegir un MOSFET de nivel lógico; los MOSFET estándar como el IRF520 o el IRF540N necesitan unos 10 V para abrirse del todo y a 5 V quedan medio abiertos y se calientan. La potencia disipada en el MOSFET es P = I² × Rds(on): para 2 A y 0,025 Ω son 2 × 2 × 0,025 = 0,1 W, así que no necesita disipador. Para repasar lo básico, mira cómo usar un MOSFET con Arduino.
| MOSFET | Tensión de puerta | Rds(on) | Idoneidad |
|---|---|---|---|
| IRLZ44N | Nivel lógico, totalmente abierto con 4–5 V | 0,025 Ω (a 5 V) | Ideal para Uno y Nano; a 3,3 V solo con tiras cortas |
| IRLB8721 | También abre bien a 3,3 V | Unos 0,009 Ω (a 4,5 V) | Una de las mejores opciones para ESP32 y Pico |
| AO3400 (SMD) | Abre con 2,5 V | Unos 0,03 Ω (a 4,5 V) | Placas pequeñas, 2–3 A por canal |
| IRF520 / IRF540N | Necesita unos 10 V | Alta a 5 V | No recomendado, se calienta |
Esquema del circuito y tabla de conexiones
Para cada canal de color montas el mismo pequeño circuito, tres veces. Si sujetas el IRLZ44N con la cara impresa hacia ti, las patas están, de izquierda a derecha, en el orden Gate, Drain, Source; también puedes comprobar el orden de patas con la herramienta de transistores. Entre la Gate y el pin de la placa pon una resistencia de 220 Ω, que limita el pico de corriente que se toma del pin mientras se carga la capacidad de la puerta. Entre la Gate y GND añade también una resistencia pull-down de 10 kΩ; evita que el MOSFET se active solo y encienda la tira al azar cuando los pines quedan flotantes al arrancar la placa o al subir el código. La regla más importante: el negativo de la fuente de 12 V y el GND de la placa deben estar unidos, si no la señal de puerta no tiene referencia. Lo explicamos con detalle en el artículo sobre la masa común (GND).
| Conexión | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Gate del MOSFET rojo (con 220 Ω) | D9 | GPIO 25 | GP11 |
| Gate del MOSFET verde (con 220 Ω) | D10 | GPIO 26 | GP12 |
| Gate del MOSFET azul (con 220 Ω) | D11 | GPIO 27 | GP13 |
| Drain de los MOSFET | Terminales R, G, B de la tira | Terminales R, G, B de la tira | Terminales R, G, B de la tira |
| Source de los MOSFET | GND | GND | GND |
| Potenciómetro de tono (patilla central) | A0 | GPIO 34 | GP26 (ADC0) |
| Potenciómetro de brillo (patilla central) | A1 | No se usa | No se usa |
| Extremos de los potenciómetros | 5V y GND | 3V3 y GND | 3V3 y GND |
| Negativo de la fuente de 12 V | GND | GND | GND |
| Terminal +12V de la tira | Positivo de la fuente | Positivo de la fuente | Positivo de la fuente |
Cálculo de potencia: ¿qué fuente necesito?
Para elegir la fuente, calcula primero la corriente de la tira en blanco total: I = metros × A/m. Una tira de 5 metros de 60 LED/m consume 5 × 1,2 = 6 A; la potencia, con P = V × I, es 12 × 6 = 72 W. Elige siempre la fuente con un margen de aproximadamente el 20 %: en este ejemplo sirve una de 12 V y 8 A (96 W). Una tira de 2 metros de 30 LED/m consume 1,2 A, así que una fuente de 12 V y 2 A es suficiente. El cable también se elige según la corriente; para corrientes de más de 5 A usa cable de al menos 0,75 mm² de sección en lugar de cables dupont. Si quieres alimentar la placa con la misma fuente, el jack de alimentación o el pin Vin del Arduino Uno admite 12 V y funciona sin problema con cargas ligeras. En cambio, en las placas ESP32 y en la Pico no conectes 12 V directamente; la entrada VSYS de la Pico admite como máximo 5,5 V. Para estas placas lo más limpio es bajar los 12 V a 5 V con un regulador reductor LM2596 y llevarlos al pin 5V en el ESP32 o al pin VSYS en la Pico. Puedes comprobar los cálculos con la calculadora de la ley de Ohm y ampliar con el artículo de cálculo de potencia eléctrica.
Montaje paso a paso
- Monta todo el circuito antes de enchufar la fuente; no cambies conexiones con el circuito energizado.
- Suelda cuatro cables a las pistas de soldadura de la tira o usa un conector listo; conecta el terminal +12V al positivo de la fuente.
- Coloca los tres MOSFET y une las patas Source a la línea común de GND. Las líneas de una protoboard sirven para aproximadamente 1 A; con tiras de varios amperios haz el camino de corriente con soldadura o con bornes de tornillo.
- Conecta la pata Drain de cada MOSFET al terminal de color correspondiente de la tira (R, G, B).
- Conecta las patas Gate a D9, D10 y D11 con resistencias de 220 Ω; añade una resistencia de 10 kΩ entre cada Gate y GND.
- Conecta el negativo de la fuente de 12 V al pin GND de Arduino para crear la masa común.
- Conecta Arduino al ordenador por USB, sube el primer código y después enchufa la fuente.
- Comprueba que cada color se enciende por separado; si se enciende un color equivocado, intercambia los números de pin en el código.
Primer código: mezclar colores con Arduino
Una vez montado el circuito, lo más seguro para empezar es probar cada canal por separado. El código siguiente usa los pines PWM 9, 10 y 11 del Uno y muestra seis colores distintos en secuencia con la función setColor(). Si quieres entender la lógica del PWM, consulta el artículo qué es el PWM.
1const int PIN_R = 9; // kırmızı MOSFET kapısı / red MOSFET gate
2const int PIN_G = 10; // yeşil MOSFET kapısı / green MOSFET gate
3const int PIN_B = 11; // mavi MOSFET kapısı / blue MOSFET gate
4
5void setColor(uint8_t r, uint8_t g, uint8_t b) {
6 analogWrite(PIN_R, r); // 255 = tam parlak, 0 = sönük / 255 = full, 0 = off
7 analogWrite(PIN_G, g);
8 analogWrite(PIN_B, b);
9}
10
11void setup() {
12 pinMode(PIN_R, OUTPUT);
13 pinMode(PIN_G, OUTPUT);
14 pinMode(PIN_B, OUTPUT);
15 setColor(0, 0, 0); // başlangıçta kapalı / off at start
16}
17
18void loop() {
19 setColor(255, 0, 0); delay(1000); // kırmızı / red
20 setColor(0, 255, 0); delay(1000); // yeşil / green
21 setColor(0, 0, 255); delay(1000); // mavi / blue
22 setColor(255, 120, 0); delay(1000); // turuncu / orange
23 setColor(160, 0, 255); delay(1000); // mor / purple
24 setColor(255, 255, 255); delay(1000); // beyaz / white
25}Hay una diferencia importante: si conectas directamente a un pin un LED RGB de ánodo común, la lógica es inversa (255 lo apaga), pero en el circuito con MOSFET analogWrite(pin, 255) abre el MOSFET por completo y enciende el color a máximo brillo; 0 lo apaga. En el Uno, los pines 9 y 10 dependen del Timer1 y el pin 11 del Timer2, y los tres trabajan a unos 490 Hz; a esa frecuencia el ojo no percibe parpadeo. Sin embargo, la función tone() usa el Timer2 y estropea el PWM del pin 11, y la biblioteca Servo desactiva el PWM en los pines 9 y 10. Si tu proyecto lleva zumbador o servo, planifica los pines en consecuencia. Además, el brillo de los colores de la tira no es igual; si el blanco se ve azulado, puedes equilibrarlo bajando el canal azul a unos 200.
Degradado lento de color: rueda de color con millis()
Para que la tira recorra todos los colores suavemente se usa la lógica de una rueda de color: un valor de tono entre 0 y 767 se divide en tres zonas. En los primeros 256 pasos el rojo baja y el verde sube, en los siguientes 256 se pasa de verde a azul y en el último tramo de azul a rojo. Como la suma de los dos canales es 255 en cada paso, los colores fluyen sin saltos. Como en el código usamos millis() en lugar de delay(), dentro de loop() puedes hacer otras tareas, como leer un botón o medir un sensor. Nuestro ojo no percibe el brillo de forma lineal: los cambios pequeños en valores bajos se notan mucho y en valores altos apenas. Por eso la función gamma8() del código escala el valor con su cuadrado (v × v / 255) y hace más naturales las transiciones con poca luz. Si aumentas STEP_MS, la vuelta completa dura más; con 15 ms una vuelta tarda unos 11,5 segundos.
1const int PIN_R = 9; // kırmızı / red
2const int PIN_G = 10; // yeşil / green
3const int PIN_B = 11; // mavi / blue
4
5const unsigned long STEP_MS = 15; // 768 x 15 ms = yaklaşık 11,5 s / about 11.5 s per cycle
6unsigned long lastStep = 0;
7int hue = 0; // renk tonu 0-767 / hue 0-767
8
9uint8_t gamma8(uint8_t v) {
10 return (uint16_t)v * v / 255; // basit gama düzeltmesi / simple gamma correction
11}
12
13void setColor(uint8_t r, uint8_t g, uint8_t b) {
14 analogWrite(PIN_R, gamma8(r));
15 analogWrite(PIN_G, gamma8(g));
16 analogWrite(PIN_B, gamma8(b));
17}
18
19void wheel(int h) {
20 uint8_t p = h % 256;
21 if (h < 256) setColor(255 - p, p, 0); // kırmızı -> yeşil / red -> green
22 else if (h < 512) setColor(0, 255 - p, p); // yeşil -> mavi / green -> blue
23 else setColor(p, 0, 255 - p); // mavi -> kırmızı / blue -> red
24}
25
26void setup() {
27 pinMode(PIN_R, OUTPUT);
28 pinMode(PIN_G, OUTPUT);
29 pinMode(PIN_B, OUTPUT);
30}
31
32void loop() {
33 if (millis() - lastStep >= STEP_MS) {
34 lastStep = millis();
35 wheel(hue);
36 hue = (hue + 1) % 768;
37 }
38 // burada buton ya da sensör okuyabilirsin / you can read buttons or sensors here
39}Elegir color y brillo con potenciómetros
Para elegir el color a mano bastan dos potenciómetros: el de A0 determina el tono (0–767) y el de A1 el brillo general (0–255). Como analogRead() devuelve valores de 0 a 1023, los escalamos con map() al rango que queremos. El brillo se aplica multiplicando cada canal por bri / 255, de modo que se mantiene el tono y solo se atenúa la luz. También es posible ajustar R, G y B directamente con tres potenciómetros, pero la rueda de color con un solo mando es mucho más intuitiva y te permite alcanzar todos los colores saturados, salvo el blanco.
1const int PIN_R = 9;
2const int PIN_G = 10;
3const int PIN_B = 11;
4const int POT_HUE = A0; // renk tonu / hue
5const int POT_BRI = A1; // parlaklık / brightness
6
7void setup() {
8 pinMode(PIN_R, OUTPUT);
9 pinMode(PIN_G, OUTPUT);
10 pinMode(PIN_B, OUTPUT);
11}
12
13void loop() {
14 int hue = map(analogRead(POT_HUE), 0, 1023, 0, 767);
15 int bri = map(analogRead(POT_BRI), 0, 1023, 0, 255);
16
17 uint8_t r, g, b;
18 uint8_t p = hue % 256;
19 if (hue < 256) { r = 255 - p; g = p; b = 0; } // kırmızı -> yeşil / red -> green
20 else if (hue < 512) { r = 0; g = 255 - p; b = p; } // yeşil -> mavi / green -> blue
21 else { r = p; g = 0; b = 255 - p; } // mavi -> kırmızı / blue -> red
22
23 analogWrite(PIN_R, (uint16_t)r * bri / 255); // parlaklığı uygula / apply brightness
24 analogWrite(PIN_G, (uint16_t)g * bri / 255);
25 analogWrite(PIN_B, (uint16_t)b * bri / 255);
26 delay(20);
27}Control de tira RGB con ESP32 (LEDC)
En el ESP32 el PWM usa la unidad de hardware LEDC, y tú decides la frecuencia y la resolución. 5 kHz y 8 bits dan una luz sin parpadeo y el conocido rango 0–255. En el core 3.x de Arduino se usan ledcAttach(pin, frecuencia, resolución) y ledcWrite(pin, valor), mientras que en el 2.x primero se configura un canal con ledcSetup(), se asigna al pin con ledcAttachPin() y ledcWrite() escribe en el canal; el código siguiente admite ambas versiones con #if. Como los pines del ESP32 dan 3,3 V, es importante elegir un MOSFET de baja tensión de puerta, como el IRLB8721 de la tabla. Conectamos el potenciómetro al GPIO 34, un pin ADC1 que funciona sin problemas con el Wi-Fi activo; el ADC es de 12 bits, así que los valores van de 0 a 4095, y para reducir el ruido se promedian ocho lecturas. Para conocer la placa, mira el artículo qué es el ESP32.
1const int PIN_R = 25; // kırmızı MOSFET kapısı / red MOSFET gate
2const int PIN_G = 26; // yeşil / green
3const int PIN_B = 27; // mavi / blue
4const int POT_HUE = 34; // ADC1, yalnız giriş / ADC1, input only
5const int PWM_FREQ = 5000; // 5 kHz, titreşimsiz / flicker-free
6const int PWM_RES = 8; // 8 bit: 0-255
7
8void setColor(uint8_t r, uint8_t g, uint8_t b) {
9#if ESP_ARDUINO_VERSION_MAJOR >= 3
10 ledcWrite(PIN_R, r); // core 3.x: pine yaz / write to pin
11 ledcWrite(PIN_G, g);
12 ledcWrite(PIN_B, b);
13#else
14 ledcWrite(0, r); // core 2.x: kanala yaz / write to channel
15 ledcWrite(1, g);
16 ledcWrite(2, b);
17#endif
18}
19
20void setup() {
21#if ESP_ARDUINO_VERSION_MAJOR >= 3
22 ledcAttach(PIN_R, PWM_FREQ, PWM_RES);
23 ledcAttach(PIN_G, PWM_FREQ, PWM_RES);
24 ledcAttach(PIN_B, PWM_FREQ, PWM_RES);
25#else
26 ledcSetup(0, PWM_FREQ, PWM_RES);
27 ledcSetup(1, PWM_FREQ, PWM_RES);
28 ledcSetup(2, PWM_FREQ, PWM_RES);
29 ledcAttachPin(PIN_R, 0);
30 ledcAttachPin(PIN_G, 1);
31 ledcAttachPin(PIN_B, 2);
32#endif
33 analogReadResolution(12); // 0-4095
34 setColor(0, 0, 0);
35}
36
37void loop() {
38 long sum = 0;
39 for (int i = 0; i < 8; i++) {
40 sum += analogRead(POT_HUE); // 8 okumayı topla / sum 8 readings
41 }
42 int hue = map(sum / 8, 0, 4095, 0, 767);
43 uint8_t p = hue % 256;
44 if (hue < 256) setColor(255 - p, p, 0); // kırmızı -> yeşil / red -> green
45 else if (hue < 512) setColor(0, 255 - p, p); // yeşil -> mavi / green -> blue
46 else setColor(p, 0, 255 - p); // mavi -> kırmızı / blue -> red
47 delay(20);
48}Código MicroPython con Raspberry Pi Pico
En la Pico, cualquier pin GPIO puede generar PWM y duty_u16() acepta valores de 0 a 65535. En el código convertimos los valores de color de 0–255 a ese rango multiplicando por 257 (255 × 257 = 65535). El potenciómetro está en GP26 (ADC0); como read_u16() también devuelve 0–65535, se convierte fácilmente a tono. GP12 y GP13 comparten el mismo slice PWM (slice 6); como les damos la misma frecuencia no hay problema, pero si intentas poner frecuencias distintas, el último ajuste afecta a los dos. Como la Pico trabaja a 3,3 V, la recomendación de MOSFET que dimos para el ESP32 también vale aquí. Para la puesta en marcha, lee el artículo qué es la Raspberry Pi Pico.
1from machine import Pin, PWM, ADC
2import time
3
4pins = (11, 12, 13) # R, G, B MOSFET kapıları / gates
5leds = []
6for p in pins:
7 pwm = PWM(Pin(p))
8 pwm.freq(1000) # 1 kHz PWM
9 pwm.duty_u16(0) # başlangıçta kapalı / off at start
10 leds.append(pwm)
11
12pot = ADC(26) # GP26 = ADC0
13
14def set_color(r, g, b):
15 # 0-255 değerini 0-65535'e çevir / convert 0-255 to 0-65535
16 leds[0].duty_u16(r * 257)
17 leds[1].duty_u16(g * 257)
18 leds[2].duty_u16(b * 257)
19
20def wheel(hue):
21 p = hue % 256
22 if hue < 256:
23 return 255 - p, p, 0 # kırmızı -> yeşil / red -> green
24 elif hue < 512:
25 return 0, 255 - p, p # yeşil -> mavi / green -> blue
26 return p, 0, 255 - p # mavi -> kırmızı / blue -> red
27
28while True:
29 hue = pot.read_u16() * 767 // 65535 # 0-767 ton / hue
30 set_color(*wheel(hue))
31 time.sleep_ms(20)Ideas de proyectos con tira LED RGB
- Ambiente sensible a la música: con un sensor de sonido, cambia el color y el brillo de la tira al ritmo de la música; los detalles están en el artículo de LED sensible a la música.
- Iluminación trasera del televisor con mando: cambia color y brillo desde el sofá con un receptor IR y mando.
- Luz de escalera con movimiento: cuando el sensor PIR detecta a alguien, enciende la tira poco a poco y apágala pasado un rato.
- Luz nocturna automática: que un LDR encienda un naranja cálido con poco brillo cuando oscurece.
- Control desde el móvil: monta un servidor web con el ESP32 y usa el selector de color desde el navegador.
- Alarma amanecer: 20 minutos antes de la hora de despertar, enciende la tira poco a poco del rojo oscuro al blanco.
Errores comunes y cómo solucionarlos
| Síntoma | Causa probable | Solución |
|---|---|---|
| La tira no se enciende | No hay GND común o el terminal +12V no está conectado | Une el negativo de la fuente al GND de la placa y revisa el terminal +12V de la tira |
| Un color está siempre encendido diga lo que diga el código | Drain y Source del MOSFET están invertidos o el MOSFET se ha quemado | Revisa el orden de patas (G-D-S) y cambia el MOSFET si hace falta |
| La tira parpadea sola al arrancar | Falta la resistencia pull-down de la Gate | Añade 10 kΩ entre cada Gate y GND |
| El MOSFET se calienta mucho | MOSFET que no es de nivel lógico o tensión de puerta insuficiente a 3,3 V | Usa MOSFET de nivel lógico como IRLZ44N o IRLB8721 |
| Los colores están cambiados (se enciende verde en vez de rojo) | Las etiquetas de la tira o el orden de los cables son distintos | Intercambia los valores de PIN_R, PIN_G y PIN_B en el código |
| El final de la tira se ve amarillento y apagado | Caída de tensión en una tira larga | Alimenta las tiras de más de 5 m por los dos extremos y usa cable grueso |
| La placa se reinicia | Fuente insuficiente, la tensión se hunde | Usa una fuente más potente y alimenta la placa con un regulador aparte |
| Parpadeo o líneas en la cámara | Frecuencia PWM baja | Sube la frecuencia a 1–5 kHz en ESP32 y Pico |
La tira RGB no direccionable, con tres MOSFET y tres pines PWM, es la forma más práctica de añadir una capa de luz potente y barata a tu habitación, tu escritorio o tu proyecto. Si quieres controlar cada LED por separado, el siguiente paso puede ser la WS2812B. En la app BlueGrays puedes ver paso a paso, con esquema y código, proyectos como la mezcla de colores con LED RGB, el degradado suave, la lámpara mezcladora de colores con ESP32 y el ciclo de colores RGB con Pico.
Preguntas frecuentes
¿Se puede conectar una tira LED RGB directamente a Arduino?
No. Una tira de 12 V puede consumir más de un amperio por metro, mientras que un pin de Arduino da unos 20 mA y trabaja a 5 V. Tienes que manejar la tira con un MOSFET de nivel lógico por cada canal de color; Arduino solo envía la señal PWM a la puerta del MOSFET.
¿Qué MOSFET se usa para una tira LED de 12 V?
Para Arduino Uno y Nano de 5 V, el IRLZ44N es una opción habitual y adecuada. En placas de 3,3 V como ESP32 y Raspberry Pi Pico, MOSFET que abren del todo con poca tensión de puerta, como el IRLB8721 o el AO3400, dan mejores resultados. El IRF520 y el IRF540N no abren del todo a 5 V y se calientan.
¿Cuántos amperios consume una tira LED RGB de 5 metros?
Una tira 5050 de 60 LED/m consume en blanco total unos 1,2 A por metro; 5 metros son unos 6 A y 72 W. En una tira de 30 LED/m estos valores se reducen a la mitad. Elige la fuente con un 20 % de margen; para 6 A sirve una de 12 V y 8 A.
¿Cuál es la diferencia entre una tira RGB y una WS2812B?
En una tira RGB no direccionable todos los LED muestran el mismo color a la vez y se manejan con tres MOSFET. En la WS2812B cada LED tiene su propio chip controlador y desde un único pin de datos se envía un color distinto a cada LED. La WS2812B es ideal para efectos en movimiento y la tira RGB para iluminación lisa, barata y potente.
¿Por dónde se puede cortar una tira LED RGB?
Las tiras de 12 V funcionan con segmentos de tres LED y solo se pueden cortar por las marcas de corte sobre las pistas de cobre; ese intervalo es de 5 cm en 60 LED/m y de 10 cm en 30 LED/m. Si cortas por otro sitio, ese segmento no se enciende. El trozo cortado se puede reconectar soldando cables a las pistas o con un conector de presión.
¿Puedo alimentar Arduino con la fuente de 12 V de la tira?
Puedes alimentar el Arduino Uno con 12 V por el jack o por el pin Vin; el regulador de la placa lo soporta con cargas ligeras. En las placas ESP32 y en la Raspberry Pi Pico tienes que bajar los 12 V a 5 V con un reductor como el LM2596. En todos los casos, el negativo de la fuente debe estar unido al GND de la placa.
Proyectos para hacer después de leer esto
Ver todos los proyectos
Uso de Led RGB
Dentro de un solo LED se esconden tres colores: el LED RGB se enciende en rojo, luego en verde y luego en azul, cada color medio segundo encendido y medio segundo apagado, y la secuencia vuelve a…

Transición de color suave con Led RGB
Un solo LED RGB pasa lentamente del rojo al verde, del verde al azul y vuelve al rojo, en un bucle de arcoíris que nunca se detiene.

Control de LED RGB con ESP32
Generación ilimitada de colores con un solo LED RGB en lugar de 3 LEDs separados. Hacemos transición arco iris estableciendo valores R/G/B con analogWrite() como en Arduino. La teoría del color (como rojo+verde=amarillo) se ve de forma práctica.

Lámpara con mezclador de colores ESP32 (3 potenciómetros + LED RGB + OLED)
Una lámpara mezcladora de colores inteligente: gira 3 potenciómetros en el ESP32 y mezcla el color que quieras. Al girar los potenciómetros rojo, verde y azul, el LED RGB de cátodo común cambia de color al instante. La pantalla OLED SSD1306 muestra en vivo el valor de 0-255 de cada color, barras de relleno y el código de color web HEX (como #FF8040).

Raspberry Pi Pico LED RGB Ciclo de Colores (PWM de 3 Canales)
¡Un LED, millones de colores! Un LED RGB contiene 3 LEDs: rojo, verde y azul. Con un canal PWM del Pico para cada uno, los colores se mezclan: rojo + verde = amarillo, verde + azul = cian, los tres = blanco. El LED recorre 8 colores. Aprende múltiples canales PWM, funciones (def), mezcla RGB, conversión de 8 a 16 bits (x257) y cátodo común vs ánodo común.

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.

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.

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

