ESP32 S3 - TCS3200D/TCS230 Farbsensor
Lernen Sie, wie Sie den TCS3200D/TCS230-Farbsensor für eine genaue RGB-Farberkennung an Ihren ESP32 S3 anschließen. Dieses einsteigerfreundliche Tutorial behandelt Verdrahtung, Kalibrierung und Farbmessungen in Echtzeit mit Ihrem ESP32 S3.
Was Sie bauen werden:
- Eine verdrahtete Verbindung zwischen dem TCS3200D/TCS230-Farbsensor und dem ESP32 S3
- Einen Kalibrierungs-Sketch, der minimale und maximale Pulsbreiten für jeden Farbkanal erfasst
- Einen Sketch zum Farbauslesen, der Rohdaten des Sensors in Standard-RGB-Werte (0–255) umwandelt
- Eine Ausgabe im seriellen Monitor, die Farbmessungen für rote, grüne und blaue Objekte in Echtzeit anzeigt
Erforderliche Hardware
Oder Sie können die folgenden Kits kaufen:
| 1 | × | DIYables ESP32 S3 Starter-Kit (ESP32 S3 enthalten) | |
| 1 | × | DIYables Sensor-Kit (18 Sensoren/Displays) |
Offenlegung: Einige der in diesem Abschnitt bereitgestellten Links sind Amazon-Affiliate-Links. Wir können eine Provision für Käufe erhalten, die über diese Links getätigt werden, ohne zusätzliche Kosten für Sie. Wir schätzen Ihre Unterstützung.
Überblick über TCS3200D/TCS230 Color Sensor
Der TCS3200D/TCS230 ist ein optischer Sensor, der Farben erkennt, indem er Lichtreflexionen über spezielle Fotodioden-Filter misst. Er gibt ein Rechtecksignal aus, dessen Frequenz proportional zur erfassten Lichtintensität ist, wodurch er sich einfach an die digitalen Eingangspins des ESP32 S3 anschließen lässt. Seine integrierten weißen LEDs sorgen für eine gleichmäßige Beleuchtung, sodass die Messwerte unter verschiedenen Umgebungslichtbedingungen zuverlässig bleiben.
Wichtige Spezifikationen
- 64 Fotodioden in einer 8×8-Matrix (16 Rot-, 16 Grün-, 16 Blau- und 16 Klarfilter)
- Frequenzausgang proportional zur Lichtintensität
- Betriebsspannung: 2,7 V bis 5,5 V (5 V empfohlen)
- Integrierte weiße LED-Beleuchtung für gleichmäßige Messwerte
- Ausgangsfrequenzbereich: 2 Hz bis 500 kHz
- Ideal für Einsteiger: einfacher digitaler Ausgang, keine komplexe Analogmessung
Pinbelegung
Der TCS3200D/TCS230-Farbsensor hat 8 Anschlusspins, die jeweils eine bestimmte Aufgabe bei Stromversorgung, Steuerung und Signalausgabe erfüllen:
- VCC: Eingang der Stromversorgung (mit 5 V verbinden)
- GND: Masseanschluss (0-V-Bezug)
- S0: Steuerpin 1 für die Frequenzskalierung
- S1: Steuerpin 2 für die Frequenzskalierung
- S2: Pin 1 zur Farbfilterauswahl
- S3: Pin 2 zur Farbfilterauswahl
- OUT: Pin für das Frequenzausgangssignal (mit einem digitalen Pin des ESP32 S3 verbinden)
- OE: Ausgangsfreigabe-Pin (aktiv LOW, normalerweise mit GND verbunden)
Funktionsweise
Der TCS3200-Farbsensor arbeitet mit zwei Steuersystemen:
Frequenzskalierung (Pins S0 und S1):
- S0=LOW, S1=LOW: Energiesparmodus (ausgeschaltet)
- S0=LOW, S1=HIGH: 2 % Frequenzskalierung
- S0=HIGH, S1=LOW: 20 % Frequenzskalierung
- S0=HIGH, S1=HIGH: 100 % Frequenzskalierung (empfohlen)
Farbfilterauswahl (Pins S2 und S3):
- S2=LOW, S3=LOW: Rotfilter aktiv
- S2=LOW, S3=HIGH: Blaufilter aktiv
- S2=HIGH, S3=LOW: Klarfilter (keine Filterung)
- S2=HIGH, S3=HIGH: Grünfilter aktiv
So funktionieren die Messungen:
- Der OUT-Pin gibt ein Rechtecksignal aus
- Die Frequenz steigt mit hellerem Licht (2 Hz bis 500 kHz)
- Der ESP32 S3 misst die Pulsbreite mit pulseIn()
- Kürzere Pulse = helleres Licht = höhere Farbintensität
- Die Kalibrierung wandelt Pulsbreiten in Standard-RGB-Werte (0-255) um
Messgenauigkeit maximieren
Befolgen Sie diese Tipps für genaue Farbmessungen mit dem TCS3200:
- Halten Sie einen festen Abstand von 1-3 cm zwischen Sensor und Objekt ein
- Positionieren Sie den Sensor in einem gleichbleibenden Winkel (senkrecht funktioniert am besten)
- Verwenden Sie die integrierten weißen LEDs für eine stabile Beleuchtung
- Schirmen Sie den Sensor nach Möglichkeit vor externen Lichtquellen ab
- Führen Sie die Kalibrierung in Ihrer tatsächlichen Arbeitsumgebung durch
- Testen Sie auf flachen, matten Oberflächen, um die besten Ergebnisse zu erzielen
Verdrahtungsdiagramm
Verbinden Sie den TCS3200D-Farbsensor anhand der Pinzuordnung in der folgenden Tabelle mit Ihrem ESP32 S3. Der Sensor arbeitet mit 5 V, die der ESP32 S3 bei USB-Versorgung über seinen 5V-Pin bereitstellt, sodass keine zusätzliche Spannungsregelung erforderlich ist.
Sicherheitshinweise
Der TCS3200-Sensor funktioniert am besten mit einer 5-V-Versorgung, die der ESP32 S3 bei USB-Versorgung über den 5V-Pin liefern kann. Die Signalleitungen des Sensors werden bei den meisten Modulen ohne Pegelwandler direkt mit den digitalen Pins des ESP32 S3 verbunden. Überprüfen Sie jedoch vor dem Anschließen die Ausgangsspannung Ihres Moduls.
| TCS3200 Farbsensor | ESP32 S3 |
|---|---|
| VCC | 5V |
| GND | GND |
| S0 | GPIO41 |
| S1 | GPIO40 |
| S2 | GPIO16 |
| S3 | GPIO7 |
| OUT | GPIO18 |
Dieses Bild wurde mit Fritzing erstellt. Klicken Sie, um das Bild zu vergrößern.
ESP32 S3 Code - Sensorkalibrierung
Der folgende Code richtet den TCS3200-Sensor an Ihrem ESP32 S3 ein und führt Sie durch einen Kalibrierungsprozess, der den gesamten Dynamikbereich Ihres Sensors und Ihrer Umgebung erfasst. Laden Sie diesen Sketch zuerst hoch und halten Sie den Sensor dann an verschiedene Farben – von hellem Weiß bis zu tiefem Schwarz –, damit er genaue minimale und maximale Pulsbreitenwerte für jeden Kanal aufzeichnen kann.
Was dieser Code macht:
- Schaltet den Sensor mit voller Frequenzskalierung (100 %) ein
- Wechselt nacheinander zwischen Rot-, Grün- und Blaufilter
- Erfasst minimale und maximale Pulsbreiten für jede Farbe
- Aktualisiert die Kalibrierungswerte fortlaufend, während Sie verschiedene Farben zeigen
- Zeigt Messwerte in Echtzeit im seriellen Monitor an
/*
* Dieser ESP32 S3 Code wurde von newbiely.de entwickelt
* Dieser ESP32 S3 Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt.
* Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte:
* https://newbiely.de/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;
}
Schnelle Schritte
- Neu beim ESP32 S3? Arbeiten Sie zuerst unsere Anleitung Erste Schritte mit dem ESP32 S3 durch.
- Bauteile verdrahten: Folgen Sie dem obigen Verdrahtungsplan, um alle Pins korrekt anzuschließen.
- Board anschließen: Verbinden Sie den ESP32 S3 über ein USB-C-Kabel mit Ihrem Computer.
- Arduino IDE öffnen: Starten Sie die Software auf Ihrem Computer.
- Board auswählen: Wählen Sie im Menü Tools den ESP32 S3 und den richtigen COM-Port aus.
- Code kopieren: Fügen Sie den Kalibrierungscode in einen neuen Arduino-IDE-Sketch ein.
- Code hochladen: Klicken Sie auf die Schaltfläche Upload und warten Sie, bis der Vorgang abgeschlossen ist.
- Seriellen Monitor öffnen: Stellen Sie die Baudrate auf 115200 ein, um die Kalibrierungsdaten anzuzeigen.
- Auf weiße Objekte richten: Beginnen Sie mit hellweißem Papier oder hellweißen Oberflächen.
- Auf schwarze Objekte richten: Wechseln Sie zu dunklen, schwarzen Oberflächen.
- Auf farbige Objekte richten: Zeigen Sie dem Sensor verschiedene farbige Gegenstände (rot, grün, blau, gelb usw.).
- Stabilisierung der Werte beobachten: Nach 10-20 Sekunden ändern sich die Min/Max-Werte nicht mehr wesentlich.
- Werte notieren: Schreiben Sie alle sechs Zahlen auf (redMin, redMax, greenMin, greenMax, blueMin, blueMax).
- Profi-Tipp: Halten Sie während der Kalibrierung einen gleichbleibenden Sensorabstand (2-3 cm) ein, um möglichst genaue Ergebnisse zu erzielen.
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
------------------------------------------
Kalibrierungswerte aus diesem Beispiel:
- RedMin = 38, redMax = 210
- GreenMin = 51, greenMax = 185
- BlueMin = 58, blueMax = 172
ESP32 S3 Code - RGB-Farbwerte auslesen
Der folgende Code verwendet Ihre notierten Kalibrierungswerte, um genaue, normierte RGB-Werte vom TCS3200-Sensor zu liefern. Nachdem Sie Ihre Kalibrierungswerte eingetragen haben, laden Sie den Sketch hoch und richten den Sensor auf verschiedenfarbige Oberflächen, um die RGB-Ausgabe in Echtzeit im seriellen Monitor zu sehen. Die Messwerte werden fortlaufend aktualisiert, während Sie farbige Objekte in den Erfassungsbereich bewegen.
Was dieser Code macht:
- Verwendet Ihre Kalibrierungswerte, um die Sensormesswerte zu normieren
- Misst nacheinander den roten, grünen und blauen Kanal
- Wandelt Roh-Pulsbreiten in das Standard-RGB-Format (0-255) um
- Zeigt die Farbwerte fortlaufend im seriellen Monitor an
- Aktualisiert die Messwerte in Echtzeit, während Sie farbige Objekte bewegen
/*
* Dieser ESP32 S3 Code wurde von newbiely.de entwickelt
* Dieser ESP32 S3 Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt.
* Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte:
* https://newbiely.de/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;
}
Schnelle Schritte
- Neu beim ESP32 S3? Arbeiten Sie zuerst unsere Anleitung Erste Schritte mit dem ESP32 S3 durch.
- Kalibrierungsvariablen finden: Suchen Sie diese Zeilen im oberen Teil des Codes (etwa Zeile 10-15):
int redMin = 0;
int redMax = 0;
int greenMin = 0;
int greenMax = 0;
int blueMin = 0;
int blueMax = 0;
- Kalibrierungswerte eintragen: Ersetzen Sie alle Nullen durch die Zahlen, die Sie bei der Kalibrierung notiert haben. Zum Beispiel:
int redMin = 38;
int redMax = 210;
int greenMin = 51;
int greenMax = 185;
int blueMin = 58;
int blueMax = 172;
- Code hochladen: Klicken Sie auf Upload, um den geänderten Code auf Ihren ESP32 S3 zu übertragen.
- Seriellen Monitor öffnen: Stellen Sie die Baudrate auf 115200 ein, um die RGB-Werte zu sehen.
- Mit farbigen Objekten testen: Halten Sie rote, grüne, blaue, gelbe oder andere farbige Gegenstände vor den Sensor.
- RGB-Werte ablesen: Beobachten Sie, wie sich die Farbmessungen im seriellen Monitor in Echtzeit aktualisieren.
- Profi-Tipp: Für gleichbleibende Ergebnisse sollten Sie immer denselben Abstand und dieselben Lichtverhältnisse wie bei der Kalibrierung beibehalten.
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
Die Ausgabe verstehen:
- Die Werte reichen von 0 (keine Farbe erkannt) bis 255 (maximale Intensität)
- Höhere Zahlen bedeuten, dass mehr von dieser Farbe reflektiert wird
- Die ersten drei Zeilen zeigen ein rotes Objekt (hoher Rotwert, niedrige Grün-/Blauwerte)
- Die mittleren drei Zeilen zeigen ein grünes Objekt (hoher Grünwert)
- Die letzten drei Zeilen zeigen ein blaues Objekt (hoher Blauwert)
Projektanwendungen
Der ESP32 S3 in Kombination mit dem TCS3200D/TCS230-Sensor eröffnet eine Vielzahl farbbezogener Projekte – von einfachen Erkennungsaufgaben bis hin zu komplexen automatisierten Systemen.
- Automatischer Farbsortierer: M&Ms, LEGO-Steine oder Perlen mit einem Servomechanismus nach Farbe sortieren
- Farbzuordnungsspiel: Benutzer herausfordern, Objekte zu finden, die einem Ziel-RGB-Wert entsprechen
- Linienfolgender Roboter: Einen Roboter bauen, der farbigen Klebebandpfaden auf dem Boden folgt
- Qualitätskontrollsystem: Fehlerhafte Produkte durch Vergleich der Farben mit Referenzstandards erkennen
- Intelligente Lichtsteuerung: RGB-LED-Farben automatisch an erkannte Umgebungsfarben anpassen
- Wandfarben-Erkenner: Ein Handgerät bauen, das Wandfarben für die Wohnungsgestaltung erkennt
- Lehrreicher Farbmischer: Die additive Farbtheorie durch Anzeige der RGB-Werte gemischter Farben veranschaulichen
Video-Bereich
Sehen Sie sich unten die Schritt-für-Schritt-Videoanleitung für dieses ESP32-S3-Projekt an.
Fordern Sie sich heraus
Diese Herausforderungen bringen Ihre Fähigkeiten mit dem ESP32 S3 und dem TCS3200 weiter voran – von einfachem LED-Feedback bis hin zu vollständigen Anwendungen mit drahtloser Farbübertragung.
- Anfänger: Eine RGB-LED hinzufügen, die in der vom Sensor erkannten Farbe leuchtet
- Anfänger: Bei erkannten Grundfarben Farbnamen („Rot“, „Grün“, „Blau“) statt nur Zahlen anzeigen
- Fortgeschritten: Ein Farb-Memory-Spiel bauen, das zufällige Farben anzeigt und testet, ob Benutzer sie zuordnen können
- Fortgeschritten: Ein farbbasiertes Sicherheitssystem erstellen, das nur entriegelt, wenn ein bestimmtes farbiges Objekt gezeigt wird
- Experte: Einen vollständigen Farbsortierer mit Servomotoren bauen, der Objekte physisch nach Farbe in Behälter sortiert
- Experte: Eine Smartphone-App entwickeln, die RGB-Werte vom ESP32 S3 über Bluetooth empfängt und die tatsächliche Farbe auf dem Bildschirm anzeigt