Ing Edison V

1

1. Sensor conversor de luz a frecuencia TCS 3210/3200

Es un sensor del color programable convertidor de luz a frecuencia, puede filtrar los

datos RGB de la luz fuente y convertirlo a una onda cuadrada con frecuencia

directamente proporcional a la intensidad de luz irradiada. La frecuencia de salida a

escala completa se puede escalar con (SO, S1 Opciones seleccionables 2%, 20%, 100%

de frecuencia), y pin S2, S3 controlar el filtro de RGB. Las entradas y salidas digitales

permiten interfaz con un microcontrolador o arduino directamente.

Características:

1. De alta resolución de Conversión de Luz

2. Intensidad de Frecuencia

3. Programable al color y escala total deseado

4. Se comunica directamente con un microcontrolador

5. Alimentación única Operar (2,7 V a 5,5 V)

6. Error de no linealidad Típicamente 0,2% a 50 kHz

7. montaje superficial

8. En el TCS3210, el convertidor de luz a frecuencia lee una matriz 8 x 8 de

fotodiodos. Dieciséis fotodiodos tienen filtros azules, 16 fotodiodos tienen filtros

verdes, 16 fotodiodos tienen filtros rojos, y 16 fotodiodos son claras sin filtros

Ing Edison V

2

2. Pines de configuración y selección

Los pines S0 y S1 nos permite seleccionar la frecuencia de trabajo

Ing Edison V

3

3. Recepción de datos

La salida del sensor es una onda cuadrada con frecuencia directamente proporcional a

la intensidad del color que incida sobre los fotodiodos .Una manera de contar los ciclos

para determinar la frecuencia es usar una interrupción externa Timmer o con arduino

mediante la instrucción pulseIn.

El sensor convierte la luz captada a pulsos de luz RGB(red, Green, blue, rojo, verde azul),

mediante la combinación de los colores primarios obtenemos los colores verde,

naranja, violeta que nos permiten obtener un plano general de los colores más

importantes del circulo cromático

Para lograr obtener todas las tonalidades de color del circulo cromático es necesario

realizar la conversión de TSL(tono, saturación, luminancia) a RGB según los cálculos de

modelo de color.

4. Propiedades del color

Las propiedades del color son básicamente, elementos diferentes que hacen único un

determinado color, le hacen variar su aspecto y definen su apariencia final.

Matiz (Hue o Tonalidad, se representa en grados 0-360)

• Denominado también tono, tinte y color, es la propiedad del color que se

refiere al estado puro del color, el color puro al cual más se acerca. Es la

cualidad por la cual diferenciamos y damos su nombre al color.

• El matiz nos permite distinguir el rojo del azul, y se refiere al recorrido que hace

un tono hacia uno u otro lado del círculo cromático

• Los tres colores primarios representan los tres matices primarios, y mezclando

éstos podemos obtener los demás matices o colores.

Valor o luminosidad

• Es un término que se usa para describir cuan claro o cuan oscuro parece un

color y se refiere a la cantidad de luz percibida (una camisa en el sol o en la

sombra).

Ing Edison V

4

Saturación o brillo

• Este concepto representa la viveza o palidez de un color, su intensidad, y puede

relacionarse con el ancho de banda de la luz que estamos visualizando.

• describe la pureza del color, es decir, la intensidad o palidez del mismo (una

camisa nueva o descolorida),

Ing Edison V

5

En la imagen del círculo cromático se observa las diferentes tonalidades de color que se

obtienen en los 360 grados, colores que son percibidos sólo por el ojo humano.

5. Modelos de Color

Modelo RGB

Este es el modelo de definición de colores usado en trabajos digitales tomando valores

de 0 a 255

El modelo HSL o TSL (Matiz (TONO), Saturación, Luminosidad)

Es un modelo de representaciones considerado "natural", ya que se acerca bastante a la

percepción fisiológica del color que tiene el ojo humano, sus valores van de 0 a 360

grados

El modelo HSL consiste en descomponer el color según criterios fisiológicos:

HSL es parecido a HSV

El color rojo, equivale en RGB es (255,0,0), y en HSL (0,100%,50%) con una saturación

del 100% y una luminosidad del 50%.

Ing Edison V

6

6. Montaje en arduino

Ing Edison V

7

Ing Edison V

8

7. Código de Arduino 8. /*

9. programa que lee el sensor de color TCS3210/3200 por medio de cambios de frecuencia,

10. cuando detecta los colores rojo, verde y azul, lee tinte, luminancia y RGB

11. programa adaptado de los publicados por el fabricante, Parallax, Taos y strat-num.fr

12.

13.

14. configuracion de escala o frecuencia xxxxxxxxxxxxxxx configuracion para deteccion de color

15. S0|S1 xx S2|S3

16. 0|0 power down xx 0|0 red

17. 0|1 escala 1/50 fre FO= 10Khz xx 0|1 blue 18. 1|0 scaling 1/5 fre FO= 100Khz xx 1|0 clear (no filter)

19. 1|1 scaling 1/1 (default) fre FO= 500Khz xx 1|1 green

20.

21. s3 s2 out vdd

22. 8 7 6 5

23. I____I____I____I

24. I I

25. I I

26. I_*____________I

27. I I I I

28. 1 2 3 4

29. S0 S1 OE GND

30. 31. */

