Arduino: reconocer colores con el módulo TCS230 – TCS3200

En principio hay que dejar en claro que nos vamos a encontrar en los sitios de venta y en la información técnica en-línea con diversos formatos de soporte físico de este sensor. Voy a mostrar al menos 4 en la imagen que sigue.

Confusiones de Mercado:

Antes de seguir se presenta la necesidad de aclarar que hay una controversia difícil de resolver: los vendedores, sea en sitios como Mercadolibre o internacionales como eBay, nombran a estos sensores como «TCS230 TCS3200 Recognition Color Sensor Detector Module» («Módulo Sensor Detector de Reconocimiento de Color TCS230 TCS3200»). Es decir, en el nombre descriptivo aparecen dos códigos, y estos códigos son los nombres de dos chips diferentes: TCS230 y TCS3200. Modelos diferentes. Si alguien desea dilucidar qué chip detector posee su propio módulo recomiendo leer y seguir este debate en el foro oficial de Arduino. O más fácil, una observación detallada de la ventana del chip permite ver de cuántos fotodiodos se compone. Si es una matriz de 8×8 (es visible con facilidad), su sensor corresponde a la descripción y ejemplos que tratamos aquí. Si la matriz es de 4×4 o 8×4, usted se encuentra en presencia de otro sensor. Digamos que, de ser así, y la cantidad y nombre de los pines de entrada/salida de su módulo coinciden con las descripciones que ofrezco aquí, usted puede probar con su sensor los diagramas de conexión y programas propuestos en este artículo. Para mayor tranquilidad, según sus hojas de datos, tanto el TCS230 como el TCS3200 poseen una matriz de 8×8 fotodiodos y la descripción de funcionamiento de la primera hoja coincide en todos sus parámetros, excepto en el tamaño de los fotodiodos, que es de 110 µm x 110 µm separados 134-µm centro a centro en el TCS3200, y de 120 µm x 120 µm separados 144-µm en el TCS230. También se nota una diferencia física en el diagrama de ambos chips, visible en la forma de sus conexiones metálicas internas. La opinión en el debate del foro de Arduino es que el TCS230 en una versión anterior de fabricación del TCS3200, lo cual es muy posible porque la empresa fabricante originalmente era TAOS, y luego se convirtió en AMS.

Diagrama en la hojas de datos del chip TCS230 y TCS3200:

Módulo Sensor/Detector de reconocimiento de color

Descripción básica:

Este módulo utiliza un sensor integrado provisto de 64 fotodiodos. De estos 64 fotodiodos, 16 tienen filtro para el color rojo, 16 para el color verde, 16 para el color azul y 16 para luz directa (sin ningún filtro).

Al estar distribuidos uniformemente sobre el chip, estos fotodiodos captan la luz, filtran los colores, y generan una salida de señal de onda cuadrada cuyo ancho de pulso indica la información sobre la intensidad del rojo (R = red: rojo), verde (G = green: verde) y azul (B = blue: azul).

Si observa de cerca un chip TCS3200, se pueden ver los diferentes filtros:

En el módulo que se ve en la foto de cabecera, el sensor se ha montado junto con cuatro LEDs blancos que aportan la iluminación. El módulo posee ocho pines de conexión.

El rango de distancia para la medición es de 10 mm. El módulo mide 31,6 mm x 24,4 mm. Sus pines están separados entre sí con la separación estándar de la placas de circuito impreso preperforadas y de las protoboard, o placas de prototipo.

El módulo acepta una alimentación de 3 a 5 voltios aplicada en dos pines, y para la conexión con un Arduino u otro microcontrolador se utilizan 6 pines:

Control: S0, S1, S2, S3
OUT (SALIDA): que se encarga de enviar la información
OE (Output Enable: habilitación de la salida)

Las entradas se pueden controlar desde una salida digital del Arduino u otra plaqueta de control, o en el caso de OE, conectarla a tierra (lado -, o negativo, de la alimentación) para habilitar el módulo de manera constante.

Los TCS3200 son sensores que convierten en frecuencia la intensidad de luz medida por una matriz de fotodiodos. La frecuencia entregada por el sensor TCS3200 es mayor cuanta mayor luminosidad se detecte. La configuración en matriz de los fotodiodos permite lograr un promedio del valor que se mide para compensar diferencias de color en la superficie que se muestrea. También dispone de filtros de color distribuidos de manera uniforme por la superficie, ubicados sobre los fotodiodos, que, al ir alternando su estado, sirven para distinguir cada componente de la luz.

