ESP8266 - Sensor de Cor TCS3200D/TCS230
Este tutorial guia você no uso do ESP8266 com o sensor de cor TCS3200D/TCS230 para detecção de cor precisa e medição RGB.
Em detalhes, vamos aprender:
- Como conectar o sensor TCS3200D/TCS230 ao ESP8266
- Como calibrar o sensor para obter leituras precisas
- Como programar o ESP8266 para ler e exibir valores 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 sensor de cor TCS3200D/TCS230 utiliza uma grade de 64 fotodiodos dispostos em uma matriz 8×8 para detectar cores por meio de filtragem específica de comprimento de onda. Dentro desse arranjo, 16 fotodiodos incorporam filtros de comprimento de onda vermelho, 16 usam filtros de comprimento de onda verde, 16 empregam filtros de comprimento de onda azul e 16 operam sem filtragem (resposta clara). A medição de cor ocorre selecionando conjuntos de filtros específicos e avaliando a frequência do sinal de saída.
Os módulos TCS3200D comuns possuem arranjos de iluminação LED branca integrados, que fornecem iluminação consistente do alvo, garantindo estabilidade da medição independentemente das flutuações da luz externa e aumentando a sensibilidade em condições de pouca luz.
Pinagem
Configuração dos pinos do módulo sensor TCS3200D/TCS230:
- Pino VCC: Entrada da tensão de alimentação (+5V).
- Pino GND: Referência de terra (0V).
- Pinos S0, S1: Seletores de escala da frequência de saída.
- Pinos S2, S3: Seletores de filtro do canal de cor.
- Pino OUT: Saída de onda quadrada modulada em frequência.
- Pino OE: Entrada de habilitação da saída (habilita quando LOW). Os módulos padrão normalmente ligam isto internamente ao GND. Se não estiver conectado, ligue manualmente ao GND.
Como Funciona
O funcionamento do sensor depende de dois controles principais: qual grupo de filtros de fotodiodos ativar e qual faixa de frequência de saída gerar. Dois pares de pinos de controle gerenciam essas funções:
Controle de escala de frequência (pinos S0 e S1):
- S0=LOW, S1=LOW: Estado desligado
- S0=LOW, S1=HIGH: Fator de escala de 2%
- S0=HIGH, S1=LOW: Fator de escala de 20%
- S0=HIGH, S1=HIGH: Fator de escala de 100% (velocidade máxima)
Seleção do canal de cor (pinos S2 e S3):
- S2=LOW, S3=LOW: Fotodiodos vermelhos ativos
- S2=LOW, S3=HIGH: Fotodiodos azuis ativos
- S2=HIGH, S3=LOW: Fotodiodos claros ativos (sem filtragem)
- S2=HIGH, S3=HIGH: Fotodiodos verdes ativos
O pino OUT entrega frequências de onda quadrada que vão de aproximadamente 2 Hz a 500 kHz. Maior intensidade de luz produz saída de frequência maior. A função pulseIn() do ESP8266 mede a duração do pulso, que se correlaciona de forma inversa — iluminação mais forte produz durações mais curtas. As medições calibradas são traduzidas para o formato RGB convencional de 0-255.
Alcançando a Precisão Ideal
- Mantenha o sensor posicionado a 1-3 cm do alvo de medição, com alinhamento angular estável.
- Utilize a iluminação LED branca integrada para uma iluminação repetível.
- Proteja o sensor da luz ambiente variável para melhorar a consistência da medição.
Diagrama de Ligação
Conecte o sensor de cor TCS3200 ao ESP8266 da seguinte forma:
| Sensor de Cor TCS3200 | ESP8266 |
|---|---|
| VCC | 3V3 |
| GND | GND |
| S0 | D6 (GPIO12) |
| S1 | D7 (GPIO13) |
| S2 | D2 (GPIO4) |
| S3 | D5 (GPIO14) |
| OUT | D1 (GPIO5) |
This image is created using Fritzing. Click to enlarge image
Para mais informações, veja Pinagem do ESP8266 e como alimentar o ESP8266 e outros componentes.
Código ESP8266 - Calibração do Sensor
A calibração elimina a interferência do ambiente nas medições brutas. Variáveis como a intensidade da saída do LED, o espaçamento do alvo, a refletividade do material e a iluminação da sala afetam as leituras. A rotina de calibração identifica as larguras de pulso mínima e máxima em todos os canais de cor, estabelecendo limites de referência para converter os dados brutos em valores RGB precisos de 0–255, ajustados ao seu ambiente de uso.
/*
* Este código de ESP8266 NodeMCU foi desenvolvido por pt.newbiely.com
* Este código de ESP8266 NodeMCU é disponibilizado ao público sem nenhuma restrição.
* Para tutoriais completos e diagramas de ligação, visite:
* https://pt.newbiely.com/tutorials/esp8266/esp8266-tcs3200d-tcs230-color-sensor
*/
// Define color sensor pins
#define PIN_S0 D6 // The ESP8266 pin GPIO12 connected to the S0 of the color module
#define PIN_S1 D7 // The ESP8266 pin GPIO13 connected to the S1 of the color module
#define PIN_S2 D2 // The ESP8266 pin GPIO4 connected to the S2 of the color module
#define PIN_S3 D5 // The ESP8266 pin GPIO14 connected to the S3 of the color module
#define PIN_sensorOut D1 // The ESP8266 pin GPIO5 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 ESP8266 no Arduino IDE, siga estes passos:
- Confira o tutorial como configurar o ambiente para o ESP8266 no Arduino IDE se esta for sua primeira vez usando o ESP8266.
- Faça a ligação dos componentes como mostrado no diagrama.
- Conecte a placa ESP8266 ao seu computador usando um cabo USB.
- Abra o Arduino IDE no seu computador.
- Escolha a placa ESP8266 correta, como (por exemplo, NodeMCU 1.0 (ESP-12E Module)), e a respectiva porta COM.
- Copie o código de calibração e abra-o no Arduino IDE.
- Clique no botão Upload para compilar e fazer o upload para o ESP8266.
- Abra o Serial Monitor.
- Aponte o sensor para superfícies diferentes: branca (papel), preta e várias cores.
- Observe os valores Min/Max serem atualizados automaticamente.
- Quando os valores se estabilizarem (normalmente 10-20 segundos), anote os seis parâmetros de calibração.
8
Serial.println("Hello World!");
Message (Enter to send message to 'Nodemcu 1.0 (ESP-12E 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
------------------------------------------
Parâmetros de calibração de exemplo extraídos da saída acima:
- RedMin = 42, redMax = 210
- GreenMin = 55, greenMax = 185
- BlueMin = 60, blueMax = 172
Código ESP8266 - Lendo Valores RGB
/*
* Este código de ESP8266 NodeMCU foi desenvolvido por pt.newbiely.com
* Este código de ESP8266 NodeMCU é disponibilizado ao público sem nenhuma restrição.
* Para tutoriais completos e diagramas de ligação, visite:
* https://pt.newbiely.com/tutorials/esp8266/esp8266-tcs3200d-tcs230-color-sensor
*/
// Define color sensor pins
#define PIN_S0 D6 // The ESP8266 pin GPIO12 connected to the S0 of the color module
#define PIN_S1 D7 // The ESP8266 pin GPIO13 connected to the S1 of the color module
#define PIN_S2 D2 // The ESP8266 pin GPIO4 connected to the S2 of the color module
#define PIN_S3 D5 // The ESP8266 pin GPIO14 connected to the S3 of the color module
#define PIN_sensorOut D1 // The ESP8266 pin GPIO5 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
- Localize as variáveis 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
- Substitua os seis valores zero de exemplo pelos dados de calibração medidos. Exemplo usando os valores 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 atualizado para o ESP8266.
- Posicione um objeto 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 'Nodemcu 1.0 (ESP-12E 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
Os valores RGB exibidos seguem a escala padrão de 0-255. Larguras de pulso menores (indicando reflexos mais brilhantes) geram saídas RGB mais altas; larguras de pulso maiores (reflexos mais fracos) resultam em valores mais baixos.
A partir dos valores RGB, você pode:
- Identificar cores específicas comparando as proporções RGB
- Separar objetos pela detecção de cor
- Combinar cores entre amostras diferentes
- Disparar ações com base nas cores detectadas
Aplicações do Projeto
Com a capacidade de medição RGB em funcionamento, você pode desenvolver:
- Sistema de separação cromática: Categorize objetos por cor (diferenciação vermelho/verde/azul)
- Dispositivo de verificação de cor: Confirme a consistência de cor entre amostras
- Seguidor de trajeto colorido: Robôs que navegam seguindo marcadores cromáticos
- Inspeção visual de qualidade: Detecte defeitos de produção por meio da análise de cor
- Automação acionada por cor: Execute ações quando tons específicos forem detectados