Color con ARDUINO Education

COLOR

¿Qué es RGB?

El modo de color RGB está basado en la suma de los colores lumínicos primarios. A esto se le conoce como síntesis aditiva, donde los colores deben sumarse para conseguir uno nuevo. Esos colores son el Rojo (Red), el Verde (Green) y el Azul (Blue).

Para indicar con qué proporción es mezclado cada color, se asigna un valor a cada uno de los colores primarios, de manera que el valor «0» significa que no interviene en la mezcla y, a medida que ese valor aumenta, se entiende que aporta más intensidad a la mezcla.

CÓDIGO BINARIO

Aunque el intervalo de valores podría ser cualquiera (valores reales entre 0 y 1, valores enteros entre 0 y 37, etc.), es frecuente que cada color primario se codifique con un byte (8 bits).

Así pues, los valores RGB oscilarán entre 0 y 255.

La intensidad de cada color es definido por un conjunto de valores escritos entre paréntesis (correspondientes a valores «R», «G» y «B») y separados por comas.

De este modo, el rojo se obtiene con (255,0,0), el verde con (0,255,0) y el azul con (0,0,255), obteniendo, en cada caso un color resultante monocromático.

La ausencia de color, es decir el color negro, se obtiene cuando las tres componentes son 0: (0,0,0).

El color blanco se forma con los tres colores primarios a su máximo valor (255,255,255).

La combinación de dos colores a su máximo valor de 255 con un tercero con valor 0 da lugar a tres colores intermedios.

PALETA DE COLORES

Basándonos en este concepto de mezcla de colores vamos a preparar un “equipo de mezcla” que nos permita ver cada uno de los colores de forma individual en tres leds y la mezcla de los tres en un dispositivo RGB.

Con un potenciómetro para cada color indicaremos al “equipo de mezcla” qué cantidad de cada color vamos a colocar en la mezcla.

Con un led de cada color, asociado a la posición de cada potenciómetro, nos haremos una idea de forma visual de la cantidad de cada color que estamos mezclando.

A través del monitor en serie veremos los valores de la mezcla.

A través de un display veremos los valores de la mezcla.

Y con un led RGB veremos el resultado de la mezcla.

PASO 1. POTENCIÓMETRO

Un potenciómetro es un dispositivo eléctrico que tiene una resistencia variable, lo que hace que podamos usarlo para controlar el voltaje en un circuito. Es decir, se puede regular para no tener resistencia o para tener mucha resistencia.

El potenciómetro del Student Kit de Arduino Education tiene un rango de 0 a 10.000 Ohmios.

El primer paso para entender cómo funciona es hacer un montaje sencillo con un potenciómetro. 

El potenciómetro tiene dos pines en un lado y un solo pin en el  otro. 

En los diagramas esquemáticos, los potenciómetros generalmente están representados por un símbolo que se parece a un resistor con una flecha apuntando hacia el centro del resistor.

Los dos pines de un lado deberán conectarse a una fuente de energía y a tierra. Y el pin del otro lado a un pin analógico de la placa.

*En la lección Regulador de la plataforma educativa del Student Kit tienes información detallada del funcionamiento interno de un potenciómetro.

El potenciómetro es un dispositivo de entrada analógico y lo vamos a conectar al pin analógico A0.

Todos los pines analógicos en Arduino son pines de entrada. Eso  significa que NO tienen que ser declarados como

pinMode(Potenciometro,INPUT);

Señal analógica y señal digital

Una señal analógica es un rango de valores entre 0 y 1.023.

El comando para leer una señal analógica es:

analogRead(A0);

Y devolverá un valor entre 0 y 1023.

Una señal digital es encendido o apagado, HIGH o LOW.

El comando para leer una señal digital es:

digitalRead(2);

Y devolverá HIGH o LOW

PASO 2. MONITOR EN SERIE

Para poder ver el efecto que tiene el potenciómetro en nuestra placa vamos a utilizar el monitor en serie del IDE de Arduino.

