Arduino - Sensor de Cor TCS3200D/TCS230
Este tutorial mostra como conectar um sensor de reconhecimento de cores TCS3200D/TCS230 ao Arduino para medir e identificar valores RGB de vários objetos. Você vai dominar técnicas de calibração do sensor e a programação para detecção de cores.
Tópicos abordados:
- Ligação do módulo sensor TCS3200D/TCS230 à sua placa Arduino
- Calibração para o ambiente, para obter leituras precisas
- Programação do Arduino para extrair dados de cor RGB
Hardware Necessário
Or you can buy the following kits:
| 1 | × | DIYables STEM V3 Starter Kit (Arduino included) | |
| 1 | × | DIYables Sensor Kit (18 sensors/displays) |
Divulgação: Alguns dos links desta seção são links de afiliado da Amazon. Podemos receber uma comissão pelas compras feitas por meio desses links, sem custo adicional para você. Agradecemos o seu apoio.
Sobre o Sensor de Cor TCS3200D/TCS230
Construído em torno de uma matriz de fotodiodos 8x8, o TCS3200D/TCS230 identifica cores por meio de filtragem óptica especializada. A grade de 64 diodos inclui 16 fotodiodos com filtro vermelho, 16 unidades com filtro verde, 16 sensores com filtro azul e 16 fotodiodos sem filtro (clear). A detecção de cor acontece alternando entre os tipos de filtro e analisando a frequência da onda quadrada de saída, que representa a intensidade da luz.
Os LEDs brancos integrados na maioria dos módulos fornecem uma iluminação constante do alvo, garantindo medições estáveis em diferentes condições de ambiente e melhorando o desempenho com pouca luz.
Pinagem
Os pinos de conexão do módulo TCS3200D/TCS230 incluem:
- Pino VCC: Conexão da alimentação (+5V).
- Pino GND: Conexão do terra (0V).
- Pinos S0, S1: Entradas de controle da escala de frequência.
- Pinos S2, S3: Entradas de seleção do filtro de cor.
- Pino OUT: Saída de frequência (onda quadrada).
- Pino OE: Controle de habilitação da saída (ativo em LOW). A maioria dos módulos comerciais já liga este pino ao terra internamente, dispensando ligação externa. Se não estiver ligado, conecte-o ao GND manualmente.
Como Funciona
Para operar o sensor, é preciso configurar dois parâmetros principais: o canal de cor ativo e a intensidade do sinal. Pares de pinos de controle gerenciam essas configurações:
Escala da saída via S0 e S1:
- Ambos LOW: Modo de desligamento
- S0 LOW, S1 HIGH: Escala de frequência de 2%
- S0 HIGH, S1 LOW: Escala de frequência de 20%
- Ambos HIGH: Escala total de 100%
Seleção do filtro via S2 e S3:
- Ambos LOW: Canal vermelho ativo
- S2 LOW, S3 HIGH: Canal azul ativo
- S2 HIGH, S3 LOW: Canal clear (sem filtro)
- Ambos HIGH: Canal verde ativo
O pino OUT gera sinais de onda quadrada que vão de aproximadamente 2 Hz a 500 kHz. Frequências mais altas indicam maior intensidade de luz no canal selecionado. Medir a largura do pulso com pulseIn() fornece a relação inversa — pulsos mais curtos significam cores mais brilhantes. Após a calibração, a conversão gera valores RGB padrão.
Maximizando a Precisão da Leitura
- Mantenha uma distância de 1-3 cm entre o sensor e o alvo, mantendo o posicionamento constante.
- Ative os LEDs brancos da placa para ter uma iluminação uniforme.
- Reduza a interferência da luz ambiente protegendo o sensor, para melhorar a precisão.
Diagrama de Ligação
Esquema de conexão entre o sensor de cor TCS3200 e o Arduino:
| Sensor de Cor TCS3200 | Arduino |
|---|---|
| VCC | 5V |
| GND | GND |
| S0 | Pino 4 |
| S1 | Pino 3 |
| S2 | Pino 6 |
| S3 | Pino 5 |
| OUT | Pino 7 |
This image is created using Fritzing. Click to enlarge image
Código Arduino - Calibração do Sensor pela Largura do Pulso
A calibração para o ambiente é essencial porque a saída bruta do sensor varia com vários fatores: intensidade dos LEDs da placa, distância do alvo, propriedades de reflexão da superfície e iluminação ao redor. Considere essas variáveis como interferência na medição. A calibração quantifica essa interferência definindo os limites mínimo e máximo de cada canal de cor, permitindo uma conversão precisa para a escala RGB padrão de 0–255 na sua montagem específica.
/*
* Este código de Arduino foi desenvolvido por pt.newbiely.com
* Este código de Arduino é disponibilizado ao público sem nenhuma restrição.
* Para tutoriais completos e diagramas de ligação, visite:
* https://pt.newbiely.com/tutorials/arduino/arduino-tcs3200d-tcs230-color-sensor
*/
// Define color sensor pins
#define PIN_S0 4
#define PIN_S1 3
#define PIN_S2 6
#define PIN_S3 5
#define PIN_sensorOut 7
// Variables for Color Pulse Width Measurements
int redPW = 0;
int greenPW = 0;
int bluePW = 0;
// Variables to track min and max pulse widths for calibration
int redMin = 10000, redMax = 0;
int greenMin = 10000, greenMax = 0;
int blueMin = 10000, blueMax = 0;
void setup() {
// Set S0 - S3 as outputs
pinMode(PIN_S0, OUTPUT);
pinMode(PIN_S1, OUTPUT);
pinMode(PIN_S2, OUTPUT);
pinMode(PIN_S3, OUTPUT);
// Set Pulse Width scaling to 20%
digitalWrite(PIN_S0, HIGH);
digitalWrite(PIN_S1, LOW);
// Set Sensor output as input
pinMode(PIN_sensorOut, INPUT);
// Setup Serial Monitor
Serial.begin(9600);
Serial.println("=== TCS3200 Calibration ===");
Serial.println("Point the sensor at different objects (white, black, colors).");
Serial.println("Min and Max values are tracked automatically.");
Serial.println("When values look stable, note them down for the next code.");
Serial.println("------------------------------------------");
}
void loop() {
// Read Red Pulse Width
redPW = getRedPW();
// Delay to stabilize sensor
delay(200);
// Read Green Pulse Width
greenPW = getGreenPW();
// Delay to stabilize sensor
delay(200);
// Read Blue Pulse Width
bluePW = getBluePW();
// Delay to stabilize sensor
delay(200);
// Update min and max values
if (redPW < redMin) redMin = redPW;
if (redPW > redMax) redMax = redPW;
if (greenPW < greenMin) greenMin = greenPW;
if (greenPW > greenMax) greenMax = greenPW;
if (bluePW < blueMin) blueMin = bluePW;
if (bluePW > blueMax) blueMax = bluePW;
// Print the pulse width values with min/max
Serial.print("Red PW = ");
Serial.print(redPW);
Serial.print(" - Green PW = ");
Serial.print(greenPW);
Serial.print(" - Blue PW = ");
Serial.println(bluePW);
Serial.print(" Min -> R:");
Serial.print(redMin);
Serial.print(" G:");
Serial.print(greenMin);
Serial.print(" B:");
Serial.println(blueMin);
Serial.print(" Max -> R:");
Serial.print(redMax);
Serial.print(" G:");
Serial.print(greenMax);
Serial.print(" B:");
Serial.println(blueMax);
Serial.println("------------------------------------------");
delay(1000);
}
// Function to read Red Pulse Widths
int getRedPW() {
// Set sensor to read Red only
digitalWrite(PIN_S2, LOW);
digitalWrite(PIN_S3, LOW);
// Read the Pulse Width
int PW = pulseIn(PIN_sensorOut, LOW);
// Return the value
return PW;
}
// Function to read Green Pulse Widths
int getGreenPW() {
// Set sensor to read Green only
digitalWrite(PIN_S2, HIGH);
digitalWrite(PIN_S3, HIGH);
// Read the Pulse Width
int PW = pulseIn(PIN_sensorOut, LOW);
// Return the value
return PW;
}
// Function to read Blue Pulse Widths
int getBluePW() {
// Set sensor to read Blue only
digitalWrite(PIN_S2, LOW);
digitalWrite(PIN_S3, HIGH);
// Read the Pulse Width
int PW = pulseIn(PIN_sensorOut, LOW);
// Return the value
return PW;
}
Passos Rápidos
- Abra o código de calibração no Arduino IDE
- Faça o upload para a sua placa Arduino usando o botão Upload
- Abra o Serial Monitor para ver as leituras em tempo real com o acompanhamento de Min/Max
- Passe o sensor por vários objetos: superfícies brancas (papel), itens pretos, além de objetos de cores variadas
- Observe os valores Min/Max sendo atualizados automaticamente à medida que os extremos são registrados
- Quando os números se estabilizarem (normalmente em 10-20 segundos), anote as seis constantes de calibração
8
Serial.println("Hello World!");
Message (Enter to send message to 'Arduino Uno' on 'COM15')
New Line
9600 baud
=== TCS3200 Calibration ===
Point the sensor at different objects (white, black, colors).
Min and Max values are tracked automatically.
When values look stable, note them down for the next code.
------------------------------------------
Red PW = 42 - Green PW = 55 - Blue PW = 60
Min -> R:42 G:55 B:60
Max -> R:42 G:55 B:60
------------------------------------------
Red PW = 210 - Green PW = 185 - Blue PW = 172
Min -> R:42 G:55 B:60
Max -> R:210 G:185 B:172
------------------------------------------
Red PW = 44 - Green PW = 57 - Blue PW = 61
Min -> R:42 G:55 B:60
Max -> R:210 G:185 B:172
------------------------------------------
Por exemplo, a partir da saída acima, seus valores de calibração seriam:
- RedMin = 42, redMax = 210
- GreenMin = 55, greenMax = 185
- BlueMin = 60, blueMax = 172
Código Arduino - Lendo os Valores de Cor RGB
/*
* Este código de Arduino foi desenvolvido por pt.newbiely.com
* Este código de Arduino é disponibilizado ao público sem nenhuma restrição.
* Para tutoriais completos e diagramas de ligação, visite:
* https://pt.newbiely.com/tutorials/arduino/arduino-tcs3200d-tcs230-color-sensor
*/
// Define color sensor pins
#define PIN_S0 4
#define PIN_S1 3
#define PIN_S2 6
#define PIN_S3 5
#define PIN_sensorOut 7
// Calibration Values
// Replace these values with your actual calibration data from the previous step
int redMin = 0; // Red minimum pulse width
int redMax = 0; // Red maximum pulse width
int greenMin = 0; // Green minimum pulse width
int greenMax = 0; // Green maximum pulse width
int blueMin = 0; // Blue minimum pulse width
int blueMax = 0; // Blue maximum pulse width
// Variables for Color Pulse Width Measurements
int redPW = 0;
int greenPW = 0;
int bluePW = 0;
// Variables for final Color values
int redValue;
int greenValue;
int blueValue;
void setup() {
// Set S0 - S3 as outputs
pinMode(PIN_S0, OUTPUT);
pinMode(PIN_S1, OUTPUT);
pinMode(PIN_S2, OUTPUT);
pinMode(PIN_S3, OUTPUT);
// Set Pulse Width scaling to 20%
digitalWrite(PIN_S0, HIGH);
digitalWrite(PIN_S1, LOW);
// Set Sensor output as input
pinMode(PIN_sensorOut, INPUT);
// Setup Serial Monitor
Serial.begin(9600);
}
void loop() {
// Read Red value
redPW = getRedPW();
// Map to value from 0-255
redValue = map(redPW, redMin, redMax, 255, 0);
// Delay to stabilize sensor
delay(200);
// Read Green value
greenPW = getGreenPW();
// Map to value from 0-255
greenValue = map(greenPW, greenMin, greenMax, 255, 0);
// Delay to stabilize sensor
delay(200);
// Read Blue value
bluePW = getBluePW();
// Map to value from 0-255
blueValue = map(bluePW, blueMin, blueMax, 255, 0);
// Delay to stabilize sensor
delay(200);
// Print output to Serial Monitor
Serial.print("Red = ");
Serial.print(redValue);
Serial.print(" - Green = ");
Serial.print(greenValue);
Serial.print(" - Blue = ");
Serial.println(blueValue);
}
// Function to read Red Pulse Widths
int getRedPW() {
// Set sensor to read Red only
digitalWrite(PIN_S2, LOW);
digitalWrite(PIN_S3, LOW);
// Read the Pulse Width
int PW = pulseIn(PIN_sensorOut, LOW);
// Return the value
return PW;
}
// Function to read Green Pulse Widths
int getGreenPW() {
// Set sensor to read Green only
digitalWrite(PIN_S2, HIGH);
digitalWrite(PIN_S3, HIGH);
// Read the Pulse Width
int PW = pulseIn(PIN_sensorOut, LOW);
// Return the value
return PW;
}
// Function to read Blue Pulse Widths
int getBluePW() {
// Set sensor to read Blue only
digitalWrite(PIN_S2, LOW);
digitalWrite(PIN_S3, HIGH);
// Read the Pulse Width
int PW = pulseIn(PIN_sensorOut, LOW);
// Return the value
return PW;
}
Passos Rápidos
- Localize as declarações das variáveis de calibração perto do início do código:
int redMin = 0; // Red minimum pulse width
int redMax = 0; // Red maximum pulse width
int greenMin = 0; // Green minimum pulse width
int greenMax = 0; // Green maximum pulse width
int blueMin = 0; // Blue minimum pulse width
int blueMax = 0; // Blue maximum pulse width
- Atualize TODOS os seis valores zero usando os dados de calibração do exercício anterior. Exemplo de alteração (usando os resultados de calibração redMin = 42, redMax = 210, greenMin = 55, greenMax = 185, blueMin = 60, blueMax = 172):
int redMin = 42;
int redMax = 210;
int greenMin = 55;
int greenMax = 185;
int blueMin = 60;
int blueMax = 172;
- Faça o upload do código modificado para o Arduino
- Posicione um alvo colorido na frente do sensor
- Acompanhe a saída RGB no Serial Monitor
8
Serial.println("Hello World!");
Message (Enter to send message to 'Arduino Uno' on 'COM15')
New Line
9600 baud
Red = 210 - Green = 35 - Blue = 20
Red = 25 - Green = 200 - Blue = 40
Red = 30 - Green = 45 - Blue = 215
Os valores RGB agora estão mapeados para a faixa padrão de 0-255. Larguras de pulso menores (mais luz) produzem valores RGB maiores, e larguras de pulso maiores (menos luz) produzem valores RGB menores.
Aplicações
Agora que você consegue ler valores RGB, pode criar projetos como:
- Separador de cores: Separe objetos por cor (vermelho, verde, azul)
- Jogo de combinar cores: Verifique se dois objetos têm a mesma cor
- Robô seguidor de linha: Siga linhas coloridas no chão
- Controle de qualidade: Detecte produtos com defeito pela cor
- Alarme ativado por cor: Acione um buzzer ou LED quando uma cor específica for detectada