LED RGB

320px-rgb_led
[By oomlout CC BY-SA from Wikimedia]

Descrición

Un LED RGB ( R= red, vermello, G= green, verde e B= blue, azul) é un LED que incorpora tres LEDs no mesmo encapsulado, de xeito que se poden formar miles de cores axustando de maneira individual a intensidade de cada LED. Os tres LEDs poden estar unidos polo negativo ou cátodo, ou polo positivo ou ánodo.

[tecnoloxia.org CC By-SA]

Dependendo da intensidade de cada un dos LEDs RGB obteremos diferentes cores. O que imos facer é enviar un valor entre 0 e 255 a cada un dos pins PWM dos LEDs.

[By Quark67 CC BY-SA from Wikimedia]

Exemplos:

  • Branco: RGB= 255,255,255
  • Vermello: RGB= 255,0,0
  • Verde: RGB= 0,255,0
  • Azul: RGB= 0,0,255
  • Negro (Apagado): RGB= 0,0,0
  • Amarelo: RGB= 255,255,0
  • Maxenta: RGB= 255,0,255
  • Cian: RGB= 0,255,255

Tomando outros valores podemos conseguir un total de 256 x 256 x 256 = 16.777.216 cores distintas.

Montaxe

Conectamos o LED RGB, con resistencias de protección para cada LED, nos pins dixitais PWM ~9, ~10 e ~11.

Segundo sexa de ánodo ou cátodo común a montaxe será diferente:

RGB cátodo común

RGB cátodo común: Debemos conectar a patilla común a 0V (GND)

RGB ánodo común

RGB ánodo común: Neste caso a patilla común vai a 5V.

Programas:

Se usamos un LED RGB con cátodo común, a cada LED chegaralle o valor correspondente a dito sinal PWM, pero se usamos un LED RGB con ánodo común, o valor resultante será 255-PWM, xa que en repouso os LEDs xa reciben 5V (255)

Nota: Para visualizar ben as cores, cómpre colocar un papel branco detrás do LED RGB.

1. Cores

1. Cores: A cada pin RGB enviamos un valor desde 0 a 255, obtendo diferentes cores

Cátodo común:

// Declaración de variables:

int R_Pin = 11;      // Asignamos un pin a cada LED
int G_Pin = 10;
int B_Pin = 9;
 
int vermello = 0;      // Creamos unha variable para cada cor
int verde = 0;
int azul = 0;

// Configuración:

void setup()          // Declaramos os pins 9, 10 e 11 como de saída
{
  pinMode(R_Pin, OUTPUT);
  pinMode(G_Pin, OUTPUT);
  pinMode(B_Pin, OUTPUT);  
}
 
// Programa:

// Creamos unha funcion "cor" que permita acender os LEDs coa intensidade axeitada para conseguir as cores que desexamos
void cor(int vermello, int verde, int azul)
{
    analogWrite(R_Pin, vermello);
    analogWrite(G_Pin, verde);
    analogWrite(B_Pin, azul);
}

// Cada vez que queremos xerar unha cor, invocamos a función "cor" cos correspondentes valores RGB
void loop()
{
    cor(255,0,0);    // vermello
    delay(1000); 
    cor(0,255,0);    // verde
    delay(1000); 
    cor(0,0,255);    // azul
    delay(1000); 
    cor(255,255,255);    // branco
    delay(1000);
    cor(255,0,255);      // maxenta
    delay(1000);
    cor(255,255,0);      // amarelo
    delay(1000);
    cor(0,255,255);      // cian
    delay(1000);  
    cor(0,0,0);      // apagado
    delay(1000);    
}

Ánodo común:

O programa é igual, agás que agora na definición da función “cor” escribimos 255 menos o valor da variable, xa que en repouso xa está alimentado a 5V, o que equivale a un sinal PWM de 255, e o valor que chega ao LED é a diferenza:

void cor(int vermello, int verde, int azul)
{
    analogWrite(R_Pin, 255-vermello);
    analogWrite(G_Pin, 255-verde);
    analogWrite(B_Pin, 255-azul);
}

2. Cor hexadecimal