El Monitor en Serie es una herramienta que nos permite mostrar información de la placa Arduino UNO.

void setup()
{
Serial.begin(9600); //habilita la comunicación
}
void loop()
{
  Serial.println(analogRead(A0)); //Valores de entrada analógica de 0 a 1023
}

Al ejecutar el programa con nuestro montaje y regular el potenciómetro veremos en la pantalla del monitor en serie cómo varían los valores.

Como hemos visto anteriormente los valores para un color RGB oscilarán entre 0 y 255. Es decir, estos serán los valores que debemos darle a los LEDs.

Entonces, ¿cómo convertimos valores que nos da el potenciómetro de entre 0 y 1023 a valores de entre 0 y 255 que daremos a los LED? Vamos a hacer un pequeño ejercicio visualizando valores en el monitor en serie para comprenderlo.

PASO 3. FUNCIÓN MAP()

Utilizaremos la función

map(value,fromLow, fromHigh, toLow, toHigh);

Donde:

value: el número que se va a asignar.

fromLow: el límite inferior del rango actual del valor.

fromHigh: el límite superior del rango actual del valor.

toLow: el límite inferior del rango objetivo del valor.

toHigh: el límite superior del rango objetivo del valor

map(valorPot,0,1023,0,255);

Vamos a hacer un pequeño programa con nuestro potenciómetro para ver en el monitor en serie los valores de tres formas:

• Valor del potenciómetro de 0 a 1023
• Valor en porcentaje, de 0% a 100%
• Valor de 0 a 255

int valorPot;  //valor del potenciómetro, con valores de 0 a 1023 (10 bits)
int valorPor;  //valor en porcentage, de 0% a 100%
int valorR;  //valor de la intensidad de la luz de salida, con valores entre 0 y 255 (8 bits)
void setup()
{
Serial.begin(9600);  //inicializa el puerto en serie
}
void loop()
{
 valorPot = analogRead(A0); //mete en la variable valorPot la lectura del potenciómetro
Serial.print(valorPot); //imprime la lectura del potenciómetro (de 0 a 1023)
Serial.print("\t"); //imprime una tabulación
 valorPor = map(valorPot,0,1023,0,100); //cambia los valores de valorPot de un rango a otro y lo guarda en valorPor
Serial.print(valorPor); //imprime el valor valorPor
Serial.print("%"); //imprime el carácter %
Serial.print("\t"); //imprime una tabulación
 valorR = map(valorPot,0,1023,0,255); //cambia los valores de valorPot de un rango a otro y lo guarda en valorR
Serial.println(valorR); //imprime el valor valorR
}

PASO 4. REGULAR UN LED CON UN POTENCIÓMETRO

En este momento ya sabemos leer los valores de un potenciómetro y “traducirlos” a otro rango de valores. Este rango de valores (de 0 a 255) es el que necesitaremos para ilumirar con más o menos intensidad un led.

Vamos a añadir a nuestro montaje un led y hacer que el potenciómetro regule la intensidad del mismo.

Puede que conozcas la función digitalWrite(pin, HIGH/LOW) para encender o apargar leds. Como hemos visto anteriormente, éste es una valor digital (todo o nada). Lo que ahora nos interesa es regular la intensidad del led mediante valores analógicos (de 0 a 255). La función con la que podemos hacerlo es:

analogWrite(pin,valor);

Donde:

pin: pin de conexión a la placa Arduino

valor: intensidad que queremos darle (entre 0 y 255)

El objetivo es que el led brille más o menos en función del valor del potenciómetro. Es decir, no le vamos a decir enciéndete o apágate (digital) sin más, sino que le diremos que se encienda en función de un valor (analógico). Para ello debemos utilizar los pins PWM de la placa Arduino (marcados con una tilde de eñe ~).

¿Qué es un pin PWM?

La modulación de ancho de pulso, o PWM, es una técnica para obtener resultados analógicos con medios digitales. Mediante este proceso un pin digital simula enviar valores analógicos.

