LED RGB - pensactius/Tutoriales GitHub Wiki

(Información extraída de DroneBot Workshop)

Introducción

Los LEDs son excelentes como indicadores y display de bajo coste. Consumen poco y son ideales para proyectos alimentados con baterías.

Los LEDs RGB están formados por tres LEDs combinados en un mismo encapsulado. Además de emitir los tres colores primarios RGB (rojo, verde, azul) pueden mostrar potencialmente cualquier color del arco iris combinado diferentes intensidades de cada componente de los tres colores.

Hay diferentse modelos de LEDs RGB, en este artículo veremos dos tipos:

LED RGB estandard
LEDs RGB inteligentes

Los LEDs estandard pueden usarse directamente, mientras que las tiras de LEDs inteligentes requiren de un microcontrolador. Un Arduino es ideal para ambos tipos.

Antes de realizar los proyectos con LEDs echemos un vistazo a la teoría del color, esto nos ayudará a entender cómo crear multitud de colores a partir de los tres primarios.

Teoría del Color

La teoría del color estudia la mezcla de colores para obtener diferentes efectos visuales.

Los primeros trabajos alrededor de la teoría del color datan de mediados del 1400 y los primeras investigaciones fueron realizadas por Leonardo da Vinci e Isaac Newton. Fue Newton quien elaboró el concepto de rueda de color, un diagrama que describe el uso de "colores coplementarios" que se usa todavía hoy en día.

Estos trabajos iniciales eran muy subjetivos ya que se basaban en la percepción personal, más que en uso de modelos del mundo real.

La teoría del color moderna data de finales del siglo 19 y principios del 20.

Mezcla Aditiva vs Substractiva

Hay dos modelos básicos de mezcla de colores - Aditivo y Substractivo.

Los modelos aditivos usan los colores primarios que se AÑADEN entre ellos para producir el color deseado. El modelo Substractivo funciona al contrario, los colores primarios se substraen uno del otro para conseguir el efecto deseado.

El modelo aditivo se usa en dispositivos que emiten luz, como nuestros LEDs RGB o la pantalla de vídeo en la que probablemente estás leyendo esto ahora. El modelo RGB es el más popular (pero no el único) y usa una mezcla de Rojo, Verde y Azul para crear prácticamente cualquier color.

Uno de los colores que no se pueden crear con el modelo aditivo es el Negro. Por este motivo, las pantallas que usan el esquema RGB se contruyen normalmente sobre un fondo negro, de forma que la ausencia de rojo, verde y azul da como resultado el negro.

Si se combina con igual intensidad rojo, verde y azul da como resultado el blanco.

Un modelo Substractivo bastante común es el Cyan, Magenta, Yellow (cian, magenta, amarillo) o CMY. El modelo substrativo se usa en medios que absorben luz, como los medios impresos. Si tienes una impresora a color los cartuchos que usa son precisamente de color cyan, magenta y amarillo.

Muchas impresoras usan el modelo CMYK, donde la "K" viene de "key" (clave), y representa el color clave que es el negro.

Los modelos CMY o CMYK no pueden producir blanco, por eso normalmente se usan sobre un medio (papel) blanco de forma que la ausencia de color da precisamente el blanco del papel.

Puesto que los LEDs usan el modelo aditivo nos centraremos en este modelo a lo largo de este artículo.

Temperatura de Color

Si alguna vez has comoprado luces para casa probablemente habrás oído el término "temperatura del color".

La temperatura del color explica la diferencia de tonalidad entre dos bombillas que son, en principio, blancas ambas, pero que emiten diferente color.

La temperatura de color se mide en Grados Kelvin.

La bombilla que emite un color blanco cálido de tu comedor o dormitorio suele tener una temperatura de unos 2700 - 3200 grados Kelvin.

Las luces usadas en estudios de video o fotografía suelen ser de unos 5500 - 5600 grados Kelvin, parecida a la temperatura de color de la luz solar.

Cuanta más alta es la temperatura más blanca se percibe la luz, mientras que a menos temperatura más rojiza se percibe.

LEDs RGB Básicos

Usaremos dos tipos de LEDs RGB en nuestros experimentos.

El primer tipo es lo que llamaremos "básico", el típico LED RGB que viene en un encapsulado como se muestra en la figura:

El segundo tipo serán los LEDs RGB direccionables o inteligentes, también conocidos como "NeoPixel".

LED RGB de Ánodo & Cátodo común

Los LED RGB básicos están disponibles en dos configuraciones - ánodo común y cátodo común. La configuración describe qué pata de los tres leds internos está conectada entre ellos - la positiva (ánodo común) o la negativa (cátodo común).

