Usando el sensor de color TCS230/TCS3200 con Arduino

Los sensores de color brindan soluciones más confiables para desafíos de automatización complejos. Se utilizan en diversas industrias, incluidas las industrias de alimentos y bebidas, automotriz y manufacturera, para fines tales como la detección de materiales, la detección de marcas de color en las piezas, la verificación de pasos en el proceso de fabricación, etc.

Mientras que los costosos sensores de color se usan en aplicaciones industriales, los sensores económicos como el sensor de color TCS230 se pueden usar para aplicaciones menos estrictas.

El sensor de color TCS230 (también conocido como TCS3200) es bastante popular, económico y fácil de usar. Antes de usar este sensor de color en nuestro proyecto Arduino, sería bueno ver cómo funciona realmente un sensor de color.

¿Cómo funcionan los sensores de color?

La luz blanca está compuesta por tres colores primarios (rojo, verde y azul), que tienen diferentes longitudes de onda. Estos colores se combinan entre sí para formar diferentes tonos de colores.

Cuando la luz blanca cae sobre cualquier superficie, algunas longitudes de onda de luz se absorben y otras se reflejan, dependiendo de las propiedades del material de la superficie. El color que vemos es el resultado de que las longitudes de onda se reflejen en nuestros ojos.

Ahora, volviendo al sensor, un sensor de color típico incluye un LED blanco de alta intensidad que proyecta una luz modulada sobre el objeto. Para detectar el color de la luz reflejada, casi todos los sensores de color consisten en una rejilla de filtro sensible al color, también conocida como ‘ Filtro Bayer ‘ y una matriz de fotodiodos debajo, como se muestra en la imagen a continuación.

Un solo píxel se compone de 4 filtros, uno rojo, uno azul, uno verde y un filtro transparente (sin filtro). Este patrón también se conoce como el ‘ Patrón de Bayer ‘. Cada filtro pasa la luz de un solo color al fotodiodo que se encuentra debajo, mientras que el filtro transparente pasa la luz tal como es, como se muestra a continuación. Esta luz adicional que pasa a través del filtro transparente es una gran ventaja en condiciones de poca luz.

Luego, el chip de procesamiento se dirige a cada fotodiodo (un color a la vez) y mide la intensidad de la luz. Como hay una matriz de fotodiodos, los resultados primero se promedian y luego se envían para su procesamiento. Al medir el nivel relativo de luz roja, verde y azul, se determina el color del objeto.

Módulo sensor de color TCS230

En el corazón del módulo se encuentra un chip sensor RGB económico de Texas Advanced Optoelectronic Solutions – TCS230. El sensor de color TCS230 es un detector de color completo que puede detectar y medir una gama casi infinita de colores visibles.

El sensor en sí se puede ver en el centro del módulo, rodeado por los cuatro LED blancos. Los LED se encienden cuando se enciende el módulo y se utilizan para iluminar el objeto que se detecta. Gracias a estos LED, el sensor también puede funcionar en completa oscuridad para determinar el color o el brillo del objeto.

El TCS230 funciona con una tensión de alimentación de 2,7 a 5,5 voltios y proporciona salidas de nivel lógico TTL.

Operación TCS230

El TCS230 detecta el color con la ayuda de una matriz de fotodiodos de 8 x 8, de los cuales dieciséis fotodiodos tienen filtros rojos, 16 fotodiodos tienen filtros verdes, 16 fotodiodos tienen filtros azules y los 16 fotodiodos restantes son transparentes sin filtros.

Si observas de cerca el sensor, puedes ver estos filtros.

Cada uno de los 16 fotodiodos está conectado en paralelo, por lo que al usar dos pines de control S2 y S3 puede elegir cuál de ellos leer. Entonces, por ejemplo, si deseas detectar solo el color rojo, puede seleccionar 16 fotodiodos con filtro rojo configurando los dos pines en BAJO de acuerdo con la tabla.

Del mismo modo, puedes elegir diferentes tipos de fotodiodos mediante diferentes combinaciones de S2 y S3.

Un convertidor interno de corriente a frecuencia convierte las lecturas de los fotodiodos en una onda cuadrada cuya frecuencia es proporcional a la intensidad del color elegido. El rango de la frecuencia de salida típica es 2HZ~500KHZ.

El sensor tiene dos pines de control más, S0 y S1, que se utilizan para escalar la frecuencia de salida. La frecuencia se puede escalar a tres valores preestablecidos diferentes de 2%, 20% o 100%. Esta función de escalado de frecuencia permite que el sensor se use con una variedad de microcontroladores y otros dispositivos.

