Como utilizar o módulo sensor de cor TCS3200 / TCS230 com Arduino

O módulo sensor de cor TCS3200 / TCS230 é capaz de detectar cores do tipo RGB (do inglês Red, Green e Blue, que significa Vermelho, Verde e Azul) de objetos à sua frente.

No centro do módulo sensor de cor TCS3200 / TCS230 há um chip sensor RGB TCS3200 / TCS230 que é o responsável pela detecção das cores. Esse pequeno chip é formado por 64 fotodiodos (em um arranjo 8 x 8), conforme pode ser observado na Figura 2. Vale lembrar que o fotodiodo é um dispositivo semicondutor que converte luz em corrente elétrica.

Os 64 pequenos fotodiodos possuem 4 diferentes filtros: 16 sensores têm filtro de identificação da cor verde, 16 da cor vermelha, 16 da cor azul e 16 que não possuem filtro, ou seja, detectarão toda a luminosidade. Com essa funcionalidade, é possível medir o nível de luminosidade de qualquer objeto e definir sua cor.

Os fotodiodos com filtro comum são conectados em paralelo e por meio dos pinos de controle podemos escolher qual dos filtros queremos ler. Por exemplo, se desejamos detectar a cor verde, precisamos selecionar a leitura dos 16 fotodiodos com filtro verde. Fazemos isso, configurando os pinos S2 e S3 como nível lógico ALTO. A Tabela 1 detalha o modo de configuração dos pinos S2 e S3 para os demais filtros dos fotodiodos.

S2	S3	Filtros do Fotodiodo
Baixo	Baixo	Vermelho
Baixo	Alto	Azul
Alto	Baixo	Claro (sem filtro)
Alto	Alto	Verde

Após a detecção, usando um conversor de corrente para frequência, as leituras dos fotodiodos são convertidas ondas quadradas com frequência diretamente proporcional à intensidade da luz. Usando um microcontrolador podemos ler estas ondas e obter os resultados para a cor.

A faixa de frequência de saída é de 2HZ ~500KHZ. O módulo sensor de cor TCS3200 / TCS230 possui dois pinos (S0 e S1) para controle da frequência de saída. A frequência pode ser dimensionada para três valores predefinidos diferentes de 2%, 20% ou 100%, conforme a Tabela 2.

S0	S1	Escala de fraquência
Baixo	Baixo	Desligar
Baixo	Alto	2%
Alto	Baixo	20%
Alto	Alto	100%

Para auxiliar a detecção das cores, o sensor conta com 4 LEDs brancos em volta do sensor, conforme a Figura 3. Os LEDs são acionados quando o módulo é ligado e são usados para iluminar o objeto que terá sua cor detectada.

Quanto a pinagem, temos a configuração da Figura 4.

Cada pino possui uma função específica:

• GND: Pino de aterramento;
• VCC: Pino de alimentação do módulo. Essa alimentação pode variar entre 2,7V e 5,5 V;
• S0 e S1: Pinos de configuração da escala de frequência saída;
• S2 e S3: Pinos de configuração dos filtros dos fotodiodos;
• OUT: Pino de saída de sinal.

Agora que já conhecemos o módulo sensor de cor TCS3200 / TCS230, vamos utilizá-lo. A proposta deste tutorial é utilizar o módulo em conjunto com o Arduino para identificar as cores vermelha, verde, azul e branca.

MATERIAIS NECESSÁRIOS

• 1 x Placa Uno SMD R3 ATmega328;
• 1 x Cabo USB compatível com Arduino;
• 1x Módulo Sensor de Cor TCS3200;
• Jumpers Macho-Fêmea.

ESQUEMÁTICO DE LIGAÇÃO:

Inicialmente, certifique-se que sua placa UNO esteja desligada. Em seguida monte o circuito da Figura 5, utilizando o Arduino e o módulo TCS3200.

Ao montar o circuito observe os seguintes pontos:

• O módulo pode ser alimentado com 5V ou 3,3V do Arduino;
• O pino GND do módulo deve ser conectado ao GND do Arduino;
• O pino OUT do módulo deve ser conectado ao pino digital 8;
• O pino S2 do módulo deve ser conectado à porta digital 9;
• O pino S3 dever ser ligado ao pino digital 10 do Arduino.

ELABORANDO CÓDIGO

Nesse projeto, vamos realizar a leitura do módulo sensor de cor TCS3200 / TCS230 para identificação das cores vermelha, verde, azul e branca. O resultado será exibido no monitor serial.

Para facilitar o entendimento do código, acompanhe os seguintes passos:

1.Definir as constantes correspondentes aos pinos do Arduino

Iniciamos o programa definindo as constantes que serão utilizadas no código. Cada constante corresponde a um dos pinos do Arduino conectados aos pinos do sensor.

No nosso código foram declarados os pinos: PinOUT, PinS2 e PinS3.

2.Declaração das variáveis que serão utilizadas no código

Foram declaradas as variáveis red, green e blue para armazenar dados de leitura dos fotodiodos com filtro vermelho, verde e azul, respectivamente.

3.Inicialização da função cores()

