Led RGB + Arduino

Por

Kiara Navarro

enero 20, 2015

5355
 Led RGB funcionando
en Arduino.
En este pequeño tutorial explicaré cómo utilizar arduino para probar un led RGB.
Un led RGB es un diodo que emite luz en diferentes colores dependiendo de la
combinación que se le asigne a cada una de sus patitas. A diferencia de los leds
convencionales que sólo emiten un color, el led RGB puede emitir varios colores. El
acrónimo RGB proviene debido a que utiliza el sistema de colores RGB construidos
a base de Rojo, Verde (Green) y Azul (Blue) los tres colores primarios. Así, para
representar cierta tonalidad de cada color, se utilizan 8 bits lo cual resultaría 2^8
posibles combinaciones por cada color y como se está utilizando tres colores
entonces se tendría un total de 256*256*256 = 16777216 combinaciones o
tonalidades. Te invito a que visites este artículo para conocer más acerca del
funcionamiento de un led RGB por supuesto, con arduino.

Materiales
 1 Arduino UNO

 1 Led RGB cátodo común

 3 Resistencias de 220 ohms

 Cables o Jumpers

Paso 1: Creando el circuito

En el siguiente link podemos tener acceso a una tablas que indican las diferentes
combinaciones para el sistema RGB y su correspondiente color.
El pinaje de un led RGB dependerá de su fabricante pero normalmente se tiene el
siguiente esquema:

Imagen ilustrativa del pinaje de un led RGB.

Es decir que la patilla más a la izquierda representa el rojo, la segunda es la referencia en
este caso tierra, la tercera representa el verde y la última representa el azul.

De todas maneras para los que quieran saber más detalles técnicos y cómo está
conectado el led RGB pueden visitar el datasheet del fabricante.

Para utilizar un led RGB en arduino es preciso trabajar con las salidas que contienen
PWM ya a través de esas salidas, podremos generar las diferentes combinaciones que
llegarán a cada patilla del led para entonces visualizar el color que querramos.

A continuación se presenta un esquema de cómo hacer la circuitería.

Esquema del circuito para probar led RGB.

Paso 2: Creando el programa # 1

Utilizaremos dos programas de prueba, comencemos con el primero:

1 /*

2 /*

3 Kiara Navarro

4 sophiekovalevsky arroba fedoraproject.org

5 www.panamahitek.com

6 */

8 #define pinLed1 11 // Pin 11 a R

9 #define pinLed2 10 // Pin 10 a G

1 #define pinLed3 9 // Pin 10 a B

0
1
1
void setup()
1
2 {

1 pinMode(pinLed1, OUTPUT);
3
pinMode(pinLed2, OUTPUT);
1
4 pinMode(pinLed3, OUTPUT);

1 }
5

1
6 void loop() {

1 // Verde
7 digitalWrite(pinLed1, LOW);
1 digitalWrite(pinLed2, HIGH);
8
digitalWrite(pinLed3, LOW);
1
9 delay(500);

2 // Azul
0
digitalWrite(pinLed1, LOW);
2
1 digitalWrite(pinLed2, LOW);

2 digitalWrite(pinLed3, HIGH);
2
delay(500);
2
// Rojo
3
digitalWrite(pinLed1, HIGH);
2
4 digitalWrite(pinLed2, LOW);
2 digitalWrite(pinLed3, LOW);
5
delay(500);
2
6 //Violeta

2 digitalWrite(pinLed1, HIGH);
7
digitalWrite(pinLed2, LOW);
2
8 digitalWrite(pinLed3, HIGH);

2 delay(500);
9 //Amarillo
3 digitalWrite(pinLed1, HIGH);
0
digitalWrite(pinLed2, HIGH);
3
1 digitalWrite(pinLed3, LOW);

3 delay(500);
2
//Azul Marino
3
3 digitalWrite(pinLed1, LOW);

3
4 digitalWrite(pinLed2, HIGH);

3 digitalWrite(pinLed3, HIGH);
5
delay(500);
3
6 //Blanco

3 digitalWrite(pinLed1, HIGH);
7
digitalWrite(pinLed2, HIGH);
3
digitalWrite(pinLed3, HIGH);
8
delay(500);
3
9 // Negro - No presenta ningún color
4 digitalWrite(pinLed1, LOW);
0
digitalWrite(pinLed2, LOW);
4
1 digitalWrite(pinLed3, LOW);

4 delay(500);
2
}
4
3

4
4

4
5

4
6

4
7

4
8

4
9

5
0

5
1

5
2

5
3

5
4

5
5

5
6

5
7

5
8

5
9

6
0

