Arduino Nano ESP32 - Sensor de Cor TCS3200D/TCS230
Neste tutorial, vamos explorar como conectar o sensor de cor TCS3200D/TCS230 ao Arduino Nano ESP32 para uma detecção de cores precisa e a medição de valores RGB.
O que você vai realizar:
- Conectar o sensor TCS3200D/TCS230 ao Arduino Nano ESP32
- Calibrar o sensor para medições de cor precisas
- Ler e exibir valores de cor RGB
Hardware Necessário
Or you can buy the following kits:
| 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 emprega uma matriz estruturada de 64 fotodiodos em uma configuração 8×8 para a detecção óptica de cores. A matriz é composta por 16 fotodiodos com filtros ópticos vermelhos, 16 com filtros verdes, 16 com filtros azuis e 16 sem filtros (transparentes). A detecção de cores funciona ativando grupos de filtros específicos e analisando a frequência da forma de onda de saída.
Os módulos de sensor TCS3200D padrão incorporam matrizes de LEDs brancos que fornecem iluminação consistente ao alvo da medição, entregando leituras estáveis em diferentes ambientes de iluminação e permitindo a operação em condições de pouca luz.
Pinagem
Terminais de conexão do módulo do sensor TCS3200D/TCS230:
- Pino VCC: Alimentação positiva (+5V).
- Pino GND: Referência de terra (0V).
- Pinos S0, S1: Pinos de configuração da escala de frequência.
- Pinos S2, S3: Pinos de ativação do filtro de cor.
- Pino OUT: Saída de onda quadrada codificada em frequência.
- Pino OE: Pino de ativação da saída (ativo quando LOW). Os módulos padrão ligam este pino ao GND internamente. Se estiver flutuando, conecte-o manualmente ao GND.
Como Funciona
O funcionamento do sensor depende de dois parâmetros configuráveis: qual filtro de cor ativar e qual faixa de frequência de saída usar. Dois pares de pinos de controle gerenciam essas configurações:
Configuração da escala de frequência (pinos S0 e S1):
- S0=LOW, S1=LOW: Sensor desligado
- S0=LOW, S1=HIGH: Escala de saída de 2%
- S0=HIGH, S1=LOW: Escala de saída de 20%
- S0=HIGH, S1=HIGH: Escala de saída de 100% (frequência total)
Ativação do filtro de cor (pinos S2 e S3):
- S2=LOW, S3=LOW: Matriz de fotodiodos vermelhos ativa
- S2=LOW, S3=HIGH: Matriz de fotodiodos azuis ativa
- S2=HIGH, S3=LOW: Matriz de fotodiodos transparentes ativa (sem filtro)
- S2=HIGH, S3=HIGH: Matriz de fotodiodos verdes ativa
O pino OUT gera frequências de onda quadrada dentro da faixa aproximada de 2 Hz a 500 kHz. Quanto maior a intensidade da luz, maior a frequência de saída. A função pulseIn() do Arduino mede a duração do pulso, que apresenta comportamento inverso: quanto mais brilhante a iluminação, menor a duração do pulso. Por meio da calibração, essas medições de pulso se transformam na já conhecida notação RGB de 0-255.
Maximizando a Precisão da Medição
- Estabeleça uma distância fixa entre o sensor e o objeto (ideal: 1-3 cm) com posicionamento angular estável.
- Ative a iluminação por LED branco integrada para obter resultados reproduzíveis.
- Proteja de fontes de luz externas oscilantes para obter maior precisão.
Diagrama de Ligação
Ligue o sensor de cor TCS3200 ao Arduino Nano ESP32 de acordo com esta configuração:
| Sensor de Cor TCS3200 | Arduino Nano ESP32 |
|---|---|
| VCC | 5V |
| GND | GND |
| S0 | D4 |
| S1 | D3 |
| S2 | D6 |
| S3 | D5 |
| OUT | D7 |
This image is created using Fritzing. Click to enlarge image
Código Arduino Nano ESP32 - Calibração do Sensor
A calibração neutraliza os fatores ambientais que afetam o desempenho do sensor. Variáveis como a intensidade do LED, a proximidade do objeto, as características da superfície e a iluminação ao redor impactam as medições brutas. Este fluxo de calibração determina as durações mínima e máxima de pulso para cada canal de cor, criando limites de referência que traduzem a saída bruta do sensor em valores RGB padronizados de 0–255, otimizados para as suas condições de uso.
/*
* Este código de Arduino Nano ESP32 foi desenvolvido por pt.newbiely.com
* Este código de Arduino Nano ESP32 é disponibilizado ao público sem nenhuma restrição.
* Para tutoriais completos e diagramas de ligação, visite:
* https://pt.newbiely.com/tutorials/arduino-nano-esp32/arduino-nano-esp32-tcs3200d-tcs230-color-sensor
*/
// Define color sensor pins
#define PIN_S0 D4 // The Arduino Nano ESP32 pin connected to the S0 of the color module
#define PIN_S1 D3 // The Arduino Nano ESP32 pin connected to the S1 of the color module
#define PIN_S2 D6 // The Arduino Nano ESP32 pin connected to the S2 of the color module
#define PIN_S3 D5 // The Arduino Nano ESP32 pin connected to the S3 of the color module
#define PIN_sensorOut D7 // The Arduino Nano 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
Para começar com o Arduino Nano ESP32, siga estes passos:
- Se você é novo no Arduino Nano ESP32, consulte o tutorial sobre como configurar o ambiente para o Arduino Nano ESP32 no Arduino IDE.
- Ligue os componentes de acordo com o diagrama de ligação.
- Conecte a placa Arduino Nano ESP32 ao seu computador usando um cabo USB.
- Abra o Arduino IDE no seu computador.
- Selecione a placa Arduino Nano ESP32 e a porta COM correspondente.
- Copie o código de calibração e cole-o no Arduino IDE.
- Clique no botão Upload para compilar e fazer upload do código.
- Abra o Serial Monitor para observar o progresso da calibração.
- Aponte o sensor para superfícies de cores diferentes: materiais brancos (papel), superfícies pretas e vários objetos coloridos.
- Acompanhe os parâmetros Mín/Máx conforme eles são atualizados em tempo real.
- Quando os valores se estabilizarem (geralmente em 10-20 segundos), anote todos os seis números de calibração.
8
Serial.println("Hello World!");
Message (Enter to send message to 'Arduino Nano ESP32' 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
------------------------------------------
Parâmetros de calibração extraídos da saída de exemplo:
- RedMin = 42, redMax = 210
- GreenMin = 55, greenMax = 185
- BlueMin = 60, blueMax = 172
Código Arduino Nano ESP32 - Leitura de Cor RGB
/*
* Este código de Arduino Nano ESP32 foi desenvolvido por pt.newbiely.com
* Este código de Arduino Nano ESP32 é disponibilizado ao público sem nenhuma restrição.
* Para tutoriais completos e diagramas de ligação, visite:
* https://pt.newbiely.com/tutorials/arduino-nano-esp32/arduino-nano-esp32-tcs3200d-tcs230-color-sensor
*/
// Define color sensor pins
#define PIN_S0 D4 // The Arduino Nano ESP32 pin connected to the S0 of the color module
#define PIN_S1 D3 // The Arduino Nano ESP32 pin connected to the S1 of the color module
#define PIN_S2 D6 // The Arduino Nano ESP32 pin connected to the S2 of the color module
#define PIN_S3 D5 // The Arduino Nano ESP32 pin connected to the S3 of the color module
#define PIN_sensorOut D7 // The Arduino Nano 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 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
- Insira os valores de calibração que você anotou no lugar dos zeros. Exemplo de substituição com 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 upload do código atualizado para o Arduino Nano ESP32.
- Coloque um alvo colorido na frente do sensor.
- Abra o Serial Monitor para ver as medições RGB.
8
Serial.println("Hello World!");
Message (Enter to send message to 'Arduino Nano ESP32' 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 de saída seguem a escala padrão de 0-255. Larguras de pulso menores (reflexões intensas) correspondem a números RGB maiores; larguras de pulso maiores (reflexões fracas) correspondem a valores menores.
Aplicações do Projeto
Com a detecção de cor RGB funcionando, você pode construir:
- Separador de cores automatizado: Classifique itens com base em propriedades cromáticas (categorização em vermelho/verde/azul)
- Ferramenta de comparação de cores: Verifique a consistência de cor entre várias amostras
- Navegação guiada por cores: Robôs que seguem caminhos coloridos
- Inspeção na fabricação: Identifique defeitos de produtos por meio do desvio de cor
- Controle ativado por cor: Acione comportamentos específicos quando determinadas cores aparecerem