4.Configuração dos pinos de entrada e saída e inicialização da comunicação serial

No setup() definimos os pinos de configuração dos filtros dos fotodiodos (S2 e S3) como saída e o pino OUT como entrada.

Além disto, inicializamos a comunicação serial por meio da instrução Serial.begin(9600);

5.Leitura dos fotodiodos

Na função loop() definimos o modo de configuração dos pinos S2 e S3 para os filtros dos fotodiodos e realizamos a leitura do pino OUT do módulo sensor de cor TCS3200 / TCS230.

Iniciamos configurando os pinos S2 e S3 como nível lógico baixo (LOW) para ativar a leitura dos fotodiodos com filtro vermelho. Em seguida, usamos a função pulseIn() para captar a largura do pulso do pino OUT do módulo sensor de cor, a armazenamos na variável red e imprimimos no monitor serial.

Repetimos a mesma lógica para configuração dos pinos S2 e S3 e realização da leitura para os filtros dos fotodiodos verde e azul.

Ao final, chamamos a função cores().

6.Função cores()

A função cores() será responsável por comparar os valores de leitura do sensor de cor e retornar qual a cor detectada.

Com base nesses passos, o código será escrito da seguinte forma:

/*
  -  DETECÇÃO DE CORES UTILIZANDO MÓDULO SENSOR DE CORES TCS3200  -
  =================================================
  === BLOG DA ROBOTICA - www.blogdarobotica.com ===
  =================================================
  Autor: Jonas Souza
  E-mail: contato@blogdarobotica.com
  Facebook: facebook.com/blogdarobotica
  Instagram:@blogdarobotica
  YouTube: youtube.com/user/blogdarobotica
  =================================================
  === CASA DA ROBOTICA - www.casadarobotica.com ===
  =================================================
  Facebook: facebook.com/casadaroboticaoficial
  Instagram:@casadarobotica
  ==================================================
*/


#define PinOUT 8 //Definição do Pino OUT na entrada digital 8
#define PinS2  9 //Definição do Pino S2 na entrada digital 9
#define PinS3 10 //Definição do Pinto S3 na entrada digital 10

int red;//Declaração da variável que representará a cor vermelha
int green; //Declaração da variável que representará a cor verde
int blue; // Declaração da variável que representará a cor azul

void cores(); //Inicialização da função

void setup() {
  pinMode(PinOUT, INPUT); //Definição do PinOUT como sendo um pino de entrada
  pinMode(PinS2, OUTPUT); //Definição do Pino S2 como sendo um pino de saída
  pinMode(PinS3, OUTPUT); //Definição do Pino S3 como sendo um pino de saída
  Serial.begin(9600); //Inicia o monitor Serial com velocidade de 9600
}

void loop() {
  digitalWrite(PinS2, LOW); // Aciona um valor LOW ao Pino S2
  digitalWrite(PinS3, LOW); // Aciona um valor LOW ao Pino S3
  red = pulseIn(PinOUT, LOW); // define red como sendo responsável por ler a informação de pulso LOW do pino out
  Serial.print(" R: "); // Mostra a letra R no monitor Serial, representando red
  Serial.print(red); // Mostra o valor lido no PulseIn
  delay(15); // delay de 15 milissegundos até o próximo comando


  digitalWrite(PinS2, HIGH); // Aciona um valo high ao Pino S2
  digitalWrite(PinS3, HIGH); // Aciona um valo high ao Pino S3
  green = pulseIn(PinOUT, LOW); // define green como sendo responsável por ler a informação de pulso low no pino out
  Serial.print(" G: "); // Mostra a letra R no monitor Serial, representando green
  Serial.print(green); // Mostra o valor lido no PulseIn
  delay(15); // delay de 15 milissegundos até o próximo comando


  digitalWrite(PinS2, LOW);// Aciona um valor loq ao Pino S2
  digitalWrite(PinS3, HIGH); // Aciona um valor high ao Pino S3
  blue = pulseIn(PinOUT, LOW);// define blue como sendo responsável por ler a informação de pulso low no pino out
  Serial.print(" B: "); // Mostra a letra B no monitor Serial, representando blue
  Serial.println(blue); // Mostra o valor lido no PulseIn
  delay(15); // delay de 15 milissegundos até o próximo comando

  cores(); //chamada da função cores()
  delay(1000);
}

void cores() { //funçao responsavel por definir a cor que o sensor de luminosidade está lendo
  if ( blue < 20 && red < 20 && green < 20) { //detecção da cor branca
    Serial.println("Branco");
  }
  
  else if (blue < red && blue < green) { //detecção da cor azul
    Serial.println("Azul");
  }

  else if (green < red && green < blue) { //detecção da cor verde
    Serial.println("Verde");
  }

  else if (red < blue && red < green && red < 100) { //detecção da cor vermelha
    Serial.println("Vermelho");
  }
}

Por fim, temos o funcionamento do projeto, mostrado no Vídeo 1.

Espero ter ajudado,

Obrigado a todos e em caso de dúvidas deixe seu comentário abaixo!

Att. Jonas Souza