ESP32 - Sensor de Cor TCS3200D/TCS230
Este guia mostra como conectar um sensor de cor TCS3200D/TCS230 ao ESP32 para detectar e medir cores RGB com precisão. Aprenda a calibrar o sensor e a programar o ESP32 para ler os valores de cor de objetos.
O que você vai aprender:
- Conectar o sensor de cor TCS3200D/TCS230 ao ESP32
- Calibrar o sensor para compensar fatores do ambiente
- Escrever o código do ESP32 para medir e exibir valores RGB
Hardware Necessário
Or you can buy the following kits:
| 1 | × | DIYables ESP32 Starter Kit (ESP32 included) | |
| 1 | × | DIYables ESP32 S3 Starter Kit (ESP32 S3 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
O TCS3200D/TCS230 usa uma matriz de 64 fotodiodos organizada em uma configuração 8×8 para identificar cores. Essa matriz tem 16 fotodiodos com filtros ópticos vermelhos, 16 com filtros verdes, 16 com filtros azuis e 16 sem filtro (transparentes). O sensor funciona selecionando tipos específicos de filtro e convertendo a intensidade da luz detectada em uma saída de onda quadrada modulada em frequência.
A maioria dos módulos do sensor tem iluminação integrada com LED branco, que mantém as medições consistentes ao fornecer uma fonte de luz controlada, independente das condições do ambiente.
Pinagem
O módulo do sensor TCS3200D/TCS230 oferece estes pontos de conexão:
- Pino VCC: Conecte à alimentação de 3.3V ou 5V.
- Pino GND: Conecte ao terra (0V).
- Pinos S0, S1: Controles de escala da frequência de saída.
- Pinos S2, S3: Seletores do filtro de cor.
- Pino OUT: Sinal de saída em frequência de onda quadrada.
- Pino OE: Habilitação da saída (ativo em LOW). Normalmente já vem ligado ao GND nos módulos comerciais. Se estiver exposto, conecte ao GND.
Como Funciona
O funcionamento do sensor depende de dois parâmetros configuráveis: o filtro de cor ativo e a intensidade do sinal de saída. Dois pares de pinos de controle definem essas configurações:
Os pinos S0/S1 configuram a escala da frequência de saída:
- S0=LOW, S1=LOW: Sensor desligado
- S0=LOW, S1=HIGH: Saída a 2% da frequência base
- S0=HIGH, S1=LOW: Saída a 20% da frequência base
- S0=HIGH, S1=HIGH: Saída a 100% da frequência base
Os pinos S2/S3 selecionam o filtro de cor ativo:
- S2=LOW, S3=LOW: Filtro vermelho ativado
- S2=LOW, S3=HIGH: Filtro azul ativado
- S2=HIGH, S3=LOW: Sem filtro (transparente/sem filtragem)
- S2=HIGH, S3=HIGH: Filtro verde ativado
O pino OUT produz uma saída em frequência entre cerca de 2 Hz e 500 kHz. A magnitude da frequência está ligada à intensidade da luz: mais luz resulta em frequência mais alta. Usar pulseIn() para medir a duração do pulso dá o inverso: uma largura de pulso menor indica iluminação mais forte. Depois da calibração, essas medições são convertidas em valores RGB padrão de 0 a 255.
Otimizando a Estabilidade das Medições
- Posicione o sensor de 1 a 3 cm da superfície do alvo, sempre com a mesma orientação.
- Ative os LEDs brancos integrados para ter uma iluminação padronizada.
- Bloqueie fontes de luz externas para reduzir a variação nas medições.
Diagrama de Ligação
Esquema de conexão do ESP32 com o sensor de cor TCS3200:
| Sensor de Cor TCS3200 | ESP32 |
|---|---|
| VCC | 3.3V |
| GND | GND |
| S0 | GPIO 17 |
| S1 | GPIO 16 |
| S2 | GPIO 18 |
| S3 | GPIO 5 |
| OUT | GPIO 19 |
This image is created using Fritzing. Click to enlarge image
Se você não sabe como alimentar o ESP32 e outros componentes, veja as instruções no tutorial a seguir: Como alimentar o ESP32.
Código ESP32 - Calibração do Sensor pela Largura de Pulso
A calibração compensa as variáveis do ambiente que afetam as leituras brutas do sensor: variações no brilho do LED, distância do objeto, diferenças de refletividade da superfície e condições de luz ambiente. Esses fatores causam erros de medição que precisam ser quantificados. O processo de calibração registra as larguras de pulso mínima e máxima de cada canal de cor, criando os limites para um mapeamento RGB preciso de 0 a 255 no seu ambiente.
/*
* Este código de ESP32 foi desenvolvido por pt.newbiely.com
* Este código de ESP32 é disponibilizado ao público sem nenhuma restrição.
* Para tutoriais completos e diagramas de ligação, visite:
* https://pt.newbiely.com/tutorials/esp32/esp32-tcs3200d-tcs230-color-sensor
*/
// Define color sensor pins
#define PIN_S0 17 // The ESP32 pin connected to the S0 of the color module
#define PIN_S1 16 // The ESP32 pin connected to the S1 of the color module
#define PIN_S2 18 // The ESP32 pin connected to the S2 of the color module
#define PIN_S3 5 // The ESP32 pin connected to the S3 of the color module
#define PIN_sensorOut 19 // The ESP32 pin connected to the OUT of the color module
// 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
- Se esta é a primeira vez que você usa o ESP32, veja como configurar o ambiente para o ESP32 no Arduino IDE.
- Copie o código de calibração para o Arduino IDE
- Clique no botão Upload do Arduino IDE para fazer o upload do código para o ESP32
- Abra o Serial Monitor (defina o baud rate como 9600)
- Aponte o sensor para objetos de cores diferentes: papel branco, superfície preta e várias cores
- Acompanhe os valores Min/Max, que são atualizados automaticamente
- Depois que os valores se estabilizarem (10 a 20 segundos), anote os seis números de calibração
8
Serial.println("Hello World!");
Message (Enter to send message to 'ESP32 Dev Module' 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
------------------------------------------
Exemplo de resultados de calibração da saída:
- RedMin = 42, redMax = 210
- GreenMin = 55, greenMax = 185
- BlueMin = 60, blueMax = 172
Código ESP32 - Lendo os Valores de Cor RGB
/*
* Este código de ESP32 foi desenvolvido por pt.newbiely.com
* Este código de ESP32 é disponibilizado ao público sem nenhuma restrição.
* Para tutoriais completos e diagramas de ligação, visite:
* https://pt.newbiely.com/tutorials/esp32/esp32-tcs3200d-tcs230-color-sensor
*/
// Define color sensor pins
#define PIN_S0 17 // The ESP32 pin connected to the S0 of the color module
#define PIN_S1 16 // The ESP32 pin connected to the S1 of the color module
#define PIN_S2 18 // The ESP32 pin connected to the S2 of the color module
#define PIN_S3 5 // The ESP32 pin connected to the S3 of the color module
#define PIN_sensorOut 19 // The ESP32 pin connected to the OUT of the color module
// 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
- Encontre as constantes de calibração no 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
- Troque os seis zeros pelos seus valores reais de calibração. Por exemplo (usando 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;
- Copie o código acima e abra no Arduino IDE
- Clique no botão Upload do Arduino IDE para fazer o upload do código para o ESP32
- Coloque um objeto colorido na frente do sensor
- Veja o resultado no Serial Monitor
8
Serial.println("Hello World!");
Message (Enter to send message to 'ESP32 Dev Module' on 'COM15')
New Line
9600 baud
Red = 210 - Green = 35 - Blue = 20
Red = 25 - Green = 200 - Blue = 40
Red = 30 - Green = 45 - Blue = 215
Agora a saída mostra valores RGB padrão de 0 a 255. Larguras de pulso menores (iluminação mais forte) resultam em números RGB maiores; larguras de pulso maiores (iluminação mais fraca) produzem valores menores.
Ideias de Aplicação
Com a leitura de RGB funcionando, explore estas possibilidades de projeto:
- Separação automática de cores: Classifique itens por tonalidade (identificação de vermelho, verde e azul)
- Sistema de comparação de cores: Verifique se as cores de dois objetos combinam
- Seguidor de linha colorida: Construa robôs que seguem caminhos coloridos
- Verificação de qualidade na produção: Identifique peças com defeito pelo desvio de cor
- Resposta acionada por cor: Ative buzzers ou indicadores ao detectar cores específicas