Raspberry Pi Pico - TCS3200D/TCS230 Color Sensor
This comprehensive guide shows you how to connect the TCS3200D/TCS230 color sensor to Raspberry Pi Pico for precise color measurement and RGB value extraction. Master calibration procedures and develop color recognition capabilities in your projects.
Learning objectives:
- Establishing connections between TCS3200D/TCS230 and Raspberry Pi Pico
- Executing sensor calibration to eliminate environmental noise
- Developing Raspberry Pi Pico programs for RGB color measurement using MicroPython
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 sensor utilizes a photodiode matrix arranged in an 8×8 grid for color detection through optical filtering. Within this 64-element array, 16 photodiodes feature red spectral filters, another 16 use green filters, 16 employ blue filters, and the remaining 16 operate without filters (clear response). Color measurement happens by activating specific filter sets and analyzing the resulting frequency-modulated square-wave output.
Built-in white LED arrays on typical modules deliver constant illumination to targets, maintaining reading stability regardless of external lighting variations and enhancing performance in dim environments.
Pinout
Available connections on the TCS3200D/TCS230 sensor board:
- 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
Two critical settings control sensor behavior: which color channel to activate and what output signal strength to generate. Two pairs of control inputs 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 range. Frequency increases with light intensity—brighter illumination produces higher frequency output. By measuring pulse duration (which correlates inversely—shorter durations indicate stronger light), we can translate these measurements into conventional 0-255 RGB format through calibration.
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
TCS3200 color sensor to Raspberry Pi Pico wiring configuration:
| TCS3200 Color Sensor | Raspberry Pi Pico |
|---|---|
| VCC | VBUS (5V) |
| GND | GND |
| OUT | GP9 |
| S0 | GP6 |
| S1 | GP5 |
| S2 | GP8 |
| S3 | GP7 |
This image is created using Fritzing. Click to enlarge image
Raspberry Pi Pico Code - Pulse Width Calibration
Calibration eliminates environmental interference from raw measurements. Variables including LED output strength, target spacing, material reflectivity, and room lighting all affect readings. Think of these as systematic errors requiring measurement. 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 Raspberry Pi Pico MicroPython code was developed by newbiely.com
This Raspberry Pi Pico code is made available for public use without any restriction
For comprehensive instructions and wiring diagrams, please visit:
https://newbiely.com/tutorials/raspberry-pico/raspberry-pi-pico-tcs3200d-tcs230-color-sensor
"""
from machine import Pin
import utime
# Pin Definitions
OUT_PIN = Pin(9, Pin.IN) # GP9 connected to OUT
S0_PIN = Pin(6, Pin.OUT) # GP6 connected to S0
S1_PIN = Pin(5, Pin.OUT) # GP5 connected to S1
S2_PIN = Pin(8, Pin.OUT) # GP8 connected to S2
S3_PIN = Pin(7, Pin.OUT) # GP7 connected to S3
# Set frequency scaling to 20% (S0=HIGH, S1=LOW)
S0_PIN.value(1)
S1_PIN.value(0)
# Variables to track min and max pulse widths for each color
red_min = 999999
red_max = 0
green_min = 999999
green_max = 0
blue_min = 999999
blue_max = 0
def read_pulse_width():
"""Read the pulse width from OUT pin in microseconds"""
# Wait for pulse to start (LOW to HIGH)
timeout = utime.ticks_ms()
while OUT_PIN.value() == 0:
if utime.ticks_diff(utime.ticks_ms(), timeout) > 100:
return 0
# Measure HIGH pulse duration
pulse_start = utime.ticks_us()
timeout = utime.ticks_ms()
while OUT_PIN.value() == 1:
if utime.ticks_diff(utime.ticks_ms(), timeout) > 100:
return 0
pulse_end = utime.ticks_us()
# Return duration in microseconds
return utime.ticks_diff(pulse_end, pulse_start)
def read_red():
"""Read red color pulse width
"""
S2_PIN.value(0)
S3_PIN.value(0)
utime.sleep_ms(10)
return read_pulse_width()
def read_green():
"""Read green color pulse width"""
S2_PIN.value(1)
S3_PIN.value(1)
utime.sleep_ms(10)
return read_pulse_width()
def read_blue():
"""Read blue color pulse width
"""
S2_PIN.value(0)
S3_PIN.value(1)
utime.sleep_ms(10)
return read_pulse_width()
print("=== TCS3200 Calibration ===")
print("Point the sensor at different objects (white, black, colors).")
print("Min and Max values are tracked automatically.")
print("When values look stable, note them down for the next code.")
print()
try:
while True:
# Read all three colors
red_pw = read_red()
green_pw = read_green()
blue_pw = read_blue()
# Update min values
if red_pw > 0 and red_pw < red_min:
red_min = red_pw
if green_pw > 0 and green_pw < green_min:
green_min = green_pw
if blue_pw > 0 and blue_pw < blue_min:
blue_min = blue_pw
# Update max values
if red_pw > red_max:
red_max = red_pw
if green_pw > green_max:
green_max = green_pw
if blue_pw > blue_max:
blue_max = blue_pw
# Display current readings and min/max
print("-" * 42)
print(f"Red PW = {red_pw} - Green PW = {green_pw} - Blue PW = {blue_pw}")
print(f" Min -> R:{red_min} G:{green_min} B:{blue_min}")
print(f" Max -> R:{red_max} G:{green_max} B:{blue_max}")
utime.sleep_ms(500)
except KeyboardInterrupt:
print("\nCalibration stopped")
print(f"\nFinal calibration values:")
print(f"redMin = {red_min}, redMax = {red_max}")
print(f"greenMin = {green_min}, greenMax = {green_max}")
print(f"blueMin = {blue_min}, blueMax = {blue_max}")
Detailed Instructions
Please follow these instructions step by step:
- Ensure that Thonny IDE is installed on your computer.
- Ensure that MicroPython firmware is installed on your Raspberry Pi Pico.
- If this is your first time using a Raspberry Pico, refer to the Raspberry Pi Pico - Getting Started tutorial for detailed instructions.
- Connect the Raspberry Pi Pico to the TCS3200 sensor according to the provided diagram.
- Connect the Raspberry Pi Pico to your computer using a USB cable.
- Launch the Thonny IDE on your computer.
- On Thonny IDE, select MicroPython (Raspberry Pi Pico) Interpreter by navigating to Tools Options.
- In the Interpreter tab, select MicroPython (Raspberry Pi Pico) from the drop-down menu.
- Ensure the correct port is selected. Thonny IDE should automatically detect the port, but you may need to select it manually (e.g., COM3 on Windows or /dev/ttyACM0 on Linux).
- Copy the above code and paste it to the Thonny IDE's editor.
- Save the script to your Raspberry Pi Pico by:
- Click the Save button, or use Ctrl+S keys.
- In the save dialog, you will see two sections: This computer and Raspberry Pi Pico. Select Raspberry Pi Pico
- Save the file as tcs3200_calibration.py
- Click the green Run button (or press F5) to run the script. The script will execute.
- Expose sensor to diverse surfaces: white materials (printer paper), black objects, plus multi-colored items
- Watch Min/Max boundaries update automatically as extremes are detected
- Once values stabilize (generally 10-20 seconds), press Stop button or Ctrl+C to stop
- Document all six calibration parameters displayed
Shell x
>>> %Run -c $EDITOR_CONTENT
MPY: soft reboot
=== 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
------------------------------------------
Calibration stopped
Final calibration values:
redMin = 42, redMax = 210
greenMin = 55, greenMax = 185
blueMin = 60, blueMax = 172
MicroPython (Raspberry Pi Pico) • Board CDC @ COM29 ≡
Sample calibration parameters extracted from above output:
- RedMin = 42, redMax = 210
- GreenMin = 55, greenMax = 185
- BlueMin = 60, blueMax = 172
Raspberry Pi Pico Code - RGB Value Measurement
"""
This Raspberry Pi Pico MicroPython code was developed by newbiely.com
This Raspberry Pi Pico code is made available for public use without any restriction
For comprehensive instructions and wiring diagrams, please visit:
https://newbiely.com/tutorials/raspberry-pico/raspberry-pi-pico-tcs3200d-tcs230-color-sensor
"""
from machine import Pin
import utime
# Pin Definitions
OUT_PIN = Pin(9, Pin.IN) # GP9 connected to OUT
S0_PIN = Pin(6, Pin.OUT) # GP6 connected to S0
S1_PIN = Pin(5, Pin.OUT) # GP5 connected to S1
S2_PIN = Pin(8, Pin.OUT) # GP8 connected to S2
S3_PIN = Pin(7, Pin.OUT) # GP7 connected to S3
# Calibration values - REPLACE with your calibrated values!
red_min = 0
red_max = 0
green_min = 0
green_max = 0
blue_min = 0
blue_max = 0
# Set frequency scaling to 20% (S0=HIGH, S1=LOW)
S0_PIN.value(1)
S1_PIN.value(0)
def read_pulse_width():
"""Read the pulse width from OUT pin in microseconds"""
# Wait for pulse to start (LOW to HIGH)
timeout = utime.ticks_ms()
while OUT_PIN.value() == 0:
if utime.ticks_diff(utime.ticks_ms(), timeout) > 100:
return 0
# Measure HIGH pulse duration
pulse_start = utime.ticks_us()
timeout = utime.ticks_ms()
while OUT_PIN.value() == 1:
if utime.ticks_diff(utime.ticks_ms(), timeout) > 100:
return 0
pulse_end = utime.ticks_us()
# Return duration in microseconds
return utime.ticks_diff(pulse_end, pulse_start)
def read_red():
"""Read red color pulse width
"""
S2_PIN.value(0)
S3_PIN.value(0)
utime.sleep_ms(10)
return read_pulse_width()
def read_green():
"""Read green color pulse width"""
S2_PIN.value(1)
S3_PIN.value(1)
utime.sleep_ms(10)
return read_pulse_width()
def read_blue():
"""Read blue color pulse width
"""
S2_PIN.value(0)
S3_PIN.value(1)
utime.sleep_ms(10)
return read_pulse_width()
def map_value(value, in_min, in_max, out_min, out_max):
"""Map value from one range to another"""
if in_max == in_min:
return out_min
return int((value - in_min) * (out_max - out_min) // (in_max - in_min) + out_min)
def constrain(value, min_val, max_val):
"""Constrain value between min and max
"""
return max(min_val, min(value, max_val))
print("TCS3200 Color Sensor - RGB Reading")
print()
try:
while True:
# Read pulse widths for all colors
red_pw = read_red()
green_pw = read_green()
blue_pw = read_blue()
# Convert to 0-255 RGB values
# Lower pulse width = brighter = higher RGB value
red_value = map_value(red_pw, red_min, red_max, 255, 0)
green_value = map_value(green_pw, green_min, green_max, 255, 0)
blue_value = map_value(blue_pw, blue_min, blue_max, 255, 0)
# Constrain to 0-255 range
red_value = constrain(red_value, 0, 255)
green_value = constrain(green_value, 0, 255)
blue_value = constrain(blue_value, 0, 255)
# Display RGB values
print(f"Red = {red_value} - Green = {green_value} - Blue = {blue_value}")
utime.sleep_ms(500)
except KeyboardInterrupt:
print("\nProgram stopped")
Detailed Instructions
- Identify calibration variables at code start:
red_min = 0
red_max = 0
green_min = 0
green_max = 0
blue_min = 0
blue_max = 0
- Substitute all six zero placeholders with measured calibration data. Example using values redMin = 42, redMax = 210, greenMin = 55, greenMax = 185, blueMin = 60, blueMax = 172:
red_min = 42
red_max = 210
green_min = 55
green_max = 185
blue_min = 60
blue_max = 172
- Copy the updated code and paste it to Thonny IDE's editor
- Save the script to your Raspberry Pi Pico as tcs3200_sensor.py
- Click the green Run button (or press F5) to execute the script
- Arrange colored sample before sensor
- Check RGB output in the Shell at the bottom of Thonny
Shell x
>>> %Run -c $EDITOR_CONTENT
MPY: soft reboot
TCS3200 Color Sensor - RGB Reading
Red = 210 - Green = 35 - Blue = 20
Red = 25 - Green = 200 - Blue = 40
Red = 30 - Green = 45 - Blue = 215
MicroPython (Raspberry Pi Pico) • Board CDC @ COM29 ≡
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.
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