Usando o Sensor de Cor TCS230

This tutorial is not available in English

Introdução

A sua aplicação precisa identificar cores, mas você não sabe como implementar essa função? O Sensor de Cor TCS230 é utilizado para detectar cores do tipo RGB (red, green e blue) em objetos colocados à sua frente, e assim você é capaz de atuar sobre objetos de uma cor específica.

Nesse tutorial você irá aprender a identificar cores e a implementar uma lógica para atuar sobre uma determinada cor lida.

Lista de Materiais

Lista completa de produtos

comprar

BlackBoard UNO R3

R$ 94,90 no PIX

Cabo USB AB 1.50m

R$ 10,35 no PIX

Sensor de Cor TCS230

R$ 47,40 no PIX

Resistor 300Ω - Pacote com 10 unidades

R$ 0,71 no PIX

LED RGB Alto Brilho - 5 unidades

R$ 4,27 no PIX

Micro Servo 9g SG90

R$ 11,30 no PIX

Garra Robótica Ant V2

R$ 8,55 no PIX

Protoboard 400 Pontos

R$ 6,55 no PIX

WorkPlate 400 - Preta

R$ 14,15 no PIX

Jumpers Macho-Macho x40 Unidades

R$ 7,50 no PIX

Jumpers Macho-Fêmea x40 Unidades

R$ 7,50 no PIX

Conceitos Teóricos

Sensor de Cor TCS230

O módulo aceita uma alimentação de 3 a 5 V e são utilizados cinco pinos para a conexão ao Arduino. São eles: os pinos de controle S0 e S1, que configuram a escala de frequência na saída para 2%, 20% ou 100%; S2 e S3, que selecionam o filtro de cor a ser lida; OUT, que é o responsável pelo envio das informações; e o pino OE (Operational Enable), que deve ser ligado ao GND, já que o módulo vai enviar informações continuamente ao Arduino.

tabela-logica — Tabela de seleção de filtros e escala de frequência
Fonte: Datasheet TCS230

O sensor possui 64 fotodiodos que captam a intensidade da luz, dos quais 48 são filtrados para as cores RGB (16 para a cor vermelha, 16 para a cor verde e 16 para a cor azul), e o restante não possui filtro. Ele gera na saída um sinal de onda quadrada com as informações sobre a intensidade das cores RGB, como na imagem abaixo.

saida-sensor — Processo de identificação de cor e envio de informações para o Arduino
Fonte: RandomNerdTutorials

Servo Motor

pinagem-servo — Pinagem Servomotor
Fonte: Flickr

Os servomotores de aeromodelismo, como o MG90S e o MG996R, possuem uma tensão de alimentação e operação entre 4,8 V e 6 V, assim como três pinos de conexão, sendo eles VCC (fio vermelho), GND (fio marrom) e PPM (fio laranja), como na imagem ao lado. Com ele é possível controlar a posição do eixo através dos comandos enviados pelo microcontrolador.

Vale lembrar que os servomotores trabalham com um sinal PPM (Pulse-Position Modulation), de rádio controle, porém podemos controlá-los utilizando placas da plataforma Arduino, juntamente com a biblioteca "Servo" da Arduino IDE, que envia um sinal PPM através dos pinos digitais da placa.

Para este tutorial usamos a Garra Robótica Ant V2, portanto, antes de mais nada, monte a estrutura da garra seguindo os passos de seu manual de montagem.

Projeto Identificando Cores

Nesse primeiro projeto vamos usar o sensor TCS230 para identificar cores.

Circuito

Monte o circuito conforme a figura abaixo. Note que utilizamos um LED RGB, que irá acender a cor corresponde ao objeto colocado na frente do sensor de cores.

Código

Com o circuito pronto, copie e carregue o código abaixo para sua BlackBoard.

/*******************************************************************************
* Sensor Cor TCS230 : Identificando Cores (v1.0)
*
* O LED RGB ira mudar de cor de acordo com a cor do objeto lido pelo sensor.
*
* Copyright 2020 RoboCore.
* Escrito por Matheus Cassioli (23/07/2019).
* Atualizado por Giovanni de Castro (20/01/2020).
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version (<https://www.gnu.org/licenses/>).
*******************************************************************************/

