Arduino UNO Q - TCS3200D/TCS230 Color Sensor
The TCS3200D/TCS230 color recognition sensor detects colors by measuring red, green, and blue light intensity. It outputs a frequency-based signal that you read with pulseIn(), then map to standard 0-255 RGB values after calibration.
In this tutorial, you will learn:
- How the TCS3200D/TCS230 color sensor works
- How to wire it to the Arduino UNO Q MCU
- How to run the calibration sketch to get accurate readings
- How to read RGB values and detect dominant colors
- How to use Bridge to expose color data to the Linux side (Python)
- How to use Telegram to query RGB values and color name on Arduino UNO Q
- How to use OpenClaw on Arduino UNO Q with the color sensor
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 the TCS3200D/TCS230 Color Sensor
The TCS3200D/TCS230 uses an 8×8 array of photodiodes: 16 red-filtered, 16 green-filtered, 16 blue-filtered, and 16 clear. It converts light intensity into a square-wave frequency on the OUT pin. By switching filters and measuring pulse widths, you get RGB values.
Most modules include white LEDs to illuminate the target object, giving consistent readings in varying ambient light.
Pinout
- VCC: 5V power supply
- GND: Ground
- S0, S1: Output frequency scaling — HIGH/LOW = 20% scaling (recommended)
- S2, S3: Color filter selection
- OUT: Square-wave frequency output — measure with pulseIn()
- OE: Output enable (active LOW) — most modules wire this to GND internally
Filter Selection (S2, S3)
| S2 | S3 | Filter |
|-----|-----|---------|
| LOW | LOW | Red |
| LOW | HIGH| Blue |
| HIGH| LOW | Clear |
| HIGH| HIGH| Green |
Pulse Width → RGB
Lower pulse width = more light = higher RGB value. After calibration:
rgb = map(pulseWidth, calibMin, calibMax, 255, 0);
Wiring Diagram
This image is created using Fritzing. Click to enlarge image
| TCS3200 Pin | Arduino UNO Q MCU |
|---|---|
| VCC | 5V |
| GND | GND |
| S0 | D4 |
| S1 | D3 |
| S2 | D6 |
| S3 | D5 |
| OUT | D7 |
How To Program For TCS3200 Color Sensor
- Configure all control pins as outputs, OUT as input, set frequency scaling:
pinMode(S0, OUTPUT);
pinMode(S1, OUTPUT);
pinMode(S2, OUTPUT);
pinMode(S3, OUTPUT);
pinMode(sensorOut, INPUT);
digitalWrite(S0, HIGH); // 20% scaling
digitalWrite(S1, LOW);
- Select a filter and measure pulse width:
// Red
digitalWrite(S2, LOW);
digitalWrite(S3, LOW);
int redPW = pulseIn(sensorOut, LOW);
// Green
digitalWrite(S2, HIGH);
digitalWrite(S3, HIGH);
int greenPW = pulseIn(sensorOut, LOW);
// Blue
digitalWrite(S2, LOW);
digitalWrite(S3, HIGH);
int bluePW = pulseIn(sensorOut, LOW);
- Map to 0-255 after calibration (lower PW = brighter = higher value):
int redValue = map(redPW, redMin, redMax, 255, 0);
Arduino UNO Q Code — Calibration
The TCS3200 readings are affected by distance, LED brightness, and ambient light. Run this calibration sketch first to find the minimum and maximum pulse widths for your specific setup.
/*
* This Arduino UNO Q code was developed by newbiely.com
*
* This Arduino UNO Q code is made available for public use without any restriction
*
* For comprehensive instructions and wiring diagrams, please visit:
* https://newbiely.com/tutorials/arduino-uno-q/arduino-uno-q-tcs3200d-tcs230-color-sensor
*/
// COPYRIGHT newbiely.com
// AUTHOR: newbiely
// This code is made available for public use without restriction.
// For complete instructions, tutorials, and further information, visit:
// https://newbiely.com/tutorials/arduino-uno-q/arduino-uno-q-tcs3200d-tcs230-color-sensor
// TCS3200 Color Sensor - Calibration Sketch
// Run this first to find the min/max pulse widths for your environment.
// Point the sensor at white, black, and various colored objects.
// Note the stable Min and Max values, then enter them into the main sketch.
#define S0 4
#define S1 3
#define S2 6
#define S3 5
#define sensorOut 7
int redPW = 0, greenPW = 0, bluePW = 0;
int redMin = 10000, redMax = 0;
int greenMin = 10000, greenMax = 0;
int blueMin = 10000, blueMax = 0;
int getRedPW() {
digitalWrite(S2, LOW);
digitalWrite(S3, LOW);
return pulseIn(sensorOut, LOW);
}
int getGreenPW() {
digitalWrite(S2, HIGH);
digitalWrite(S3, HIGH);
return pulseIn(sensorOut, LOW);
}
int getBluePW() {
digitalWrite(S2, LOW);
digitalWrite(S3, HIGH);
return pulseIn(sensorOut, LOW);
}
void setup() {
pinMode(S0, OUTPUT);
pinMode(S1, OUTPUT);
pinMode(S2, OUTPUT);
pinMode(S3, OUTPUT);
pinMode(sensorOut, INPUT);
// Frequency scaling 20%
digitalWrite(S0, HIGH);
digitalWrite(S1, LOW);
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 main sketch.");
Serial.println("------------------------------------------");
}
void loop() {
redPW = getRedPW(); delay(200);
greenPW = getGreenPW(); delay(200);
bluePW = getBluePW(); delay(200);
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;
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("------------------------------------------");
}
Detailed Instructions
First time with Arduino UNO Q? Follow the Getting Started with Arduino UNO Q tutorial before proceeding.
- Connect: Wire the color sensor to the Arduino UNO Q MCU as shown in the wiring diagram.
- Open Arduino App Lab: Launch Arduino App Lab and wait until it detects your Arduino UNO Q.
- Create a new App: Click the Create New App button.
- Give the App a name, for example: ColorSensorCalibration
- Click Create to confirm.
- Paste the sketch: Copy the calibration code above and paste it into sketch/sketch.ino.
- Upload: Click the Run button in Arduino App Lab.
- Move the sensor over different objects: a white object, a black object, and some colored objects.
- Watch the Min and Max values stabilize after 10–20 seconds — note them down.
App Lab Console Output
sketch.ino
1#include "Arduino_RouterBridge.h"
Serial Monitor
Python
[2026-04-29 09:00:00] === TCS3200 Calibration ===
[2026-04-29 09:00:00] Point the sensor at different objects (white, black, colors).
[2026-04-29 09:00:00] Min and Max values are tracked automatically.
[2026-04-29 09:00:00] When values look stable, note them down for the main sketch.
[2026-04-29 09:00:00] ------------------------------------------
[2026-04-29 09:00:01] Red PW = 42 - Green PW = 55 - Blue PW = 60
[2026-04-29 09:00:01] Min -> R:42 G:55 B:60
[2026-04-29 09:00:01] Max -> R:42 G:55 B:60
[2026-04-29 09:00:01] ------------------------------------------
[2026-04-29 09:00:02] Red PW = 210 - Green PW = 185 - Blue PW = 172
[2026-04-29 09:00:02] Min -> R:42 G:55 B:60
[2026-04-29 09:00:02] Max -> R:210 G:185 B:172
[2026-04-29 09:00:02] ------------------------------------------
From the output above, your calibration values are:
- redMin = 42, redMax = 210
- greenMin = 55, greenMax = 185
- blueMin = 60, blueMax = 172
Arduino UNO Q Code — Read RGB Values
Now update the six calibration variables at the top with your actual values and upload this main sketch to read accurate RGB values.
/*
* This Arduino UNO Q code was developed by newbiely.com
*
* This Arduino UNO Q code is made available for public use without any restriction
*
* For comprehensive instructions and wiring diagrams, please visit:
* https://newbiely.com/tutorials/arduino-uno-q/arduino-uno-q-tcs3200d-tcs230-color-sensor
*/
// COPYRIGHT newbiely.com
// AUTHOR: newbiely
// This code is made available for public use without restriction.
// For complete instructions, tutorials, and further information, visit:
// https://newbiely.com/tutorials/arduino-uno-q/arduino-uno-q-tcs3200d-tcs230-color-sensor
// TCS3200 Color Sensor - Read RGB Values
// IMPORTANT: Run the calibration sketch first and replace the 0 values below
// with your actual calibration numbers.
#define S0 4
#define S1 3
#define S2 6
#define S3 5
#define sensorOut 7
// Calibration values — replace with your values from the calibration sketch
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
int redPW = 0, greenPW = 0, bluePW = 0;
int redValue = 0, greenValue = 0, blueValue = 0;
int getRedPW() {
digitalWrite(S2, LOW);
digitalWrite(S3, LOW);
return pulseIn(sensorOut, LOW);
}
int getGreenPW() {
digitalWrite(S2, HIGH);
digitalWrite(S3, HIGH);
return pulseIn(sensorOut, LOW);
}
int getBluePW() {
digitalWrite(S2, LOW);
digitalWrite(S3, HIGH);
return pulseIn(sensorOut, LOW);
}
void setup() {
pinMode(S0, OUTPUT);
pinMode(S1, OUTPUT);
pinMode(S2, OUTPUT);
pinMode(S3, OUTPUT);
pinMode(sensorOut, INPUT);
// Frequency scaling 20%
digitalWrite(S0, HIGH);
digitalWrite(S1, LOW);
Serial.begin(9600);
Serial.println("Arduino UNO Q TCS3200 Color Sensor ready");
}
void loop() {
redPW = getRedPW(); delay(200);
greenPW = getGreenPW(); delay(200);
bluePW = getBluePW(); delay(200);
// Map pulse width to 0-255 (lower PW = more light = higher value)
redValue = map(redPW, redMin, redMax, 255, 0);
greenValue = map(greenPW, greenMin, greenMax, 255, 0);
blueValue = map(bluePW, blueMin, blueMax, 255, 0);
Serial.print("Red = "); Serial.print(redValue);
Serial.print(" - Green = "); Serial.print(greenValue);
Serial.print(" - Blue = "); Serial.println(blueValue);
}
Detailed Instructions
- In the code above, find these lines:
int redMin = 0;
int redMax = 0;
int greenMin = 0;
int greenMax = 0;
int blueMin = 0;
int blueMax = 0;
- Replace all six 0 values with your calibration numbers. For example:
int redMin = 42;
int redMax = 210;
int greenMin = 55;
int greenMax = 185;
int blueMin = 60;
int blueMax = 172;
- Create a new App (or update the previous one), paste the code, and click Run.
- Point the sensor at different colored objects and observe the Serial Monitor.
App Lab Console Output
sketch.ino
1#include "Arduino_RouterBridge.h"
Serial Monitor
Python
[2026-04-29 09:00:01] Arduino UNO Q TCS3200 Color Sensor ready
[2026-04-29 09:00:02] Red = 210 - Green = 35 - Blue = 20
[2026-04-29 09:00:03] Red = 25 - Green = 200 - Blue = 40
[2026-04-29 09:00:04] Red = 30 - Green = 45 - Blue = 215
[2026-04-29 09:00:05] Red = 225 - Green = 220 - Blue = 218
Bridge: Linux + MCU
This section shows how both processors of the Arduino UNO Q work together so the Linux side can continuously read color data via Bridge:
- The color sensor is connected to the MCU — the MCU reads RGB values every 600 ms and caches them
- The MPU cannot read the sensor directly — it calls Bridge functions to get RGB or color name
- The MPU has Wi-Fi — running full Debian Linux, it can respond to Telegram commands with live color readings
- Arduino_RouterBridge enables RPC communication between the two processors
- ⚠️ /dev/ttyHS1 (Linux) and Serial1 (MCU) are RESERVED by the router — never open them in user code
The MCU loop reads R, G, B channels every 600 ms and caches the values. Bridge callbacks serve the cached values instantly, without blocking.
MCU Code (Bridge)
/*
* This Arduino UNO Q code was developed by newbiely.com
*
* This Arduino UNO Q code is made available for public use without any restriction
*
* For comprehensive instructions and wiring diagrams, please visit:
* https://newbiely.com/tutorials/arduino-uno-q/arduino-uno-q-tcs3200d-tcs230-color-sensor
*/
// COPYRIGHT newbiely.com
// AUTHOR: newbiely
// This code is made available for public use without restriction.
// For complete instructions, tutorials, and further information, visit:
// https://newbiely.com/tutorials/arduino-uno-q/arduino-uno-q-tcs3200d-tcs230-color-sensor
#include "Arduino_RouterBridge.h"
#define S0 4
#define S1 3
#define S2 6
#define S3 5
#define sensorOut 7
// Calibration values — replace with your values from the calibration sketch
int redMin = 42;
int redMax = 210;
int greenMin = 55;
int greenMax = 185;
int blueMin = 60;
int blueMax = 172;
// Cached RGB values
int cached_red = 0;
int cached_green = 0;
int cached_blue = 0;
unsigned long last_read_ms = 0;
const unsigned long READ_INTERVAL = 600;
int getRedPW() {
digitalWrite(S2, LOW);
digitalWrite(S3, LOW);
return pulseIn(sensorOut, LOW);
}
int getGreenPW() {
digitalWrite(S2, HIGH);
digitalWrite(S3, HIGH);
return pulseIn(sensorOut, LOW);
}
int getBluePW() {
digitalWrite(S2, LOW);
digitalWrite(S3, HIGH);
return pulseIn(sensorOut, LOW);
}
String get_rgb(String arg) {
return "R:" + String(cached_red) + " G:" + String(cached_green) + " B:" + String(cached_blue);
}
String get_color(String arg) {
int r = cached_red;
int g = cached_green;
int b = cached_blue;
// Detect dominant color
if (r > 200 && g > 200 && b > 200) return "white";
if (r < 50 && g < 50 && b < 50) return "black";
if (r > g && r > b) return "red";
if (g > r && g > b) return "green";
if (b > r && b > g) return "blue";
return "unknown";
}
void setup() {
Bridge.begin();
Monitor.begin();
pinMode(S0, OUTPUT);
pinMode(S1, OUTPUT);
pinMode(S2, OUTPUT);
pinMode(S3, OUTPUT);
pinMode(sensorOut, INPUT);
// Frequency scaling 20%
digitalWrite(S0, HIGH);
digitalWrite(S1, LOW);
Bridge.provide("get_rgb", get_rgb);
Bridge.provide("get_color", get_color);
Monitor.println("Arduino UNO Q TCS3200 Color Sensor Bridge ready");
}
void loop() {
unsigned long now = millis();
if (now - last_read_ms >= READ_INTERVAL) {
last_read_ms = now;
int redPW = getRedPW(); delay(200);
int greenPW = getGreenPW(); delay(200);
int bluePW = getBluePW(); delay(200);
cached_red = constrain(map(redPW, redMin, redMax, 255, 0), 0, 255);
cached_green = constrain(map(greenPW, greenMin, greenMax, 255, 0), 0, 255);
cached_blue = constrain(map(bluePW, blueMin, blueMax, 255, 0), 0, 255);
}
}
Python Code (Bridge)
/*
* This Arduino UNO Q code was developed by newbiely.com
*
* This Arduino UNO Q code is made available for public use without any restriction
*
* For comprehensive instructions and wiring diagrams, please visit:
* https://newbiely.com/tutorials/arduino-uno-q/arduino-uno-q-tcs3200d-tcs230-color-sensor
*/
# COPYRIGHT newbiely.com
# AUTHOR: newbiely
# This code is made available for public use without restriction.
# For complete instructions, tutorials, and further information, visit:
# https://newbiely.com/tutorials/arduino-uno-q/arduino-uno-q-tcs3200d-tcs230-color-sensor
from arduino.app_utils import *
import time
def loop():
rgb = Bridge.call("get_rgb")
color = Bridge.call("get_color")
print(f"Color: {color} | {rgb}")
time.sleep(1)
App.run(user_loop=loop)
Detailed Instructions
- Connect: Wire the color sensor to the Arduino UNO Q as shown in the wiring diagram.
- Open Arduino App Lab and create a new App named ColorSensorBridge.
- Update calibration values in the MCU Bridge code (redMin, redMax, etc.) with your values from the calibration sketch.
- Paste the MCU sketch into sketch/sketch.ino.
- Paste the Python code into the Python file.
- Install the library: Click the Add sketch library button (the open book icon with a + sign) in the left sidebar.
- Search for Arduino_RouterBridge created by Arduino and click the Install button.
Bricks
No bricks added...
Sketch Libraries
No sketch libra...
Files
python
sketch
.gitignore
README.md
app.yaml
sketch.ino
- Upload: Click the Run button.
- Point the sensor at different colored objects — watch the Python console update every second.
App Lab Console Output
sketch.ino
1#include "Arduino_RouterBridge.h"
Serial Monitor
Python
[2026-04-29 09:00:01] Arduino UNO Q TCS3200 Color Sensor Bridge ready
sketch.ino
1#include "Arduino_RouterBridge.h"
Serial Monitor
Python
[2026-04-29 09:00:02] Color: red | R:215 G:30 B:25
[2026-04-29 09:00:03] Color: green | R:28 G:205 B:38
[2026-04-29 09:00:04] Color: blue | R:22 G:40 B:218
[2026-04-29 09:00:05] Color: white | R:228 G:222 B:220
[2026-04-29 09:00:06] Color: black | R:12 G:10 B:8
Telegram
Query the color sensor remotely via Telegram commands on the Arduino UNO Q.
MCU sketch: Keep the same MCU sketch from the previous Bridge section.
Python Code (Telegram)
/*
* This Arduino UNO Q code was developed by newbiely.com
*
* This Arduino UNO Q code is made available for public use without any restriction
*
* For comprehensive instructions and wiring diagrams, please visit:
* https://newbiely.com/tutorials/arduino-uno-q/arduino-uno-q-tcs3200d-tcs230-color-sensor
*/
# COPYRIGHT newbiely.com
# AUTHOR: newbiely
# This code is made available for public use without restriction.
# For complete instructions, tutorials, and further information, visit:
# https://newbiely.com/tutorials/arduino-uno-q/arduino-uno-q-tcs3200d-tcs230-color-sensor
from arduino.app_utils import *
import requests
import time
TELEGRAM_BOT_TOKEN = "YOUR_TELEGRAM_BOT_TOKEN"
CHAT_ID = "YOUR_CHAT_ID"
last_update_id = 0
def get_updates():
global last_update_id
url = f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/getUpdates"
params = {"offset": last_update_id + 1, "timeout": 5}
try:
response = requests.get(url, params=params, timeout=10)
data = response.json()
if data["ok"]:
return data["result"]
except Exception as e:
print(f"Error getting updates: {e}")
return []
def send_message(chat_id, text):
url = f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/sendMessage"
payload = {"chat_id": chat_id, "text": text}
try:
requests.post(url, data=payload, timeout=10)
except Exception as e:
print(f"Error sending message: {e}")
def loop():
updates = get_updates()
for update in updates:
last_update_id = update["update_id"]
if "message" not in update:
continue
message = update["message"]
chat_id = message["chat"]["id"]
text = message.get("text", "").strip()
print(f"Received: {text}")
if text == "/start":
send_message(chat_id,
"Arduino UNO Q Color Sensor Bot\n"
"/rgb - Read RGB values (0-255)\n"
"/color - Detect dominant color")
elif text == "/rgb":
result = Bridge.call("get_rgb")
send_message(chat_id, f"RGB values: {result}")
elif text == "/color":
result = Bridge.call("get_color")
send_message(chat_id, f"Detected color: {result}")
else:
send_message(chat_id, "Unknown command. Send /start for help.")
time.sleep(0.5)
App.run(user_loop=loop)
Detailed Instructions
- Replace YOUR_TELEGRAM_BOT_TOKEN with your actual Telegram bot token from BotFather.
- Replace YOUR_CHAT_ID with your Telegram chat ID.
- Paste this Python code into your App's Python file (keep the same MCU sketch).
- Click the Run button and test with /rgb and /color commands.
App Lab Console Output
sketch.ino
1#include "Arduino_RouterBridge.h"
Serial Monitor
Python
[2026-04-29 09:10:00] Waiting for Telegram messages...
[2026-04-29 09:10:03] Received: /rgb
[2026-04-29 09:10:06] Received: /color
Telegram
12:45
Welcome to Telegram!
ArduinoBot
10:19
Chatting with Arduino...
BotFather
Yesterday
Your bot has been created.
ArduinoBot
bot
OpenClaw
...OPENCLAW
OpenClaw support for Arduino UNO Q TCS3200D/TCS230 Color Sensor is coming soon.
...OPENCLAW
Project Ideas
You can build many useful projects with the TCS3200 color sensor and Arduino UNO Q:
- Color Sorter Machine: Detect the color of objects on a conveyor belt via Bridge — have the MCU trigger a servo to redirect each object to the correct bin based on its detected color
- Remote Color Logger: Log detected colors and RGB values to a CSV file on Linux every 5 seconds — use a Telegram /report command to get the last 10 readings with timestamps
- Color-Activated Alert: Use Telegram to define a target color — when the sensor detects that exact color, send an instant Telegram notification (e.g., for quality control on a production line)
- Plant Health Monitor: Point the sensor at plant leaves — track the green channel value daily to detect early yellowing or discoloration, and send a Telegram alert if the green value drops below a threshold
- Interactive Color Game: Send a Telegram message like "Show me BLUE in 10 seconds" — the MCU reads the color and Python replies with whether the player showed the correct color before the timer
Challenge Yourself
Ready to go further with the TCS3200 color sensor on Arduino UNO Q? Try these challenges:
- Easy: Add a /history Telegram command that returns the last 5 detected colors with timestamps stored in a Python list — useful for reviewing recent readings without checking the console.
- Medium: Implement averaging: instead of caching a single reading, have the MCU read each R/G/B channel 3 times and return the average — this smooths out noise and improves color detection accuracy.
- Advanced: Build a color learning system: add /learn red, /learn green, /learn blue Telegram commands that capture the current RGB reading and store it as the reference for that color — then use these stored references for color matching instead of hardcoded thresholds.