Esteiras e correias transportadoras são utilizadas largamente na indústria e na automação de processos. A identificação e contagem de objetos que circulam por essas esteiras são aplicações de automação muito importantes na indústria atual. Para realizar essa tarefa vários sensores são utilizados e também diferentes tipos de circuitos microcontrolados e CLP’s podem ser programados para controlar e fazer a interface com o sensor.
Neste post vamos conhecer um tipo de sensor importante para identificação e contagem de objetos, o Sensor de Cor TCS230, e vamos desenvolver uma aplicação com Arduino na qual esse sensor vai ser empregado para contar objetos coloridos que são transportados por uma esteira rolante portátil.
A primeira seção do artigo apresenta o sensor TCS230, seu princípio de funcionamento e aplicações, bem como a esteira transportadora utilizada na prototipagem. Na segunda seção vamos aprender a utilizar o sensor em si. Vamos montar todo o hardware e circuito, desenvolver o firmware para embarcar no Arduino, testar e colocar para funcionar!
Esteiras e correias transportadoras são praticamente a espinha dorsal de uma linha de montagem. É em torno delas e dos objetos transportados por elas que os funcionários e robôs de uma linha de produção executam as suas tarefas. Recentemente alguns modelos de correias e esteiras transportadoras portáteis foram desenvolvidas para serem usadas em bancadas e em pequenos projetos de prototipagem eletrônica. Neste artigo vamos utilizar uma esteira transportadora portátil feita para ser usada com o Arduino. Por meio desse kit é possível prototipar e testar sistemas para controle de velocidade e direção da esteira e diversas processos automáticos de contagem e classificação.
A figura 1 mostra a esteira que utilizamos em nossa montagem:
Figura 1: Esteira Portátil com sensor de Cores
O objetivo dessas esteiras é transportar materiais por uma certa distância e possibilitar que os trabalhadores e mecanismos de automação possam operar e realizar outros trabalhos sobre esses objetos. Também são utilizadas para separação, contagem, identificação e classificação de objetos, o que é feito utilizando-se diversos tipos de sensores, dentre eles, sensores de cor como o TCS230.
O sensor de cor TCS230 baseia-se em uma matriz 8×8 de fotodiodos combinados com um conversor corrente-frequência. Portanto, são 64 fotodiodos que constituem a célula principal do sensor. Desses 64, 16 possuem filtros para a luz verde, 16 para a vermelha, 16 para a luz azul e 16 não possuem filtro algum. Sob esse conjunto de fotodiodos incide a luz refletida pelos objetos posicionados ao alcance do sensor. Os fotodiodos geram uma corrente de saída de acordo com a intensidade da luz refletida e também de acordo com seus filtros.
Figura 2: Esquema lógico do sensor TCS320. Fonte: Datasheet
Essa corrente de saída é convertida em uma onda quadrada de 50% de duty cycle, isto é, uma onda em que metade do período está em nível alto e outra metade em nível baixo. A frequência dessa onda quadrada é diretamente proporcional à intensidade da luz refletida percebida pelos conjuntos de fotodiodos.
Cada bloco de 16 fotodiodos pode ser selecionado pelos pinos S2 e S3. Os pinos S0 e S1 permitem regular a escala de frequência e também desligar a saída. Veja a tabela abaixo, também retirada do datasheet do sensor:
Tabela 1: Tabela de seleção de filtros e escala de frequência. Fonte: Datasheet
Por meio da matriz de fotodiodos e os seus respectivos filtros, nós podemos facilmente identificar as cores primárias do padrão RGB (red, green, blue) lendo a frequência de saída para cada filtro de cor diferente e obter uma aproximação do código RGB do objeto (um código RGB é um valor entre 0 e 255 associado a uma cor).
Mas para que alguém iria querer saber a cor dos objetos em uma esteira rolante ou em um protótipo? É uma pergunta que você pode estar se fazendo nesse exato momento. Para respondê-la, vamos te mostrar algumas aplicações corriqueiras de sensores de cor na indústria moderna. Veja!
Além dessas aplicações comuns na indústria, os sensores de cor nos permitem desenvolver robôs e dispositivos que possam fazer escolhas de acordo com informações sobre cores também. Por exemplo, uma garra robótica que só deve agarrar objetos da cor vermelha (ou outra para a qual ele esteja programado) ou um carro ou robô que precise identificar placas e outras sinalizações que possuem variações de cor.
Agora sim! Vamos pôr a mão na massa. Nessa aplicação nós vamos empregar o sensor TCS230 para identificar e contar objetos de cores diferentes. O Objetivo de nosso protótipo é:
“Identificar objetos por cor usando o sensor de Cor TCS230 e um arduino integrados em uma esteira portátil. O circuito deve mostrar no terminal serial quantos objetos de cada cor já passaram pela esteira. Além disso, vamos acender leds de cores diferentes para indicar que um objeto acabou de passar na esteira.”
Para fazermos essa aplicação, vamos utilizar a esteira portátil que apresentamos lá em cima. Vamos utilizar o Arduino UNO como placa de prototipagem.
Materiais necessários para o projeto com Sensor de Cor TCS230 e Arduino
Está tudo aí na mesa? Então vamos partir para a montagem e programação!
As ligações entre o Arduino e o sensor foram feitas da seguinte forma:
Tabela 2: Ligação de Hardware entre Arduino UNO e o sensor TCS230
Para cada led foi utilizado um resistor de 220 ohms para limitar as respectivas correntes. As demais ligações com o sensor foram feitas diretamente. A fonte de alimentação utilizada para o motor DC que aciona a esteira transportadora não está conectada ao Vcc do Arduino e do sensor para evitar ruídos e interferências.
Após montado o hardware, podemos nos preocupar com o firmware. Abaixo vamos entender cada parte do programa que faz a leitura das cores
Na figura 3 temos as variáveis globais de nosso programa. Definimos algumas variáveis para configurar os pinos digitais do arduino e algumas outras de controle. Os contadores, responsáveis por contar quantas vezes uma cor é identificada na esteira também foram declaradas.
const int s0 = 9; const int s1 = 10; const int s2 = 13; const int s3 = 12; const int out = 11; int RedLed = 2; int GreenLed = 4; int BlueLed = 7; int colorIsRed = 1; int colorIsBlue = 2; int colorIsGreen = 3; int colorIsWhite = 3; // Contador int CountR; int CountB; int CountG; int ultimaCor = 0; int NoColor = 0; // Variáveis que armazenam o valor das cores int red = 0; int green = 0; int blue = 0; // Variáveis usadas na calibração int mediaR; int mediaB; int mediaG;
Na figura 4, temos a função void Setup(). Aqui são feitas todas as inicializações do programa. As configurações feitas aqui são:
Note a função calibraSensor() é chamada antes de qualquer leitura. Os valores lidos pelo sensor são muito sensíveis às condições de iluminação local, de forma que qualquer mudança no ambiente que mude um pouco a iluminação faz com que os valores se alterem.
Dessa forma, é preciso calibrar as leituras para cada condição de iluminação ambiente antes de iniciar as leituras. Para mais detalhes sobre essa função de calibração, deixe seu comentário aqui no blog e faça o download dos códigos fonte do projeto.
void setup(){
CountR = CountG = CountB = 0;
// Configura as entradas e saidas
pinMode(s0, OUTPUT);
pinMode(S1, OUTPUT);
pinMode(s2, OUTPUT);
pinMode(s3, OUTPUT);
pinMode(out, INPUT);
pinMode(RedLed, OUTPUT);
pinMode(GreenLed, OUTPUT);
pinMode(BlueLed, OUTPUT);
// Seleciona a escala de frequencia para 20%
digitalWrite(s0, HIGH);
digitalWrite(s1, LOW);
// Inicializa a porta serial
Serial.begin(9600);
delay(500);
// Chama função para calibrar o sensor
calibraSensor();
}
Na figura 5 vemos a função void Loop(), que após a calibração será onde o programa permanecerá. Nessa função nós chamamos a rotina ReadColor() para ler o sensor e depois usamos a função IdentificaCor() para identificar qual cor corresponde aos valores lidos pelo sensor.
Dependendo de qual cor foi identificada, nós mostramos no terminal serial o nome da cor e número de vezes que ela foi identificada. Além disso, o led correspondente a cor identificada é acionado.
Caso nenhuma das cores azul, vermelha ou verde seja identificada, é mostrado no terminal serial “Cor Identificada: Nenhuma”. Para identificar outras cores é preciso fazer expandir a função de calibração para as outras cores e adicionar uma condição na void Loop() para identificar essa nova cor. Deixamos como desafio desse post a implementação de cores adicionais no programa que você pode fazer o download aqui.
void loop()
{
int CorIdentificada;
//chama funçao para ler o sensor
Readcolor();
//imprimi valores na tela
Serial.print(" Leitura do sensor por filtro: ");
Serial.println();
Serial.print(" Azul : ");
Serial.print(blue, DEC);
Serial.print(" Vermelho :");
Serial.print(red, DEC);
Serial.print(" Verde : ");
Serial.print(green, DEC);
Serial.println();
CorIdentificada = IdentificaCor();
//Verifica se a cor vermelha foi detectada
if (CorIdentificada == colorIsRed)
{
if(ultimaCor != colorIsRed)
CountR++;
Serial.print(" Cor Identificada Vermelho: ");
Serial.print(CountR,'DEC');
digitalWrite(RedLed, HIGH); //Acende o led vermelho
digitalWrite(GreenLed, LOW);
digitalWrite(BlueLed, LOW);
delay(25);
ultimaCor = colorIsRed;
}
//Verifica se a cor azul foi detectada
else if (CorIdentificada == colorIsBlue)
{
if(ultimaCor != colorIsBlue)
CountB++;
Serial.print(" Cor Identificada: Azul - Contador:");
Serial.print(CountB,'DEC');
digitalWrite(RedLed, LOW);
digitalWrite(GreenLed, LOW);
digitalWrite(BlueLed, HIGH); //Acende o led azul
delay(25);
ultimaCor = colorIsBlue;
}
//Verifica se a cor verde foi detectada
else if (CorIdentificada == colorIsGreen)
{
if(ultimaCor != colorIsGreen)
CountG++;
Serial.print(" Cor Identificada: Verde Contador: ");
Serial.print(CountG,'DEC');
digitalWrite(RedLed, LOW);
digitalWrite(GreenLed, HIGH); //Acende o led verde
digitalWrite(BlueLed, LOW);
delay(25);
ultimaCor = colorIsGreen;
}
else
{
ultimaCor = NoColor;
Serial.print(" Cor Identificada: Nenhuma ");
}
Serial.println();
Serial.println();
digitalWrite(RedLed, LOW);
digitalWrite(GreenLed, LOW);
digitalWrite(BlueLed, LOW);
//Aguarda 1500 milisegundos antes de fazer nova leitura
delay(10);
}
Como você viu na função void loop(), nós utilizamos duas funções especiais para ler o sensor e identificar a cor que está na esteira num dado momento. A primeira delas é a função ReadColor(), que você pode conferir na figura 6.
void Readcolor()
{
//le saida com filtro vermelho
digitalWrite(s2, LOW);
digitalWrite(s3, LOW);
delay(50);
red = pulseIn(out, digitalRead(out) == HIGH ? LOW : HIGH);
//Le saida com filtro azul
digitalWrite(s3, HIGH);
delay(50);
blue = pulseIn(out, digitalRead(out) == HIGH ? LOW : HIGH);
//le saida com filtro verde
digitalWrite(s2, HIGH);
delay(50);
green = pulseIn(out, digitalRead(out) == HIGH ? LOW : HIGH);
Serial.print(" Leitura do sensor por filtro: ");
Serial.println();
Serial.print(" Azul : ");
Serial.print(blue, DEC);
Serial.print(" Vermelho :");
Serial.print(red, DEC);
Serial.print(" Verde : ");
Serial.print(green, DEC);
Serial.println();
}
Essa função seta os sinais S2 e S3 do TCS230 de forma a selecionar cada um dos três filtros de cor e faz a leitura do sinal OUT para cada filtro selecionado. Essas leituras são armazenadas nas variáveis red, blue e green para serem comparadas com os valores de referência obtidos na função de calibração.
Por fim, temos a função IdentificaCor(), apresentada na figura 7. Essa função nada mais faz do que comparar os valores lidos pela função ReadColor() com os valores de referência obtidos na calibração. A função retorna um inteiro identificando qual a cor presente na esteira naquele exato momento.
int IdentificaCor()
{
//verifica se a cor e verde
if( (blue>(mediaBG-15) && blue<(mediaBG+15)) && (red>(mediaRG-15) && red<(mediaRG+15)) && (green>(mediaGG-15) && green<(mediaGG+15)))
return colorIsGreen;
//verifica se a cor e azul
else if((blue>(mediaBB-15) && blue<(mediaBB+15)) && (red>(mediaRB-15) && red<(mediaRB+15)) && (green >(mediaGB-15) && green<(mediaGB+15)) )
return colorIsBlue;
//Verifica se a cor e vermelha
else if((blue>(mediaBR-15) && blue<(mediaBR+15)) && (red>(mediaRR-15) && red<(mediaRR+15)) && (green >(mediaGR-15) && green<(mediaGR+15)) )
return colorIsRed;
}
Você também pode conferir o código completo e atualizado visitando o repositório desse post no GitHub da Eletrogate.
Agora que o hardware está montado e firmware que você baixou aqui está carregado no arduino, é hora de rodar o programa! Assim que você energizar o Arduino, abra o terminal serial pela própria IDE Arduino e você verá as mensagens da função de calibração, como mostrado na figura 8.
Trata-se de uma menu bem simplificado para que você possa calibrar o sensor para as cores vermelho, azul e verde dentro das condições de seu ambiente local. Para fazer a calibração siga os seguintes passos:
Figura 8: Função de calibração
Figura 9: Projeto rodando após calibração
Agora que você entendeu como tudo funciona e já até tem um código fonte como base, é hora de pôr a mão na massa e desenvolver as suas próprias funcionalidades novas, adicionar novas cores e expandir o uso do sensor TCS230. Boa sorte!
Esteira com sensor TCS230
Conheça a Metodologia Eletrogate e ofereça aulas de robótica em sua escola!
|
A Eletrogate é uma loja virtual de componentes eletrônicos do Brasil e possui diversos produtos relacionados à Arduino, Automação, Robótica e Eletrônica em geral.
Tenha a Metodologia Eletrogate dentro da sua Escola! Conheça nosso Programa de Robótica nas Escolas!
Rua Rio de Janeiro, 441 - Sala 1301
Centro - Belo Horizonte/MG
CEP 30160-041
*Não temos atendimento físico
Eletrogate Componentes Eletrônicos
CNPJ: 18.917.521/0001-73