const int PINO_SENSOR_S0 = 8; // Pino 8 da BlackBoard conectado ao pino S0 do TCS230
const int PINO_SENSOR_S1 = 9; // Pino 9 da BlackBoard conectado ao pino S1 do TCS230
const int PINO_SENSOR_S2 = 11; // Pino 12 da BlackBoard conectado ao pino S2 do TCS230
const int PINO_SENSOR_S3 = 12; // Pino 11 da BlackBoard conectado ao pino S3 do TCS230
const int PINO_SENSOR_OUT = 10; // Pino 10 da BlackBoard conectado ao pino OUT do TCS230

const int PINO_LED_VERMELHO = 2; // Pino correspondente a cor vermelha
const int PINO_LED_VERDE = 3; // Pino correspondente a cor verde
const int PINO_LED_AZUL = 4; // Pino correspondente a cor azul

// Variaveis que armazenam o valor das cores
int vermelho = 0;
int verde = 0;
int azul = 0;

void setup(){
  
  pinMode(PINO_SENSOR_S0, OUTPUT); // Pino S0 configurado como saida
  pinMode(PINO_SENSOR_S1, OUTPUT); // Pino S1 configurado como saida
  pinMode(PINO_SENSOR_S2, OUTPUT); // Pino S2 configurado como saida
  pinMode(PINO_SENSOR_S3, OUTPUT); // Pino S3 configurado como saida
  pinMode(PINO_SENSOR_OUT, INPUT); // Pino OUT configurado como entrada

  pinMode(PINO_LED_VERMELHO, OUTPUT); // Pino Vermelho RGB configurado como saida
  pinMode(PINO_LED_VERDE, OUTPUT); // Pino Verde RGB configurado como saida
  pinMode(PINO_LED_AZUL, OUTPUT); // Pino Azul RGB configurado como saida

  digitalWrite(PINO_SENSOR_S0,HIGH); // Inicia o codigo com o pino S0 em nivel alto
  digitalWrite(PINO_SENSOR_S1,LOW); // Inicia o codigo com o pino S1 em nivel baixo

}

void loop(){
  leitura_cores(); // Chama a rotina que le as cores

  // Verifica se a cor vermelha foi detectada
  if (vermelho < azul && vermelho < verde){
    digitalWrite(PINO_LED_VERMELHO, HIGH); // Vermelho em nivel alto
    digitalWrite(PINO_LED_VERDE, LOW); // Verde em nivel baixo
    digitalWrite(PINO_LED_AZUL, LOW); // Azul em nivel baixo
  }
  
  if (azul < vermelho && azul < verde) { // Verifica se a cor azul foi detectada
    digitalWrite(PINO_LED_VERMELHO, LOW); // Vermelho em nivel baixo
    digitalWrite(PINO_LED_VERDE, LOW); // Verde em nivel baixo
    digitalWrite(PINO_LED_AZUL, HIGH); // Azul em nivel alto
  }
  
  if (verde < vermelho && verde < azul) { // Verifica se a cor verde foi detectada
    digitalWrite(PINO_LED_VERMELHO, LOW); // Vermelho em nivel baixo
    digitalWrite(PINO_LED_VERDE, HIGH); // Verde em nivel alto
    digitalWrite(PINO_LED_AZUL, LOW); // Azul em nivel baixo
  }

  delay(100); // Aguarda 100 milissegundos

}

