Controlar LED RGB con Arduino

¡Hola, maker! Bienvenido a este tutorial de Ingtelecto. Hoy vamos a trabajar con uno de los componentes más vistosos y fundamentales en el mundo de Arduino: el LED RGB. Este no es un LED común; es una pequeña fábrica de colores.

En esta lección, no solo aprenderás a conectarlo, sino que entenderás la "magia" detrás de la mezcla de colores. Descubrirás qué es el PWM (Modulación por Ancho de Pulso) y cómo Arduino lo usa para "engañar" a nuestros ojos y crear millones de tonalidades distintas a partir de solo tres colores básicos: Rojo, Verde y Azul.

Este proyecto es la base para crear luces ambientales, indicadores de estado complejos, o incluso tu propia lámpara inteligente. ¡Ah! Y por supuesto, tenemos un video completo para guiarte en el proceso. ¡Vamos a ello!

Materiales Necesarios para el Proyecto

Para seguir este tutorial, necesitarás reunir los siguientes componentes. La mayoría son parte de cualquier kit de inicio de Arduino.

Aquí una clara imagen de los materiales:

Conceptos Clave del Proyecto

Antes de conectar cables, es crucial entender el "por qué" de dos componentes clave: el LED RGB y la técnica PWM.

1. ¿Qué es un LED RGB? 💡

Un LED RGB no es más que tres LEDs separados (uno Rojo, uno Verde y uno Azul) encapsulados juntos en una sola carcasa de plástico.

Por eso, en lugar de los 2 pines habituales de un LED, este tiene 4 pines:

• 1 pin para el color Rojo (R).
• 1 pin para el color Verde (G).
• 1 pin para el color Azul (B).
• 1 pin "Común" para todos ellos.

Este pin común define el tipo de LED:

• Cátodo Común (El que usamos): El pin común (el más largo) es el Cátodo (-) y debe conectarse a GND (Tierra). Para encender un color, envías un voltaje POSITIVO (5V) a su pin correspondiente.
• Ánodo Común: El pin común (el más largo) es el Ánodo (+) y debe conectarse a 5V. Para encender un color, envías un voltaje BAJO (GND) a su pin, invirtiendo la lógica.

¡Es vital que sepas cuál tienes! Este tutorial asume un LED de Cátodo Común, como se indica en el documento base.

2. La Magia del PWM (Modulación por Ancho de Pulso) ⚙️

Quizás te preguntes: "Si los pines digitales de Arduino solo dan 0V (apagado) o 5V (encendido), ¿cómo puedo obtener un 'medio rojo' o un 'azul suave'?"

La respuesta es PWM (Pulse Width Modulation). En lugar de dar un voltaje constante, Arduino puede encender y apagar un pin digital extremadamente rápido (cientos de veces por segundo).

• Si el pin está 0% del tiempo encendido (0% Duty Cycle), el LED está apagado.
• Si está 100% del tiempo encendido (100% Duty Cycle), el LED brilla al máximo.
• Si está 50% del tiempo encendido (50% Duty Cycle), nuestros ojos no ven el parpadeo, sino que perciben un brillo a la mitad de la intensidad.

En Arduino, esto se controla con la función analogWrite(). Esta función no da un voltaje analógico real, sino que simula uno usando PWM.

Le damos un valor entre 0 (0% ON) y 255 (100% ON).

• analogWrite(pin, 0); ➔ 0V (LED apagado)
• analogWrite(pin, 127); ➔ ~2.5V (LED a media intensidad)
• analogWrite(pin, 255); ➔ 5V (LED a máxima intensidad)

Importante: No todos los pines digitales de Arduino pueden hacer PWM. Solo los que tienen el símbolo ~ (tilde) junto al número (como los pines 3, 5, 6, 9, 10, 11 en el UNO).

Conexiones del Circuito (Hardware)

Vamos a construir el circuito. La clave aquí es identificar correctamente los 4 pines de tu LED RGB. Recuerda: el pin más largo es el Cátodo Común (GND).

Tabla de Conexiones: Arduino a LED RGB

Diagramas de Conexión

Puedes guiarte por el diagrama esquemático para entender la lógica, o por el diagrama de protoboard para el montaje físico.

Explicación Detallada del Montaje

Sigue estos pasos con calma para asegurar que todo esté en su lugar.

1. Insertar el LED: Coloca el LED RGB en la protoboard, con cada uno de sus 4 pines en una fila separada. Identifica el pin más largo (Cátodo Común).
2. Conectar el Cátodo (GND): Usa un cable jumper (negro, por convención) para conectar el pin más largo del LED a uno de los rieles (buses) de la protoboard. Este será tu riel de GND.
3. Conectar el GND de Arduino: Usa otro cable jumper (negro) para conectar un pin GND de tu Arduino a ese mismo riel de GND en la protoboard. Ahora el LED y el Arduino comparten la misma tierra.
4. Colocar las Resistencias: Conecta una resistencia de 220Ω a cada uno de los 3 pines restantes del LED (Rojo, Verde y Azul). Un extremo de la resistencia va en la misma fila que el pin del LED, y el otro extremo en una fila vacía. (¿Por qué? Las resistencias limitan la corriente para proteger tanto los LEDs internos como los pines de tu Arduino).
5. Conectar el Pin Rojo (R): Usa un cable jumper (rojo, si tienes) para conectar desde el Pin Digital ~3 de tu Arduino hasta la fila donde termina la resistencia conectada al pin Rojo del LED.
6. Conectar el Pin Verde (G): Usa un cable jumper (verde) para conectar desde el Pin Digital ~5 de tu Arduino hasta la fila donde termina la resistencia conectada al pin Verde del LED.
7. Conectar el Pin Azul (B): Usa un cable jumper (azul) para conectar desde el Pin Digital ~6 de tu Arduino hasta la fila donde termina la resistencia conectada al pin Azul del LED.