Dependiendo del ciclo de trabajo (cantidad de tiempo que esté enviando energía) el resultado visual será de más o menos intensidad en el led.

Así pues, con el siguiente programa regulamos con un potenciómetro la intensidad de un led y vemos en el monitor en serie los valores:

int valorPot;  //valor del potenciómetro, con valores de 0 a 1023 (10 bits)
int valorPor;  //valor en porcentaje, de 0% a 100%
int valorR;  //valor de la intensidad de la luz de salida, con valores entre 0 y 255 (8 bits)
#define LedR 11 //llama al pin 11 LedR. Es un pin PWM
void setup()
{
Serial.begin(9600);  //inicializa el puerto en serie
pinMode(LedR, OUTPUT); // LedR (lo que está en el pin 10) es de salida
}
void loop()
{
 valorPot = analogRead(A0); //mete en la variable valPot la lectura del potenciómetro
Serial.print(valorPot); //imprime la lectura del potenciómetro(de 0 a 1023)
Serial.print("\t"); //imprime una tabulación
 valorPor = map(valorPot,0,1023,0,100); //cambia los valores de valorPot de un rango a otro y guárdalo en valorPor
Serial.print(valorPor); //imprime valorPor
Serial.print("%"); //imprime el carácter %
Serial.print("\t"); //imprime una tabulación
 valorR = map(valorPot,0,1023,0,255); //cambia los valores de valorPot de un rango a otro y guárdalo en valorR
Serial.println(valorR); //imprime valorR
analogWrite(LedR,valorR); //enciende el led rojo con la intensidad valorR
}

PASO 5. REGULAR 3 LED CON 3 POTENCIÓMETROS

El siguiente paso es añadir al montaje un led verde y otro azul y dos potenciómetros más.

En nuestro programa añadiremos todo lo necesario para estos nuevos componentes:

int valorPotR;  //define valorPotR para el valor del potenciómetro (0-1023) que conecta con el led Red
int valorPorR;  //define valorPorR para el valor del potenciómetro (en porcentaje) que conecta con el led Red
int valorR;  //define valorR para el valor del potenciómetro (0-255) que conecta con el led Red
int valorPotG; //define valorPotG para el valor del potenciómetro (0-1023) que conecta con el led Green
int valorPorG; //define valorPorG para el valor del potenciómetro (en porcentaje) que conecta con el led Green
int valorG; //define valorG para el valor del potenciómetro (0-255) que conecta con el led Green
int valorPotB; //define valorPotB para el valor del potenciómetro (0-1023) que conecta con el led Blue
int valorPorB; //define valorPorB para el valor del potenciómetro (en porcentaje) que conecta con el led Blue
int valorB; //define valorB para el valor del potenciómetro (0-255) que conecta con el led Blue
#define LedR 11  //llama al pin 11 LedR
#define LedG 10  //llama al pin 10 LedG
#define LedB 9  //llama al pin 9 LedB
#define PotR A0 //llama al pin A0 PotR
#define PotG A2 //llama al pin A2 PotG
#define PotB A1 //llama al pin A1 PotB
void setup()
{
Serial.begin(9600);  //inicializa el puerto en serie
pinMode(LedR, OUTPUT); // LedR (lo que está en el pin 11) es de salida
pinMode(LedG, OUTPUT); // LedG (lo que está en el pin 10) es de salida
pinMode(LedB, OUTPUT); // LedB (lo que está en el pin 9) es de salida
}
void loop()
{
 valorPotR = analogRead(PotR); //mete en la variable valPotR la lectura del potenciómetro R
 valorPotG = analogRead(PotG); //mete en la variable valPotG la lectura del potenciómetro G
 valorPotB = analogRead(PotB); //mete en la variable valPotB la lectura del potenciómetro B
 valorPorR = map(valorPotR,0,1023,0,100); //cambia los valores de valorPotR a porcentaje y guárdalo en valorPorR
 valorPorG = map(valorPotG,0,1023,0,100); //cambia los valores de valorPotG a porcentaje y guárdalo en valorPorG
 valorPorB = map(valorPotB,0,1023,0,100); //cambia los valores de valorPotB a porcentaje y guárdalo en valorPorB
 valorR = map(valorPotR,0,1023,0,255); //cambia los valores de valorPotR a rango 0-255 y guárdalo en valorR
 valorG = map(valorPotG,0,1023,0,255); //cambia los valores de valorPotG a rango 0-255 y guárdalo en valorG
 valorB = map(valorPotB,0,1023,0,255); //cambia los valores de valorPotB a rango 0-255 y guárdalo en valorB
analogWrite(LedR,valorR); //enciende el led RED con la intensidad valorR
analogWrite(LedG,valorG); //enciende el led GREEN con la intensidad valorG
analogWrite(LedB,valorB); //enciende el led BLUE con la intensidad valorB
Serial.print(valorR); //imprime valorR (0-255)
Serial.print("\t"); //imprime una tabulación
Serial.print(valorG); //imprime valorG (0-255)
Serial.print("\t"); //imprime una tabulación
Serial.println(valorB); //imprime valorB (0-255)
}