Puedes obtener un factor de escala diferente mediante diferentes combinaciones de S0 y S1. Para Arduino, la mayoría de las aplicaciones usan la escala del 20%.

S0	S1	Escalado de frecuencia de Salida
BAJO	BAJO	APAGADO
BAJO	ALTO	2%
ALTO	BAJO	20%
ALTO	ALTO	100%

Asignación de pines del módulo del sensor de color TCS230

El siguiente diagrama muestra el pinout de un módulo TCS230 común.

GND es un pin de tierra.

OE es el pin de habilitación de salida (Output Enable). Este pin rara vez se usa y en la mayoría de los módulos está habilitado permanentemente. Si aún no está habilitado, conéctalo a una lógica BAJO.

S0 & S1 Los pines se utilizan para seleccionar la escala de frecuencia.

S2 & S3 Los pines se utilizan para seleccionar la matriz de colores.

OUT es una onda cuadrada de nivel TTL.

VCC suministra energía al módulo. Conéctalo a la fuente de alimentación de 2,7 V a 5,5 V.

Cableado del sensor de color TCS230 a Arduino UNO

Conectar el TCS 230 a un Arduino es muy simple. Se utilizan todos los pines, excepto el pin de habilitación de salida, y el módulo se alimenta de forma segura desde la salida de 5 voltios del Arduino.

A continuación, se muestra la conexión para los experimentos con el TCS230:

Ninguno de los pines utilizados en Arduino es crítico porque el módulo no requiere ninguna función específica de pin, por lo que, si desea usar pines diferentes, puede hacerlo de manera segura. Solo asegúrese de cambiar los números de pin en el código para reflejar cualquier cambio en el cableado.

Una vez que tu sensor está conectado al Arduino, ¡es hora de escribir algo de código!

Calibración del sensor

De hecho, usaremos dos scketch para trabajar con el sensor de color TCS230

El primer sketch (sketch de calibración) nos ayudará a obtener los datos sin procesar del sensor.
El segundo sketch (sketch principal de Arduino) utilizará los datos sin procesar recibidos previamente para mostrar los valores RGB para el color detectado.

Ten en cuenta que ambos sketches utilizarán la misma conexión de hardware.

A continuación, se muestra el esquema de calibración. Este scketch pregunta al sensor TCS230 color por color y lee el ancho de pulso del pin de salida. La salida se muestra en el monitor serie.

Carga el scketch en tu Arduino y monta el sensor de modo que quede frente a los objetos. Comienza por encontrar un objeto de referencia para el color blanco y negro. Estos objetos de referencia producirán lecturas en valores máximos y mínimos para los tres colores.

// Define color sensor pins
#define S0 4
#define S1 5
#define S2 6
#define S3 7
#define sensorOut 8

// Variables for Color Pulse Width Measurements
int redPW = 0;
int greenPW = 0;
int bluePW = 0;

void setup() {
	// Set S0 - S3 as outputs
	pinMode(S0, OUTPUT);
	pinMode(S1, OUTPUT);
	pinMode(S2, OUTPUT);
	pinMode(S3, OUTPUT);

	// Set Pulse Width scaling to 20%
	digitalWrite(S0,HIGH);
	digitalWrite(S1,LOW);

	// Set Sensor output as input
	pinMode(sensorOut, INPUT);

	// Setup Serial Monitor
	Serial.begin(9600);
}

void loop() {
	// Read Red Pulse Width
	redPW = getRedPW();
	// Delay to stabilize sensor
	delay(200);

	// Read Green Pulse Width
	greenPW = getGreenPW();
	// Delay to stabilize sensor
	delay(200);

	// Read Blue Pulse Width
	bluePW = getBluePW();
	// Delay to stabilize sensor
	delay(200);

	// Print output to Serial Monitor
	Serial.print("Red PW = ");
	Serial.print(redPW);
	Serial.print(" - Green PW = ");
	Serial.print(greenPW);
	Serial.print(" - Blue PW = ");
	Serial.println(bluePW);
}


// Function to read Red Pulse Widths
int getRedPW() {
	// Set sensor to read Red only
	digitalWrite(S2,LOW);
	digitalWrite(S3,LOW);
	// Define integer to represent Pulse Width
	int PW;
	// Read the output Pulse Width
	PW = pulseIn(sensorOut, LOW);
	// Return the value
	return PW;
}

