ESP8266 - TCS3200D/TCS230 Color Sensor
This tutorial guides you through using ESP8266 with the TCS3200D/TCS230 color sensor for precise color detection and RGB measurement.
In detail, we will learn:
- How to connect the TCS3200D/TCS230 sensor to ESP8266
- How to calibrate the sensor for accurate readings
- How to program ESP8266 to read and display RGB values
Hardware Preparation
Or you can buy the following kits:
| 1 | × | DIYables Sensor Kit (30 sensors/displays) | |
| 1 | × | DIYables Sensor Kit (18 sensors/displays) |
Disclosure: Some of the links provided in this section are Amazon affiliate links. We may receive a commission for any purchases made through these links at no additional cost to you.
Additionally, some of these links are for products from our own brand, DIYables .
Additionally, some of these links are for products from our own brand, DIYables .
Overview of TCS3200D/TCS230 Color Sensor
The TCS3200D/TCS230 color sensor utilizes a grid of 64 photodiodes arranged in an 8×8 matrix for color detection through wavelength-specific filtering. Within this array, 16 photodiodes incorporate red wavelength filters, 16 use green wavelength filters, 16 employ blue wavelength filters, and 16 operate without filtering (clear response). Color measurement occurs by selecting particular filter sets and evaluating the frequency of the output signal.
Common TCS3200D modules feature built-in white LED illumination arrays that provide consistent target lighting, ensuring measurement stability regardless of external lighting fluctuations and enhancing sensitivity in dim conditions.
Pinout
Pin configuration of the TCS3200D/TCS230 sensor module:
- VCC pin: Supply voltage input (+5V).
- GND pin: Ground reference (0V).
- S0, S1 pins: Output frequency scaling selectors.
- S2, S3 pins: Color channel filter selectors.
- OUT pin: Frequency-modulated square wave output.
- OE pin: Output enable input (enables when LOW). Standard modules typically hard-wire this to GND internally. If not connected, manually wire to GND.
How It Works
Sensor operation depends on two primary controls: which photodiode filter group to activate and what output frequency range to generate. Two control pin pairs manage these functions:
Frequency scaling control (S0 and S1 pins):
- S0=LOW, S1=LOW: Power down state
- S0=LOW, S1=HIGH: 2% scaling factor
- S0=HIGH, S1=LOW: 20% scaling factor
- S0=HIGH, S1=HIGH: 100% scaling factor (full speed)
Color channel selection (S2 and S3 pins):
- S2=LOW, S3=LOW: Red photodiodes active
- S2=LOW, S3=HIGH: Blue photodiodes active
- S2=HIGH, S3=LOW: Clear photodiodes active (no filtering)
- S2=HIGH, S3=HIGH: Green photodiodes active
The OUT pin delivers square-wave frequencies spanning approximately 2 Hz to 500 kHz. Higher light intensity produces higher frequency output. ESP8266's pulseIn() function measures pulse duration, which correlates inversely—brighter illumination produces shorter durations. Calibrated measurements translate into conventional 0-255 RGB format.
Achieving Optimal Precision
- Keep sensor positioned 1-3 cm from measurement target with stable angular alignment.
- Utilize integrated white LED illumination for repeatable lighting.
- Shield sensor from variable ambient light to enhance measurement consistency.
Wiring Diagram
Connect the TCS3200 color sensor to ESP8266 as follows:
| TCS3200 Color Sensor | 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
See more in ESP8266's pinout and how to supply power to the ESP8266 and other components.
ESP8266 Code - Sensor Calibration
Calibration eliminates environmental interference from raw measurements. Variables including LED output strength, target spacing, material reflectivity, and room lighting all affect readings. The calibration routine identifies minimum and maximum pulse widths across all color channels, establishing reference boundaries for converting raw data into accurate 0–255 RGB values matched to your deployment environment.
/*
* This ESP8266 NodeMCU code was developed by newbiely.com
*
* This ESP8266 NodeMCU code is made available for public use without any restriction
*
* For comprehensive instructions and wiring diagrams, please visit:
* https://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;
}
Detailed Instructions
To get started with ESP8266 on Arduino IDE, follow these steps:
- Check out the how to setup environment for ESP8266 on Arduino IDE tutorial if this is your first time using ESP8266.
- Wire the components as shown in the diagram.
- Connect the ESP8266 board to your computer using a USB cable.
- Open Arduino IDE on your computer.
- Choose the correct ESP8266 board, such as (e.g. NodeMCU 1.0 (ESP-12E Module)), and its respective COM port.
- Copy the calibration code and open it in Arduino IDE.
- Click the Upload button to compile and upload to ESP8266.
- Launch the Serial Monitor.
- Direct the sensor at different surfaces: white (paper), black, and various colors.
- Watch the Min/Max values update automatically.
- When values stabilize (typically 10-20 seconds), record all six calibration parameters.
COM6
=== 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
------------------------------------------
Autoscroll
Clear output
9600 baud
Newline
Sample calibration parameters extracted from above output:
- RedMin = 42, redMax = 210
- GreenMin = 55, greenMax = 185
- BlueMin = 60, blueMax = 172
ESP8266 Code - Reading RGB Values
/*
* This ESP8266 NodeMCU code was developed by newbiely.com
*
* This ESP8266 NodeMCU code is made available for public use without any restriction
*
* For comprehensive instructions and wiring diagrams, please visit:
* https://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;
}
Detailed Instructions
- Locate the calibration variables at the code start:
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
- Replace all six zero placeholders with measured calibration data. Example using values 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;
- Upload the updated code to ESP8266.
- Position a colored object in front of the sensor.
- Open Serial Monitor to view RGB measurements.
COM6
Red = 210 - Green = 35 - Blue = 20
Red = 25 - Green = 200 - Blue = 40
Red = 30 - Green = 45 - Blue = 215
Autoscroll
Clear output
9600 baud
Newline
Displayed RGB values conform to standard 0-255 scaling. Reduced pulse widths (indicating brighter reflections) generate higher RGB outputs; extended pulse widths (dimmer reflections) yield lower values.
From the RGB values, you can:
- Identify specific colors by comparing RGB ratios
- Sort objects by color detection
- Match colors between different samples
- Trigger actions based on detected colors
Project Applications
With operational RGB measurement capability, you can develop:
- Chromatic sorting system: Categorize objects by color (red/green/blue differentiation)
- Color verification device: Confirm color consistency between samples
- Colored path follower: Robots that navigate along chromatic markers
- Visual quality inspection: Detect production defects via color analysis
- Color-triggered automation: Execute actions when specific hues are detected