Control de un Led RGB con Arduino

Los Leds RGB no son nuevos, pero su abaratamiento en los últimos años ha contribuido a su popularización en una amplia variedad de aplicaciones de señalización, iluminación y decoración, entre otras. Están disponibles en distintos formatos, desde el tradicional encapsulado en 5 mm a tiras de varios metros, según nuestras necesidades. En este artículo veremos una forma sencilla de controlarlos empleando una placa Arduino.

Introducción

El led RGB es un tipo especial de LED que tiene la capacidad de generar luz de cualquier color. El truco empleado para lograrlo es utilizar en realidad no uno sino tres leds dentro del mismo encapsulado, de cada uno de los tres colores primarios: rojo (Red), verde (Green) y azul (Blue). Si se controla adecuadamente la cantidad de corriente que se suministra a cada led, se puede controlar la componente de luz de cada uno de estos tres colores y combinarlos para lograr el color que se desee.

Conexiones

Estos tres leds no tienen todos sus pines disponibles, sino que se conectan juntos todos los ánodos o todos los cátodos, dando lugar a dos tipos de leds RGB: ánodo común y cátodo común. El conexionado interno es el que muestra la siguiente imagen:

Como cualquier led, para encenderlo debemos polarizarlo en forma directa, esto es conectando el ánodo a una tensión mas positiva que el cátodo. La disposición de los cuatro pines es la misma en los dos tipos de diodos, siendo el mas largo siempre el terminal común (ánodo o cátodo, según el caso).

Para nuestro proyecto vamos a emplear los siguientes materiales: una placa Arduino UNO, un Prototype Shield (aunque tambien sirve una placa protoboard común), tres resistencias de 1K para limitar la corriente, cables de conexión y por supuesto nuestro led RGB.

Primero probamos el Led en forma manual, sin controlarlo desde Arduino, como se vé en este video

Luego conectamos el LED a la placa Arduino, empleando las salidas 9, 10 y 11 que pueden ser usadas como salidas tanto digitales como analógicas.

Programa

El programa, que se puede ver a continuación es muy simple.

//Profe Tolocka - www.profetolocka.com.ar - profetolocka@gmail.com
//
// Control de LED RGB usando salidas digitales

const byte ROJO=9;    //Salida color Rojo
const byte VERDE=10;    //Salida color Azul
const byte AZUL=11;   //Salida color Verde

void setup () { //Inicialización
  pinMode (ROJO, OUTPUT);
  pinMode (VERDE, OUTPUT);
  pinMode (AZUL, OUTPUT);

  digitalWrite (ROJO, HIGH);
  digitalWrite (VERDE, HIGH);
  digitalWrite (AZUL, HIGH);
}

void loop () {
  //Me aseguro que los tres catodos estén a Vcc (leds apagados)

  digitalWrite (ROJO, LOW);    //Prende Rojo
  delay (1000);
  digitalWrite (ROJO, HIGH);    //Apaga Rojo
    
  digitalWrite (VERDE, LOW);    //Prende Verde
  delay (1000);
  digitalWrite (VERDE, HIGH);    //Apaga Verde

  digitalWrite (AZUL, LOW);    //Prende Azul
  delay (1000);
  digitalWrite (AZUL, HIGH);    //Apaga Azul  
       
  
}

En las primeras líneas se definen tres constantes tipo byte que se corresponden con los tres pines utilizados: 9, 10 y 11. Esto se hace sólo a los fines de lograr una mayor claridad en el código.

A continuación, en la función setup se configuran esos tres pines como salidas y se los deja en nivel alto (HIGH) para que al comenzar el led RGB esté completamente apagado (recuerden que al ser ánodo común, enciende cuando los cátodos se conectan a GND o a un estado LOW).

Finalmente, en la función loop, que se repite indefinidamente, hay tres bloques de código para prender el led en colores Rojo, Verde y Azul respectivamente poniendo a LOW la salida correspondiente durante un tiempo de 1 segundo (1000 mili segundos).

En el video puede verse el programa en funcionamiento

Esta otra versión es similar, sólo que implementa una función llamada “RGB_Led” que tiene un parámetro que permite indicar en qué color hay que prender el led (Rojo, Verde o Azul) o si se debe apagar.

//Profe Tolocka - www.profetolocka.com.ar - profetolocka@gmail.com
//
// Control de LED RGB usando salidas digitales

const byte ROJO=9;    //Salida color Rojo
const byte VERDE=10;    //Salida color Azul
const byte AZUL=11;   //Salida color Verde

const byte LED_OFF=0, LED_ROJO=1, LED_VERDE=2, LED_AZUL=3;

void setup () { //Inicialización

  //Inicializar pines
  pinMode (ROJO, OUTPUT);
  pinMode (VERDE, OUTPUT);
  pinMode (AZUL, OUTPUT);

 //Me aseguro que los tres catodos estén a Vcc (leds apagados)
  digitalWrite (ROJO, HIGH);
  digitalWrite (VERDE, HIGH);
  digitalWrite (AZUL, HIGH);
}