PASO 6. Led RGB

Ya disponemos de tres leds (red, green y blue) y tres potenciómetros con los que regulamos su intensidad. Ahora vamos a incorporar un led RGB en el que veremos la mezcla final de los tres colores. 

Un led RGB es un led con 4 pies. El más largo es el cátodo que conectaremos a tierra y los otros tres a pins PWM para poder mandar la información de los tres canales, Red, Green y Blue. Con esa información el led RGB hace la mezcla de colores que veremos

La función para programar el led RGB es la misma que para un led común solo que deberemos ponerla por triplicado para enviar el valor de los tres canales.

int valorPotR;  //define valorPotR para el valor del potenciómetro (0-1023) que conecta con el led Red
int valorPorR;  //define valorPorR para el valor del potenciómetro (en porcentaje) que conecta con el led Red
int valorR;  //define valorR para el valor del potenciómetro (0-255) que conecta con el led Red
int valorPotG; //define valorPotG para el valor del potenciómetro (0-1023) que conecta con el led Green
int valorPorG; //define valorPorG para el valor del potenciómetro (en porcentaje) que conecta con el led Green
int valorG; //define valorG para el valor del potenciómetro (0-255) que conecta con el led Green
int valorPotB; //define valorPotB para el valor del potenciómetro (0-1023) que conecta con el led Blue
int valorPorB; //define valorPorB para el valor del potenciómetro (en porcentaje) que conecta con el led Blue
int valorB; //define valorB para el valor del potenciómetro (0-255) que conecta con el led Blue
#define LedR 11  //llama al pin 11 LedR
#define LedG 10  //llama al pin 10 LedG
#define LedB 9  //llama al pin 9 LedB
#define PotR A0 //llama al pin A0 PotR
#define PotG A2 //llama al pin A2 PotG
#define PotB A1 //llama al pin A1 PotB
#define LedRRGB 6  //elegimos pins PWM
#define LedGRGB 5  //elegimos pins PWM
#define LedBRGB 3  //elegimos pins PWM
void setup()
{
Serial.begin(9600);  //inicializa el puerto en serie
pinMode(LedR, OUTPUT); // LedR (lo que está en el pin 11) es de salida
pinMode(LedG, OUTPUT); // LedG (lo que está en el pin 10) es de salida
pinMode(LedB, OUTPUT); // LedB (lo que está en el pin 9) es de salida
pinMode(LedRRGB, OUTPUT); // LedRRGB (lo que está en el pin 6) es de salida
pinMode(LedGRGB, OUTPUT); // LedGRGB (lo que está en el pin 5) es de salida
pinMode(LedBRGB, OUTPUT); // LedBRGB (lo que está en el pin 3) es de salida
}
void loop()
{
 valorPotR = analogRead(PotR); //mete en la variable valPotR la lectura del potenciómetro R
 valorPotG = analogRead(PotG); //mete en la variable valPotG la lectura del potenciómetro G
 valorPotB = analogRead(PotB); //mete en la variable valPotB la lectura del potenciómetro B
 valorPorR = map(valorPotR,0,1023,0,100); //cambia los valores de valorPotR a porcentaje y guárdalo en valorPorR
 valorPorG = map(valorPotG,0,1023,0,100); //cambia los valores de valorPotG a porcentaje y guárdalo en valorPorG
 valorPorB = map(valorPotB,0,1023,0,100); //cambia los valores de valorPotB a porcentaje y guárdalo en valorPorB
 valorR = map(valorPotR,0,1023,0,255); //cambia los valores de valorPotR a rango 0-255 y guárdalo en valorR
 valorG = map(valorPotG,0,1023,0,255); //cambia los valores de valorPotG a rango 0-255 y guárdalo en valorG
 valorB = map(valorPotB,0,1023,0,255); //cambia los valores de valorPotB a rango 0-255 y guárdalo en valorB
analogWrite(LedR,valorR); //enciende el led RED con la intensidad valorR
analogWrite(LedG,valorG); //enciende el led GREEN con la intensidad valorG
analogWrite(LedB,valorB); //enciende el led BLUE con la intensidad valorB
analogWrite(LedRRGB,valorR); //enciende el led RED del RGB con la intensidad valorR
analogWrite(LedGRGB,valorG); //enciende el led GREEN del RGB con la intensidad valorG
analogWrite(LedBRGB,valorB); //enciende el led BLUE del RGB con la intensidad valorB
Serial.print(valorR); //imprime valorR (0-255)
Serial.print("\t"); //imprime una tabulación
Serial.print(valorG); //imprime valorG (0-255)
Serial.print("\t"); //imprime una tabulación
Serial.println(valorB); //imprime valorB (0-255)
}