// Rotina que le o valor das cores
void leitura_cores(){
  
  digitalWrite(PINO_SENSOR_S2, LOW); // Pino S2 em nivel baixo
  digitalWrite(PINO_SENSOR_S3, LOW); // Pino S3 em nivel baixo

  if(digitalRead(PINO_SENSOR_OUT) == HIGH){ // Verifica o nivel logico no pino OUT do sensor
    vermelho = pulseIn(PINO_SENSOR_OUT, LOW); // Le duracao do pulso na saida
  } else {
    vermelho = pulseIn(PINO_SENSOR_OUT, HIGH); // Le duracao do pulso na saida
  }
    
  digitalWrite(PINO_SENSOR_S3, HIGH); // PINO S3 em nivel alto

  if(digitalRead(PINO_SENSOR_OUT) == HIGH){ // Verifica o nivel logico no pino OUT do sensor
    azul = pulseIn(PINO_SENSOR_OUT, LOW); // Le duracao do pulso na saida
  } else {
    azul = pulseIn(PINO_SENSOR_OUT, HIGH); // Le duracao do pulso na saida
  }
    
  digitalWrite(PINO_SENSOR_S2, HIGH); // Pino S2 em nivel alto

  if(digitalRead(PINO_SENSOR_OUT) == HIGH){ // Verifica o nivel logico no pino OUT do sensor
    verde = pulseIn(PINO_SENSOR_OUT, LOW); // Le duracao do pulso na saida
  } else {
    verde = pulseIn(PINO_SENSOR_OUT, HIGH); // Le duracao do pulso na saida
  }
  
}

Entendendo o Código

No início do código definimos os pinos para a conexão com o sensor de cor e os pinos que são conectados ao LED RGB. Posteriormente criamos as variáveis vermelho, verde e azul, que armazenam os valores das cores.

const int PINO_SENSOR_S0 = 8; // Pino 8 da BlackBoard conectado ao pino S0 do TCS230
const int PINO_SENSOR_S1 = 9; // Pino 9 da BlackBoard conectado ao pino S1 do TCS230
const int PINO_SENSOR_S2 = 11; // Pino 12 da BlackBoard conectado ao pino S2 do TCS230
const int PINO_SENSOR_S3 = 12; // Pino 11 da BlackBoard conectado ao pino S3 do TCS230
const int PINO_SENSOR_OUT = 10; // Pino 10 da BlackBoard conectado ao pino OUT do TCS230

const int PINO_LED_VERMELHO = 2; // Pino correspondente a cor vermelha
const int PINO_LED_VERDE = 3; // Pino correspondente a cor verde
const int PINO_LED_AZUL = 4; // Pino correspondente a cor azul

//Variaveis que armazenam o valor das cores
int vermelho = 0;
int verde = 0;
int azul = 0;

No setup do programa, definimos as entradas e saídas, e também deixamos o pino S0 em nível alto e o pino S1 em nível baixo, configurando como 20% a frequência de saída.

pinMode(PINO_SENSOR_S0, OUTPUT); // Pino S0 configurado como saida
pinMode(PINO_SENSOR_S1, OUTPUT); // Pino S1 configurado como saida
pinMode(PINO_SENSOR_S2, OUTPUT); // Pino S2 configurado como saida
pinMode(PINO_SENSOR_S3, OUTPUT); // Pino S3 configurado como saida
pinMode(PINO_SENSOR_OUT, INPUT); // Pino OUT configurado como entrada
  
pinMode(PINO_LED_VERMELHO, OUTPUT); // Pino Vermelho RGB configurado como saida
pinMode(PINO_LED_VERDE, OUTPUT); // Pino Verde RGB configurado como saida
pinMode(PINO_LED_AZUL, OUTPUT); // Pino Azul RGB configurado como saida

digitalWrite(PINO_SENSOR_S0,HIGH); // Inicia o codigo com o pino S0 em nivel alto
digitalWrite(PINO_SENSOR_S1,LOW); // Inicia o codigo com o pino S1 em nivel baixo

Pulando brevemente o looping do código, inserimos a função leitura_cores(), que contém a rotina de leitura das cores. Para realizar essa leitura de cores, primeiramente definimos os pinos S2 e S3 em nível lógico baixo, para ativar no sensor o filtro de cor vermelha, e então verificamos através da lógica if(digitalRead(PINO_SENSOR_OUT) == HIGH) se o nível lógico do pino OUT do sensor está alto. Caso essa condição seja verdadeira, atribuímos à variável vermelho a duração do pulso do pino de saída do sensor em nível baixo através do comando pulseIn(PINO_SENSOR_OUT, LOW). Caso contrário, utilizamos o comando pulseIn(PINO_SENSOR_OUT, HIGH) para atribuir à variável vermelho a duração do pulso de saída do sensor em nível alto. Em seguida, ativamos o filtro de cor azul do sensor, mantendo o pino S2 em nível lógico baixo, e definindo o pino S3 em nível lógico alto. Após a ativação do filtro de cor azul, da mesma maneira da variável vermelho, verificamos o nível lógico da saída do sensor atribuímos a sua duração de pulso à variável azul. Por fim, o filtro de cor verde é ativado, passando o pino S2 para nível lógico alto também, para que possamos atribuir à variável verde a duração do pulso do pino de saída do sensor, da mesma forma que foi feita com as variáveis vermelho e azul.