void RGB_Led (unsigned char modo) {
//Prende el led del color especificado o lo apaga

  switch (modo) {
    case LED_OFF: //Apagar
                  digitalWrite (ROJO, HIGH);
                  digitalWrite (VERDE, HIGH);
                  digitalWrite (AZUL, HIGH);  
                  break;
    case LED_ROJO: //Prende ROJO
                  digitalWrite (ROJO, LOW);
                  digitalWrite (VERDE, HIGH);
                  digitalWrite (AZUL, HIGH);      
                  break;
                
    case LED_VERDE: //Prende VERDE
                  digitalWrite (ROJO, HIGH);
                  digitalWrite (VERDE, LOW);
                  digitalWrite (AZUL, HIGH);  
                  break;
                
    case LED_AZUL: //Prende AZUL
                  digitalWrite (ROJO, HIGH);
                  digitalWrite (VERDE, HIGH);
                  digitalWrite (AZUL, LOW);  
                  break;            
  
  }
  
}


void loop () {
 
  RGB_Led (LED_OFF);
  delay (1000);
  RGB_Led (LED_ROJO);
  delay (1000);
  RGB_Led (LED_VERDE);
  delay (1000);
  RGB_Led (LED_AZUL);
  delay (1000);

}

Con la misma conexión se puede controlar al led usando las salidas en modo PWM. En este caso, el led se excita con una señal cuadrada de ciclo de trabajo programable. Como la frecuencia de esta señal es elevada (unos 500 Hz) a los fines prácticos equivale a una tensión analógica variable, lo que nos permite controlar el brillo del led y la componente de cada color, logrando distintas combinaciones.

Este programa funciona de esa forma.

//Profe Tolocka - www.profetolocka.com.ar - profetolocka@gmail.com
//
// Control de LED RGB usando PWMs

const byte ROJO=9;    //Salida color Rojo
const byte VERDE=10;    //Salida color Azul
const byte AZUL=11;   //Salida color Verde

const byte LED_OFF=0, LED_ROJO=1, LED_VERDE=2, LED_AZUL=3;  //Para usar en la funcion de control del LED

void setup () { //Inicialización

 //Me aseguro que los tres catodos estén a Vcc (leds apagados)
  analogWrite (ROJO, 255);
  analogWrite (VERDE, 255);
  analogWrite (AZUL, 255);
}

void RGB_Led (byte RGB_Rojo, byte RGB_Verde, byte RGB_Azul) {
//Prende el led del color especificado 

  analogWrite (ROJO, 255-RGB_Rojo);
  analogWrite (VERDE, 255-RGB_Verde);
  analogWrite (AZUL, 255-RGB_Azul);  

}


void loop () {
 
  unsigned char r=0;
  unsigned char v=0;  
  unsigned char a=0;
   
  RGB_Led (255, 0, 0);      //Rojo
  delay (1000);
  RGB_Led (0, 255, 0);      //Verde
  delay (1000);  
  RGB_Led (0, 0, 255);      //Azul
  delay (1000);  
  RGB_Led (0, 0, 0);        //OFF
  delay (1000);

  for (r=0; r<255; r++) {
    RGB_Led (r, v, a);
    delay (10);
  }
  for (v=0; v<255; v++) {
    RGB_Led (r, v, a);
    delay (10);
  }
  for (int a=0; a<255; a++) {
    RGB_Led (r, v, a);
    delay (10);
  }
      
}

En setup se inicializan las tres salidas, pero esta vez especificando el ciclo de trabajo del PWM, que se debe fijar entre 0 (mínimo) y 255 (máximo). Para que los leds internos del led RGB queden apagados se fijan los 3 PWM a 255 (recuerden que estas salidas se aplican a los cátodos).

La función RGB_Led acepta tres parámetros: la componente roja, verde y azul. Estos parámetros, que van entre 0 y 255 establecen el ciclo de trabajo de cada una de las salidas. El valor se resta de 255 para que funcionen con la misma lógica que el PWM de Arduino, esto es, 0 es mínimo y 255 es máximo. Si usáramos un led Cátodo común, esto no sería necesario.

En loop se demuestra cómo emplear la función RGB_Led. En los tres primeros casos, se prende el led en sus colores básicos. En el cuarto, se lo apaga. Luego, con los bucles for van cambiando los valores de cada componente, lo que hace que el led pase a través de un gradiente de distintos colores. Esto se puede ver en el video.

Minibloq

Para aquellos que recién se inicien en la programación de Arduino, el entorno Minibloq es una buena forma de comenzar. El siguiente “componente” de Minibloq controla el led a través de las tres salidas programando los tres PWM con valores aleatorios entre 0 y 255 (el bloque del “dado” entrega un valor entre 0 y 100 que se multiplica por 2.5) y luego haciendo un retardo de 100 ms.

Espero que se diviertan haciendo sus propias experiencias!

Les comparto este video que les puede servir para sacar algunas ideas