UN RGB VARIABLE POR UNA SALIDA PWM.
ÍNDICE:
0.- TEORÍA: EL LED RGB.
1.- VARIACIÓN DE COLORES CON EL RGB.
2.- RGB CON POTENCIÓMETROS.
3.- RGB CON PULSADORES.
4.- CONSTRUYE TU PROPIO PROYECTO CON UN RGB.
0.- TEORÍA: EL LED RBG
Teoría y práctica RGB: http://www.prometec.net/rgb-led/
LAS PANTALLAS RBG.
Las pantallas están formadas por PÍXELES, y cada píxel tiene tres luces diminutas de color rojo, verde y azul (Red,Green,Blue). Por eso se denominan pantallas RGB.
Estos tres colores básicos pueden formar combinación entre ellos llegando a poder conseguir hata 16 millones de tonalidades diferentes, que son más de los que el ojo humano puede distinguir.
El LED RGB (light emitting diode red gren blue) contienen tres diodos emisores de luz en su interior. El propósito de este es poder crear, en teoría, toda la gamma de colores posibles mezclando cada color con intensidades distintas. Cuando se mezclan los tres a la misma intensidad de obtiene el blanco.
Para el control de este LED es común usar el encapsulado de 5mm como en los LED comunes, agregando un pin de conexión por cada color y uno para el nodo común.
Este nodo común puede ser el cátodo o el ánodo como se muestra a continuación:
Las caídas de voltaje y consumo de corriente para cada color son:
Pueden crear un sin fin de juegos de intensidades para modificar el comportamiento del LED RGB a su gusto, también se pueden modificar las frecuencias de cambio entre los colores para producir efectos de rapidez, cámara lenta, etc.
Para saber qué intensidad escribir para cada color pueden ayudarse de un programa editor de gráficos como Paint, Photoshop, GIMP, etc. abrir la paleta de colores y elegir los números se que indican en las pestañas RGB.
Podemos apreciar los valores R = 0, G = 255 y B = 255 para crear el color celeste. De la misma forma pueden encontrar los valores necesarios para las demás gamas de colores.
Cabe señalar que un color más opaco simplemente baja la intensidad del led y no necesariamente se verá más gris, si no que simplemente más “apagado”.
LA SALIDA PWM.
PWM significa modulación por ancho de pulso. Consiste en generar una onda cuadrada compuesta por un tramo alto de 5voltios y otro bajo en 0voltios.
Si modificamos el tiempo en que se mantiene el tramo alto de 5 voltios, podemos obtener un valor medio de la señal cuadrada que es lo que se conoce como modular por ancho de pulso.
El tiempo en que la señal del valor de 5voltios está en alto se conoce como ciclo de trabajo. Se expresa en %. De esta forma, por ejemplo, una señal que está tanto tiempo en alto con 5v como en bajo con 0 voltios tendrá un ciclo de trabajo equivalente al 50% y equivale por tanto a un valor promedio de 2,50 voltios.
Este tipo de señal modulada sólo la proporcionan aquellos pines marcados con el símbolo PMW - y son gobernados por la instrucción:
Estos tres colores básicos pueden formar combinación entre ellos llegando a poder conseguir hata 16 millones de tonalidades diferentes, que son más de los que el ojo humano puede distinguir.
El LED RGB (light emitting diode red gren blue) contienen tres diodos emisores de luz en su interior. El propósito de este es poder crear, en teoría, toda la gamma de colores posibles mezclando cada color con intensidades distintas. Cuando se mezclan los tres a la misma intensidad de obtiene el blanco.
Para el control de este LED es común usar el encapsulado de 5mm como en los LED comunes, agregando un pin de conexión por cada color y uno para el nodo común.
Este nodo común puede ser el cátodo o el ánodo como se muestra a continuación:
Las caídas de voltaje y consumo de corriente para cada color son:
| LED Rojo | 2,1[V] | 20[mA] |
| LED Verde | 3,3[V] | 20[mA] |
| LED Azul | 3,3[V] | 20[mA] |
Pueden crear un sin fin de juegos de intensidades para modificar el comportamiento del LED RGB a su gusto, también se pueden modificar las frecuencias de cambio entre los colores para producir efectos de rapidez, cámara lenta, etc.
Para saber qué intensidad escribir para cada color pueden ayudarse de un programa editor de gráficos como Paint, Photoshop, GIMP, etc. abrir la paleta de colores y elegir los números se que indican en las pestañas RGB.
Podemos apreciar los valores R = 0, G = 255 y B = 255 para crear el color celeste. De la misma forma pueden encontrar los valores necesarios para las demás gamas de colores.
Cabe señalar que un color más opaco simplemente baja la intensidad del led y no necesariamente se verá más gris, si no que simplemente más “apagado”.
LA SALIDA PWM.
PWM significa modulación por ancho de pulso. Consiste en generar una onda cuadrada compuesta por un tramo alto de 5voltios y otro bajo en 0voltios.
Si modificamos el tiempo en que se mantiene el tramo alto de 5 voltios, podemos obtener un valor medio de la señal cuadrada que es lo que se conoce como modular por ancho de pulso.
El tiempo en que la señal del valor de 5voltios está en alto se conoce como ciclo de trabajo. Se expresa en %. De esta forma, por ejemplo, una señal que está tanto tiempo en alto con 5v como en bajo con 0 voltios tendrá un ciclo de trabajo equivalente al 50% y equivale por tanto a un valor promedio de 2,50 voltios.
Este tipo de señal modulada sólo la proporcionan aquellos pines marcados con el símbolo PMW - y son gobernados por la instrucción:
analogWrite(pin, valor);
Se considera una salida analógica porque nos permite obtener valores intermedios entre el 0 y el 255, es decir, 8 bits, 256 valores diferentes que son mucho más de los único dos valores (0 o 1) que pueden proporcionar los pines digitales de arduino.
RGB CON TRES PULSADORES El objetivo de este tutorial consiste en combinar la utilización de pulsadores para controlar el color de un led RGB.
El modelo RGB se basa en la posibilidad de representar un color mediante la mezcla por adición de los tres colores de luz primarios: rojo, verde y azul.
Antes de adentrarnos en el montaje, enumeraremos los componentes necesarios para realizar el experimento:
Deberemos comprobar que la patilla más larga del led RGB sea la que esté conectada a tierra. En nuestro diagrama se trata de la segunda patilla, pero esto puede variar según el tipo de led RGB que tengamos.
Se considera una salida analógica porque nos permite obtener valores intermedios entre el 0 y el 255, es decir, 8 bits, 256 valores diferentes que son mucho más de los único dos valores (0 o 1) que pueden proporcionar los pines digitales de arduino.
Por tanto, una salida PWM se considera como analógica y nos permite modular entre un rango de 0 a 5 voltios para poder controlar entre otras cosas: la velocidad de un motor, la luminosidad de un led, etc.
Para conseguirlo, basta con poner en "valor" un número comprendido entre 0 y 255. Siendo 0 el equivalente a 0voltios, 128 el equivalente a 2,5voltios (50%) y 255 el equivalente a 5voltios (1
/*
Programa para controlar un LED RGB con arduino.
Usando las salidas PWM se puede controlar la intensidad de cada color para hacer las mezclas.
Se hacen dos funciones:
rgbon(): Muestra los 3 colores principales uno despues de otro (rojo, verde y azul)
colors(): Permite elegir entre tres colores (amarillo (y), narajno (o) o rosado (p))
usando sus siglas en ingles
Materiales:
1 Arduino UNO Rev3
1 LED RGB de 4 patas catodo comun
3 resistencias de 220[ohm]
cables de conexion
Autor: Arduino UTFSM
Fecha: 22 Mayo 2014
*/
/*-----Declaracion de variables para cada color R G B-----*/
int rled = 11; // Pin PWN 11 para led rojo
int bled = 10; // Pin PWM 10 para led azul
int gled = 9; // Pin PWM 9 para led verde
/*----Declaracion de variables auxiliares-----*/
int i; // Variable para ciclos repetitivos
int repeat = 5; // Variables para cantidad limite de repeticiones
void setup() {
/*----- Se inicializan pines PWM como salida*/
pinMode(rled, OUTPUT);
pinMode(bled, OUTPUT);
pinMode(gled, OUTPUT);
}
void loop() {
for(i=0; i<repeat; i++) //Se repite la ejecucion de la funcion rgbon() "repeat" veces
rgbon();
delay(2000); //Se espera 1 segundo
1.- VARIACIÓN DE COLORES CON UN RGB
Vamos a realizar el montaje de un led RGB conectado cada uno de sus tres ledes a los pines analógicos de arduino para poder ir modificando la intensidad de los leds desde el programa.
Montaremos el RGB en una protoboard conectando tres resistencias de 220Ohmios (o directamente el "módulo RGB" puesto que al tratarse de un módulo ya lleva las resistencias incorporadas).
CÓDIGOVamos a realizar el montaje de un led RGB conectado cada uno de sus tres ledes a los pines analógicos de arduino para poder ir modificando la intensidad de los leds desde el programa.
Montaremos el RGB en una protoboard conectando tres resistencias de 220Ohmios (o directamente el "módulo RGB" puesto que al tratarse de un módulo ya lleva las resistencias incorporadas).
Utilizaremos los pines 9,10 y 11 PWM.
Si puedes, pon una pelota de ping pong en el RGB para que se difuminen mejor los colores conseguidos.
RGB de cátodo común (-).
CÓDIGO
int redPin = 11;
int greenPin = 10;
int bluePin = 9;
void setup() {
pinMode(redPin, OUTPUT);
pinMode(greenPin, OUTPUT);
pinMode(bluePin, OUTPUT);
}
void loop() {
setColor(255, 0, 0); // red
delay(1000);
setColor(0, 255, 0); // green
delay(1000);
setColor(0, 0, 255); // blue
delay(1000);
setColor(255, 255, 0); // yellow
delay(1000);
setColor(80, 0, 80); // purple
delay(1000);
setColor(0, 255, 255); // aqua
delay(1000);
}
void setColor(int red, int green, int blue) {
analogWrite(redPin, red);
analogWrite(greenPin, green);
analogWrite(bluePin, blue);
}
CÓDIGO: (busca si quieres, tu propio código en internet)
const int RED_PIN = 9;
const int GREEN_PIN = 10;
const int BLUE_PIN = 11;
int DISPLAY_TIME = 10; // velocidad de cambio luces
void setup(){
pinMode(RED_PIN, OUTPUT);
pinMode(GREEN_PIN, OUTPUT);
pinMode(BLUE_PIN, OUTPUT);
}
void loop(){
mainColors();
showSpectrum();
}
void mainColors(){
digitalWrite(RED_PIN, LOW); //2^3 son ocho posibles colores con on/off
digitalWrite(GREEN_PIN, LOW); //en este caso apagados todos off
digitalWrite(BLUE_PIN, LOW);
delay(1000);
digitalWrite(RED_PIN, HIGH);
digitalWrite(GREEN_PIN, LOW);
digitalWrite(BLUE_PIN, LOW);
delay(1000);
digitalWrite(RED_PIN, LOW);
digitalWrite(GREEN_PIN, HIGH);
digitalWrite(BLUE_PIN, LOW);
delay(1000);
digitalWrite(RED_PIN, LOW);
digitalWrite(GREEN_PIN, LOW);
digitalWrite(BLUE_PIN, HIGH);
delay(1000);
digitalWrite(RED_PIN, HIGH); //yelow
digitalWrite(GREEN_PIN, HIGH);
digitalWrite(BLUE_PIN, LOW);
delay(1000);
digitalWrite(RED_PIN, LOW); //cyan
digitalWrite(GREEN_PIN, HIGH);
digitalWrite(BLUE_PIN, HIGH);
delay(1000);
digitalWrite(RED_PIN, HIGH); //purple
digitalWrite(GREEN_PIN, LOW);
digitalWrite(BLUE_PIN, HIGH);
delay(1000);
digitalWrite(RED_PIN, HIGH); //white
digitalWrite(GREEN_PIN, HIGH);
digitalWrite(BLUE_PIN, HIGH);
delay(1000);
}
void showSpectrum(){ //a rainbow con simples colores de la función showRGB()
int x;
for (x = 0; x < 768; x++){
showRGB(x);
delay(DISPLAY_TIME);
}
}
// la siguiente funcion showRGB() muestra espectro colores
//traslada un número entre (0-767) respecto cada color 3x255
//establece tres zonas de colores
//0 es rojo puro, 255 verde, 511 azul y 767 rojo otra vez.
void showRGB(int color){ //color representar un numero
int redIntensity;
int greenIntensity;
int blueIntensity;
if (color <= 255) { //zona1
redIntensity = 255 - color; // red goes from on to off
greenIntensity = color; // green goes from off to on
blueIntensity = 0; // blue is always off
}
else if (color <= 511) { //zona 2
redIntensity = 0; // red is always off
greenIntensity = 255 - (color - 256); // green on to off
blueIntensity = (color - 256); // blue off to on
}
else if (color >= 512) { //zona 3
redIntensity = (color - 512); // red off to on
greenIntensity = 0; // green is always off
blueIntensity = 255 - (color - 512); // blue on to off
}
analogWrite(RED_PIN, redIntensity);
analogWrite(BLUE_PIN, blueIntensity);
analogWrite(GREEN_PIN, greenIntensity);
}
RGB de cátodo común (-).
CÓDIGO
int redPin = 11;
int greenPin = 10;
int bluePin = 9;
void setup() {
pinMode(redPin, OUTPUT);
pinMode(greenPin, OUTPUT);
pinMode(bluePin, OUTPUT);
}
void loop() {
setColor(255, 0, 0); // red
delay(1000);
setColor(0, 255, 0); // green
delay(1000);
setColor(0, 0, 255); // blue
delay(1000);
setColor(255, 255, 0); // yellow
delay(1000);
setColor(80, 0, 80); // purple
delay(1000);
setColor(0, 255, 255); // aqua
delay(1000);
}
void setColor(int red, int green, int blue) {
analogWrite(redPin, red);
analogWrite(greenPin, green);
analogWrite(bluePin, blue);
}
CÓDIGO: (busca si quieres, tu propio código en internet)
const int RED_PIN = 9;
const int GREEN_PIN = 10;
const int BLUE_PIN = 11;
int DISPLAY_TIME = 10; // velocidad de cambio luces
void setup(){
pinMode(RED_PIN, OUTPUT);
pinMode(GREEN_PIN, OUTPUT);
pinMode(BLUE_PIN, OUTPUT);
}
void loop(){
mainColors();
showSpectrum();
}
void mainColors(){
digitalWrite(RED_PIN, LOW); //2^3 son ocho posibles colores con on/off
digitalWrite(GREEN_PIN, LOW); //en este caso apagados todos off
digitalWrite(BLUE_PIN, LOW);
delay(1000);
digitalWrite(RED_PIN, HIGH);
digitalWrite(GREEN_PIN, LOW);
digitalWrite(BLUE_PIN, LOW);
delay(1000);
digitalWrite(RED_PIN, LOW);
digitalWrite(GREEN_PIN, HIGH);
digitalWrite(BLUE_PIN, LOW);
delay(1000);
digitalWrite(RED_PIN, LOW);
digitalWrite(GREEN_PIN, LOW);
digitalWrite(BLUE_PIN, HIGH);
delay(1000);
digitalWrite(RED_PIN, HIGH); //yelow
digitalWrite(GREEN_PIN, HIGH);
digitalWrite(BLUE_PIN, LOW);
delay(1000);
digitalWrite(RED_PIN, LOW); //cyan
digitalWrite(GREEN_PIN, HIGH);
digitalWrite(BLUE_PIN, HIGH);
delay(1000);
digitalWrite(RED_PIN, HIGH); //purple
digitalWrite(GREEN_PIN, LOW);
digitalWrite(BLUE_PIN, HIGH);
delay(1000);
digitalWrite(RED_PIN, HIGH); //white
digitalWrite(GREEN_PIN, HIGH);
digitalWrite(BLUE_PIN, HIGH);
delay(1000);
}
void showSpectrum(){ //a rainbow con simples colores de la función showRGB()
int x;
for (x = 0; x < 768; x++){
showRGB(x);
delay(DISPLAY_TIME);
}
}
// la siguiente funcion showRGB() muestra espectro colores
//traslada un número entre (0-767) respecto cada color 3x255
//establece tres zonas de colores
//0 es rojo puro, 255 verde, 511 azul y 767 rojo otra vez.
void showRGB(int color){ //color representar un numero
int redIntensity;
int greenIntensity;
int blueIntensity;
if (color <= 255) { //zona1
redIntensity = 255 - color; // red goes from on to off
greenIntensity = color; // green goes from off to on
blueIntensity = 0; // blue is always off
}
else if (color <= 511) { //zona 2
redIntensity = 0; // red is always off
greenIntensity = 255 - (color - 256); // green on to off
blueIntensity = (color - 256); // blue off to on
}
else if (color >= 512) { //zona 3
redIntensity = (color - 512); // red off to on
greenIntensity = 0; // green is always off
blueIntensity = 255 - (color - 512); // blue on to off
}
analogWrite(RED_PIN, redIntensity);
analogWrite(BLUE_PIN, blueIntensity);
analogWrite(GREEN_PIN, greenIntensity);
}
/*
Programa para controlar un LED RGB con arduino.
Usando las salidas PWM se puede controlar la intensidad de cada color para hacer las mezclas.
Se hacen dos funciones:
rgbon(): Muestra los 3 colores principales uno despues de otro (rojo, verde y azul)
colors(): Permite elegir entre tres colores (amarillo (y), narajno (o) o rosado (p))
usando sus siglas en ingles
Materiales:
1 Arduino UNO Rev3
1 LED RGB de 4 patas catodo comun
3 resistencias de 220[ohm]
cables de conexion
Autor: Arduino UTFSM
Fecha: 22 Mayo 2014
*/
/*-----Declaracion de variables para cada color R G B-----*/
int rled = 11; // Pin PWN 11 para led rojo
int bled = 10; // Pin PWM 10 para led azul
int gled = 9; // Pin PWM 9 para led verde
/*----Declaracion de variables auxiliares-----*/
int i; // Variable para ciclos repetitivos
int repeat = 5; // Variables para cantidad limite de repeticiones
void setup() {
/*----- Se inicializan pines PWM como salida*/
pinMode(rled, OUTPUT);
pinMode(bled, OUTPUT);
pinMode(gled, OUTPUT);
}
void loop() {
for(i=0; i<repeat; i++) //Se repite la ejecucion de la funcion rgbon() "repeat" veces
rgbon();
delay(2000); //Se espera 1 segundo
colors('y'); //Se enciende el LED en color amarillo (y de yellow)
delay(500);
colors('o'); //Se enciende el LED en color naranko (o de orange)
delay(500);
colors('p'); //Se enciende el LED en color rosado (p de pink)
delay(500);
}
/*-----Funcion para mostrar colores principales cada 500 ms-----*/
void rgbon(){
analogWrite(rled,255); // Se enciende color rojo
delay(500); // Se esperan 500 ms
analogWrite(rled,0); // Se apaga color rojo
analogWrite(bled,255); // Se enciende color azul
delay(500); // Se esperan 500 ms
analogWrite(bled,0); // Se apaga color azul
analogWrite(gled,255); // Se enciende color verde
delay(500); // Se esperan 500 ms
analogWrite(gled,0); // Se apaga colo verde
}
/*-----Funcion que permite escoger entre color amarillo, naranjo o rosado-----*/
void colors(char color){ //La funcion recibe un parametro que se guarda en variable color
switch(color){ //Se compara variable color con dato guardado
case 'y': analogWrite(rled,255); // Si color == 'y' se enciende color amarillo
analogWrite(gled,255); // Mezclando r = 255 / g = 255 / b = 0
analogWrite(bled,0);
break;
case 'o': analogWrite(rled,255); // Si color == 'o' se enciende color naranjo
analogWrite(gled,180); // Mezclando r = 255 / g = 180 / b = 0
analogWrite(bled,0);
break;
case 'p': analogWrite(rled,255); // Si color == 'p' se enciende color rosado
analogWrite(gled,0); // Mezclando r = 255 / g = 0 / b = 255
analogWrite(bled,255);
break;
}
}
2.- RBG CON POTENCIÓMETROS.
Lo que pretendemos hacer con el siguiente montaje es no sólo encender un LED-RGB mediante Arduino (con la consecuente obligación de acudir al código cada vez que se desee un nuevo color) sino de cambiar también el color del LED utilizando los diferentes valores que nos da cada POTENCIOMETRO.
Así pues, y una vez montado, sólo tendremos que girar en un sentido o en otro los distintos potenciómetros para obtener las diferentes mezclas de colores que nos ofrecen este tipo de LEDs.
La patilla central de nuestros potenciómetros deberá conectarse en una entrada analógica (en este caso hemos elegido la A0, A1 y A2) así como conectar tanto a la tensión de 5V como a GND las patillas de los extremos, para que al girar el potenciómetro nos varíe la resistencia interna y por tanto se modifique el valor del mismo.
Una vez hecho esto procederemos a conectar nuestro LED-RGB a la protoboard (recordad que el cátodo corresponde a la parte más ancha de metal que hay dentro del capuchón transparente, esto nos servirá de guía a la hora de orientarnos en el montaje y evitar errores a la hora de seleccionar los colores). La primera patilla empezando por la izquierda es la equivalente al color rojo (si tenéis el cátodo también en el lado izquierdo claro), la segunda es la que usaremos para alimentar el LED conectándolo a los 5V, la tercera es la equivalente al color verde y la cuarta y última la que nos dará el color azul. Es muy importante no olvidar las resistencias ya que estas son las encargadas de crear la diferencia de potencial necesaria para que los diferentes colores se iluminen. Cada una de las patillas de color estarán conectadas a las salidas digitales 9, 10 y 11 (Rojo, Verde y Azul respectivamente).
CÓDIGO: RGB CON POTENCIÓMETRO.
// Programa que varia el color del LED según el valor obtenido por unos potenciómetros
//Declara puertos de entradas y salidas y variables
int ledRojo = 9; //Declara Pin LED Rojo
int ledVerde=10; //Declara Pin LED Verde
int ledAzul=11; //Declara Pin LED Azul
int pinPot0 = A0; //Declara Pin Potenciometro Rojo
int pinPot1 = A1; //Declara Pin Potenciometro Verde
int pinPot2 = A2; //Declara Pin Potenciometro Azul
int valorsensor0 = 0; //Valores analogicos de la salida del potenciometro
int valorsensor1 = 0; // || || || ||
int valorsensor2 = 0; // || || || ||
void setup() // Función de configuración, se ejecuta cada vez que el Arduino se inicia
{
pinMode(ledRojo,OUTPUT); //El LED Rojo como una salida
pinMode(ledVerde,OUTPUT); //El LED Verde como una salida
pinMode(ledAzul,OUTPUT); //El LED Azul como una salida
Serial.begin(9600);
}
void loop() //Función cíclica
{
valorsensor0 = analogRead(pinPot0); // 1er posicion: Intensidad Rojo
valorsensor1 = analogRead(pinPot1); // 2da posición: Intensidad Verde
valorsensor2 = analogRead(pinPot2); // 3ra posición: Intensidad Azul
analogWrite(ledRojo, valorsensor0); //segun el valor de tres potenciómetros
analogWrite(ledVerde, valorsensor1);
analogWrite(ledAzul, valorsensor2);
delay (1000);
}
Los colores están comprendidos entre los valores 0 – 255 siendo 0 apagado y 255 el color a la máxima intensidad. Los valores 0 – 1032 hacen referencia a lo que Arduino lee de los potenciómetros (Las entradas analógicas sólo leen diez digitos, es decir, hasta un máximo de 1023. Esta señal siempre está comprendida entre 0 -1032 independientemente de la resistencia del potenciómetro.
CÓDIGO
*/
Programa que varia el color del LED según
el valor obtenido por unos potenciómetros.
*/
//--------------------------------------------------
//Declara puertos de entradas y salidas y variables
//--------------------------------------------------
int ledRojo = 9; //Declara Pin LED Rojo
int ledVerde=10; //Declara Pin LED Verde
int ledAzul=11; //Declara Pin LED Azul
int pinPot0 = A0; //Declara Pin Potenciometro Rojo
int pinPot1 = A1; //Declara Pin Potenciometro Verde
int pinPot2 = A2; //Declara Pin Potenciometro Azul
int valorsensor0 = 0; //Valores analogicos de la salida del potenciometro
int valorsensor1 = 0; // || || || ||
int valorsensor2 = 0; // || || || ||
float divisionR;
float divisionV;
float divisionA;
Cambia los colores de un RGB mediante un pulsador: http://www.arduino.utfsm.cl/cambiar-colores-de-un-led-rgb-con-pulsador/
delay(500);
colors('o'); //Se enciende el LED en color naranko (o de orange)
delay(500);
colors('p'); //Se enciende el LED en color rosado (p de pink)
delay(500);
}
/*-----Funcion para mostrar colores principales cada 500 ms-----*/
void rgbon(){
analogWrite(rled,255); // Se enciende color rojo
delay(500); // Se esperan 500 ms
analogWrite(rled,0); // Se apaga color rojo
analogWrite(bled,255); // Se enciende color azul
delay(500); // Se esperan 500 ms
analogWrite(bled,0); // Se apaga color azul
analogWrite(gled,255); // Se enciende color verde
delay(500); // Se esperan 500 ms
analogWrite(gled,0); // Se apaga colo verde
}
/*-----Funcion que permite escoger entre color amarillo, naranjo o rosado-----*/
void colors(char color){ //La funcion recibe un parametro que se guarda en variable color
switch(color){ //Se compara variable color con dato guardado
case 'y': analogWrite(rled,255); // Si color == 'y' se enciende color amarillo
analogWrite(gled,255); // Mezclando r = 255 / g = 255 / b = 0
analogWrite(bled,0);
break;
case 'o': analogWrite(rled,255); // Si color == 'o' se enciende color naranjo
analogWrite(gled,180); // Mezclando r = 255 / g = 180 / b = 0
analogWrite(bled,0);
break;
case 'p': analogWrite(rled,255); // Si color == 'p' se enciende color rosado
analogWrite(gled,0); // Mezclando r = 255 / g = 0 / b = 255
analogWrite(bled,255);
break;
}
}
2.- RBG CON POTENCIÓMETROS.
Lo que pretendemos hacer con el siguiente montaje es no sólo encender un LED-RGB mediante Arduino (con la consecuente obligación de acudir al código cada vez que se desee un nuevo color) sino de cambiar también el color del LED utilizando los diferentes valores que nos da cada POTENCIOMETRO.
Así pues, y una vez montado, sólo tendremos que girar en un sentido o en otro los distintos potenciómetros para obtener las diferentes mezclas de colores que nos ofrecen este tipo de LEDs.
La patilla central de nuestros potenciómetros deberá conectarse en una entrada analógica (en este caso hemos elegido la A0, A1 y A2) así como conectar tanto a la tensión de 5V como a GND las patillas de los extremos, para que al girar el potenciómetro nos varíe la resistencia interna y por tanto se modifique el valor del mismo.
Una vez hecho esto procederemos a conectar nuestro LED-RGB a la protoboard (recordad que el cátodo corresponde a la parte más ancha de metal que hay dentro del capuchón transparente, esto nos servirá de guía a la hora de orientarnos en el montaje y evitar errores a la hora de seleccionar los colores). La primera patilla empezando por la izquierda es la equivalente al color rojo (si tenéis el cátodo también en el lado izquierdo claro), la segunda es la que usaremos para alimentar el LED conectándolo a los 5V, la tercera es la equivalente al color verde y la cuarta y última la que nos dará el color azul. Es muy importante no olvidar las resistencias ya que estas son las encargadas de crear la diferencia de potencial necesaria para que los diferentes colores se iluminen. Cada una de las patillas de color estarán conectadas a las salidas digitales 9, 10 y 11 (Rojo, Verde y Azul respectivamente).
CÓDIGO: RGB CON POTENCIÓMETRO.
// Programa que varia el color del LED según el valor obtenido por unos potenciómetros
//Declara puertos de entradas y salidas y variables
int ledRojo = 9; //Declara Pin LED Rojo
int ledVerde=10; //Declara Pin LED Verde
int ledAzul=11; //Declara Pin LED Azul
int pinPot0 = A0; //Declara Pin Potenciometro Rojo
int pinPot1 = A1; //Declara Pin Potenciometro Verde
int pinPot2 = A2; //Declara Pin Potenciometro Azul
int valorsensor0 = 0; //Valores analogicos de la salida del potenciometro
int valorsensor1 = 0; // || || || ||
int valorsensor2 = 0; // || || || ||
void setup() // Función de configuración, se ejecuta cada vez que el Arduino se inicia
{
pinMode(ledRojo,OUTPUT); //El LED Rojo como una salida
pinMode(ledVerde,OUTPUT); //El LED Verde como una salida
pinMode(ledAzul,OUTPUT); //El LED Azul como una salida
Serial.begin(9600);
}
void loop() //Función cíclica
{
valorsensor0 = analogRead(pinPot0); // 1er posicion: Intensidad Rojo
valorsensor1 = analogRead(pinPot1); // 2da posición: Intensidad Verde
valorsensor2 = analogRead(pinPot2); // 3ra posición: Intensidad Azul
analogWrite(ledRojo, valorsensor0); //segun el valor de tres potenciómetros
analogWrite(ledVerde, valorsensor1);
analogWrite(ledAzul, valorsensor2);
delay (1000);
}
Los colores están comprendidos entre los valores 0 – 255 siendo 0 apagado y 255 el color a la máxima intensidad. Los valores 0 – 1032 hacen referencia a lo que Arduino lee de los potenciómetros (Las entradas analógicas sólo leen diez digitos, es decir, hasta un máximo de 1023. Esta señal siempre está comprendida entre 0 -1032 independientemente de la resistencia del potenciómetro.
CÓDIGO
*/
Programa que varia el color del LED según
el valor obtenido por unos potenciómetros.
*/
//--------------------------------------------------
//Declara puertos de entradas y salidas y variables
//--------------------------------------------------
int ledRojo = 9; //Declara Pin LED Rojo
int ledVerde=10; //Declara Pin LED Verde
int ledAzul=11; //Declara Pin LED Azul
int pinPot0 = A0; //Declara Pin Potenciometro Rojo
int pinPot1 = A1; //Declara Pin Potenciometro Verde
int pinPot2 = A2; //Declara Pin Potenciometro Azul
int valorsensor0 = 0; //Valores analogicos de la salida del potenciometro
int valorsensor1 = 0; // || || || ||
int valorsensor2 = 0; // || || || ||
float divisionR;
float divisionV;
float divisionA;
//------------------------------------
//Funcion principal
//------------------------------------
void setup() // Se ejecuta cada vez que el Arduino se inicia
{
pinMode(ledRojo,OUTPUT); //El LED Rojo como una salida
pinMode(ledVerde,OUTPUT); //El LED Verde como una salida
pinMode(ledAzul,OUTPUT); //El LED Azul como una salida
Serial.begin(9600);
}
//------------------------------------
//Funcion ciclicla
//------------------------------------
void loop()
//Funcion principal
//------------------------------------
void setup() // Se ejecuta cada vez que el Arduino se inicia
{
pinMode(ledRojo,OUTPUT); //El LED Rojo como una salida
pinMode(ledVerde,OUTPUT); //El LED Verde como una salida
pinMode(ledAzul,OUTPUT); //El LED Azul como una salida
Serial.begin(9600);
}
//------------------------------------
//Funcion ciclicla
//------------------------------------
void loop()
{
// Llamada a la función Color que recibe
// 1er posicion: Intensidad Rojo
// 2da posición: Intensidad Verde
// 3ra posición: Intensidad Azul
float Constante = (float) 255 / 1023; //Divide el máximo valor de color entre el máximo valor del potenciómetro
valorsensor0 = analogRead(pinPot0);
valorsensor1 = analogRead(pinPot1);
valorsensor2 = analogRead(pinPot2);
divisionR = Constante * valorsensor0;
divisionV = Constante * valorsensor1;
divisionA = Constante * valorsensor2;
color(divisionR,divisionV,divisionA); // Carga un valor para (ROJO,VERDE,AZUL)
//segun el valor de tres potenciómetros.
}
//------------------------------------
// Llamada a la función Color que recibe
// 1er posicion: Intensidad Rojo
// 2da posición: Intensidad Verde
// 3ra posición: Intensidad Azul
float Constante = (float) 255 / 1023; //Divide el máximo valor de color entre el máximo valor del potenciómetro
valorsensor0 = analogRead(pinPot0);
valorsensor1 = analogRead(pinPot1);
valorsensor2 = analogRead(pinPot2);
divisionR = Constante * valorsensor0;
divisionV = Constante * valorsensor1;
divisionA = Constante * valorsensor2;
color(divisionR,divisionV,divisionA); // Carga un valor para (ROJO,VERDE,AZUL)
//segun el valor de tres potenciómetros.
}
//------------------------------------
//Funcion color
//------------------------------------
void color(int rojo, int verde, int azul)
//------------------------------------
void color(int rojo, int verde, int azul)
{
//ROJO. Le resta al total (255) el valor obtenido de los potenciómetros
analogWrite(ledRojo, 255-rojo);
//VERDE. Le resta al total (255) el valor obtenido de los potenciómetros
analogWrite(ledVerde, 255-verde);
//AZUL. Le resta al total (255) el valor obtenido de los potenciómetros
analogWrite(ledAzul, 255-azul);
}
//ROJO. Le resta al total (255) el valor obtenido de los potenciómetros
analogWrite(ledRojo, 255-rojo);
//VERDE. Le resta al total (255) el valor obtenido de los potenciómetros
analogWrite(ledVerde, 255-verde);
//AZUL. Le resta al total (255) el valor obtenido de los potenciómetros
analogWrite(ledAzul, 255-azul);
}
3.- RBG CON PULSADORES.
Cambia los colores de un RGB mediante un pulsador: http://www.arduino.utfsm.cl/cambiar-colores-de-un-led-rgb-con-pulsador/
RGB CON TRES PULSADORES El objetivo de este tutorial consiste en combinar la utilización de pulsadores para controlar el color de un led RGB.
El modelo RGB se basa en la posibilidad de representar un color mediante la mezcla por adición de los tres colores de luz primarios: rojo, verde y azul.
Antes de adentrarnos en el montaje, enumeraremos los componentes necesarios para realizar el experimento:
- 1 led RGB
- 3 resistencias de 270 ohmios (Con 220 ohmios será suficiente, la única diferencia que encontraremos es que a menor resistencia, el led brillará con mayor intensidad, soportando con garantías este incremento)
- 3 pulsadores táctiles
- 1 placa breadboard
- 1 microprocesador Arduino UNO
- Cables
- 1 placa breadboard pequeña adicional (opcional)
A continuación, vemos el diagrama del cableado:
Deberemos comprobar que la patilla más larga del led RGB sea la que esté conectada a tierra. En nuestro diagrama se trata de la segunda patilla, pero esto puede variar según el tipo de led RGB que tengamos.
En primer lugar, el código que vamos a introducir presupone que el led
está apagado. Si mantenemos presionado alguno de los botones, el led se
encenderá aumentando gradualmente su intensidad. El botón de la
izquierda encenderá el color rojo, el del centro, el verde y el de la
derecha, el azul.
Podremos realizar cualquier combinación con estos tres colores, teniendo en cuenta que a mayor tiempo de pulsación, obtendremos una mayor intensidad de luz. Si queremos volver a empezar con el led apagado, basta con darle al botón de reiniciar (botón rojo de la placa Arduino).
Podremos realizar cualquier combinación con estos tres colores, teniendo en cuenta que a mayor tiempo de pulsación, obtendremos una mayor intensidad de luz. Si queremos volver a empezar con el led apagado, basta con darle al botón de reiniciar (botón rojo de la placa Arduino).
Tenemos tres pines de salida para controlar el led. Mediante éstos podemos controlar cuánta potencia va a cada color del led.
Necesitamos tres pines más para los pulsadores, los cuales configuraremos como pines de entrada.
Las utilizaremos para mantener los valores actuales de la intensidad de cada canal del led y pueden variar de 0 a 255. Por tanto, si tenemos 'blue' = 0, la parte azul del led estará apagada, mientras que si tenemos 'blue'=255, brillará con la máxima intensidad.
CÓDIGO:
int redLEDPin = 11;
int greenLEDPin = 10;
int blueLEDPin = 9;
int redSwitchPin = 3;
int greenSwitchPin = 6;
int blueSwitchPin = 5;
int red = 0;
int blue = 0;
int green=0;
void setup(){
pinMode(redLEDPin, OUTPUT);
pinMode(greenLEDPin, OUTPUT);
pinMode(blueLEDPin, OUTPUT);
pinMode(redSwitchPin, INPUT_PULLUP);
pinMode(greenSwitchPin, INPUT_PULLUP);
pinMode(blueSwitchPin, INPUT_PULLUP);
}
void loop(){
if (digitalRead(redSwitchPin) == LOW) {
red ++;
if (red > 255) red = 0;
}
if (digitalRead(greenSwitchPin) == LOW) {
green ++;
if (green > 255) green = 0;
}
if (digitalRead(blueSwitchPin) == LOW) {
blue ++;
if (blue > 255) blue = 0;
}
analogWrite(redLEDPin, red);
analogWrite(greenLEDPin, green);
analogWrite(blueLEDPin, blue);
delay(10);
}
Necesitamos tres pines más para los pulsadores, los cuales configuraremos como pines de entrada.
Las utilizaremos para mantener los valores actuales de la intensidad de cada canal del led y pueden variar de 0 a 255. Por tanto, si tenemos 'blue' = 0, la parte azul del led estará apagada, mientras que si tenemos 'blue'=255, brillará con la máxima intensidad.
CÓDIGO:
int redLEDPin = 11;
int greenLEDPin = 10;
int blueLEDPin = 9;
int redSwitchPin = 3;
int greenSwitchPin = 6;
int blueSwitchPin = 5;
int red = 0;
int blue = 0;
int green=0;
void setup(){
pinMode(redLEDPin, OUTPUT);
pinMode(greenLEDPin, OUTPUT);
pinMode(blueLEDPin, OUTPUT);
pinMode(redSwitchPin, INPUT_PULLUP);
pinMode(greenSwitchPin, INPUT_PULLUP);
pinMode(blueSwitchPin, INPUT_PULLUP);
}
void loop(){
if (digitalRead(redSwitchPin) == LOW) {
red ++;
if (red > 255) red = 0;
}
if (digitalRead(greenSwitchPin) == LOW) {
green ++;
if (green > 255) green = 0;
}
if (digitalRead(blueSwitchPin) == LOW) {
blue ++;
if (blue > 255) blue = 0;
}
analogWrite(redLEDPin, red);
analogWrite(greenLEDPin, green);
analogWrite(blueLEDPin, blue);
delay(10);
}