La matriz de los sensores TCS3200 está formada por 16 fotodiodos con un filtro rojo, 16 con un filtro verde, 16 con un filtro azul y otros 16 sin filtrar. Los 64 fotodiodos no funcionan de manera simultánea sino que se activan por grupos de color antes de realizar la medición de la intensidad de luz que incide en ellos. Para elegir qué filtros deben activarse en cada momento, los TCS3200 disponen de dos pines, S2 y S3, con las que configurarlos.

Una vez obtenida la lectura de la iluminación, la corriente se convierte a frecuencia en forma de onda cuadrada con un ciclo de trabajo del 50% (mitad pulso alto, mitad pulso bajo). Enviar al microcontrolador una frecuencia en lugar de una corriente (intensidad) permite que sea más estable y soporte mejor las interferencias producidas por las pistas del circuito o los cables que unan el TCS3200 con el micro.

La máxima frecuencia que los TCS3200 puede generar (sin producir saturación) dependiendo de la intensidad de la luz medida y del color (longitud de onda de la luz) es de 600 KHz. Para poder utilizar un microcontrolador (u otros componentes) a poca velocidad, es posible escalar la frecuencia en tres niveles, la normal (máxima) al 100%, una media al 20% y otra baja al 2%. Los pines S0 y S1 de los TCS3200 son para establecer estos valores de frecuencia.

Conexiones del sensor

GND Tierra de la fuente de alimentación
OE (entrada) Habilitar la salida de frecuencia (activo bajo)
OUT (salida) Frecuencia de salida
S0, S1 (entradas) Entradas de selección de la escala de frecuencia de salida
S2, S3 (entradas) Entradas de selección del tipo de fotodiodo
VDD Voltaje de alimentación

Selección de filtro:

Para seleccionar el color que se lee de los fotodiodos, se utilizan los pines de control S2 y S3. Dado que los fotodiodos están conectados en paralelo, estableciendo S2 y S3 en diferentes combinaciones de BAJO y ALTO permite seleccionar diferentes grupos de fotodiodos. La tabla de abajo indica las opciones:

Escala de frecuencia:

Para el Arduino es común usar una escala de frecuencia del 20%. Por lo tanto, se establece el pin S0 en ALTO y el pin S1 en BAJO.

Sensor de color con Arduino y TCS3200:

En este ejemplo, se va a detectar colores con el Arduino y el sensor de color TCS3200. Esta configuración sensor no es muy precisa, pero funciona bien para detectar colores en proyectos simples.

Esquemático:

Conectar el sensor TCS3200 al Arduino es bastante sencillo. Simplemente se debe seguir el siguiente diagrama esquemático. Utilizo en este ejemplo el modelo que aparece en la foto en el encabezado de esta nota.

Las primeras pruebas serán:

1. Lectura y visualización de la frecuencia de salida en el monitor serie. En esta parte, anotaremos los valores de frecuencia al colocar diferentes colores frente al sensor.

2. Distinguir entre diferentes colores. En esta sección, insertaremos los valores de frecuencia seleccionados en el código previo, para que el sensor pueda distinguir entre diferentes colores. Detectaremos colores rojos, verdes y azules.

Leyendo la frecuencia de salida

//
// Cableado de TCS3200 a Arduino
//
#define S0 8
#define S1 9
#define S2 12
#define S3 11
#define salidaSensor 10

// Para guardar las frecuencias de los fotodiodos
int frecuenciaRojo = 0;
int frecuenciaVerde = 0;
int frecuenciaAzul = 0;

