Descrición
Nesta sección veremos como usar un LED RGB. Se para o teu proxecto necesitas moitos leds de cores, é mellor opción utilizar LEDS RGB neopixel. Pero se só necesitas un ou dous está opción non é complicada e consume moito menos.
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.
|
|
 |
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.
Por 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:
- Outras cores: Elixe 4 cores RGB que che gusten e transmíteas ao LED RGB en decimal e en hexadecimal.
- 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.
- 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:
- 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.