// Function to read Green Pulse Widths
int getGreenPW() {
	// Set sensor to read Green only
	digitalWrite(S2,HIGH);
	digitalWrite(S3,HIGH);
	// Define integer to represent Pulse Width
	int PW;
	// Read the output Pulse Width
	PW = pulseIn(sensorOut, LOW);
	// Return the value
	return PW;
}

// Function to read Blue Pulse Widths
int getBluePW() {
	// Set sensor to read Blue only
	digitalWrite(S2,LOW);
	digitalWrite(S3,HIGH);
	// Define integer to represent Pulse Width
	int PW;
	// Read the output Pulse Width
	PW = pulseIn(sensorOut, LOW);
	// Return the value
	return PW;
}

Una vez que cargues el sketch, obtendrás las lecturas. Registra las lecturas que obtengas en ambos extremos

Explicación del código:

#define S0 4
#define S1 5
#define S2 6
#define S3 7
#define sensorOut 8

int redPW = 0;
int greenPW = 0;
int bluePW = 0;

El sketch comienza con la definición de los pines utilizados para conectar el TCS230. Algunas variables también se definen para representar los anchos de pulso de la matriz de colores rojo, verde y azul.

En la configuración, definimos los pines S0-S3 como salidas. Estos pines se utilizarán para seleccionar la escala de frecuencia y el color que deseamos leer. Los pines S0 y S1 se usan para establecer la escala de frecuencia al 20 %, que es un valor común cuando se usa este sensor de color con un Arduino. A continuación, el pin de salida de los sensores se define como una entrada al Arduino, aquí es donde recibiremos la onda cuadrada. Finalmente, configuramos el monitor serie.

void setup() {
	// Set S0 - S3 as outputs
	pinMode(S0, OUTPUT);
	pinMode(S1, OUTPUT);
	pinMode(S2, OUTPUT);
	pinMode(S3, OUTPUT);

	// Set Pulse Width scaling to 20%
	digitalWrite(S0,HIGH);
	digitalWrite(S1,LOW);

	// Set Sensor output as input
	pinMode(sensorOut, INPUT);

	// Setup Serial Monitor
	Serial.begin(9600);
}

En la sección de bucle, llamamos a tres funciones getRedPW(), getGreenPW() y getBluePW() para obtener el ancho de pulso. Examinemos getRedPW() como ejemplo.

La función getRedPW() obtiene el ancho de pulso rojo. Comienza configurando los pines S2 y S3 para seleccionar el filtro rojo. Este es el único paso en el que esta función difiere de sus contrapartes verde y azul.

A continuación, se define un número entero para almacenar el ancho del pulso. Luego, el ancho del pulso se determina utilizando la función de Arduino pulseIn(). Esta función mide el ancho de pulso, ten en cuenta que la hemos configurado para medir el ancho de la parte BAJA del pulso. El resultado es el tiempo en milisegundos. Luego se devuelve este valor y la función termina.

int getRedPW() {
	// Set sensor to read Red only
	digitalWrite(S2,LOW);
	digitalWrite(S3,LOW);
	// Define integer to represent Pulse Width
	int PW;
	// Read the output Pulse Width
	PW = pulseIn(sensorOut, LOW);
	// Return the value
	return PW;
}
	pinMode(S3, OUTPUT);

	// Set Pulse Width scaling to 20%
	digitalWrite(S0,HIGH);
	digitalWrite(S1,LOW);

	// Set Sensor output as input
	pinMode(sensorOut, INPUT);

	// Setup Serial Monitor
	Serial.begin(9600);
}

Volviendo al ciclo, llamamos a tres funciones para leer los anchos de pulso de color, agregando un retraso de 200 ms entre ellos para permitir que el sensor se estabilice. Luego imprimimos los valores en el monitor serial y repetimos el ciclo.

Código Arduino: lectura de valores RGB usando el TCS230

Una vez que hayas tomado sus lecturas, puedes cargar el siguiente sketch donde leeremos los valores RGB del sensor de color TCS230.

Antes de cargar el programa, ingresa los seis valores de calibración que obtuviste del sketch de calibración en la parte superior. Reemplaza el “0” con tus valores reales.

// Define color sensor pins
#define S0 4
#define S1 5
#define S2 6
#define S3 7
#define sensorOut 8

