Guide to 9. Color Sorting Mobile Robot: Wheeled platforms equipped with color sensors to identify, sort, and transport physical objects to matching color-coded zones.

Color Sorting Mobile Robot

A complete beginner-to-advanced tutorial on building a wheeled robot that识be, sorts, and transports objects using color detection—perfect for educators, hobbyists, and makers.

What You’ll Build

You’ll create a fully autonomous mobile robot—equipped with wheels, a color sensor, and intelligent logic—that scans physical objects (like colored blocks), determines their hue, and delivers them to color-matched zones in a workspace.

• ✔ Autonomous navigation
• ✔ Real-time color recognition
• ✔ Dynamic sorting logic
• ✔ Responsive gripper or pusher mechanism

Ideal applications: warehouse automation prototypes, STEM labs, recycling sorters, and smart home helpers.

Design Tip

Color consistency is critical. Use consistent lighting (avoid shadows) and calibrate your sensor on reference color swatches before deployment.

1. Core Components

Let’s explore the essential hardware—each component selected for reliability, ease of use, and cost-effectiveness.

Microcontroller

Arduino Uno or ESP32 (dual-core, built-in Wi-Fi optional). The ESP32 excels for real-time vision or cloud integration.

Color Sensor

TAOS TCS34725 or Adafruit RGB Color Sensor. Offers RGBC (Red-Green-Blue-Clear) data with 16-bit precision.

Mobile Platform

Chassis with dual DC motors, encoders (for odometry), and a 2WD base. Example: SunFounder Smart Car Kit.

Actuation

Servo motor (e.g., SG90) or linear actuator for pushing/delivering objects into zones.

2. System Architecture

The robot operates in five unified phases:

1. Scan — Robot approaches object with color sensor illuminated.
2. Classify — Compare sensor data (R, G, B, Clear) against calibrated thresholds.
3. Plan — Choose target zone: Red, Blue, Green, or Unsorted.
4. Navigate — Use encoder feedback to drive to the zone.
5. Deploy — Release or push object into zone.

Calibration First!

Colors vary under different lighting. Before deployment:

• Place each reference color (red, green, blue) in front of the sensor.
• Record raw RGBC values.
• Define tolerance ranges (e.g., red: R ≥ 150, G ≤ 80, B ≤ 80).

Bonus: Use the Clear channel to adjust brightness—normalize RGB ratios for consistency.

3. Wiring & Setup

Here’s a clean setup using an Arduino Uno (or compatible). For ESP32, simply replace pins with suitable PWM/I²C choices.

Color Sensor (TCS34725) — I²C

Sensor Pin	Arduino Pin
VCC	3.3V
GND	GND
SCL	A5
SDA	A4
INT	(Optional) D2

Motor Driver (L298N) — Dual DC Motors

Driver Pin	Arduino Pin
IN1	9 (Left Motor EN)
IN2	8 (Left Motor DIR)
IN3	5 (Right Motor EN)
IN4	4 (Right Motor DIR)

Power Tip: Use a separate 6V or 7.4V LiPo pack for the motors—don’t draw high current from the Arduino 5V line!

4. Control Logic (Code Walkthrough)

The robot’s brain executes a simple but powerful decision tree. Here’s a simplified but production-ready sketch for Arduino (with TCS34725.h and Wire.h included).

#include <Wire.h>
#include <Adafruit_TCS34725.h>

// Motor Pins
#define L_EN 9
#define L_DIR 8
#define R_EN 5
#define R_DIR 4

// Color thresholds (custom-calibrated)
const int R_MIN = 140, R_MAX = 255;
const int G_MIN = 0, G_MAX = 85;
const int B_MIN = 0, B_MAX = 90;

Adafruit_TCS34725 tcs = Adafruit_TCS34725(TCS34725_INTEGRATIONTIME_700MS, TCS34725_GAIN_1X);

void setup() {
  Serial.begin(9600);
  if (!tcs.begin()) {
    Serial.println("Color sensor error!");
    while (1);
  }
  pinMode(L_EN, OUTPUT);
  pinMode(R_EN, OUTPUT);
  // Add your encoder or servo setup here
}

