Detección de Colores con Arduino Nano y Sensor TCS3200

Componentes y materiales

Componente	Cantidad
Arduino Nano R3	1
Módulo sensor de color TCS3200	1
Pantalla LCD I2C 16x2 (fondo azul, texto blanco)	1
Protoboard	1
Cables de conexión	Varios

Software y servicios en línea

• Arduino IDE

Descripción del proyecto

Este tutorial muestra cómo leer colores usando Arduino y el sensor TCS3200. El objetivo es detectar el color de un objeto y mostrarlo en una pantalla LCD. Este proyecto forma parte de un sistema más grande: un brazo robótico que selecciona una acción según el color del objeto detectado.

El siguiente video muestra el proyecto en funcionamiento:

Paso 1: Lista de materiales (BoM)

Los enlaces y precios son solo referenciales:

• Arduino Nano (aprox. 8 USD)
• Módulo sensor de color TCS3200 (aprox. 9 USD)
• Módulo LCD serie I2C 1602 con retroiluminación azul (aprox. 8 USD)
• Protoboard (aprox. 2 USD)
• Cables

Paso 2: El sensor de color TCS3200

Según su hoja de datos, el TCS3200 es un conversor programable de luz a frecuencia que combina fotodiodos de silicio configurables y un conversor corriente-frecuencia en un solo circuito integrado CMOS monolítico.

La salida es una onda cuadrada (ciclo de trabajo 50%) con frecuencia directamente proporcional a la intensidad de luz (irradiancia). La frecuencia de salida a escala completa puede escalarse mediante uno de tres valores preestablecidos a través de dos pines de control (S0 y S1). Las entradas y salidas digitales permiten una interfaz directa con un microcontrolador u otra lógica digital.

El pin OE (Output Enable) coloca la salida en alta impedancia para permitir el uso compartido de una línea de entrada del microcontrolador entre múltiples unidades. En el TCS3200, el conversor luz-frecuencia lee una matriz de 8×8 fotodiodos:

• 16 fotodiodos con filtro azul
• 16 fotodiodos con filtro verde
• 16 fotodiodos con filtro rojo
• 16 fotodiodos sin filtro (transparentes)

Los pines S2 y S3 seleccionan qué grupo de fotodiodos (rojo, verde, azul, claro) está activo. Los fotodiodos miden 110 μm × 110 μm y están separados por centros de 134 μm.

El pin OE (Enable) debe conectarse a GND (LOW). El sensor se alimenta entre 2.7 y 5.5 VDC; usaremos la salida de 5V del Arduino. Para un uso adecuado, se recomienda instalar un pequeño anillo de goma que aísle el sensor de la luz lateral; yo usé pegamento caliente para fijarlo.

Paso 3: Conexión del hardware

Conexión del sensor TCS3200:

• S0 → Pin D4 del Nano
• S1 → Pin D5 del Nano
• S2 → Pin D6 del Nano
• S3 → Pin D7 del Nano
• OUT → Pin D8 del Nano
• EN → GND
• VCC → +5V
• GND → GND

Conexión de la pantalla LCD I2C 16x2:

• SDA → Pin A4 del Nano
• SCL → Pin A5 del Nano

Monte el Arduino Nano en la protoboard. Conecte la salida de 5V y GND del Nano a ambos rieles de alimentación.

Paso 4: Código para Arduino

Lo primero es definir el escalado de frecuencia mediante los pines S0 y S1. Esto optimiza las lecturas para distintos contadores de frecuencia o microcontroladores. Configuraremos ambos en HIGH (100%):

digitalWrite(s0, HIGH);
digitalWrite(s1, HIGH);

Luego seleccionamos el color a leer (rojo, verde o azul) usando los pines de control S2 y S3. Como los fotodiodos están en paralelo, combinaciones de LOW/HIGH en S2 y S3 permiten seleccionar diferentes grupos:

digitalWrite(s2, LOW);  digitalWrite(s3, LOW);  red  = pulseIn(outPin, LOW); // Componente ROJO
digitalWrite(s2, HIGH); digitalWrite(s3, HIGH); grn  = pulseIn(outPin, LOW); // Componente VERDE
digitalWrite(s2, LOW);  digitalWrite(s3, HIGH); blu  = pulseIn(outPin, LOW); // Componente AZUL

En el código final, leeremos varias veces cada componente RGB y calcularemos el promedio para reducir errores por lecturas espurias.

Una vez obtenidos los tres componentes (RGB), debemos definir a qué color corresponden. Para ello, calibramos previamente con objetos de color conocido y anotamos los valores generados.

Puede partir de mis valores de referencia, ajustándolos a sus condiciones de iluminación:

void getColor() {
  readRGB();
  if (red > 8 && red < 18 && grn > 9 && grn < 19 && blu > 8 && blu < 16) color = "BLANCO";
  else if (red > 80 && red < 125 && grn > 90 && grn < 125 && blu > 80 && blu < 125) color = "NEGRO";
  else if (red > 12 && red < 30 && grn > 40 && grn < 70 && blu > 33 && blu < 70) color = "ROJO";
  else if (red > 50 && red < 95 && grn > 35 && grn < 70 && blu > 45 && blu < 85) color = "VERDE";
  else if (red > 10 && red < 20 && grn > 10 && grn < 25 && blu > 20 && blu < 38) color = "AMARILLO";
  else if (red > 65 && red < 125 && grn > 65 && grn < 115 && blu > 32 && blu < 65) color = "AZUL";
  else color = "SIN_COLOR";
}

He predefinido 6 colores: blanco, negro, rojo, verde, amarillo y azul. A medida que disminuye la luz ambiente, los valores tienden a aumentar.

Dentro de loop(), actualizo la pantalla LCD cada segundo con la lectura actual.

El código completo está disponible en mi repositorio GitHub.

Paso 5: Conclusión

Como siempre, espero que este proyecto ayude a otros a adentrarse en el apasionante mundo de la electrónica, la robótica y el IoT.

Visite mi GitHub para archivos actualizados: Color Detector

Para más proyectos, visite mi blog: MJRoBot.org

¡Saludos desde el sur del mundo!

Nos vemos en el próximo tutorial.

Gracias,

Marcelo