ESP32 S3 - TCS3200D/TCS230 Color Sensor
Learn how to connect the TCS3200D/TCS230 color sensor to your ESP32 S3 for accurate RGB color detection. This beginner-friendly tutorial covers wiring, calibration, and real-time color measurements with your ESP32 S3.
What you'll build:
- A wired connection between the TCS3200D/TCS230 color sensor and the ESP32 S3
- A calibration sketch that tracks minimum and maximum pulse widths for each color channel
- A color reading sketch that converts raw sensor data into standard RGB values (0–255)
- A Serial Monitor output showing real-time color measurements for red, green, and blue objects
Hardware Preparation
Or you can buy the following kits:
| 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 is an optical sensor that detects colors by measuring light reflections through specialized photodiode filters. It outputs a square wave signal whose frequency is proportional to the detected light intensity, making it straightforward to interface with the ESP32 S3's digital input pins. Its built-in white LEDs provide consistent illumination, so readings remain reliable across a variety of ambient lighting conditions.
Key Specifications
- 64 photodiodes in 8×8 array (16 red filters, 16 green, 16 blue, 16 clear)
- Frequency output proportional to light intensity
- Operating voltage: 2.7V to 5.5V (5V recommended)
- Built-in white LED illumination for consistent readings
- Output frequency range: 2 Hz to 500 kHz
- Ideal for beginners: simple digital output, no complex analog reading
Pinout
The TCS3200D/TCS230 color sensor has 8 connection pins, each serving a specific role in power, control, and signal output:
- VCC: Power supply input (connect to 5V)
- GND: Ground connection (0V reference)
- S0: Frequency scaling control pin 1
- S1: Frequency scaling control pin 2
- S2: Color filter selection pin 1
- S3: Color filter selection pin 2
- OUT: Frequency output signal pin (connect to ESP32 S3 digital pin)
- OE: Output enable pin (active LOW, usually connected to GND)
How It Works
The TCS3200 color sensor operates using two control systems:
Frequency scaling (S0 and S1 pins):
- S0=LOW, S1=LOW: Power down mode
- S0=LOW, S1=HIGH: 2% frequency scaling
- S0=HIGH, S1=LOW: 20% frequency scaling
- S0=HIGH, S1=HIGH: 100% frequency scaling (recommended)
Color filter selection (S2 and S3 pins):
- S2=LOW, S3=LOW: Red filter active
- S2=LOW, S3=HIGH: Blue filter active
- S2=HIGH, S3=LOW: Clear filter (no filtering)
- S2=HIGH, S3=HIGH: Green filter active
How readings work:
- The OUT pin outputs a square wave signal
- Frequency increases with brighter light (2 Hz to 500 kHz)
- ESP32 S3 measures pulse width using pulseIn()
- Shorter pulses = brighter light = higher color intensity
- Calibration converts pulse widths to standard RGB values (0-255)
Maximizing Measurement Precision
Follow these tips for accurate TCS3200 color readings:
- Keep sensor distance fixed at 1-3 cm from the object
- Position sensor at consistent angle (perpendicular works best)
- Use the built-in white LEDs for stable illumination
- Shield sensor from external light sources when possible
- Perform calibration in your actual working environment
- Test on flat, matte surfaces for best results
Wiring Diagram
Connect the TCS3200D color sensor to your ESP32 S3 using the pin assignments in the table below. The sensor operates at 5V, which the ESP32 S3 supplies via its 5V pin when powered over USB, so no additional power regulation is required.
Safety Notes
The TCS3200 sensor works best with 5V power, which the ESP32 S3 can provide via the 5V pin when powered through USB. Signal lines from the sensor connect directly to the ESP32 S3 digital pins without any level shifting needed for most modules, but verify your specific module's output voltage before connecting.
| TCS3200 Color Sensor | ESP32 S3 |
|---|---|
| VCC | 5V |
| GND | GND |
| S0 | GPIO41 |
| S1 | GPIO40 |
| S2 | GPIO16 |
| S3 | GPIO7 |
| OUT | GPIO18 |
This image is created using Fritzing. Click to enlarge image
ESP32 S3 Code - Sensor Calibration
The following code sets up the TCS3200 sensor on your ESP32 S3 and guides you through a calibration process that captures the full dynamic range of your specific sensor and environment. Upload this sketch first, then expose the sensor to a variety of colors—from bright white to deep black—so it can record accurate minimum and maximum pulse-width values for each channel.
What this code does:
- Powers up the sensor with full frequency scaling (100%)
- Cycles through red, green, and blue filters
- Tracks minimum and maximum pulse widths for each color
- Continuously updates calibration values as you show different colors
- Displays real-time measurements in the Serial Monitor
/*
* This ESP32 S3 code was developed by newbiely.com
*
* This ESP32 S3 code is made available for public use without any restriction
*
* For comprehensive instructions and wiring diagrams, please visit:
* https://newbiely.com/tutorials/esp32-s3/esp32-s3-tcs3200d-tcs230-color-sensor
*/
// Define color sensor pins
#define PIN_S0 41 // The ESP32 S3 pin connected to the S0 of the color module
#define PIN_S1 40 // The ESP32 S3 pin connected to the S1 of the color module
#define PIN_S2 16 // The ESP32 S3 pin connected to the S2 of the color module
#define PIN_S3 7 // The ESP32 S3 pin connected to the S3 of the color module
#define PIN_sensorOut 18 // The ESP32 S3 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(115200);
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
- New to ESP32 S3? Complete our Getting Started with ESP32 S3 guide first.
- Wire the components: Follow the wiring diagram above to connect all pins correctly.
- Connect your board: Plug the ESP32 S3 into your computer using a USB-C cable.
- Open Arduino IDE: Launch the software on your computer.
- Select your board: Choose ESP32 S3 and the correct COM port from the Tools menu.
- Copy the code: Paste the calibration code into a new Arduino IDE sketch.
- Upload the code: Click the Upload button and wait for the process to complete.
- Open Serial Monitor: Set baud rate to 115200 to view calibration data.
- Point at white objects: Start with bright white paper or surfaces.
- Point at black objects: Move to dark black surfaces.
- Point at colored objects: Show the sensor various colored items (red, green, blue, yellow, etc.).
- Watch values stabilize: After 10-20 seconds, the Min/Max numbers will stop changing significantly.
- Record your values: Write down all six numbers (redMin, redMax, greenMin, greenMax, blueMin, blueMax).
- Pro Tip: Keep the sensor distance consistent (2-3 cm) during calibration for the most accurate results.
8
Serial.println("Hello World!");
Message (Enter to send message to 'ESP32S3 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
------------------------------------------
Red PW = 38 - Green PW = 51 - Blue PW = 58
Min -> R:38 G:51 B:58
Max -> R:210 G:185 B:172
------------------------------------------
Calibration values from this example:
- RedMin = 38, redMax = 210
- GreenMin = 51, greenMax = 185
- BlueMin = 58, blueMax = 172
ESP32 S3 Code - RGB Color Reading
The following code applies your recorded calibration values to deliver accurate, normalized RGB readings from the TCS3200 sensor. After inserting your calibration numbers, upload the sketch and point the sensor at different colored surfaces to see real-time RGB output in the Serial Monitor. Readings update continuously as you move colored objects into view.
What this code does:
- Applies your calibration values to normalize sensor readings
- Measures red, green, and blue channels sequentially
- Converts raw pulse widths to standard RGB format (0-255)
- Displays color values continuously in Serial Monitor
- Updates readings in real-time as you move colored objects
/*
* This ESP32 S3 code was developed by newbiely.com
*
* This ESP32 S3 code is made available for public use without any restriction
*
* For comprehensive instructions and wiring diagrams, please visit:
* https://newbiely.com/tutorials/esp32-s3/esp32-s3-tcs3200d-tcs230-color-sensor
*/
// Define color sensor pins
#define PIN_S0 41 // The ESP32 S3 pin connected to the S0 of the color module
#define PIN_S1 40 // The ESP32 S3 pin connected to the S1 of the color module
#define PIN_S2 16 // The ESP32 S3 pin connected to the S2 of the color module
#define PIN_S3 7 // The ESP32 S3 pin connected to the S3 of the color module
#define PIN_sensorOut 18 // The ESP32 S3 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(115200);
}
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
- New to ESP32 S3? Complete our Getting Started with ESP32 S3 guide first.
- Locate calibration variables: Find these lines near the top of the code (around line 10-15):
int redMin = 0;
int redMax = 0;
int greenMin = 0;
int greenMax = 0;
int blueMin = 0;
int blueMax = 0;
- Insert your calibration values: Replace all zeros with the numbers you recorded during calibration. For example:
int redMin = 38;
int redMax = 210;
int greenMin = 51;
int greenMax = 185;
int blueMin = 58;
int blueMax = 172;
- Upload the code: Click Upload to transfer the modified code to your ESP32 S3.
- Open Serial Monitor: Set baud rate to 115200 to see RGB values.
- Test with colored objects: Place red, green, blue, yellow, or other colored items in front of the sensor.
- Read RGB values: Watch the color measurements update in real-time on the Serial Monitor.
- Pro Tip: For consistent results, always maintain the same distance and lighting conditions you used during calibration.
8
Serial.println("Hello World!");
Message (Enter to send message to 'ESP32S3 Dev Module' on 'COM15')
New Line
9600 baud
[2026-01-15 10:22:01] Red = 210 - Green = 35 - Blue = 20
[2026-01-15 10:22:02] Red = 215 - Green = 38 - Blue = 22
[2026-01-15 10:22:03] Red = 208 - Green = 33 - Blue = 18
[2026-01-15 10:22:05] Red = 25 - Green = 200 - Blue = 40
[2026-01-15 10:22:06] Red = 28 - Green = 205 - Blue = 42
[2026-01-15 10:22:07] Red = 22 - Green = 198 - Blue = 38
[2026-01-15 10:22:09] Red = 30 - Green = 45 - Blue = 215
[2026-01-15 10:22:10] Red = 33 - Green = 48 - Blue = 220
[2026-01-15 10:22:11] Red = 28 - Green = 42 - Blue = 210
Understanding the output:
- Values range from 0 (no color detected) to 255 (maximum intensity)
- Higher numbers mean more of that color is reflected
- First three lines show a red object (high red value, low green/blue)
- Middle three lines show a green object (high green value)
- Last three lines show a blue object (high blue value)
Project Applications
The ESP32 S3 paired with the TCS3200D/TCS230 sensor opens the door to a wide range of color-aware projects, from simple detection tasks to complex automated systems.
- Automated color sorter: Sort M&Ms, LEGO bricks, or beads by color using a servo mechanism
- Color matching game: Challenge users to find objects matching a target RGB value
- Line-following robot: Create a robot that follows colored tape paths on the floor
- Quality control system: Detect defective products by comparing colors to reference standards
- Smart lighting controller: Automatically adjust RGB LED colors to match detected ambient colors
- Paint color identifier: Build a handheld device that identifies paint colors for home decorating
- Educational color mixer: Demonstrate additive color theory by displaying RGB values of mixed colors
Video Section
Watch the step-by-step video walkthrough for this ESP32 S3 project below.
Challenge Yourself
These challenges will push your ESP32 S3 and TCS3200 skills further, from simple LED feedback to full wireless color streaming applications.
- Beginner: Add an RGB LED that lights up with the same color the sensor detects
- Beginner: Display color names ("Red", "Green", "Blue") instead of just numbers when primary colors are detected
- Intermediate: Build a color memory game that shows random colors and tests if users can match them
- Intermediate: Create a color-based security system that only unlocks when shown a specific colored object
- Advanced: Build a full color sorter with servo motors that physically separate objects into bins by color
- Advanced: Develop a smartphone app that receives RGB values from the ESP32 S3 via Bluetooth and displays the actual color on screen