Guías · 11 min de lectura

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ísticaTira de 30 LED/mTira de 60 LED/m
Tipo de LED5050 SMD (5,0 × 5,0 mm, 3 chips)5050 SMD (5,0 × 5,0 mm, 3 chips)
Tensión de trabajo12 V DC12 V DC
Potencia (blanco total)Unos 7,2 W/mUnos 14,4 W/m
Corriente (blanco total)Unos 0,6 A/mUnos 1,2 A/m
Corriente por canalUnos 0,2 A/mUnos 0,4 A/m
Intervalo de corteCada 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ísticaTira RGB de 12 V (5050)Tira WS2812B
ControlToda la tira de un colorCada LED de un color
Alimentación12 V (también hay versiones de 24 V)5 V
Cableado4 hilos: +12V, R, G, B3 hilos: 5V, DIN, GND
Circuito de potenciaUn MOSFET por canalNo hace falta, basta un pin de datos
CódigoanalogWrite / PWMBiblioteca 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ónHasta 5 m normalmente no hay problemaEn tiras largas hay que alimentar por varios puntos
EfectosColor fijo, degradado, respiraciónLuz en movimiento, arcoíris, animaciones
PrecioBarataMá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.

MOSFETTensión de puertaRds(on)Idoneidad
IRLZ44NNivel lógico, totalmente abierto con 4–5 V0,025 Ω (a 5 V)Ideal para Uno y Nano; a 3,3 V solo con tiras cortas
IRLB8721También abre bien a 3,3 VUnos 0,009 Ω (a 4,5 V)Una de las mejores opciones para ESP32 y Pico
AO3400 (SMD)Abre con 2,5 VUnos 0,03 Ω (a 4,5 V)Placas pequeñas, 2–3 A por canal
IRF520 / IRF540NNecesita unos 10 VAlta a 5 VNo recomendado, se calienta
Nunca conectes el terminal R, G o B de la tira directamente a un pin de Arduino, ni el terminal +12V a los pines de 5V o de señal de Arduino bajo ninguna circunstancia. Si 12 V llegan a un pin, el microcontrolador se quema al instante. Mientras montas el circuito, desenchufa la fuente y conéctala solo después de revisar las conexiones.

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ónArduino UnoESP32Raspberry Pi Pico
Gate del MOSFET rojo (con 220 Ω)D9GPIO 25GP11
Gate del MOSFET verde (con 220 Ω)D10GPIO 26GP12
Gate del MOSFET azul (con 220 Ω)D11GPIO 27GP13
Drain de los MOSFETTerminales R, G, B de la tiraTerminales R, G, B de la tiraTerminales R, G, B de la tira
Source de los MOSFETGNDGNDGND
Potenciómetro de tono (patilla central)A0GPIO 34GP26 (ADC0)
Potenciómetro de brillo (patilla central)A1No se usaNo se usa
Extremos de los potenciómetros5V y GND3V3 y GND3V3 y GND
Negativo de la fuente de 12 VGNDGNDGND
Terminal +12V de la tiraPositivo de la fuentePositivo de la fuentePositivo 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

  1. Monta todo el circuito antes de enchufar la fuente; no cambies conexiones con el circuito energizado.
  2. 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.
  3. 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.
  4. Conecta la pata Drain de cada MOSFET al terminal de color correspondiente de la tira (R, G, B).
  5. 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.
  6. Conecta el negativo de la fuente de 12 V al pin GND de Arduino para crear la masa común.
  7. Conecta Arduino al ordenador por USB, sube el primer código y después enchufa la fuente.
  8. 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.

C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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.

MicroPython
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íntomaCausa probableSolución
La tira no se enciendeNo hay GND común o el terminal +12V no está conectadoUne 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ódigoDrain y Source del MOSFET están invertidos o el MOSFET se ha quemadoRevisa el orden de patas (G-D-S) y cambia el MOSFET si hace falta
La tira parpadea sola al arrancarFalta la resistencia pull-down de la GateAñade 10 kΩ entre cada Gate y GND
El MOSFET se calienta muchoMOSFET que no es de nivel lógico o tensión de puerta insuficiente a 3,3 VUsa 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 distintosIntercambia los valores de PIN_R, PIN_G y PIN_B en el código
El final de la tira se ve amarillento y apagadoCaída de tensión en una tira largaAlimenta las tiras de más de 5 m por los dos extremos y usa cable grueso
La placa se reiniciaFuente insuficiente, la tensión se hundeUsa una fuente más potente y alimenta la placa con un regulador aparte
Parpadeo o líneas en la cámaraFrecuencia PWM bajaSube 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.

Ver todos los proyectos
Uso de Led RGB
AR-39Principiante
Premium

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…

4.9(73)
100
Transición de color suave con Led RGB
AR-40Principiante
Premium

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.

4.8(58)
78
Control de LED RGB con ESP32
ES-9Principiante

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.

4.6(29)
52
Lámpara con mezclador de colores ESP32 (3 potenciómetros + LED RGB + OLED)
ES-36Avanzado
Premium

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

4.7(6)
10
Raspberry Pi Pico LED RGB Ciclo de Colores (PWM de 3 Canales)
PI-15Principiante

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.

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