¡Listo! El hardware está montado. Revisa tus conexiones una vez más antes de pasar al código.

Código del Proyecto (Software)

Ahora, vamos a darle vida a nuestro LED. Abre tu Arduino IDE, copia y pega el siguiente código.

/*

* TUTORIAL INGTELECTO : Lección 2 - LED RGB

* * Este código demuestra cómo controlar un LED RGB de Cátodo Común

* usando la función analogWrite() (PWM) para mezclar colores.

* * El código cambiará el color del LED cada segundo.

*/
// 1. Declaración de Variables Globales

// Asignamos los pines PWM (con ~) a variables con nombres claros

int redPin = 3; // El pin del color Rojo va al pin ~3

int greenPin = 5; // El pin del color Verde va al pin ~5

int BluePin = 6; // El pin del color Azul va al pin ~6
// 2. Función de Configuración (Setup)

// Se ejecuta una sola vez al encender o resetear el Arduino

void setup() {

// Configuramos los 3 pines de color como SALIDAS (OUTPUT)

// ya que enviaremos señal (voltaje) desde el Arduino hacia el LED.

pinMode(redPin, OUTPUT);

pinMode(greenPin, OUTPUT);

pinMode(BluePin, OUTPUT);

}
// 3. Bucle Principal (Loop)

// Este código se repite indefinidamente

void loop() {

// Hacemos que nuestro programa cambie el color del LED

// cada segundo (1000 milisegundos)
setColor(255, 0, 0); // Llama a la función para poner el color Rojo

delay(1000); // Espera 1 segundo
setColor(0, 255, 0); // Color Verde

delay(1000); // Espera 1 segundo
setColor(0, 0, 255); // Color Azul

delay(1000); // Espera 1 segundo
setColor(255, 255, 255); // Color Blanco (Rojo+Verde+Azul al máximo)

delay(1000); // Espera 1 segundo
setColor(180, 0, 255); // Color Púrpura (Rojo y Azul mezclados)

delay(1000); // Espera 1 segundo

}
// 4. Función Personalizada: setColor()

// Esta es una función que creamos nosotros para hacer el código más limpio.

// Toma 3 valores (números) como argumentos: redValue, greenValue y blueValue.

void setColor(int redValue, int greenValue, int blueValue) {
// Usamos analogWrite() para enviar la señal PWM a cada pin

// El valor (0-255) determina el brillo de ese color
analogWrite(redPin, redValue);

analogWrite(greenPin, greenValue);

analogWrite(BluePin, blueValue);

}

Explicación Detallada del Código

Este código es un excelente ejemplo de cómo organizar un programa de forma limpia. Lo dividimos en 4 partes:

• 1. Variables Globales:
  • Usamos int redPin = 3; y similares para asignar nombres fáciles de recordar a los números de los pines. Si quisiéramos cambiar los pines, solo modificamos este lugar. Nota cómo usamos los pines ~3, ~5, y ~6, que son capaces de hacer PWM.
• 2. Función setup():
  • Aquí preparamos el hardware. Con pinMode(redPin, OUTPUT); le decimos al Arduino: "El pin 3 será una salida, yo enviaré voltaje a través de él". Hacemos esto para los tres pines de color.
• 3. Función loop():
  • Este es el corazón del programa, se repite sin parar.
  • En lugar de tener un montón de comandos analogWrite() aquí, simplemente llamamos a nuestra función personalizada: setColor().
  • setColor(255, 0, 0); significa: Llama a la función setColor y entrégale los valores: redValue=255, greenValue=0, blueValue=0. El resultado es un color rojo puro al máximo brillo.
  • delay(1000); simplemente pausa el programa por 1000 milisegundos (1 segundo) para que podamos apreciar el color.
  • Experimenta con los valores. Por ejemplo, setColor(255, 255, 0); (Rojo+Verde) te daría un color Amarillo brillante. Y setColor(255, 255, 255); enciende los tres colores al máximo, y la mezcla aditiva de luz nos da un color Blanco.
• 4. Función setColor():
  • Esta es nuestra propia función. La definimos como void (no devuelve ningún valor) y le decimos que aceptará tres argumentos enteros (int redValue, int greenValue, int blueValue).
  • Dentro de esta función está la verdadera acción: analogWrite(redPin, redValue);. Este comando toma el valor que recibió la función (ej: 255) y lo aplica como una señal PWM al pin de color rojo.
  • Hace lo mismo para el verde y el azul. Esta función es una "caja negra" reutilizable que traduce un simple código de color (R, G, B) en las señales eléctricas necesarias.

Resultado Esperado

Una vez que conectes tu Arduino al PC y subas el código:

Deberías ver cómo tu LED RGB comienza un ciclo de colores. Se iluminará en Rojo por un segundo, luego cambiará a Verde por un segundo, luego Azul, luego Blanco y finalmente Morado. Este ciclo se repetirá una y otra vez.

Solución de Problemas (Troubleshooting)

¿No funciona como se esperaba? ¡No te preocupes! La electrónica es un 90% de depuración. Revisa estos puntos comunes:

Conclusión y Próximos Pasos