void leitura_cores(){
  
  digitalWrite(PINO_SENSOR_S2, LOW); // Pino S2 em nivel baixo
  digitalWrite(PINO_SENSOR_S3, LOW); // Pino S3 em nivel baixo

  if(digitalRead(PINO_SENSOR_OUT) == HIGH){ // Verifica o nivel logico no pino OUT do sensor
    vermelho = pulseIn(PINO_SENSOR_OUT, LOW); // Le duracao do pulso na saida
  } else {
    vermelho = pulseIn(PINO_SENSOR_OUT, HIGH); // Le duracao do pulso na saida
  }
    
  digitalWrite(PINO_SENSOR_S3, HIGH); // PINO S3 em nivel alto

  if(digitalRead(PINO_SENSOR_OUT) == HIGH){ // Verifica o nivel logico no pino OUT do sensor
    azul = pulseIn(PINO_SENSOR_OUT, LOW); // Le duracao do pulso na saida
  } else {
    azul = pulseIn(PINO_SENSOR_OUT, HIGH); // Le duracao do pulso na saida
  }
    
  digitalWrite(PINO_SENSOR_S2, HIGH); // Pino S2 em nivel alto

  if(digitalRead(PINO_SENSOR_OUT) == HIGH){ // Verifica o nivel logico no pino OUT do sensor
    verde = pulseIn(PINO_SENSOR_OUT, LOW); // Le duracao do pulso na saida
  } else {
    verde = pulseIn(PINO_SENSOR_OUT, HIGH); // Le duracao do pulso na saida
  }
  
}

No looping do programa, primeiramente chamamos a função leitura_cores(), realizando assim a leitura das cores, para que possamos compará-las e atuar sobres elas. Em seguida, com as condições "if", verificamos qual foi a cor lida, através da comparação das variáveis vermelho, azul e verde. Ao identificar a cor vermelha, por exemplo, o TCS230 gera pulsos de baixa duração com o filtro de cor vermelha ativada, o que acaba gerando um valor inferior às demais cores. O mesmo ocorre com as cores verde e azul em seus respectivos filtros, portanto, podemos compará-las através da duração do pulso recebido. Através da condição if (vermelho < azul && vermelho < verde), verificamos se a variável vermelho é inferior às variáveis azul e verde. Então, caso essa condição seja verdadeira, sabemos que a cor lida pelo sensor é vermelha, e acionamos, portanto, o pino da cor vermelha do LED RGB, assim como mantemos os pinos das cores verde e azul do LED apagados.

leitura_cores(); // Chama a rotina que le as cores

// Verifica se a cor vermelha foi detectada
if (vermelho < azul && vermelho < verde){
  digitalWrite(PINO_LED_VERMELHO, HIGH); // Vermelho em nivel alto
  digitalWrite(PINO_LED_VERDE, LOW); // Verde em nivel baixo
  digitalWrite(PINO_LED_AZUL, LOW); // Azul em nivel baixo
}

Da mesma maneira que comparamos a variável vermelho, comparamos as variáveis azul e verde através das condições if (azul < vermelho && azul < verde) e if (verde < vermelho && verde < azul), respectivamente. Então acendemos e apagamos os respectivos pinos do LED para demonstrar qual foi a cor lida pelo sensor.

if (azul < vermelho && azul < verde) { // Verifica se a cor azul foi detectada
  digitalWrite(PINO_LED_VERMELHO, LOW); // Vermelho em nivel baixo
  digitalWrite(PINO_LED_VERDE, LOW); // Verde em nivel baixo
  digitalWrite(PINO_LED_AZUL, HIGH); // Azul em nivel alto
}
  