PASO 7. DISPLAY OLED

La tecnología OLED, acrónimo de Diodo Orgánico de Emisión de Luz, se basa en unos diodos orgánicos (cada uno de ellos equivale a un píxel) que permiten emitir luz al aplicarle una corriente eléctrica sin necesidad de contar con una fuente de iluminación adicional.

Para este proyecto hemos utilizado un visualizador de matriz OLED en blanco y negro de 128 x 64 píxeles con una interfaz Grove 4pin I2C incluido en el Arduino Sensor Kit que puede usarse para generar salidas visuales.

Para poder programar este dispositivo es necesario utilizar una librería.

Las librerías en Arduino son programas realizados por otras personas con los que podemos añadir nuevas funcionalidades a los programas de Arduino. Habitualmente contienen nuevas instrucciones para poder utilizar componentes no standard.

Hemos utilizado la librería propia del Sensor Kit, que puedes instalar desde el propio entorno de programación IDE de Arduino.

En el anexo puedes encontrar información de otra librería específica de esta pantalla OLED.

Añadimos a nuestro montaje la pantalla OLED:

La forma de conectar nuestro display a la placa es la siguiente:

GND: pin de tierra

VCC: es el pin de alimentación. Se puede alimentar la pantalla entre 1,8V y 6V

SDA: es el pin de la señal de datos de la interfaz I2C (lo conectamos al pin A4)

SCL: es el pin de la señal de reloj de la interfaz I2C (lo conectamos al pin A5)

En este proyecto vamos a utilizar unas pocas funciones para visualizar datos en la pantalla OLED. No obstante, a continuación hacemos un listado de muchas otras funciones que podemos utilizar:

Oled.begin(); 
//Inicializa la conexión con la pantalla

Oled.clear(); 
//Borra todos los pixels de la pantalla y sitúa el cursor para poder escribir (función print) en la esquina superior izquierda

Oled.clearDisplay(); 
//Borra todos los pixels de la pantalla