void setup() {
  // Definiendo las Salidas
  pinMode(S0, OUTPUT);
  pinMode(S1, OUTPUT);
  pinMode(S2, OUTPUT);
  pinMode(S3, OUTPUT);
  
  // Definiendo salidaSensor como entrada
  pinMode(salidaSensor, INPUT);
  
  // Definiendo la escala de frecuencia a 20%
  digitalWrite(S0,HIGH);
  digitalWrite(S1,LOW);
  
   // Iniciar la comunicacion serie 
  Serial.begin(9600);
}
void loop() {
  // Definiendo la lectura de los fotodiodos con filtro rojo
  digitalWrite(S2,LOW);
  digitalWrite(S3,LOW);
  
  // Leyendo la frecuencia de salida del sensor
  frecuenciaRojo = pulseIn(salidaSensor, LOW);
  
  // Mostrando por serie el valor para el rojo (R = Red)
  Serial.print("R = ");
  Serial.print(frecuenciaRojo);
  delay(100);
  
  // Definiendo la lectura de los fotodiodos con filtro verde
  digitalWrite(S2,HIGH);
  digitalWrite(S3,HIGH);
  
  // Leyendo la frecuencia de salida del sensor
  frecuenciaVerde = pulseIn(salidaSensor, LOW);
  
  // Mostrando por serie el valor para el verde (G = Green)
  Serial.print(" G = ");
  Serial.print(frecuenciaVerde);
  delay(100);
 
  // Definiendo la lectura de los fotodiodos con filtro azul
  digitalWrite(S2,LOW);
  digitalWrite(S3,HIGH);
  
  // Leyendo la frecuencia de salida del sensor
  frecuenciaAzul = pulseIn(salidaSensor, LOW);
  
  // Mostrando por serie el valor para el azul (B = Blue)
  Serial.print(" B = ");
  Serial.println(frecuenciaAzul);
  delay(100);
}

// Cableado de TCS3200 a Arduino

#define S0 8

#define S1 9

#define S2 12

#define S3 11

#define salidaSensor 10

// Para guardar las frecuencias de los fotodiodos

int frecuenciaRojo = 0;

int frecuenciaVerde = 0;

int frecuenciaAzul = 0;

void setup() {

// Definiendo las Salidas

pinMode(S0, OUTPUT);

pinMode(S1, OUTPUT);

pinMode(S2, OUTPUT);

pinMode(S3, OUTPUT);

// Definiendo salidaSensor como entrada

pinMode(salidaSensor, INPUT);

// Definiendo la escala de frecuencia a 20%

digitalWrite(S0,HIGH);

digitalWrite(S1,LOW);

// Iniciar la comunicacion serie

Serial.begin(9600);

}

void loop() {

// Definiendo la lectura de los fotodiodos con filtro rojo

digitalWrite(S2,LOW);

digitalWrite(S3,LOW);

// Leyendo la frecuencia de salida del sensor

frecuenciaRojo = pulseIn(salidaSensor, LOW);

// Mostrando por serie el valor para el rojo (R = Red)

Serial.print("R = ");

Serial.print(frecuenciaRojo);

delay(100);

// Definiendo la lectura de los fotodiodos con filtro verde

digitalWrite(S2,HIGH);

digitalWrite(S3,HIGH);

// Leyendo la frecuencia de salida del sensor

frecuenciaVerde = pulseIn(salidaSensor, LOW);

// Mostrando por serie el valor para el verde (G = Green)

Serial.print(" G = ");

Serial.print(frecuenciaVerde);

delay(100);

// Definiendo la lectura de los fotodiodos con filtro azul

digitalWrite(S2,LOW);

digitalWrite(S3,HIGH);

// Leyendo la frecuencia de salida del sensor

frecuenciaAzul = pulseIn(salidaSensor, LOW);

// Mostrando por serie el valor para el azul (B = Blue)

Serial.print(" B = ");

Serial.println(frecuenciaAzul);

delay(100);

}

Abrir el monitor serie configurado a una velocidad de 9600 baudios.

Colocar un objeto AZUL frente al sensor a diferentes distancias. Registrar dos mediciones: cuando el objeto se coloca a distancia del sensor, y cuando el objeto está cerca de él (ideal 1 cm).

Comprobar los valores que muestra el monitor serie. La frecuencia para el AZUL (B) debe ser la más baja en comparación con las lecturas de frecuencia del ROJO (R) y VERDE (G).

Con el objeto AZUL delante del sensor, los valores de frecuencia para el AZUL (B) oscilan entre dos valores que pueden estar separados por una relación cercana a 4 a 1 para las mediciones de cerca y de lejos.

Los valores que mostremos en este ejemplo no deben ser tomados como referencia. Para su código, usted debe medir los colores de su objeto específico con su propio sensor de color. Guarde los límites de frecuencia superior e inferior para el color AZUL, porque son necesarios más adelante.

Repetir el proceso con objetos de color VERDE y color ROJO y anotar los límites de frecuencia superior e inferior para cada uno de ellos.