if (verde < vermelho && verde < azul) { // Verifica se a cor verde foi detectada
  digitalWrite(PINO_LED_VERMELHO, LOW); // Vermelho em nivel baixo
  digitalWrite(PINO_LED_VERDE, HIGH); // Verde em nivel alto
  digitalWrite(PINO_LED_AZUL, LOW); // Azul em nivel baixo
}

O Que Deve Acontecer

Como é possível ver abaixo, o LED RGB acenderá de acordo com a cor do objeto na frente do sensor, sendo ele, azul, verde ou vermelho.

Resultado Final

Projeto Agarrando por Cores

Agora que já aprendemos a identificar cores, que tal capturar com uma garra robótica um objeto quando determinada cor for identificada?

Circuito

Para esse projeto, monte o circuito a seguir, com a garra robótica já montada.

Código

O código para o controle da garra robótica é parecido com o código do primeiro projeto, porém adicionando alguns comandos para controle do servomotor.

/*******************************************************************************
* Sensor Cor TCS230 : Agarrando por Cores (v1.0)
*
* O servomotor sera acionado para fechar uma garra robotica quando uma
* determinada cor for detectada pelo sensor.
*
* Copyright 2020 RoboCore.
* Escrito por Matheus Cassioli (23/07/2019).
* Atualizado por Giovanni de Castro (20/01/2020).
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version (<https://www.gnu.org/licenses/>).
*******************************************************************************/

#include <Servo.h> // Biblioteca do Servo Motor

const int PINO_SENSOR_S0 = 8; // Pino 8 da BlackBoard conectado ao pino S0 do TCS230
const int PINO_SENSOR_S1 = 9; // Pino 9 da BlackBoard conectado ao pino S1 do TCS230
const int PINO_SENSOR_S2 = 11; // Pino 12 da BlackBoard conectado ao pino S2 do TCS230
const int PINO_SENSOR_S3 = 12; // Pino 11 da BlackBoard conectado ao pino S3 do TCS230
const int PINO_SENSOR_OUT = 10; // Pino 10 da BlackBoard conectado ao pino OUT do TCS230

const int PINO_LED_VERMELHO = 2; // Pino correspondente a cor vermelha
const int PINO_LED_VERDE = 3; // Pino correspondente a cor verde
const int PINO_LED_AZUL = 4; // Pino correspondente a cor azul

// Variaveis que armazenam o valor das cores
int vermelho = 0;
int verde = 0;
int azul = 0;

Servo servo_motor; // Cria um objeto para o controle do servo

void setup(){
  
  pinMode(PINO_SENSOR_S0, OUTPUT); // Pino S0 configurado como saida
  pinMode(PINO_SENSOR_S1, OUTPUT); // Pino S1 configurado como saida
  pinMode(PINO_SENSOR_S2, OUTPUT); // Pino S2 configurado como saida
  pinMode(PINO_SENSOR_S3, OUTPUT); // Pino S3 configurado como saida
  pinMode(PINO_SENSOR_OUT, INPUT); // Pino OUT configurado como entrada

  pinMode(PINO_LED_VERMELHO, OUTPUT); // Pino Vermelho RGB configurado como saida
  pinMode(PINO_LED_VERDE, OUTPUT); // Pino Verde RGB configurado como saida
  pinMode(PINO_LED_AZUL, OUTPUT); // Pino Azul RGB configurado como saida


  digitalWrite(PINO_SENSOR_S0, HIGH); // Pino S0 em nivel alto
  digitalWrite(PINO_SENSOR_S1, LOW); // Pino S1 em nivel baixo

  servo_motor.attach(6); // Informa qual pino será usado para o servo declarado anteriormente

}