32. // pines de arduino para conectar el sensor

33. //tsl= tono(tinte) saturacion luminancia

34. // tinte hace referencia a un tono sólido o plano,

35. // esto es, que no contiene degradaciones.

36. struct TSL{double t; double s; double l;};//se define una funcion tipo estructura que nos permite definir y tomar

varias variables

37. int out = 2; // definicion de salida

38. int S0 = 3;

39. int S1 = 4;

40. int S2 = 5;

41. int S3 = 6; 42. int OE = 7; // salida habilitada

43. int LED = 8; // pulso de activacion de un led para deteccion de color(opcional)

44.

45. int LT = 13; // indicador de adquisicion de color segun codificacion RGB

46. int sombras_nb = 6;

47. double sombras_val[] = {30.0,60.0,120.0,180.0,240.0,330.0};

48. char* sombras_id[] = {"rojo","amarillo","verde","cyan","azul","magenta"};

49.

50. void setup() {

51. TCS3210setup();//salta a configurar el sensor

52. Serial.begin(115200);//configura la velocidad

53. Serial.print("\nleyendo sensor 3210\n");//imprime un mensaje

54. delay(100); 55. }

56.

57. void loop() {

58. struct TSL tsl = detectorColor();//toma los datos de la funcion de los colores y lo almacena en struct

59. double t = tsl.t;

60.

61. Serial.println();

62. // esta escala es aproximada al valor real. esto depende de la cantidad de luz que incida en el sensor

63. if (tsl.l < 38.0) { Serial.println("tendencia: negro"); }

64. else if (tsl.s < 4.0 && tsl.l > 60.0) { Serial.println("tendencia: blanco"); }

65. else if (tsl.s < 4.2 && tsl.l > 40.0) { Serial.println("tendencia: gris"); }

66. else // déterminacion de la tinta 67. if(t>=sombras_val[0] && t<sombras_val[sombras_nb-1])

68. {

69. for(int idx=0; idx<sombras_nb-1; ++idx)

Ing Edison V

9

70. {

71. if(t>=sombras_val[idx] && t<sombras_val[idx+1])

72. {

73. Serial.print("tendencia: "); 74. Serial.println(sombras_id[idx+1]);

75. break;

76. }

77. }

78. }else{

79. Serial.println("tendencia: rojo");

80. }

81.

82. Serial.println("\n\n");

83. delay(1000);

84. }

85. 86. // comando para detectar si hay color alfrente del sensor.

87. bool isPresent()

88. {

89. //se cataloga el grado de luminosidad segun la hoja de datos

90. //para determinar el grado de luminosdad o oscuridad

91. double isPresentTolerance = 2;

92. // número se hace grande cuando algo está en frente del sensor.

93. double isPresent = colorRead(out,0,0)/colorRead(out,0,1);

94.

95. if(isPresent < isPresentTolerance){

96. Serial.println("no hay nada en frente del sensor");

97. return false;

98. } 99. return true;

100. }

101.

102. // retorna TSL segun color detectado

103. //

104. struct TSL detectorColor(){

105. struct TSL tsl;

106. double white = colorRead(out,0,1);//out es el pin 2 del arduino

107. double red = colorRead(out,1,1);

108. double blue = colorRead(out,2,1);

109. double green = colorRead(out,3,1);

110. Serial.print("datos capturados blanco : "); Serial.println(white); 111. Serial.print("datos capturados R : "); Serial.println(red);

112. Serial.print("datos capturados G : "); Serial.println(green);

113. Serial.print("datos capturados B : "); Serial.println(blue);Serial.println();

114.

115. double r,v,b; // r,v,b € [0..1]

116. double offset = 3.0/white; // compensacion de luminosidad

117. r=min(1.0, offset+(white/red));

118. v=min(1.0, offset+(white/green));

119. b=min(1.0, offset+(white/blue));

120. Serial.print(" Rojo : "); Serial.println( r);

121. Serial.print(" verde : "); Serial.println( v);

122. Serial.print(" azul : "); Serial.println( b);

123. Serial.println(); 124.

125. // transformacion RVB -> TSL

126. // r,v,b € [0..1]

127. // t € [0°..360°]; s,l € [%]

128. double t,s,l;

129.

130. double maxRVB = max(max(r, b),v);

131. double minRVB = min(min(r, b),v);

132. double delta = maxRVB-minRVB;

133. double somme = maxRVB+minRVB;

134.

Ing Edison V

10

135. // luminancia basada en valores de colores segun software de diseño grafico

136. l=(somme/2.0);

137.

138. if(delta==0.0) // gris 139. {

140. t=s=0.0;

141. }else{

142. //saturacion

143. if ( l < 0.5 ) s = delta / somme;

144. else s = delta / ( 2.0 - delta );

145.

146. // tinte

147. double del_R = ( ( ( maxRVB - r ) / 6.0 ) + ( delta / 2.0 ) ) / delta;

148. double del_G = ( ( ( maxRVB - v ) / 6.0 ) + ( delta / 2.0 ) ) / delta;

149. double del_B = ( ( ( maxRVB - b ) / 6.0 ) + ( delta / 2.0 ) ) / delta;

150. 151. if ( r == maxRVB ) t = del_B - del_G;

152. else if ( v == maxRVB ) t = ( 1.0 / 3.0 ) + del_R - del_B;

153. else if ( b == maxRVB ) t = ( 2.0 / 3.0 ) + del_G - del_R;

154.

155. if ( t < 0 ) t += 1.0;

156. if ( t > 1 ) t -= 1.0;

157. }

