TCS3200 Color Sensor Arduino Integration: Wiring, Calibration, and Debugging

Complete Arduino Code with Frequency-to-RGB Mapping

The following sketch is fully compilable for the Arduino Uno R3. It reads the raw frequency for Red, Green, and Blue, then maps those frequencies to standard 0-255 RGB values. Because every TCS3200 module has slight manufacturing variances in the photodiode array, you must calibrate the map() functions using a pure white and pure black card under your specific shroud.

/*
  TCS3200 Color Sensor Calibration and Read Sketch
  Target Board: Arduino Uno R3 (ATmega328P)
  Reference: https://www.arduino.cc/reference/en/language/functions/advanced-io/pulsein/
*/

// Pin Definitions
#define S0 4
#define S1 5
#define S2 6
#define S3 7
#define OUT 8
#define LED_CONTROL 2 // Optional: Use a MOSFET to control LED power if needed

// Calibration Variables (REPLACE THESE WITH YOUR OWN CALIBRATION VALUES)
// Place a white card 10mm away, record min values. Place black card, record max values.
int redMin = 250;   // Example: White card red frequency
int redMax = 2100;  // Example: Black card red frequency
int greenMin = 300;
int greenMax = 2400;
int blueMin = 350;
int blueMax = 2600;

// Variables to store raw frequencies
unsigned long redFrequency = 0;
unsigned long greenFrequency = 0;
unsigned long blueFrequency = 0;

// Mapped RGB values
int redValue = 0;
int greenValue = 0;
int blueValue = 0;

void setup() {
  Serial.begin(9600);
  
  // Configure S0 and S1 for 20% output frequency scaling
  pinMode(S0, OUTPUT);
  pinMode(S1, OUTPUT);
  digitalWrite(S0, HIGH);
  digitalWrite(S1, LOW);
  
  // Configure S2 and S3 as outputs for filter selection
  pinMode(S2, OUTPUT);
  pinMode(S3, OUTPUT);
  
  // Configure OUT as input
  pinMode(OUT, INPUT);
  
  Serial.println("TCS3200 Initialized. 20% Scaling Active.");
}

void loop() {
  // 1. Read Red Filter
  digitalWrite(S2, LOW);
  digitalWrite(S3, LOW);
  redFrequency = readFrequency();
  
  // 2. Read Green Filter
  digitalWrite(S2, HIGH);
  digitalWrite(S3, HIGH);
  greenFrequency = readFrequency();
  
  // 3. Read Blue Filter
  digitalWrite(S2, LOW);
  digitalWrite(S3, HIGH);
  blueFrequency = readFrequency();
  
  // Map raw frequencies to 0-255 RGB scale
  // Note: Higher light intensity = Higher frequency = Lower RGB value (inverted logic for standard color mixing)
  // We use constrain() to prevent negative numbers or overflow if lighting changes slightly
  redValue = constrain(map(redFrequency, redMin, redMax, 255, 0), 0, 255);
  greenValue = constrain(map(greenFrequency, greenMin, greenMax, 255, 0), 0, 255);
  blueValue = constrain(map(blueFrequency, blueMin, blueMax, 255, 0), 0, 255);
  
  // Output to Serial Plotter or Monitor
  Serial.print("R:"); Serial.print(redValue);
  Serial.print(" G:"); Serial.print(greenValue);
  Serial.print(" B:"); Serial.println(blueValue);
  
  delay(500); // Allow time for serial buffer and physical settling
}

// Helper function to read frequency with error handling
unsigned long readFrequency() {
  // pulseIn measures the duration of a LOW pulse in microseconds.
  // Timeout set to 100,000 us (0.1 seconds). If freq < 10Hz, it times out.
  unsigned long pulseWidth = pulseIn(OUT, LOW, 100000UL);
  
  if (pulseWidth == 0) {
    Serial.println("\"Error: pulseIn timeout on OUT pin\"");
    return 0; // Return 0 to trigger bounds checking downstream
  }
  
  // Calculate frequency. The TCS3200 outputs a 50% duty cycle square wave.
  // Frequency = 1 / Period. Period = pulseWidth * 2 (in seconds).
  // To avoid floating point math: Freq (Hz) = 1,000,000 / (pulseWidth * 2)
  // Note: Many basic tutorials omit the '* 2' and just use 1000000/pulseWidth.
  // This yields a proportional number, but it is technically double the real Hz.
  // We include the '* 2' for physical accuracy.
  unsigned long freq = 1000000UL / (pulseWidth * 2);
  
  return freq;
}