void loop(){

  leitura_cores(); // Chama a rotina que le as cores

  servo_motor.write(90); // Informa ao servo que devera se posicionar a 90 graus

  // Verifica se a cor vermelha foi detectada
  if (vermelho < azul && vermelho < verde){
    digitalWrite(PINO_LED_VERMELHO, HIGH); // Vermelho em nivel alto
    digitalWrite(PINO_LED_VERDE, LOW); // Verde em nivel baixo
    digitalWrite(PINO_LED_AZUL, LOW); // Azul em nivel baixo
  }
  
  if (azul < vermelho && azul < verde) { // Verifica se a cor azul foi detectada
    digitalWrite(PINO_LED_VERMELHO, LOW); // Vermelho em nivel baixo
    digitalWrite(PINO_LED_VERDE, LOW); // Verde em nivel baixo
    digitalWrite(PINO_LED_AZUL, HIGH); // Azul em nivel alto
    servo_motor.write(10); // Informa ao servo que devera se posicionar a 10 graus
  }
  
  if (verde < vermelho && verde < azul) { // Verifica se a cor verde foi detectada
    digitalWrite(PINO_LED_VERMELHO, LOW);  // Vermelho em nivel baixo
    digitalWrite(PINO_LED_VERDE, HIGH); // Verde em nivel alto
    digitalWrite(PINO_LED_AZUL, LOW);  // Azul em nivel baixo
  }

  delay(300); // Aguarda 100 milissegundos

}

// Rotina que le o valor das cores
void leitura_cores(){
  
  digitalWrite(PINO_SENSOR_S2, LOW); // Pino S2 em nivel baixo
  digitalWrite(PINO_SENSOR_S3, LOW); // Pino S3 em nivel baixo

  if(digitalRead(PINO_SENSOR_OUT) == HIGH){ // Verifica o nivel logico no pino OUT do sensor
    vermelho = pulseIn(PINO_SENSOR_OUT, LOW); // Le duracao do pulso na saida do sensor
  } else {
    vermelho = pulseIn(PINO_SENSOR_OUT, HIGH); // Le duracao do pulso na saida do sensor
  }
    
  digitalWrite(PINO_SENSOR_S3, HIGH); // PINO S3 em nivel alto

  if(digitalRead(PINO_SENSOR_OUT) == HIGH){ // Verifica o nivel logico no pino OUT do sensor
    azul = pulseIn(PINO_SENSOR_OUT, LOW); // Le duracao do pulso na saida do sensor
  } else {
    azul = pulseIn(PINO_SENSOR_OUT, HIGH); // Le duracao do pulso na saida do sensor
  }
    
  digitalWrite(PINO_SENSOR_S2, HIGH); // Pino S2 em nivel alto

  if(digitalRead(PINO_SENSOR_OUT) == HIGH){ // Verifica o nivel logico no pino OUT do sensor
    verde = pulseIn(PINO_SENSOR_OUT, LOW); // Le duracao do pulso na saida do sensor
  } else {
    verde = pulseIn(PINO_SENSOR_OUT, HIGH); // Le duracao do pulso na saida do sensor
  }

}

Entendendo o Código

No início do código, adicionamos a biblioteca "Servo" da Arduino IDE, e criamos o objeto servo_motor, que é atribuído ao pino 6 na configuração do código através do comando servo_motor.attach(6).

#include <Servo.h> // Biblioteca do Servo Motor

Servo servo_motor; // Cria um objeto para o controle do servo

void setup()
  servo_motor.attach(6); // Informa qual pino será usado para o servo declarado anteriormente
}

Durante a execução de leitura de cores do sensor, e juntamente com o acender do pino azul do LED RGB, movemos o eixo do servo para o ângulo definido para o seu fechamento (10 graus). Entretanto, caso a cor lida não seja azul, o servomotor é mantido na posição de 90 graus.

servo_motor.write(90); // Informa ao servo que devera se posicionar a 90 graus

if (azul < vermelho && azul < verde) { // Verifica se a cor azul foi detectada
  servo_motor.write(10); // Informa ao servo que devera se posicionar a 10 graus
}

O Que Deve Acontecer

Ao identificar a cor azul, a garra se fecha no intuito de capturar o objeto à sua frente, e caso contrário, a garra irá se manter aberta, como se estivesse à espera de uma nova leitura, como no GIF abaixo.

Resultado Final