158.

159. // normalizacion

160. t*=360.0; // [0°..360°]

161. s*=100.0; // [%]

162. l*=100.0; // [%]

163. tsl.t=t; tsl.s=s; tsl.l=l; 164.

165. Serial.print(" tinte [0..360]: "); Serial.println(t);

166. Serial.print(" saturacion [%]: "); Serial.println(s);

167. Serial.print(" luminancia [%]: "); Serial.println(l);

168.

169. return tsl;

170. }

171.

172. /***

173. Este método devolverá el valor medido por el sensor seleccionado. Dado que la frecuencia

174. es proporcional a la intensidad de la luz del filtro de color seleccionado, el valor más pequeño es

175. (Cerca de 10 con setMode (2)), además de que es la luz. 176. params:

177. outPin: pin de salida

178. color: 0 = blanco, 1 = rojo, 2 = azul, verde = 3

179. Los LEDs se encienden LEDstate.

180. */

181. double colorRead(int outPin, int color, boolean LEDstate){

182. setMode(2); // frecuencia max 100Khz => 10us

183. //sélectiona el filtro

184. if(color == 0){//clear

185. digitalWrite(S3, LOW); //S3

186. digitalWrite(S2, HIGH); //S2

187. }else if(color == 1){//red

188. digitalWrite(S3, LOW); //S3 189. digitalWrite(S2, LOW); //S2

190. }else if(color == 2){//blue

191. digitalWrite(S3, HIGH); //S3

192. digitalWrite(S2, LOW); //S2

193. }else if(color == 3){//green

194. digitalWrite(S3, HIGH); //S3

195. digitalWrite(S2, HIGH); //S2

196. }

197.

198. if(LEDstate){

199. digitalWrite(LED, HIGH);

Ing Edison V

11

200. digitalWrite(LT, HIGH);

201. }else{

202. digitalWrite(LED, LOW);

203. digitalWrite(LT, LOW); 204. }

205.

206. //tiempo para que el sensor tome su lectura y se estabilice

207. int sensorDelay = 10; //ms

208.

209. // lee el pulso

210. double readPulse;

211. delay(sensorDelay);

212. readPulse = pulseIn(outPin, LOW, 25000000);

213. //si el tiempo es mayor de lo que lee pulsein regresa cero

214. if(readPulse < .1){ readPulse = 25000000; }

215. 216. //descativa el sensor para ahorrar energia

217. setMode(0);

218. return readPulse;

219. }

220.

221. /*** selecciona el modo

222. */

223. void setMode(int mode){

224. if(mode == 0){

225. //power OFF

226. digitalWrite(LED, LOW);

227. digitalWrite(LT, LOW);

228. digitalWrite(S0, LOW); //S0 229. digitalWrite(S1, LOW); //S1

230. }else if(mode == 1){

231. //escala 1:1

232. digitalWrite(S0, HIGH); //S0

233. digitalWrite(S1, HIGH); //S1

234. }else if(mode == 2){

235. //escala 1:5

236. digitalWrite(S0, HIGH); //S0

237. digitalWrite(S1, LOW); //S1

238. }else{ //if(mode == 3)

239. //escala 1:50

240. digitalWrite(S0, LOW); //S0 241. digitalWrite(S1, HIGH); //S1

242. }

243. }

244. ///////////////////funcion de configuracion de pines/////////////////

245. void TCS3210setup(){

246. //configuracion de frecuencia en el setup estan los pines respectivos

247. pinMode(S0,OUTPUT);

248. pinMode(S1,OUTPUT);

249. //seleccion de color

250. pinMode(S2,OUTPUT);

251. pinMode(S3,OUTPUT);

252. //salida

253. pinMode(out, INPUT); 254. //habilita la salida

255. pinMode(OE,OUTPUT); //habilita el modulo de luz

256. // activa el led

257. pinMode(LED,OUTPUT);

258. // halita la deteccion de color

259. pinMode(LT,OUTPUT);

260. }