2. Cor RGB en hexadecimal:  Podemos utilizar a notación RGB en hexadecimal, que é a que se utiliza para definir as cores en Internet. Para iso debemos indicar que os valores que enviamos son hexadecimais poñendo 0x diante do valor.

rgb_lilaPor exemplo, unha cor lila en hexadecimal é: #AC58FA, o que corresponde aos valores RGB en hexadecimal

  • vermello: 171 = 0xAB
  • verde: 88 = 0x58
  • azul: 250 = 0xFA

Só temos que substituír no programa anterior os valores RGB polos correspondentes en hexadecimal:

void loop()
{
    cor(0xFF,0x0,0x0);    // vermello
    delay(1000); 
    cor(0x0,0xFF,0x0);    // verde
    delay(1000); 
    cor(0x0,0x0,0xFF);    // azul
    delay(1000); 
    cor(0xAC,0x58,0xFA);    // lila
    delay(1000);
    cor(0xDF,0x01,0xD7);      // fuxia
    delay(1000);
    cor(0xAE,0xB4,0x04);      // verde-amarelo
    delay(1000);
    cor(0xFF,0x40,0x00);      // laranxa
    delay(1000);   
    cor(0x0,0x0,0x0);      // apagado
    delay(1000);    
}

3. Cor gradual controlada por pulsadores

3. Cor RGB gradual controlada por pulsadores: Conectamos tres pulsadores coas súas resistencias nos pins 2,3 e 4. Faremos que cada un controle un LED. O esquema cun LED RGB con cátodo común sería:

A cada pin enviamos un sinal de 0 a 255. Cada vez que prememos en cada un dos pulsadores, incrementamos o valor do pin correspondente.

// Declaración de variables:

int R_Pin = 11;      // Asignamos un pin a cada LED
int G_Pin = 10;
int B_Pin = 9;
 
int R_pulsador = 4;    // Asignamos un pin a cada pulsador
int G_pulsador = 3;    // Cada un deles vai actuar sobre un dos LEDs
int B_pulsador = 2;
 
int vermello = 0;      // Creamos unha variable para cada cor
int verde = 0;
int azul = 0;

// Configuración:
 
void setup()          // Declaramos os pins 9, 10 e 11 como de saída
{
  pinMode(R_Pin, OUTPUT);
  pinMode(G_Pin, OUTPUT);
  pinMode(B_Pin, OUTPUT);  
}

// Programa:
 
void loop()
{
  if (digitalRead(R_pulsador) == HIGH)    // Cada vez que prememos nun pulsador
  {                                      
    vermello ++;                         // aumentamos progresivamente o valor das variables 
    if (vermello > 255) {vermello = 0;}    // e poñemos a 0 cada vez que chegan a 255
  }
  if (digitalRead(G_pulsador) == HIGH)
  {
    verde ++;
    if (verde > 255) {verde = 0;}
  }
  if (digitalRead(B_pulsador) == HIGH)
  {
    azul ++;
    if (azul > 255) {azul = 0;}
  }

//Usamos un LED RGB con cátodo común:   
  analogWrite(R_Pin, vermello);        // Enviamos a cada LED o valor das variables
  analogWrite(G_Pin, verde);
  analogWrite(B_Pin, azul);  
  delay(10);

/* se usásemos un LED RGB con ánodo común debemos restar:
  analogWrite(R_Pin, 255-vermello);       
  analogWrite(G_Pin, 255-verde);
  analogWrite(B_Pin, 255-azul);
  delay(10);
*/

}

Propostas:

  1. Outras cores: Elixe 4 cores RGB que che gusten e transmíteas ao LED RGB en decimal e en hexadecimal.
  2. Ao chou: Usa a función random(0,255) para asignar un valor aleatorio entre 0 e 255 a cada LED, de xeito que vaian aparecendo cores aleatorias.
  3. Na consola: Engade ao programa anterior o necesario para visualizar o valor do sinal no monitor serie da maneira (R-G-B), e observa o resultado.

Extras:

  1. Cor RGB con potenciómetros: Conecta tres potenciómetros de xeito que cada un controle unha cor dun LED RGB, obtendo diferentes cores en función das posicións dos cursores.

Deixa un comentario