Explicación:
En este sencillo programa, declaramos como salidas los pines 11, 10 y 9 y escribimos en
ellas valores lógicos. Hemos utilizado un retardo de 500 ms. El resultado es una
combinación de colores.

Paso 2.2 Creando el programa # 2

Nuestro segundo código es:

1 /*

2 Kiara Navarro

3 sophiekovalevsky arroba fedoraproject.org

4 www.panamahitek.com

5 */

7 #define pinLed1 11 // Pin 11 a R

8 #define pinLed2 10 // Pin 10 a G

9 #define pinLed3 9 // Pin 10 a B

10

11
void setup() {
12
pinMode(pinLed1, OUTPUT);
13
pinMode(pinLed2, OUTPUT);
14
pinMode(pinLed3, OUTPUT);
15
}
16

17
void loop() {
18
#define varfija 15
19
#define retardo 5
20 for (int contador=0; contador<255; contador++) {

21 analogWrite(pinLed1, contador);

22 analogWrite(pinLed2, varfija);

23 analogWrite(pinLed3, varfija);

24 delay(retardo);

25 }

26 for (int contador=255; contador>0; contador--) {

27 analogWrite(pinLed1, contador);

28 analogWrite(pinLed2, varfija);

29 analogWrite(pinLed3, varfija);

30 delay(retardo);

31 }

32 for (int contador=0; contador<255; contador++) {

33 analogWrite(pinLed1, varfija);

34 analogWrite(pinLed2, contador);

35 analogWrite(pinLed3, varfija);

36 delay(retardo);

37 }

38 for (int contador=255; contador>0; contador--) {

39 analogWrite(pinLed1, varfija);

40 analogWrite(pinLed2, contador);

41 analogWrite(pinLed3, varfija);

42 delay(retardo);

43 }

44 for (int contador=0; contador<255; contador++) {

45 analogWrite(pinLed1, contador);

46 analogWrite(pinLed2, contador);

47 analogWrite(pinLed3, varfija);

48 delay(retardo);

49 }

50 for (int contador=255; contador>0; contador--) {

51 analogWrite(pinLed1, contador);

52 analogWrite(pinLed2, contador);

53 analogWrite(pinLed3, varfija);

54 delay(retardo);

55 }

56 for (int contador=0; contador<255; contador++) {

57 analogWrite(pinLed1, varfija);

58 analogWrite(pinLed2, varfija);

59 analogWrite(pinLed3, contador);

60 delay(retardo);

61 }

62 for (int contador=255; contador>0; contador--) {

63 analogWrite(pinLed1, varfija);

64 analogWrite(pinLed2, varfija);

65 analogWrite(pinLed3, contador);

66 delay(retardo);

67 }

68 for (int contador=0; contador<255; contador++) {

69 analogWrite(pinLed1, contador);

70 analogWrite(pinLed2, varfija);

71 analogWrite(pinLed3, contador);

72 delay(retardo);

73 }

74 for (int contador=255; contador>0; contador--) {

75 analogWrite(pinLed1, contador);

76 analogWrite(pinLed2, varfija);

77 analogWrite(pinLed3, contador);

78 delay(retardo);

79 }

80 for (int contador=0; contador<255; contador++) {

81 analogWrite(pinLed1, varfija);

82 analogWrite(pinLed2, contador);

83 analogWrite(pinLed3, contador);

84 delay(retardo);

85 }

86 for (int contador=255; contador>0; contador--) {

87 analogWrite(pinLed1, varfija);

88 analogWrite(pinLed2, contador);

89 analogWrite(pinLed3, contador);

90 delay(retardo);

91 }

92 for (int contador=0; contador<255; contador++) {

93 analogWrite(pinLed1, contador);
94

95
analogWrite(pinLed2, contador);
96
analogWrite(pinLed3, contador);
97
delay(retardo);
98
}
99
for (int contador=255; contador>0; contador--) {
10
0 analogWrite(pinLed1, contador);

10 analogWrite(pinLed2, contador);
1
analogWrite(pinLed3, contador);
10
delay(retardo);
2
}
10
3 }

10
4

Explicación: Declaramos como salidas los pines 11,10, y 9 y luego utilizamos varios bucles
for para hacer un efecto de desvanecimiento de color en el led. Utilizamos un retardo de
5 ms y una valor fijo de 15 solo para observar qué colores nos visualizaba el led.

Paso 3: Presentación del proyecto

Para finalizar les dejo con fotos de algunos colores que puede producir el led RGB.
Led RGB funcionando en Arduino.

Encendiendo un led RGB con Arduino.

Led RGB en variación de color verde con Arduino.

Otra demostración de cómo encender un led RGB.