(Imagen extraída de ebotics.com)

En cualquier caso el LED tendrá cuatro conexiones:

Conexión Común (Ánodo o Cátodo)
LED rojo (R)
LED verde (G)
LED azul (B)

Típicamente estos LEDs RGB tienen el siguiente pinout:

Resistencias de protección

No puedes conectar directamente el LED RGB a la fuente de alimentación (o los pines de Arduino) o destruirás rápidamente el LED. Como cualquier otro LED necesitarás proteger cada LED interno de exceso de corriente.

Necesitarás un total de tres resistencias de protección, una por cada LED. No intentes usar sólo una en la pata común.

Como cualquier otro LED, necesitas una serie de parámetros para calcular los valores de estas resistencias:

+ Voltaje de Alimentación (Vs)  - El voltaje que proviene de la fuente de alimentación
+ LED Forward Drop Voltage (Vf) - El voltaje que pasa por el LED al conectarlo al circuito
+ Máxima corriente del LED (i)  - Cuánta corriente puede soportar el LED

Los dos últimos parámetros los puedes encontrar en la hoja de especificación del LED.

Siendo estrictos, no deberáis asumir que los tres LEDs internos tienen las mismas especificaciones. Normalmente el Vf de cada LED será diferente.

Una vez encontrados los parámetros de cada LED interno puedes usar la siguiente fórmula para determinar la resistencia de cada uno:

Recuerda que en la fórmula las unidades de corriente son en amperios pero muchos fabricantes de LEDs dan las unidades en miliamperios. Por tanto un valor de 30 miliamperios significa 0.03 amperios.

Como ejemplo el LED usado en el proyecto extraído de dronebotworkshop.com tiene las siguientes especificaciones:

Observa que el LED rojo tiene un forward voltage drop diferente a los otros dos LEDs. Por tanto, para hacerlo bien, deberías usar valores diferentes para cada resistencia de protección.

Veamos cómo calcular la resistencia para el LED rojo. Si ponemos los valores de arriba en la fórmula de Ohm:

$R= \frac{5V-2V}{\0.03A} = \frac{3V}{\0.03A} = 100 \Omega$

Siguiendo el mismo procedimiento obtenemos los valores de resistencias:

Rojo - 100 Ohms
Verde y Azul - 50 Ohms

100 Ohms es un valor estandard de resistencia, pero 50 Ohms no. Puedes usar 47 Ohm o 56 que sí son valores estandard.

Ten en cuenta que con estos valores la intensidad que circula por los LEDs será la máxima permitida y se deteriorarán antes. Además, la mayoría de microcontroldores no son capaces de proporcionar estos valores de intensidad y puedes dañar la placa.

Es recomendable siempre trabajar con intensidades menores a las máximas.

LEDs RGB con Arduino

Ahora es el momento de conectar los LEDs y realizar algunas pruebas.

En este experimento usaremos Arduino para ajustar las intensidades de los LEDs rojo, verde y azul. Esto nos permitirá realizar combinaciones de cualquier color que queramos (excepto negro).

Para controlar los niveles usaremos tres potenciómetros, cualquier tipo sirve, siempre que el valor sea de al menos 10k.

Usaremos resistencias de 220 ohm para los tres LEDs internos, aunque puedes ajustar los valores y usar valores diferentes para cada LED. Esto permitiría un control más preciso de las intensidades de cada LED. Busca las especificaciones de tu LED (probablemente encontrarás una en Internet) y aplica la fórmula mostrada anteriormente.

Usaremos PWM para controlar la intensidad de los LEDs. Si necesitas un repaso de cómo funciona PWM echa un vistazo al artículo "Control de Motores DC con el Módulo L298N". En este artículo se usaba PWM para regular la velocidad de los motores DC pero sigue siendo válido para controlar el brillo de los LEDs.

Programa Arduino

Una vez está todo conectado habrá que cargar algún programa. Este es el sketch que usaremos:

/*
  Demostración LED RGB

  RGB-led-pot-demo.ino

  Control de un LED RGB usando tres potenciómetros.

  Código original de dronebotworkshop.com
  Modificado y adaptado por:
  PensActius 2020
  http://www.pensactius.cat

*/

// Constantes para los pines del LED
const int LED_RED = 11;
const int LED_GREEN = 10;
const int LED_BLUE = 9;

// Definición de los pines para los potenciómetros
const int POT_RED = A0;
const int POT_GREEN = A1;
const int POT_BLUE = A2;

// Variables para los valores de potenciómetros e intesidad de cada LED
int redValue;
int greenValue;
int blueValue;