void loop() {
  uint16_t red, green, blue, clear;
  tcs.getRawData(&red, &green, &blue, &clear);
  
  Serial.printf("R:%u G:%u B:%u\n", red, green, blue);

  // Normalize and classify color
  if (red > R_MIN && green < G_MAX && blue < B_MAX) {
    Serial.println("Object: RED — sending to zone A");
    deliverToZone('A');
  } 
  else if (green > G_MIN && red < R_MIN && blue < B_MAX) {
    Serial.println("Object: GREEN — sending to zone B");
    deliverToZone('B');
  } 
  else if (blue > B_MIN && red < R_MIN && green < G_MAX) {
    Serial.println("Object: BLUE — sending to zone C");
    deliverToZone('C');
  } 
  else {
    Serial.println("Unknown — store or re-scan");
  }

  delay(2000); // Wait between scans
}

void deliverToZone(char zone) {
  // Move forward 20 cm (approx. based on encoder ticks or time)
  moveForward(2000);
  // Push with servo (e.g., sweep 0→180°)
  pushObject();
  // Return to start position
  moveBackward(2000);
}

void moveForward(int ms) {
  digitalWrite(L_DIR, HIGH); digitalWrite(L_EN, HIGH);
  digitalWrite(R_DIR, HIGH); digitalWrite(R_EN, HIGH);
  delay(ms);
  stopMotors();
}

void moveBackward(int ms) {
  digitalWrite(L_DIR, LOW); digitalWrite(L_EN, HIGH);
  digitalWrite(R_DIR, LOW); digitalWrite(R_EN, HIGH);
  delay(ms);
  stopMotors();
}

void stopMotors() {
  digitalWrite(L_EN, LOW);
  digitalWrite(R_EN, LOW);
}

void pushObject() {
  // Simple servo push—replace with your hardware
  // Example: myservo.write(180); delay(300); myservo.write(0);
}

Why This Works

The sensor data is compared against calibrated thresholds—not absolute values—making it robust across lighting. The deliverToZone() function abstracts motion, keeping logic modular and debuggable.

5. Zone Layout & Navigation

A clean workspace layout ensures reliability. Here’s a recommended configuration for a 1-meter-square table:

📍

Central Zone

Start point (home). Robot begins here, returns after sorting.

🎨

Color Zones

Four zones placed at corners: Red (NW), Blue (NE), Green (SW), Yellow (SE). Use printed color tape.

Simple Navigation Strategy

Beginner approach: Use time-based movement with known travel durations (e.g., drive 2 seconds forward = 30 cm). For accuracy:

• Add encoders to measure distance per wheel revolution.
• Use line-following tape to create guided paths.
• Upgrade to Ultrasonic sensors to detect zone walls (e.g., a red zone is 15 cm wide).

Design Challenge

How would you adapt the robot for dynamic sorting—e.g., if a new color (magenta) is introduced mid-task? Think modular threshold sets and serial update capability.

6. Troubleshooting Guide

Issue: Color detection flickers or mis-reads.
Solution: Increase integration time (e.g., 700ms), add a diffuser over the sensor, and reduce ambient light.

Issue: Robot veers off course.
Solution: Calibrate motor voltages, add encoders, and implement a simple PID loop on motor speeds.

Issue: Actuator doesn’t push reliably.
Solution: Add mechanical stops, increase servo torque (use 180° travel), and ensure object placement is consistent.

7. Upgrade Path

Once the base model works, level up with:

• Machine Vision: Replace the single sensor with a camera + OpenCV (on Raspberry Pi or Jetson Nano) for 2D color mapping.
• Wireless Updates: Use ESP32 Wi-Fi to update thresholds over HTTP—no reflash needed.
• Multi-Robot Co-op: Synchronize via MQTT to handle parallel sorting tasks.
• Real-Time Analytics: Log color counts per hour on an SD card or cloud dashboard.

Ready to Build?

Conclusion

This color-sorting mobile robot brings tangible AI to your desk: simple hardware, smart decisions, and satisfying motion. Every component—sensing, logic, actuation—works together to solve a real-world task: classification through movement.

Start with the wiring and thresholds, iterate with confidence, and soon your workspace will host a truly autonomous helper—quiet, precise, and endlessly adaptable.

"Automation begins not with intelligence—but with a reliable color sensor, two wheels, and the courage to calibrate."

© 2024 Future Tech Labs • Built for Makers, by Makers