Debugging: Timeout Errors and Drifting Values

When working with frequency-based sensors, serial monitor output can quickly fill with garbage data if the physical environment shifts. If your serial monitor outputs the exact string "Error: pulseIn timeout on OUT pin", or if your mapped RGB values are stuck at 0 or maxing out at 255, follow this diagnostic tree.

The First Three Things to Check When It Fails

1. Verify S0/S1 Logic Levels: If both S0 and S1 are accidentally set to LOW in your code, the sensor enters hardware power-down mode and stops outputting the square wave entirely. This guarantees a pulseIn timeout. Ensure S0 is HIGH and S1 is LOW.
2. Inspect the Physical Shroud and Target: If the target object is highly absorptive (like matte black foam) or the shroud is leaking ambient light, the photodiodes won't generate enough current to trigger the internal oscillator. The frequency drops below 10 Hz, causing the 100ms pulseIn timeout to trigger.
3. Check the OUT Pin Connection: The TCS3200 OUT pin is a push-pull CMOS output. It must be connected directly to a digital input on the Arduino. If you accidentally wired it to an Analog pin (e.g., A0 instead of D8) without updating the #define OUT macro, pulseIn() will listen to a dead pin.

Ranked Causes for "Drifting" Color Values

If the sensor works initially but the RGB values slowly drift over 10-20 minutes, the causes are almost always thermal or electrical:

• Cause 1: LED Thermal Drift (Most Likely). The 4 white LEDs on the breakout board heat up the PCB. As the silicon die temperature rises, the dark current of the photodiodes increases, artificially inflating the baseline frequency. Fix: Add a 2-second delay between reads, or power the LEDs via a GPIO pin and a MOSFET, turning them on only during the 50ms read window.
• Cause 2: Power Supply Ripple. If the Arduino 5V rail is noisy (common when powered from a cheap laptop USB port), the internal oscillator of the TCS3200 will jitter. Fix: Add a 100nF ceramic capacitor and a 10µF electrolytic capacitor across the VCC and GND pins of the sensor module.
• Cause 3: Target Surface Angle. A 2-degree tilt in the target object changes the specular reflection angle, drastically altering the light return. Fix: Use a physical jig to hold the target at exactly 90 degrees to the sensor face.

TCS3200 vs TCS34725: When to Upgrade

While the TCS3200 is a fantastic learning tool and works well for high-contrast sorting (e.g., separating red apples from green apples), it struggles with subtle hue differentiation (e.g., sorting dark blue from black). If your project requires high-fidelity colorimetry, consider upgrading to the I2C-based TCS34725.

Extending and Simplifying the Build

Depending on your end goal, you can strip this project down to its bare essentials or scale it up into a full automated system.

How to Simplify the Build

If you only need to detect one specific color (for example, verifying that a red indicator LED on a machine is illuminated), you do not need to cycle through all three filters. Hardwire S2 and S3 to the appropriate logic levels for the Red filter, remove the filter-switching code, and simply read the frequency on the OUT pin. If the frequency exceeds your calibrated threshold, the light is red. This reduces code complexity and frees up three GPIO pins on your microcontroller.

How to Extend the Build

To turn this into a standalone sorting machine:

• Add an I2C Display: Wire an SSD1306 128x64 OLED display to the A4/A5 I2C pins. Print the dominant color name (e.g., "RED DETECTED") based on which of the three RGB values is highest. This eliminates the need for a serial monitor during deployment.
• Integrate a Servo Sorter: Connect an SG90 micro servo to Digital Pin 9. In the loop(), add logic that sweeps the servo to 0 degrees if redValue is dominant, 90 degrees if greenValue is dominant, and 180 degrees if blueValue is dominant.
• Implement Moving Average Filtering: Because the TCS3200 is susceptible to electrical noise, a single pulseIn() read can spike. Extend the code to take 10 rapid readings, discard the highest and lowest values, and average the remaining 8 before passing the frequency to the map() function. This dramatically stabilizes the RGB output on the serial plotter.