Sensor de color TCS3200 con Arduino: detecta rojo, verde y azul leyendo frecuencia

El ojo humano distingue millones de tonos sin esfuerzo, pero un microcontrolador no ve nada: solo entiende voltajes y tiempos. Entonces, ¿cómo hace un Arduino para saber si lo que tiene enfrente es rojo, verde o azul? La respuesta es un truco bien elegante del sensor TCS3200, que convierte la luz en algo que cualquier placa puede medir: una frecuencia. Al terminar este tutorial vas a tener un detector de color funcionando en el monitor serial, y lo más importante, vas a entender por qué funciona y cómo ajustarlo a la iluminación de tu pieza o tu taller.

Este proyecto es ideal si recién empiezas con sensores en Arduino: no necesitas resistencias externas, ni librerías raras, ni soldar nada. Es de los pocos sensores donde toda la magia está en saber leer una señal de pulsos.

Cómo funciona el TCS3200 por dentro

El TCS3200 es un detector de color completo en una sola plaquita. Trae el chip TAOS TCS3200 y cuatro LED blancos de ángulo amplio que iluminan el objeto que quieres medir, para que la lectura no dependa de la luz del ambiente. Adentro del chip hay una matriz de fotodiodos, y acá está lo interesante: no son todos iguales. Algunos tienen un filtro rojo encima, otros un filtro verde, otros azul, y otros quedan sin filtro (transparentes). Esos cuatro tipos están repartidos de forma pareja por toda la matriz, así ninguna posición queda "sesgada" hacia un color.

Cuando la luz reflejada por el objeto entra al sensor, el chip activa solo los fotodiodos del filtro que tú elijas (por ejemplo, los rojos) y genera una onda cuadrada cuya frecuencia es proporcional a la intensidad de ese color. Traducido: mientras más rojo tenga lo que estás midiendo, más alta es la frecuencia que salen por el pin OUT. El Arduino no "ve" el color, sino que mide cuánto dura cada pulso de esa onda. Por eso este sensor se lee con la función pulseIn() y no con un simple analogRead().

Para qué sirve un sensor así

Detectar color abre la puerta a un montón de proyectos: clasificadoras que separan objetos por color (los clásicos clasificadores de M&M o de fichas), sensores de luz ambiente, sistemas de calibración y verificación de color en líneas de producción, o robots seguidores que reaccionan a marcas de colores en el piso. Cualquier cosa donde necesites que tu electrónica "distinga" tonos.

Los pines de control: S0, S1, S2 y S3

Antes de cablear conviene entender los cuatro pines de configuración del módulo, porque son la clave de todo:

• S0 y S1: definen el escalado de frecuencia de salida (power down, 2%, 20% o 100%). En este proyecto los dejamos ambos en HIGH, que corresponde al 100%, la opción más simple para empezar.
• S2 y S3: seleccionan qué grupo de fotodiodos lee el sensor en cada momento (rojo, verde, azul o sin filtro). El código va cambiando estos dos pines para ir midiendo color por color, uno tras otro.

Esta lógica de "selecciono un filtro, mido la frecuencia, cambio de filtro" es exactamente lo que hace la función color() del programa, y entenderla te deja listo para modificar el sensor a tu gusto.

Conexiones: 7 cables y listo

El módulo se conecta directo al Arduino UNO con jumpers macho hembra, sin protoboard si no quieres. Esta es la correspondencia de pines tal como la usa el código:

Un detalle que mucha gente pasa por alto: el pin OE (Output Enable) del módulo suele venir con un puente o una resistencia interna que lo deja habilitado, así que normalmente no necesitas conectarlo. Si tu placa trae OE suelto y no obtienes lecturas, conéctalo a GND para habilitar la salida.

El código completo

Conecta todo como en la tabla, sube el siguiente programa y abre el monitor serial a 9600 baudios. Vas a ver tres números (rojo, verde y azul) y, según esos valores, el sensor te dirá qué color cree estar viendo.

/*ElectroCrea.com
Sensor de Color     Arduino
----------------------------
 VCC               5V
 GND               GND
 s0                8
 s1                9
 s2                12
 s3                11
 OUT               10               
*/
const int s0 = 8;  
const int s1 = 9;  
const int s2 = 12;  
const int s3 = 11;  
const int out = 10;    
int rojo = 0;  
int verde = 0;  
int azul = 0;  
//////////////////////////////////////////////////////////////////////////////////////VOID SETUP    
void setup(){  
  Serial.begin(9600); 
  pinMode(s0, OUTPUT);  
  pinMode(s1, OUTPUT);  
  pinMode(s2, OUTPUT);  
  pinMode(s3, OUTPUT);  
  pinMode(out, INPUT);   
  digitalWrite(s0, HIGH);  
  digitalWrite(s1, HIGH);  
}  
//////////////////////////////////////////////////////////////////////////////////////VOID LOOP    
void loop(){  
  color(); 
  Serial.print("  rojo: ");  
  Serial.print(rojo, DEC);  
  Serial.print("  verde: ");  
  Serial.print(verde, DEC);  
  Serial.print("  azul: ");  
  Serial.print(azul, DEC);  

//Las variables para detectar un color estan en funcion de los otros colores; puedes utilizar valores simplemente. 
  if (rojo < azul && verde > 100 && rojo < 80) 
  {  
   Serial.println(" - ROJO");    
  }   
  else if (azul < rojo && azul < verde)  
  {  
   Serial.println(" - AZUL");        
  }  
  else if (verde < rojo && verde < azul)  
  {  
   Serial.println(" - VERDE");       
  }  
  else{
  Serial.println("-");  
  }
  delay(300);     
  }  
    