Distinguir entre diferentes colores

El programa a continuación asigna los valores de frecuencia a valores RGB (que están cada uno entre 0 y 255).

En el paso anterior, cuando tomamos el máximo AZUL, digamos como ejemplo que obtuvimos una frecuencia de 60 y cuando colocamos el objeto AZUL a una distancia mayor obtuvimos 230.

Entonces, 60 en frecuencia corresponde a 255 (en RGB) y 230 en frecuencia a 0 (en RGB). La conversión se realiza con la función map() del lenguaje Arduino. En la función map() usted debe reemplazar los parámetros xx con los valores que usted ha registrado.

//
// Cableado de TCS3200 a Arduino
//
#define S0 8
#define S1 9
#define S2 12
#define S3 11
#define salidaSensor 10

// Para guardar las frecuencias de los fotodiodos
int frecuenciaRojo = 0;
int frecuenciaVerde = 0;
int frecuenciaAzul = 0;
int colorRojo;
int colorVerde;
int colorAzul;

void setup() {
  // Definiendo las Salidas
  pinMode(S0, OUTPUT);
  pinMode(S1, OUTPUT);
  pinMode(S2, OUTPUT);
  pinMode(S3, OUTPUT);
  
  // Definiendo salidaSensor como entrada
  pinMode(salidaSensor, INPUT);
  
  // Definiendo la escala de frecuencia a 20%
  digitalWrite(S0,HIGH);
  digitalWrite(S1,LOW);
  
   // Iniciar la comunicacion serie 
  Serial.begin(9600);
}

void loop() {
  // Definiendo la lectura de los fotodiodos con filtro rojo
  digitalWrite(S2,LOW);
  digitalWrite(S3,LOW);
  
  // Leyendo la frecuencia de salida del sensor
  frecuenciaRojo = pulseIn(salidaSensor, LOW);

  // Mapeando el valor de la frecuencia del ROJO (RED = R) de 0 a 255
  // Usted debe colocar los valores que registro. Este es un ejemplo: 
  // colorRojo = map(frecuenciaRojo, 70, 120, 255,0);
  colorRojo = map(frecuenciaRojo, xx, xx, 255,0);
  
  // Mostrando por serie el valor para el rojo (R = Red)
  Serial.print("R = ");
  Serial.print(colorRojo);
  delay(100);
  
  // Definiendo la lectura de los fotodiodos con filtro verde
  digitalWrite(S2,HIGH);
  digitalWrite(S3,HIGH);
  
  // Leyendo la frecuencia de salida del sensor
  frecuenciaVerde = pulseIn(salidaSensor, LOW);

  // Mapeando el valor de la frecuencia del VERDE (GREEN = G) de 0 a 255
  // Usted debe colocar los valores que registro. Este es un ejemplo: 
  // colorVerde = map(frecuenciaVerde, 100, 199, 255,0);
  colorVerde = map(frecuenciaVerde, xx, xx, 255,0);

  // Mostrando por serie el valor para el verde (G = Green)
  Serial.print("G = ");
  Serial.print(colorVerde);
  delay(100);
 
  // Definiendo la lectura de los fotodiodos con filtro azul
  digitalWrite(S2,LOW);
  digitalWrite(S3,HIGH);
  
  // Leyendo la frecuencia de salida del sensor
  frecuenciaAzul = pulseIn(salidaSensor, LOW);

  // Mapeando el valor de la frecuencia del AZUL (AZUL = B) de 0 a 255
  // Usted debe colocar los valores que registro. Este es un ejemplo: 
  // colorAzul = map(frecuenciaAzul, 38, 84, 255, 0);
  colorAzul = map(frecuenciaAzul, xx, xx, 255, 0);
  
  // Mostrando por serie el valor para el azul (B = Blue)
  Serial.print("B = ");
  Serial.print(colorAzul);
  delay(100);

  // Comprobar cual es el color detectado y mostrarlo
  // con un mensaje en el monitor serie
  if(colorRojo > colorVerde && colorRojo > colorAzul){
      Serial.println(" - Detectado ROJO");
  }
  if(colorVerde > colorRojo && colorVerde > colorAzul){
    Serial.println(" - Detectado VERDE");
  }
  if(colorAzul > colorRojo && colorAzul > colorVerde){
    Serial.println(" - Detectado AZUL");
  }
}

// Cableado de TCS3200 a Arduino