//---------------------------------------------------------------------------
// setup()
//---------------------------------------------------------------------------
void setup() 
{
  // Los pines del LED son SALIDAS
  pinMode (LED_RED, OUTPUT);
  pinMode (LED_GREEN, OUTPUT);
  pinMode (LED_BLUE, OUTPUT);

  // En placas Arduino UNO no es necesario especificar las entradas analógicas
  // A0,A1,etc. porque únicamente funcionan como entradas.

  // Configura puerto Serie
  Serial.begin (9600);
}

//---------------------------------------------------------------------------
// loop()
//---------------------------------------------------------------------------
void loop() 
{
  // Lee los valores de los potenciómetros
  redValue = analogRead (POT_RED);
  greenValue = analogRead (POT_GREEN);
  blueValue = analogRead (POT_BLUE);

  // Convierte los valores a rango de 0-255
  redValue = map (redValue, 0, 1023, 0, 255);
  greenValue = map (redValue, 0, 1023, 0, 255);
  blueValue = map (blueValue, 0, 1023, 0, 255);

  // Utiliza los valores calculados para establecer el color del LED RGB
  setColor (redValue, greenValue, blueValue);

  // Muestra los valores de color por el monitor serie
  Serial.print("Red: ");
  Serial.print(redValue);
  Serial.print(" - Green: ");
  Serial.print(greenValue);
  Serial.print(" - Blue: ");
  Serial.println(blueValue);
}

//---------------------------------------------------------------------------
// setColor()
//---------------------------------------------------------------------------
void setcolor (int redValue, int greenValue, int blueValue) 
{
  analogWrite (LED_RED, redValue);
  analogWrite (LED_GREEN, greenValue);
  analogWrite (LED_BLUE, blueValue);
}

Comenzamos definiendo una serie de constantes para hacer más legible el código. En primer lugar definimos los pines que se usan para conectar el LED RGB. Los tres pines que controlan cada LED interno del RGB han de soportar PWM. Si usas una placa diferente a Arduino deberás buscar qué pines soportan esta característica.

A continuación definimos trs constantes más para los pines de las tres entradas analógicas usadas por los potenciómetros.

Usamos tres variables de tipo entero para almacenar los valores rojo, verde, azul que pasaremos a los LEDs (también usado de forma temporal para leer los valores de los potenciómetros).

En la función setup() definimos los pines del LED RGB como salidas. También inicializamos el monitor serie para poder mostrar los valores RGB por pantalla. Fíjate que no es necesario definir los pines analógicos (A1, A2, etc.) como entradas ya que éstos únicamente pueden funcionar como entrada, y por tanto no hay ambigüidad a la hora de usarlos.

Antes de comentar la función loop veamos la función setColor(). Esta es una función propia - la hemos creado nosotros - para establecer el color del LED RGB.

La función acepta tres entradas - en terminología informática se dice que acepta tres parámetros - una para cada color. Utilizando la función de Arduino analogWrite producimos la señal PWM por el pin correspondiente.

Ahora que ya entendemos la función setColor ya podemos volver al loop.

Comenzamos la función loop() leyendo los valores de los tres potenciómetros usando la función de Arduino analogRead. Esta función produce un rango de valores que depende de la placa. En Arduino Uno y similares (Arduino Nano, Pro mini, etc.) el rango de valores va de 0 a 1023, ya que el microcontrolador que llevan - Atmel 328P - tiene un ADC (Analog Digital Converter - Conversor Digital Analógico) de 10 bits de resolución.

Necesitamos convertir este valor para mantenerlo a un rango entre 0 y 255 para la intensidad de cada componente RGB. Para eso usamos la función Arduino map.

Una vez realizada la conversión simplemente pasamos los valores a la función que vimos anteriormente, setColor.

Finalmente escribimos los valores al monitor serie.

Controlar un LED RGB es bastante sencillo. Pero cómo hacer para controlar multitud de LEDs RGB?

Si quieres controlar muchos LEDs RGB, como una tira de LEDs RGB (no direccionable), podrías usar tres transistores y una fuente externa de alimentación con el sketch que acabamos de ver. Los transistores son imprescindibles ya que las salidas de Arduino (y cualquier placa) son incapaces de proporcionar tanta corriente.

Por supuesto esto permitirá controlar tantos LEDs RGB como los transistores y fuentes de alimentación sean capaces de soportar, siempre y cuando lo que quieras es encenderlos todos del mismo color.

Pero ¿y si lo que quieres es controlar múltiples LEDs RGB de manera independiente? Para eso necesitas una tira de LEDs RGB direccionable. Puedes encontrar información detallada sobre cómo usar estas tiras en el artículo

Tira de LED RGB Direccionable