Interfaz del sensor de color TCS230/TCS3200 con Arduino

¿Alguna vez te has preguntado cómo funciona un sensor de color? En este artículo exploraremos la interfaz del popular sensor TCS230/TCS3200 con Arduino. Descubre cómo puedes utilizar este sensor para detectar y medir colores de una forma sencilla y eficaz en tus proyectos de electrónica. ¡Sigue leyendo para aprender más!

Los sensores de color ofrecen soluciones más confiables para desafíos complejos de automatización. Se utilizan en diversas industrias, incluidas las de alimentos y bebidas, automoción y fabricación, por ejemplo, para la detección de materiales, la detección de marcas de color en piezas, la comprobación de pasos en el proceso de fabricación, etc.

Si bien en aplicaciones industriales se utilizan sensores de color costosos, los sensores de bajo costo como el sensor de color TCS230 se pueden usar para aplicaciones menos exigentes.

El sensor de color TCS230 (también llamado TCS3200) es muy popular, rentable y fácil de usar. Antes de utilizar 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 se compone de tres colores primarios (rojo, verde y azul) que tienen diferentes longitudes de onda. Estos colores se combinan entre sí y forman diferentes tonalidades.

Cuando la luz blanca incide sobre una 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 creado por longitudes de onda que se reflejan en nuestros ojos.

Ahora volvamos al sensor: un sensor de color típico contiene 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 constan de una rejilla de filtros sensibles al color, también conocidos como «filtro bayer' y una serie de fotodiodos debajo como se muestra en la imagen a continuación.

Un solo píxel consta de 4 filtros, un filtro rojo, un azul, un verde y un filtro transparente (sin filtro). Este patrón también se conoce como “patrón bayer'. Cada filtro permite que la luz de un solo color pase al fotodiodo que se encuentra debajo, mientras que el filtro transparente deja pasar la luz sin cambios, 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 aborda cada fotodiodo (de un color cada uno) y mide la intensidad de la luz. Dado que se trata de una serie de fotodiodos, los resultados primero se promedian y luego se envían para su procesamiento. El color del objeto se determina midiendo las proporciones relativas de luz roja, verde y azul.

Módulo sensor de color TCS230

El corazón del módulo es un chip sensor RGB rentable 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 ilimitada de colores visibles.

El sensor en sí se puede ver en el centro del módulo, rodeado por cuatro LED blancos. Los LED se encienden cuando el módulo está encendido y se utilizan para iluminar el objeto detectado. Gracias a estos LED, el sensor puede funcionar incluso en completa oscuridad para determinar el color o el brillo del objeto.

El TCS230 opera con un voltaje de suministro de 2,7 a 5,5 voltios y ofrece salidas de nivel lógico TTL.

Operación TCS230

El TCS230 detecta colores utilizando una matriz de fotodiodos de 8 x 8, de los cuales 16 fotodiodos son filtros rojos, 16 fotodiodos son filtros verdes, 16 fotodiodos son filtros azules y los 16 fotodiodos restantes son transparentes sin filtros.

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

Hay 16 fotodiodos conectados en paralelo para que pueda utilizar dos pines de control S2 y S3 para seleccionar cuál de ellos debe leerse. Por ejemplo, si solo desea detectar el color rojo, puede seleccionar 16 fotodiodos con filtro rojo configurando los dos pines en BAJO según la tabla.

Asimismo, diferentes combinaciones de S2 y S3 permiten elegir diferentes tipos de fotodiodos.

Un convertidor interno de corriente-frecuencia convierte los valores medidos de los fotodiodos en una onda cuadrada cuya frecuencia es proporcional a la intensidad del color seleccionado. El rango de frecuencia de salida típico está entre 2 Hz y 500 kHz.

El sensor tiene dos pines de control adicionales, 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 escala de frecuencia permite utilizar el sensor con una variedad de microcontroladores y otros dispositivos.

Mediante diferentes combinaciones de S0 y S1 se pueden obtener diferentes factores de escala. Para Arduino, la mayoría de las aplicaciones utilizan un escalado del 20%.

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

El siguiente diagrama muestra la asignación de pines de un módulo TCS230 común.

Tierra es un pin de tierra.

OE es el pin de habilitación de salida. Este pin rara vez se usa y está habilitado permanentemente en la mayoría de los módulos. Si aún no está habilitado, arrástrelo a BAJO.

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

T2 & T3 Se utilizan bolígrafos para seleccionar la disposición de los colores.

FUERA DE El pin es una onda cuadrada con nivel TTL.

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

Cableado del sensor de color TCS230 a Arduino UNO

Conectar el TCS 230 a un Arduino es muy sencillo. 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 encontrará 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. Así que si quieres utilizar otros pines, puedes hacerlo sin preocupaciones. Solo asegúrese de cambiar los números de pin en el código para reflejar cualquier cambio en el cableado.

Una vez que su sensor esté conectado al Arduino, ¡es hora de escribir código!

Calibrar el sensor

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

1. El primer boceto (boceto de calibración) nos ayuda a obtener los datos sin procesar del sensor.
2. El segundo boceto (boceto principal de Arduino) utiliza los datos sin procesar recibidos previamente para mostrar los valores RGB para el color capturado.

Tenga en cuenta que ambos bocetos utilizan el mismo conector de hardware.

A continuación encontrará el boceto de calibración. Este boceto observa el sensor TCS230 color por color y lee el ancho de pulso del pin de salida. Luego, la salida se muestra en el monitor serie.

Cargue el boceto en su Arduino y monte el sensor para que apunte a los objetos. Primero, busque un objeto de referencia para los colores blanco y negro. Estos objetos de referencia proporcionan valores medidos para los tres colores tanto en valores máximos como mínimos.

// 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;
}

