Este artículo te guiará por los conceptos básicos para usar un LED RGB con Arduino, para que puedas crear tus propios colores con la ayuda de potenciómetros.
Te mostraré diagramas de conexión paso a paso y explicaré el código para que entiendas completamente cómo usar este componente.
Después de este tutorial, deberías tener un circuito que ilumine con el color que prefieras usando valores RGB, controlados por potenciómetros y mostrados en el Monitor Serial.
Materiales
Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.
Hardware
- x1 Arduino Uno Rev3 (Amazon)
- x1 LED RGB, cátodo común (Amazon)
- x3 Resistencias de 220 Ohm (Amazon)
- x3 Potenciómetros de 10k Ohm (Amazon)
- x1 Protoboard (Amazon)
- x~17 Cables jumper (Amazon)
- x1 Cable USB B (Amazon)
Software
- Arduino IDE
También puedes encontrar LEDs RGB en KY-016 módulos, que incluyen el LED y las resistencias necesarias en una sola PCB.
Estos módulos no permiten flexibilidad al construir el circuito, pero son más plug-and-play que sus alternativas.
No los recomendaría, prefiero la flexibilidad de usar resistencias, y algunas reseñas muestran una reproducción de color pobre al usar valores RGB.
Instrucciones
Paso 1 – Conectar el LED RGB
Este diagrama de conexión te muestra cómo conectar un LED RGB a la placa Arduino.
Ten en cuenta que este es un LED de cátodo común, en el que el pin más largo se conecta a tierra; más adelante explicaré qué significa cátodo común.
Las conexiones también se detallan en la tabla a continuación.
| Componente | Pin Arduino |
| LED – Rojo | 11 |
| LED – Cátodo | GND |
| LED – Verde | 10 |
| LED – Azul | 9 |
Asegúrate de incluir una resistencia de 220Ω entre los pines rojo, verde y azul del LED y las salidas para evitar daños al LED y al Arduino.
Conceptos básicos del LED RGB
Un LED RGB puede verse como tres LEDs — uno rojo, uno verde y uno azul — en un solo paquete; este LED único brilla combinando las intensidades de rojo, verde y azul.
Los LEDs RGB parecen LEDs normales con cuatro pines, siendo el más largo el pin común.
LEDs RGB de Cátodo Común y Ánodo Común
Mencioné antes los LEDs de cátodo común y ánodo común. Los LEDs RGB vienen en dos tipos: cátodo común y ánodo común.
En LEDs de cátodo común, el pin más largo se conecta a GND y sus componentes se encienden con una señal de 5V; en LEDs de ánodo común es al revés: el pin más largo va a 5V y una señal de 0V enciende los componentes.
En este ejemplo usaremos LEDs de cátodo común; si tienes un LED RGB de ánodo común, el cableado y las salidas deberán invertirse.
La única forma de saber si tu RGB es cátodo común o ánodo común es probar el LED; recomiendo usar un multímetro con la función de diodo.
Para probarlo, coloca la sonda negativa en el pin común y la positiva en cualquier otro pin; si el LED se enciende, es cátodo común.
Si no, coloca la sonda positiva en el pin común y la negativa en cualquier otro pin; el LED debería encenderse, lo que indica que es ánodo común.
Si no tienes un multímetro, puedes hacer esto con los pines 5V y GND del Arduino, solo asegúrate de tener una resistencia de 220Ω en tu circuito.
Controlando el brillo del LED con PWM
El brillo de un LED depende de la corriente que pasa por él, pero no podemos controlar directamente la corriente porque el Arduino Uno no tiene salidas analógicas reales; para controlar el brillo usaremos Modulación por Ancho de Pulso (PWM).
PWM enciende y apaga la salida periódicamente, y cuánto tiempo permanece encendida determina el brillo del LED.
PWM enciende y apaga la salida periódicamente, y cuánto tiempo permanece encendida determina el brillo del LED.
La intensidad del LED está determinada por el ciclo de trabajo del PWM, que es el tiempo que la salida permanece encendida. Un ciclo de trabajo del 50% significa que la salida está alta el 50% del tiempo y baja el otro 50%.
Este ciclo ocurre a 490 Hz, 490 veces por segundo, y puedes controlar este ciclo con AnalogWrite.
PWM enciende y apaga la salida periódicamente, y cuánto tiempo permanece encendida determina el brillo del LED.
Paso 2 – Conectar los tres potenciómetros
En este paso, debes conectar tres potenciómetros a 5V, GND y a los pines analógicos A0, A1 y A2.
Las patas exteriores se conectan a 5V y GND, la pata del medio se conecta a los pines analógicos según esta figura:
En forma de tabla:
| Componente | Pin Arduino |
| Pata más a la derecha (cualquiera) | 5V |
| Pata más a la izquierda (cualquiera) | GND |
| Pata del medio (rojo) | A0 |
| Pata del medio (verde) | A1 |
| Pata del medio (azul) | A2 |
Usando un potenciómetro como entrada analógica
Para controlar los valores del LED RGB, usarás las salidas de los potenciómetros (pata del medio) como entradas analógicas.
El Arduino Uno tiene 6 entradas analógicas, etiquetadas de A0 a A5; estas usan un Convertidor Analógico a Digital (ADC) de 10 bits con 6 canales.
Este convertidor devolverá un número de 0 a 1023 (1024 valores = 2¹⁰ = 10 bits), dependiendo del voltaje que lea en un canal.
Cambiaremos el ciclo de trabajo PWM de los componentes del LED según este valor.
Puedes considerar un potenciómetro en este circuito como un divisor de voltaje: al girar la perilla, la resistencia de la pata del medio cambia, y también el voltaje.
Esto “divide” la entrada de 5V en dos partes si mides el voltaje entre la salida y 5V, y entre la salida y GND.
Paso 3: Código de ejemplo Arduino RGB
Ahora que el cableado está listo, solo queda conectar el Arduino a tu PC y subir el sketch.
Puedes subir el siguiente código a través del Arduino IDE; puedes copiar el código haciendo clic en el botón en la esquina superior derecha del campo de código.
/*Example sketch to control an RGB LED with Arduino using potentiometers
More info: https://www.makerguides.com */
//Definition of pins: outputs
#define redPin 11
#define greenPin 10
#define bluePin 9
//Definition of pins: analog inputs
#define redPot A0
#define greenPot A1
#define bluePot A2
int redVal, greenVal, blueVal; // RGB component values
void setup() {
//Pin definitions
pinMode(redPin, OUTPUT);
pinMode(greenPin, OUTPUT);
pinMode(bluePin, OUTPUT);
pinMode(redPot, INPUT);
pinMode(greenPot, INPUT);
pinMode(bluePot, INPUT);
Serial.begin(9600);
}
void loop() {
//Reading potentiometer values
//When the pot is in the leftmost position, the voltage reading is 0
redVal = analogRead(redPot)/4;
greenVal = analogRead(greenPot)/4;
blueVal = analogRead(bluePot)/4;
//Sets the individual colors with the pot values
analogWrite(redPin, redVal);
analogWrite(greenPin, greenVal);
analogWrite(bluePin, blueVal);
delay(50);
//Printing the values of Red, Green and Blue in a single line
Serial.print("R: "); Serial.print(redVal);
//The \t character creates a tab space between colors
Serial.print("\tG: "); Serial.print(greenVal);
//Final value is Serial.println to create a new line between readings
Serial.print("\tB: "); Serial.println(blueVal);
}
Cómo funciona el código
El primer paso es definir los pines relevantes, esto se hace con la instrucción #define que reemplaza la palabra clave definida con el valor deseado cuando el programa se compila.
Con esto definimos las salidas del LED rojo, verde y azul como los pines 11, 10 y 9 respectivamente.
Luego hacemos el mismo procedimiento con las entradas de los potenciómetros, usando los pines analógicos A0, A1 y A2.
También definí tres variables globales, una para cada pin RGB. Estos valores se definen como enteros, que se usan cuando se trabaja con números enteros.
El valor de un entero puede ir de -2.147.483.648 a 2.147.483.647. Si quieres ser más eficiente con la memoria del Arduino puedes usar el tipo de dato byte , que va de 0 a 255.
Esto no es necesario en este ejemplo simple, pero es útil tenerlo en cuenta en sketches más complejos.
//Definition of pins: outputs #define redPin 11 #define greenPin 10 #define bluePin 9 int redVal, greenVal, blueVal; //RGB component values
En la función setup() del sketch definimos los pines del LED como salidas, y los pines de los potenciómetros como entradas usando la función pinMode().
Luego iniciamos el buffer Serial a 9600 baudios con Serial.begin(9600); con esta función podrás leer los valores de color que imprimas en una sección posterior del sketch.
void setup() {
//Pin definitions
pinMode(redPin, OUTPUT);
pinMode(greenPin, OUTPUT);
pinMode(bluePin, OUTPUT);
pinMode(redPot, INPUT);
pinMode(greenPot, INPUT);
pinMode(bluePot, INPUT);
Serial.begin(9600);
Ahora pasamos a la función loop(). Primero, leemos los valores de los potenciómetros.
Esto se hace con la función analogRead(), en la que especificas el pin y devuelve un valor entre 0 y 1024, como se mencionó antes.
Desafortunadamente, para controlar los LEDs con la función analogWrite() necesitamos valores entre 0 y 255; para esto dividimos el valor leído entre 4 y lo asignamos a nuestros enteros.
//Reading potentiometer values //When the pot is in the leftmost position, the voltage reading is 0V redVal = analogRead(redPot)/4; greenVal = analogRead(greenPot)/4; blueVal = analogRead(bluePot)/4;
En este paso uso las salidas PWM del Arduino para encender los pines rojo, verde y azul del LED RGB con los valores enteros obtenidos de los potenciómetros; solo necesitas especificar el pin y el número entre 0 y 255.
//Sets the individual colors with the pot values analogWrite(redPin, redVal); analogWrite(greenPin, greenVal); analogWrite(bluePin, blueVal);
Luego introduzco un pequeño retardo en el código para evitar que el monitor serial se desplace demasiado rápido, manteniendo la respuesta del LED RGB a las entradas.
Este retardo dura 50 milisegundos: 50 milésimas de segundo o 0,05 segundos.
Puedes ajustar este retardo a tu gusto, solo ten en cuenta que un retardo muy grande hará que los valores RGB se actualicen más lento.
delay(50);
Finalmente, para verificar qué valores RGB se muestran en el LED, los imprimiremos en el monitor serial.
Para mayor claridad, se imprimirán en una sola línea. Para esto usaremos la función Serial.print().
Aquí imprimo la letra correspondiente a cada componente del LED RGB y su valor escrito. Usé el carácter de escape \t para crear una tabulación entre cada color, escape characters que sigue a una barra invertida y no aparece en la cadena impresa, ya que realiza funciones especiales.
Además, la última función serial es Serial.println(), que asegura que el siguiente mensaje serial aparezca en una nueva línea.
Serial.print("R: "); Serial.print(redVal);
Serial.print("\\tG: "); Serial.print(greenVal);
Serial.print("\\tB: "); Serial.println(blueVal);
Para ver los mensajes en el monitor serial, presiona Ctrl+Shift+M en el Arduino IDE o haz clic en el icono de la lupa. Asegúrate de que la velocidad en baudios esté en 9600 para leer correctamente los mensajes.
Deberías ver algo similar a la siguiente imagen:
¡Eso es todo! Si seguiste los pasos correctamente, deberías poder controlar el LED RGB y producir todo tipo de colores usando los potenciómetros.
Color aditivo
La propiedad de que luces de diferentes colores se combinen para crear un nuevo color se llama color aditivo.
Esta propiedad permite que las pantallas muestren alrededor de 16 millones de tonos de color: configurando las luces roja, verde y azul a un valor de 0 a 255, como en nuestro proyecto.
Puedes probar algunas de las combinaciones básicas mostradas en la imagen a continuación, o ir a un color picker y crear la tuya propia.
Los resultados pueden variar: algunos componentes en los LEDs RGB son más fuertes que otros y pueden requerir ajustes.
Conclusión
En este artículo te he mostrado cómo usar un LED RGB con Arduino: su conexión, las salidas analógicas necesarias y un circuito simple que muestra cómo personalizar fácilmente el color del LED.
Si tienes alguna pregunta o sugerencia para este tutorial, deja un comentario abajo.
¡Me encantaría ayudarte!