Oled.clearLine(row); 
//Borra todos los pixels de la fila indicada. 
//row: fila a borrar (la primera fila es la 0)

Oled.drawGlyph(columna, fila, caracter); 
//Escribe un único caracter. 
//columna: columna en la que se coloca el cursor.
//fila: fila en la que se coloca el cursor.
//carácter: escribir entre ‘ ’ (y no entre “ “)

Oled.draw1x2Glyph(columna, fila, caracter);
//Igual que la anterior pero escalando el carácter en x e y, en 1x2 (altura)

Oled.draw2x2Glyph(columna, fila, caracter);
//Igual que la anterior pero escalando el carácter en x e y, en 2x2 (altura y anchura)

Oled.drawString(columna, fila, texto);
//Escribe un texto
//columna: columna en la que se coloca el cursor
//fila: fila en la que se coloca el cursor
//carácter: escribir entre “ “ (y no entre ´ ´)

Oled.draw1x2String(columna, fila, texto);
//Igual que la anterior pero escalando el carácter en x e y, en 1x2 (altura)

Oled.draw2x2String(columna, fila, texto);
//Igual que la anterior pero escalando el carácter en x e y, en 2x2 (altura)

Oled.setFont(font);
//Tipo de fuente (https://github.com/olikraus/u8g2/wiki/fntlist8x8)
//Font: nombre de la fuente. Si termina por:
//_f: todos los signos están incluidos
//_r: incluidos los caracteres del 0 al 127
//_u: números y letras capitales incluidas
//_n: números y algunos signos extra

Oled.setInverseFont();
//Esta función afecta a las funciones Oled.drawString, Oled.drawGlyph y Oled.drawUTF8
//Invierte los colores, dibujando el fondo en vez de dibujar el texto
//Si el argumento es 0, el texto impreso se mantiene normal
//si el argumento es 1, se invierten los colores

En este punto del proyecto y basándonos en la programación que ya teníamos, sólamente hemos incluido las funciones necesarias para visualizar en la pantalla OLED la cantidad de Red, Green y Blue que intervienen en cada momento en la mezcla.