#define S0 8

#define S1 9

#define S2 12

#define S3 11

#define salidaSensor 10

// Para guardar las frecuencias de los fotodiodos

int frecuenciaRojo = 0;

int frecuenciaVerde = 0;

int frecuenciaAzul = 0;

int colorRojo;

int colorVerde;

int colorAzul;

void setup() {

// Definiendo las Salidas

pinMode(S0, OUTPUT);

pinMode(S1, OUTPUT);

pinMode(S2, OUTPUT);

pinMode(S3, OUTPUT);

// Definiendo salidaSensor como entrada

pinMode(salidaSensor, INPUT);

// Definiendo la escala de frecuencia a 20%

digitalWrite(S0,HIGH);

digitalWrite(S1,LOW);

// Iniciar la comunicacion serie

Serial.begin(9600);

}

void loop() {

// Definiendo la lectura de los fotodiodos con filtro rojo

digitalWrite(S2,LOW);

digitalWrite(S3,LOW);

// Leyendo la frecuencia de salida del sensor

frecuenciaRojo = pulseIn(salidaSensor, LOW);

// Mapeando el valor de la frecuencia del ROJO (RED = R) de 0 a 255

// Usted debe colocar los valores que registro. Este es un ejemplo:

// colorRojo = map(frecuenciaRojo, 70, 120, 255,0);

colorRojo = map(frecuenciaRojo, xx, xx, 255,0);

// Mostrando por serie el valor para el rojo (R = Red)

Serial.print("R = ");

Serial.print(colorRojo);

delay(100);

// Definiendo la lectura de los fotodiodos con filtro verde

digitalWrite(S2,HIGH);

digitalWrite(S3,HIGH);

// Leyendo la frecuencia de salida del sensor

frecuenciaVerde = pulseIn(salidaSensor, LOW);

// Mapeando el valor de la frecuencia del VERDE (GREEN = G) de 0 a 255

// Usted debe colocar los valores que registro. Este es un ejemplo:

// colorVerde = map(frecuenciaVerde, 100, 199, 255,0);

colorVerde = map(frecuenciaVerde, xx, xx, 255,0);

// Mostrando por serie el valor para el verde (G = Green)

Serial.print("G = ");

Serial.print(colorVerde);

delay(100);

// Definiendo la lectura de los fotodiodos con filtro azul

digitalWrite(S2,LOW);

digitalWrite(S3,HIGH);

// Leyendo la frecuencia de salida del sensor

frecuenciaAzul = pulseIn(salidaSensor, LOW);

// Mapeando el valor de la frecuencia del AZUL (AZUL = B) de 0 a 255

// Usted debe colocar los valores que registro. Este es un ejemplo:

// colorAzul = map(frecuenciaAzul, 38, 84, 255, 0);

colorAzul = map(frecuenciaAzul, xx, xx, 255, 0);

// Mostrando por serie el valor para el azul (B = Blue)

Serial.print("B = ");

Serial.print(colorAzul);

delay(100);

// Comprobar cual es el color detectado y mostrarlo

// con un mensaje en el monitor serie

if(colorRojo > colorVerde && colorRojo > colorAzul){

Serial.println(" - Detectado ROJO");

}

if(colorVerde > colorRojo && colorVerde > colorAzul){

Serial.println(" - Detectado VERDE");

}

if(colorAzul > colorRojo && colorAzul > colorVerde){

Serial.println(" - Detectado AZUL");

}

La explicación de las comparaciones es:

Cuando R es el valor máximo (en parámetros RGB), sabemos que tenemos un objeto rojo.
Cuando G es el valor máximo, sabemos que tenemos un objeto verde.
Cuando B es el valor máximo, sabemos que tenemos un objeto azul.

Al colocar algo delante del sensor, deberá mostrar en su monitor serie el color detectado: rojo, verde o azul.

Agregando al programa más comparaciones se puede ampliar la detección. Como se dijo a inicio de este artículo. se trata de un ejemplo simple de uso de este detector de colores, al que, con tiempo y dedicación, se puede ampliar a los niveles de complejidad que se desee.

Robots Didácticos

Robótica, Automatización, control industrial, microcontroladores, electrónica digital

Arduino: reconocer colores con el módulo TCS230 – TCS3200

1 comentario en “Arduino: reconocer colores con el módulo TCS230 – TCS3200”