void color()  
{    
  digitalWrite(s2, LOW);  
  digitalWrite(s3, LOW);   
  rojo = pulseIn(out, digitalRead(out) == HIGH ? LOW : HIGH);  
  digitalWrite(s3, HIGH);   
  azul = pulseIn(out, digitalRead(out) == HIGH ? LOW : HIGH);  
  digitalWrite(s2, HIGH);    
  verde = pulseIn(out, digitalRead(out) == HIGH ? LOW : HIGH);  
}
//Mas información en ElectroCrea.com

Qué hace el código, paso a paso

En el setup() se configuran los pines y se dejan S0 y S1 en HIGH (escalado al 100%). En el loop(), la función color() mide los tres colores y después un bloque de if decide qué nombre mostrar.

Lo más astuto está dentro de color(): para leer cada color, primero se posicionan S2 y S3 en la combinación correspondiente al filtro, y luego se mide el pulso con pulseIn(out, digitalRead(out) == HIGH ? LOW : HIGH). Ese pequeño operador ternario es un detalle elegante: en vez de asumir si el pulso a medir es alto o bajo, mira el estado actual del pin y mide el pulso contrario, de modo que pulseIn() siempre arranca su medición de forma confiable sin quedarse colgado esperando un flanco que ya pasó.

Calibración: el paso que casi todos saltan

Acá viene la advertencia más importante, y es la que genera la mayoría de las dudas con este sensor: los valores no son universales. Quien escribió este código lo calibró con la iluminación de su mesa de trabajo, así que los umbrales del bloque if (ese rojo < 80, verde > 100, etc.) probablemente no calcen con tu montaje. Eso es totalmente normal y no significa que el sensor esté malo.

La iluminación del ambiente es el factor que más altera las lecturas. Para calibrar bien:

1. Sube el código tal cual y abre el monitor serial.
2. Acerca al sensor un objeto rojo y anota los tres valores que aparecen.
3. Repite con un objeto verde y otro azul.
4. Con esos números reales, ajusta las condiciones de los if para que cada color caiga en su rango.

Un truco práctico: mantén una distancia constante entre el sensor y el objeto (1 a 2 cm funciona bien), y trabaja en un ambiente con luz estable. Si las lecturas saltan mucho, es casi siempre por reflejos o por luz externa colándose; cubrir un poco el sensor con la mano ayuda a confirmarlo.

Variantes y mejoras

Una vez que tengas el detector básico andando, hay varias formas de subirle el nivel que el tutorial original no cubre:

• Promediar lecturas para más estabilidad: en vez de usar un solo pulseIn() por color, toma 5 lecturas seguidas y saca el promedio. Reduce el ruido y hace que la detección sea mucho más consistente, sobre todo con luz que parpadea (ampolletas LED baratas suelen hacerlo).
• Mostrar el color en una pantalla: conecta una OLED SSD1306 por I2C y, en lugar de imprimir en el monitor serial, muestra el nombre del color y hasta un cuadrito del tono detectado. Ideal para un proyecto portátil sin computador conectado.
• Clasificadora automática de objetos por color: suma un servo SG90 y arma una compuerta que derive cada objeto según el color leído. Es el típico proyecto de feria de ciencias y el TCS3200 es perfecto para eso.
• Detectar más colores: con tres lecturas RGB calibradas puedes calcular tonos intermedios (naranja, amarillo, violeta) comparando proporciones entre rojo, verde y azul, no solo cuál es el menor. Es el siguiente paso natural si quieres ir más allá de los tres primarios.

Personalización para Chile

En Chile puedes conseguir todo lo necesario para este proyecto en MechatronicStore:

• Sensor reconocedor de color TCS3200 ($6.990 CLP): el mismo módulo del tutorial, con sus 4 LED blancos integrados.
• Arduino Uno R3 (SKU X4-8, $9.990 CLP): la placa que lee el sensor y muestra los resultados.

Para las conexiones necesitas 7 jumpers macho hembra (el módulo tiene pines macho y los enchufas directo a los headers hembra del Arduino) y un cable USB tipo A a B para programar y alimentar la placa. Si en otro tutorial ves que usan una placa "compatible" o un clon, cualquier Arduino UNO o equivalente cumple la misma función, porque solo estamos usando pines digitales comunes.

Recursos

• Tutorial original (español): Sensor de Color TCS3200 por Alberto Cárdenas en ElectroCrea.
• Código completo (.ino): Sensor_De_Color_TCS3200.ino

Versión chilena con componentes en stock local en MechatronicStore.