#include "Arduino_SensorKit.h" //Librería con las funciones para escribir en la pantalla OLED
int valorPotR;  //define valorPotR para el valor del potenciómetro (0-1023) que conecta con el led Red 
int valorPorR;  //define valorPorR para el valor del potenciómetro (en porcentaje) que conecta con el led Red 
int valorR;  //define valorR para el valor del potenciómetro (0-255) que conecta con el led Red 
int valorPotG; //define valorPotG para el valor del potenciómetro (0-1023) que conecta con el led Green 
int valorPorG; //define valorPorG para el valor del potenciómetro (en porcentaje) que conecta con el led Green 
int valorG; //define valorG para el valor del potenciómetro (0-255) que conecta con el led Green 
int valorPotB; //define valorPotB para el valor del potenciómetro (0-1023) que conecta con el led Blue 
int valorPorB; //define valorPorB para el valor del potenciómetro (en porcentaje) que conecta con el led Blue 
int valorB; //define valorB para el valor del potenciómetro (0-255) que conecta con el led Blue 
#define LedR 11  //llama al pin 11 LedR 
#define LedG 10  //llama al pin 10 LedG 
#define LedB 9  //llama al pin 9 LedB 
#define PotR A0 //llama al pin A0 PotR 
#define PotG A2 //llama al pin A2 PotG 
#define PotB A1 //llama al pin A1 PotB 
#define LedRRGB 6  //elegimos pins PWM 
#define LedGRGB 5  //elegimos pins PWM 
#define LedBRGB 3  //elegimos pins PWM 
void setup() 
{
Oled.begin();  //Inicia la comunicación
Oled.setFlipMode(1);  //0 ó 1 indica la orientación de la pantalla
Oled.clearDisplay(); //limpia la pantalla          
Serial.begin(9600);  //inicializa el puerto en serie 
pinMode(LedR, OUTPUT); // LedR (lo que está en el pin 11) es de salida 
pinMode(LedG, OUTPUT); // LedG (lo que está en el pin 10) es de salida 
pinMode(LedB, OUTPUT); // LedB (lo que está en el pin 9) es de salida 
pinMode(LedRRGB, OUTPUT); // LedRRGB (lo que está en el pin 6) es de salida 
pinMode(LedGRGB, OUTPUT); // LedGRGB (lo que está en el pin 5) es de salida 
pinMode(LedBRGB, OUTPUT); // LedBRGB (lo que está en el pin 3) es de salida 
} 
void loop() 
{  
 valorPotR = analogRead(PotR); //mete en la variable valPotR la lectura del potenciómetro R 
 valorPotG = analogRead(PotG); //mete en la variable valPotG la lectura del potenciómetro G 
 valorPotB = analogRead(PotB); //mete en la variable valPotB la lectura del potenciómetro B 
 valorPorR = map(valorPotR,0,1023,0,100); //cambia los valores de valorPotR a porcentaje y guárdalo en valorPorR 
 valorPorG = map(valorPotG,0,1023,0,100); //cambia los valores de valorPotG a porcentaje y guárdalo en valorPorG 
 valorPorB = map(valorPotB,0,1023,0,100); //cambia los valores de valorPotB a porcentaje y guárdalo en valorPorB 
 valorR = map(valorPotR,0,1023,0,255); //cambia los valores de valorPotR a rango 0-255 y guárdalo en valorR 
 valorG = map(valorPotG,0,1023,0,255); //cambia los valores de valorPotG a rango 0-255 y guárdalo en valorG 
 valorB = map(valorPotB,0,1023,0,255); //cambia los valores de valorPotB a rango 0-255 y guárdalo en valorB 
analogWrite(LedR,valorR); //enciende el led RED con la intensidad valorR 
analogWrite(LedG,valorG); //enciende el led GREEN con la intensidad valorG 
analogWrite(LedB,valorB); //enciende el led BLUE con la intensidad valorB 
analogWrite(LedRRGB,valorR); //enciende el led RED del RGB con la intensidad valorR 
analogWrite(LedGRGB,valorG); //enciende el led GREEN del RGB con la intensidad valorG 
analogWrite(LedBRGB,valorB); //enciende el led BLUE del RGB con la intensidad valorB 
Serial.print(valorR); //imprime valorR (0-255) 
Serial.print("\t"); //imprime una tabulación 
Serial.print(valorG); //imprime valorG (0-255) 
Serial.print("\t"); //imprime una tabulación 
Serial.println(valorB); //imprime valorB (0-255)
Oled.setFont(u8x8_font_chroma48medium8_r); //determina el tipo de letra
Oled.drawString(5,1,"Tibot"); //imprime "Tibot" en las coordenadas 5, 1
Oled.setCursor(0,4); //coloca el cursor en las coordenadas 0, 4
Oled.print("("); //imprime (
Oled.print(valorR); //imprime valorR
Oled.print(","); //imprime ,
Oled.print(valorG); //imprime valorG
Oled.print(","); //imprime ,
Oled.print(valorB); //imprime valorb
Oled.print(")"); //imprime )
delay(1500); // espera 1500 ms
Oled.setCursor(0,4); //coloca el cursor en las coordenadas 0, 4
Oled.drawString(0,4,"             "); //escribe (13 espacios) para borrar la línea
}

PROYECTO FINAL

Este es el proyecto final que hemos realizado.

Puedes imitarlo o, ¡poner en marcha tu creatividad y diseñar el tuyo propio!

Hemos diseñado y construido una estructura decorativa con forma de paleta de pintura en la que se verán las distintas intensidades de RED, GREEN y BLUE en cada Led y la mezcla resultante en un led RGB. Además, veremos en una pantalla OLED la proporción de cada color.

Este es el diseño de paleta que hemos utilizado (lo puedes descargar en pdf en la sección de descargables):