Podemos observar no intervalo do espectro eletromagnético a luz visível, que cada frequência equivale a sessão de uma cor.O Módulo Sensor de Cor RGB TCS230 tem em sua arquitetura interna um circuito capaz de converter luz no formato de frequência. Neste tutorial vamos aprender a identificar cores com Arduino e o Módulo Sensor de Cor RGB TCS230.
Cada cor com sua frequência correspondente como podemos observar na ilustração abaixo:
Montando o projeto
Para o desenvolvimento desse projeto será necessária uma placa de desenvolvimento Arduino Uno, onde ela será responsável por receber os sinais do Módulo Sensor de Cor RGB TCS230 e controlar as portas do microcontrolador para deslocamento do micro servo.
A cada cor detectada o Micro Servo 9g SG90 TowerPro será comandado por um sinal PWM para deslocamento em ângulo correspondente a cor no painel (0 a 180 Graus).
Componentes Utilizados:
– Módulo Sensor de Cor RGB TCS230
– Micro Servo 9g SG90 TowerPro
A montagem do protótipo pode ser observada pela figura abaixo:
Vamos ligar a alimentação VCC e o GND do sensor de cores e do servo motor aos respectivos na alimentação em 5v no Arduino.
O sensor de cores é composto pelos pinos VCC, GND, S0, S1,S2,S3, OUT e OE.
– S2 e S3 são responsáveis pela seleção da cor a ser lida Red, Green ou Blue, S0 e S1
(No datasheet do sensor é possível consultar as combinações para cada leitura de cor individualmente).
– S0 e S1 configura a escala de frequência na saída 2%, 20% ou 100% (Para o Arduino é comumente utilizado 20 %, para isto, S0 deve estar em HIGH e S1 em LOW).
– OE Habilita a saída de frequência (Ativo em LOW).
– OUT Propriamente é a saída da frequência.
Abaixo temos na prática a montagem do projeto:
O vídeo de funcionamento deste projeto pode ser acessado em:
O sensor de cor tem essa proteção arredondada preta em volta para impedir interferência de luzes externas do ambiente no momento da captação das cores.
Desenvolvendo o código
Após montagem do hardware, prosseguimos para o código onde se controlará os sinais do sensor e na atuação do servo motor.
O Código como pode ser observado abaixo, será carregado para o microcontrolador ATMEGA do Arduino:
#include <Servo.h> // inclui a biblioteca servo.h
#define pinServo 7 // define o pino 7 como o de comando do servo motor
#define S0 8 // Atribui ao pino 8 o nome de SO, referente ao pino SO do sensor de cor
#define S1 9 // Atribui ao pino 9 o nome de S1, referente ao pino S1 do sensor de cor
#define S2 12 // Atribui ao pino 12 o nome de S2, referente ao pino S2 do sensor de cor
#define S3 11 // Atribui ao pino 11 o nome de S3, referente ao pino S3 do sensor de cor
#define OutSensor 10 // Atribui ao pino 10 o nome de OutSensor, referente ao pino OUT do sensor de cor
int red = 0; // declara uma variavel int de nome red_frequency
int green = 0; // declara uma variavel int de nome green_frequency
int blue = 0;// declara uma variavel int de nome blue_frequency
Servo servo; // declara uma variavel de nome servo na biblioteca Servo.h
void setup(){
pinMode(S0, OUTPUT); // define o pino denominado SO como saída
pinMode(S1, OUTPUT); // define o pino denominado S1 como saída
pinMode(S2, OUTPUT); // define o pino denominado S2 como saída
pinMode(S3, OUTPUT); // define o pino denominado S3 como saída
pinMode(OutSensor, INPUT); // define o pino denominado OutSensor como saída
Serial.begin(9600); // Inicia a comunicação serial
digitalWrite(S0, HIGH); // configura a escala de frequência do sensor para 20%
digitalWrite(S1, LOW); // configura a escala de frequência do sensor para 20%
servo.attach(pinServo); // inicia a comunicação com o servo motor
}
void loop(){
// leitura da cor vermelha
digitalWrite(S2,LOW); // configuração para os Fotodiodos red serem lidos
digitalWrite(S3,LOW); // configuração para os Fotodiodos red serem lidos
red = pulseIn (OutSensor, LOW); // armazena na variável red a frequência lida em OutSensor
Serial.print ("R= "); // escreve a letra R no monitor serial
Serial.print (red); // apresenta os valores armazenados na variável red no monitor serial
Serial.print (" "); // espaço de texto no monitor serial
// leitura da cor verde
digitalWrite(S2,HIGH); // configuração para os Fotodiodos green serem lidos
digitalWrite(S3,HIGH); // configuração para os Fotodiodos green serem lidos
green = pulseIn (OutSensor, LOW); // armazena na variável green a frequência lida em OutSensor
Serial.print ("G= "); // escreve a letra G no monitor serial
Serial.print (green); // apresenta os valores armazenados na variável green no monitor serial
Serial.print (" "); // espaço de texto no monitor serial
// leitura da cor azul
digitalWrite(S2,LOW); // configuração para os Fotodiodos blue serem lidos
digitalWrite(S3,HIGH); // configuração para os Fotodiodos blue serem lidos
blue = pulseIn (OutSensor, LOW); // armazena na variável blue a frequência lida em OutSensor
Serial.print ("B= "); // escreve a letra B no monitor serial
Serial.print (blue); // apresenta os valores armazenados na variável blue no monitor serial
Serial.print (" "); // espaço de texto no monitor serial
// condiçoes para detecção das cores e atuação do servo motor
if (47 < red && red < 70 && 140 < green && green < 180 && 110 < blue && blue < 130){ // se os valores de RGB estiverem dentro dos parâmetros determinados, executa o codigo abaixo
Serial.println("| Vermelho");
servo.write(179);}
else if (140 < red && red < 160 && 85 < green < green < 115 && 45< blue && blue < 65){ // se os valores de RGB estiverem dentro dos parâmetros determinados, executa o codigo abaixo
Serial.println("| Azul");
servo.write(0);}
else if (150 < red && red < 175 && 130< green && green < 155 && 120< blue && blue < 140){ // se os valores de RGB estiverem dentro dos parâmetros determinados, executa o codigo abaixo
Serial.println("| Verde");
servo.write(90);}
else if (30<red&&red<55 && 110 < green && green < 135 && 105 < blue && blue < 125){ // se os valores de RGB estiverem dentro dos parâmetros determinados, executa o codigo abaixo
Serial.println("| Laranja");
servo.write(50);}
else if (25 < red && red < 45 && 35 < green && green < 55 && 55 < blue && blue < 76){ // se os valores de RGB estiverem dentro dos parâmetros determinados, executa o codigo abaixo
Serial.println("| Amarelo");
servo.write(150);}
else if (65 < red && red < 90 && 100 < green && green < 120 && 50 < blue && blue < 77){ // se os valores de RGB estiverem dentro dos parâmetros determinados, executa o codigo abaixo
Serial.println("| Roxo");
servo.write(115);}
else if (115 < red && red < 135 && 155 < green && green < 170 && 110 < blue && blue < 140){ // se os valores de RGB estiverem dentro dos parâmetros determinados, executa o codigo abaixo
Serial.println("| Marron");
servo.write(32);}
else if (80 < red && red < 95 && 55 < green && green < 70 && 35 < blue && blue < 50){ // se os valores de RGB estiverem dentro dos parâmetros determinados, executa o codigo abaixo
Serial.println("| Azul Claro");
servo.write(65);}
else if (74 < red && red < 90 && 45 < green && green < 75 && 60 < blue && blue < 90){ // se os valores de RGB estiverem dentro dos parâmetros determinados, executa o codigo abaixo Serial.println("| Verde Claro"); servo.write(130);} else if (red > 240 && green > 270 && blue > 200){ // se os valores de RGB estiverem dentro dos parâmetros determinados, executa o codigo abaixo
Serial.println("| Preto");}
else if (red < 50 && green < 50 && blue < 50){ // se os valores de RGB estiverem dentro dos parâmetros determinados, executa o codigo abaixo
Serial.println("| Branco");}
Serial.println(); // quebra um linha no texto do serial monitor
delay(300); // atraso de 300 milisegundos
}
}
Você pode consultar, baixar, modificar e compartilhar o código deste tutorial em nosso repositório do GitHub! E lá você encontra todos os códigos já publicados aqui no blog! Vamos compartilhar conhecimento!
Mergulhando no projeto
Software
Iniciamos o código nomeando cada porta IO do Arduino com o seu respectivo nome dos pinos do sensor (S0,S1,S2,S3,OUT) e incluindo a biblioteca <servo.h> para controle do servo.
Função Setup
Na função setup definiremos as portas onde conectados o os pinos do sensor como saídas digitais pinMode (S0, OUTPUT), definir também os sinais que serão recebidos do sensor como pinMode (OUT, INPUT).
Para este projeto trabalhamos com a frequência do sensor em 20%, valor comumente utilizado quando em projetos com Arduino, para isto, deixamos a porta S0 em nível Alto e S1 em baixo.
Inicia-se a comunicação Serial.begin(9600) e do servo motor Servo.attach(pinServo).
Função Loop
A Função loop inicia com a leitura do valor de cada frequência das cores enviadas pelo sensor, e armazena esses dados nas variáveis Red, Green e Blue.
Como pode se observar no código, cada leitura de cor inicia com sua seleção individual em S2 e S3 para habilitar a sua leitura.
Logo após esses valores são apresentados no monitor serial na IDE do Arduino, como podemos observar abaixo R, G e B:
A seguir, inicia uma série de comparações para determinação do reconhecimento de cada cor:
Exemplo:
if (47<red&&red<70 && 140<green&&green<180 && 110<blue&&blue<130)
Se os valores de RGB estiverem dentro dos parâmetros determinados, executa o código abaixo:
Serial.println(“| Vermelho”); servo.write(179);
É apresentado o nome da respectiva cor reconhecida no monitor serial e um comando é enviado para o servo motor, fazendo assim o deslocamento do ponteiro no painel.
Esta estrutura se repete para reconhecimento de 11 cores diferentes, a cada cor reconhecida seu nome é apresentado no monitor serial e o ângulo correspondente é enviado.
Novas cores podem ser adicionadas, basta inclui-la de acordo com sua faixa de frequência correspondente em cada cor Red, Green e Blue.
Obs: Estas faixas de frequências das cores R,G e B podem ser recalibradas, os valores encontrados neste projeto foram determinados utilizando Sensor de cor TCS230 envolvido com uma proteção de preta contra luzes externas, sem esta proteção os valores variam conforme iluminação ambiente.
Ao terminar as comparações Serial.println() quebra uma linha de texto no monitor serial e delay(300) insere um atraso no programa de 300ms para melhor visualização dos valores das cores no monitor serial.
Hardware
Módulo Sensor de Cor RGB TCS230
O Sensor de cor TCS230 é composto por uma matriz de fotodiodos com 4 diferentes filtros. Um Fotodiodo é simplesmente um semicondutor que converte luz em corrente. O Sensor contém:
– 16 Fotodiodos com filtro vermelho – Sensitivo para o comprimento de onda vermelha
– 16 Fotodiodos com filtro verde – Sensitivo para o comprimento de onda verde
– 16 Fotodiodos com filtro azul – Sensitivo para o comprimento de onda azul
– 16 Fotodiodos sem filtro
Com um zoom sobre o chip TCS230, podemos visualizar os diferentes tipos de filtros, como mostra a figura abaixo:
Pinagem:
– VCC: 2.7 – 5.5V
– GND: GND
– S0: Configura a frequência de saída
– S1: Configura a frequência de saída
– S2: Seleciona a cor a ser lida R,G ou B
– S3: Seleciona a cor a ser lida R,G ou B
– OE: Habilita a saída
– OUT: Saída da frequência
O micro servo é controlado por PWM (pulse width modulation), de acordo com a largura do pulso recebido no seu pino de sinal, o micro servo tem um circuito interno que comanda o motor para o determinado ângulo correspondente ao pulso recebido.
Pinagem:
– VCC: 3 – 7.2V
– GND: GND
– IN: Entrada de Sinal (PWM)
Conclusão
Neste tutorial, podemos aprender um pouco sobre o funcionamento do módulo sensor de cores TCS230 e como controlar um motor servo. Este projeto pode ser implementado em esteiras de produtos na indústria como qualidade de frutas, verificação de cor de tampas, etiquetas mal colocadas, detecção de presença de graxa em rolamentos entre outros. Deixe abaixo suas dúvidas e sugestões, compartilhe conhecimento!
Deixe uma resposta