// Calibration Values
// *Get these from Calibration Sketch
int redMin = 0; // Red minimum value
int redMax = 0; // Red maximum value
int greenMin = 0; // Green minimum value
int greenMax = 0; // Green maximum value
int blueMin = 0; // Blue minimum value
int blueMax = 0; // Blue maximum value

// Variables for Color Pulse Width Measurements
int redPW = 0;
int greenPW = 0;
int bluePW = 0;

// Variables for final Color values
int redValue;
int greenValue;
int blueValue;

void setup() {
	// Set S0 - S3 as outputs
	pinMode(S0, OUTPUT);
	pinMode(S1, OUTPUT);
	pinMode(S2, OUTPUT);
	pinMode(S3, OUTPUT);

	// Set Sensor output as input
	pinMode(sensorOut, INPUT);

	// Set Frequency scaling to 20%
	digitalWrite(S0,HIGH);
	digitalWrite(S1,LOW);

	// Setup Serial Monitor
	Serial.begin(9600);
}

void loop() {
	// Read Red value
	redPW = getRedPW();
	// Map to value from 0-255
	redValue = map(redPW, redMin,redMax,255,0);
	// Delay to stabilize sensor
	delay(200);

	// Read Green value
	greenPW = getGreenPW();
	// Map to value from 0-255
	greenValue = map(greenPW, greenMin,greenMax,255,0);
	// Delay to stabilize sensor
	delay(200);

	// Read Blue value
	bluePW = getBluePW();
	// Map to value from 0-255
	blueValue = map(bluePW, blueMin,blueMax,255,0);
	// Delay to stabilize sensor
	delay(200);

	// Print output to Serial Monitor
	Serial.print("Red = ");
	Serial.print(redValue);
	Serial.print(" - Green = ");
	Serial.print(greenValue);
	Serial.print(" - Blue = ");
	Serial.println(blueValue);
}


// Function to read Red Pulse Widths
int getRedPW() {
	// Set sensor to read Red only
	digitalWrite(S2,LOW);
	digitalWrite(S3,LOW);
	// Define integer to represent Pulse Width
	int PW;
	// Read the output Pulse Width
	PW = pulseIn(sensorOut, LOW);
	// Return the value
	return PW;
}

// Function to read Green Pulse Widths
int getGreenPW() {
	// Set sensor to read Green only
	digitalWrite(S2,HIGH);
	digitalWrite(S3,HIGH);
	// Define integer to represent Pulse Width
	int PW;
	// Read the output Pulse Width
	PW = pulseIn(sensorOut, LOW);
	// Return the value
	return PW;
}

// Function to read Blue Pulse Widths
int getBluePW() {
	// Set sensor to read Blue only
	digitalWrite(S2,LOW);
	digitalWrite(S3,HIGH);
	// Define integer to represent Pulse Width
	int PW;
	// Read the output Pulse Width
	PW = pulseIn(sensorOut, LOW);
	// Return the value
	return PW;
}

Carga el sketch y observe los resultados con muestras de diferentes colores. Puedes hacer ajustes menores a los valores de calibración si es necesario.

Código Explicación

Notarás que la mayor parte de este scketch es exactamente igual que el scketch anterior, excepto que, los seis valores de calibración que obtuviste del programa de calibración se ingresan en la parte superior.

// Calibration Values
int redMin = 0; // Red minimum value
int redMax = 0; // Red maximum value
int greenMin = 0; // Green minimum value
int greenMax = 0; // Green maximum value
int blueMin = 0; // Blue minimum value
int blueMax = 0; // Blue maximum value

Se definen tres nuevas variables para los valores RGB que queremos generar.

int redValue;
int greenValue;
int blueValue;

En la sección del loop, leemos cada uno de los valores utilizando la misma función utilizada en el programa anterior. Luego usamos la función Arduino map() para convertir estos valores en valores RGB, usando nuestros valores de calibración como referencia.

Ten en cuenta que hemos invertido el rango (el valor mínimo se asigna a 255 y el valor máximo se asigna a 0) porque nuestras funciones devuelven el ancho del pulso, no la frecuencia.

// Read Red value
redPW = getRedPW();
// Map to value from 0-255
redValue = map(redPW, redMin,redMax,255,0);
// Delay to stabilize sensor
delay(200);

Finalmente, mostramos los valores en el monitor serial. Estas lecturas finales corresponderán a los valores RGB del elemento que se está escaneando.

Interfacing TCS230/TCS3200 Color Sensor with Arduino. Last Minute Engineers. https://lastminuteengineers.com/tcs230-tcs3200-color-sensor-arduino-tutorial/