Tan pronto como cargue el boceto, recibirá dichas medidas. Registre las lecturas que obtenga en ambos extremos.

Explicación del código:

El boceto comienza definiendo 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.

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

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

En la configuración definimos los pines S0-S3 como salidas. Estos pines se utilizan para seleccionar la escala de frecuencia y el color al que queremos apuntar. Los pines S0 y S1 se usan para configurar 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 del sensor se define como la entrada al Arduino. Aquí obtenemos 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 del pulso. investiguemos getRedPW() como ejemplo.

El getRedPW() La función recibe el ancho del pulso rojo. Primero, los pines S2 y S3 se configuran para seleccionar el filtro rojo. Este es el único paso que distingue esta característica 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 usando el Arduino. pulseIn() Función. Esta función mide el ancho del pulso. Tenga en cuenta que lo 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 finaliza.

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;
}

De vuelta en el bucle, llamamos a tres funciones para leer los anchos de pulso de color y agregamos un retraso de 200 ms entre ellas para permitir que el sensor se estabilice. Luego imprimimos los valores en el monitor serie y repetimos el ciclo.

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);
}

Código Arduino: lectura de valores RGB de TCS230

Una vez que hayas tomado tus medidas, puedes subir el siguiente boceto donde leemos los valores RGB del sensor de color TCS230.

Antes de cargar el boceto, ingrese los seis valores de calibración obtenidos del boceto de calibración en la parte superior del boceto. Reemplace el «0» con sus 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;
}

Cargue el boceto y observe los resultados utilizando muestras de diferentes colores. Si es necesario, puede realizar pequeños ajustes a los valores de calibración.

Explicación del código

Notarás que la mayor parte de este boceto es exactamente igual que el boceto anterior excepto:

Los seis valores de calibración que determinó a partir del boceto de calibración se ingresan en la parte superior del boceto.

// 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 bucle, leemos cada valor usando la misma función que en el boceto anterior. Luego usamos el Arduino. map() Función para convertir estos valores a valores RGB usando como referencia nuestros valores de calibración.

Tenga en cuenta que hemos invertido el rango (el valor mínimo se asigna a 255 y el valor máximo 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 en serie. Estas medidas finales corresponden a los valores RGB del objeto escaneado.

Interfaz del sensor de color TCS230/TCS3200 con Arduino

Los sensores de color proporcionan soluciones más confiables a los desafíos de automatización complejos. Se utilizan en diversas industrias, incluidas la alimentaria, automotriz y manufacturera, con el propósito de detectar materiales, marcar colores en piezas, verificar pasos en el proceso de fabricación, entre otros.

¿Cómo funcionan los sensores de color?

La luz blanca está compuesta por tres colores primarios (rojo, verde y azul), los cuales tienen diferentes longitudes de onda. Estos colores se combinan entre sí para formar diferentes tonos de colores. Cuando la luz blanca incide en una superficie, algunas longitudes de onda de luz son absorbidas y otras son reflejadas, dependiendo de las propiedades del material de la superficie. El color que vemos es el resultado de qué longitudes de onda son reflejadas de nuevo en nuestros ojos.

En cuanto al sensor, este incluye un LED blanco de alta intensidad que proyecta luz modulada sobre el objeto. Para detectar el color de la luz reflejada, la mayoría de los sensores de color constan de una rejilla de filtros sensibles al color, también conocida como «Filtro Bayer», y una matriz de fotodiodos debajo de esta rejilla.

Un solo píxel está compuesto por 4 filtros: uno rojo, uno azul, uno verde y uno claro (sin filtro). Este patrón también es conocido como el ‘Patrón Bayer’. Cada filtro pasa luz de un solo color al fotodiodo debajo, mientras que el filtro claro pasa luz tal como es.

Módulo del sensor de color TCS230

En el corazón del módulo se encuentra un chip sensor RGB económico de Texas Advanced Optoelectronic Solutions, el TCS230. El sensor 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 observar en el centro del módulo, rodeado por los cuatro LED blancos. Los LEDs se iluminan cuando el módulo recibe energía y se utilizan para iluminar el objeto que se está detectando. Gracias a estos LEDs, el sensor también puede funcionar en completa oscuridad para determinar el color o brillo del objeto.

Operación del TCS230

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

Si observas detenidamente el sensor, podrás ver estos filtros. Cada 16 fotodiodos están conectados en paralelo, por lo que mediante dos pines de control, S2 y S3, puedes elegir cuál leer.

Esquema de pines del módulo del sensor de color TCS230

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

1. GND es el pin de tierra.
2. OE es el pin de Habilitar Salida. Este pin rara vez se usa y en la mayoría de los módulos está permanentemente habilitado.
3. Los pines S0 y S1 se utilizan para seleccionar la escala de frecuencia.
4. Los pines S2 y S3 se usan para seleccionar la matriz de colores.
5. El pin OUT es una onda cuadrada de nivel lógico TTL.
6. El pin VCC suministra energía al módulo. Conéctalo a la fuente de alimentación de 2.7V a 5.5V.

Conexión del sensor de color TCS230 a Arduino UNO

Conectar el TCS230 a un Arduino es muy sencillo. Todos los pines se utilizan, excepto el pin de Habilitar Salida, y el módulo recibe energía 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 el Arduino son críticos, ya que el módulo no requiere características específicas de los pines, por lo que si deseas utilizar pines diferentes, puedes hacerlo de forma segura. Simplemente asegúrate de cambiar los números de los pines en el código para reflejar cualquier cambio en la conexión.

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

Calibración del Sensor

Usaremos dos sketches 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 previamente recibidos para mostrar los valores RGB del color detectado.

Antes de usar una página web, se debe contar con autorización de la traducción del contenido solicitado:

Ir a la fuente original