ESP32 C3 Super Mini - TCS3200D/TCS230 Farbsensor
Erfahren Sie, wie Sie den TCS3200D/TCS230 Farbsensor an Ihren ESP32 C3 Super Mini anschließen, um RGB-Farben genau zu erkennen. Dieses einsteigerfreundliche Tutorial behandelt die Kalibrierung und Farbmessungen in Echtzeit.
Was Sie lernen werden:
- Was der TCS3200D/TCS230 Farbsensor ist und wie er Farben erkennt
- Wie Sie den TCS3200 Sensor mit dem ESP32 C3 Super Mini verdrahten
- Wie Sie den Sensor für genaue Messwerte kalibrieren
- Wie Sie RGB-Farbwerte auslesen und anzeigen
- Praktische Anwendungen für Farberkennungsprojekte
Erforderliche Hardware
| 1 | × | ESP32 C3 Super Mini | |
| 1 | × | USB-Kabel Typ-A zu Typ-C (für USB-A PC) | |
| 1 | × | USB-Kabel Typ-C zu Typ-C (für USB-C PC) | |
| 1 | × | TCS3200D/TCS230 Color Recognition Sensor Module | |
| 1 | × | Breadboard | |
| 1 | × | Verbindungskabel |
Oder Sie können die folgenden Kits kaufen:
| 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.
Hauptmerkmale:
- 64 Fotodioden in einem 8×8-Array (16 Rotfilter, 16 Grün, 16 Blau, 16 ohne Filter)
- Frequenzausgang proportional zur Lichtintensität
- Betriebsspannung: 2,7V bis 5,5V (5V empfohlen)
- Eingebaute weiße LED-Beleuchtung für gleichmäßige Messwerte
- Ausgangsfrequenzbereich: 2 Hz bis 500 kHz
- Ideal für Einsteiger: einfacher digitaler Ausgang, keine komplexe analoge Messung
Warum er nützlich ist:
- Funktioniert dank der integrierten LEDs bei verschiedenen Lichtverhältnissen
- Einfache Anbindung an die digitalen Pins des ESP32 C3 Super Mini
- Perfekt für Projekte zum Sortieren, Abgleichen und Erkennen von Farben
Pinbelegung
Der TCS3200D/TCS230 Farbsensor hat 8 Anschlusspins:
- VCC: Stromversorgungseingang (mit 5V verbinden)
- GND: Masseanschluss (0V-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 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: Ohne Filter (keine Filterung)
- S2=HIGH, S3=HIGH: Grünfilter aktiv
Wie die Messung funktioniert:
- Der OUT-Pin gibt ein Rechtecksignal aus
- Die Frequenz steigt mit hellerem Licht (2 Hz bis 500 kHz)
- Der ESP32 C3 Super Mini 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 TCS3200 Farbmesswerte:
- Halten Sie den Sensorabstand fest bei 1-3 cm zum Objekt
- Positionieren Sie den Sensor in einem gleichbleibenden Winkel (senkrecht funktioniert am besten)
- Verwenden Sie die eingebauten weißen LEDs für eine stabile Beleuchtung
- Schirmen Sie den Sensor nach Möglichkeit von externen Lichtquellen ab
- Führen Sie die Kalibrierung in Ihrer tatsächlichen Arbeitsumgebung durch
- Testen Sie auf flachen, matten Oberflächen für beste Ergebnisse
Verdrahtungsdiagramm
Verbinden Sie den TCS3200D Farbsensor mit Ihrem ESP32 C3 Super Mini gemäß dieser einfachen Verdrahtung:
Sicherheitshinweis:
- Hinweis: Der TCS3200 Sensor funktioniert am besten mit 5V, die der ESP32 C3 Super Mini über den 5V-Pin liefern kann, wenn er per USB versorgt wird.
| TCS3200 Farbsensor | ESP32 C3 Super Mini |
|---|---|
| VCC | 5V |
| GND | GND |
| S0 | D4 |
| S1 | D3 |
| S2 | D6 |
| S3 | D5 |
| OUT | D7 |
Dieses Bild wurde mit Fritzing erstellt. Klicken Sie, um das Bild zu vergrößern.
ESP32 C3 Super Mini Code - Sensorkalibrierung
Beginnen Sie mit diesem Kalibrierungscode, um Ihren TCS3200 Sensor für Ihre spezifische Umgebung zu optimieren.
Was dieser Code macht:
- Schaltet den Sensor mit voller Frequenzskalierung (100%) ein
- Wechselt nacheinander zwischen Rot-, Grün- und Blaufilter
- Erfasst die minimalen und maximalen Pulsbreiten für jede Farbe
- Aktualisiert die Kalibrierungswerte fortlaufend, während Sie verschiedene Farben zeigen
- Zeigt Echtzeit-Messwerte im Seriellen Monitor an
/*
* Dieser ESP32 C3 Super Mini Code wurde von newbiely.de entwickelt
* Dieser ESP32 C3 Super Mini 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-c3/esp32-c3-super-mini-tcs3200d-tcs230-color-sensor
*/
// Define color sensor pins
#define PIN_S0 4 // The ESP32 C3 SuperMini pin connected to the S0 of the color module
#define PIN_S1 3 // The ESP32 C3 SuperMini pin connected to the S1 of the color module
#define PIN_S2 6 // The ESP32 C3 SuperMini pin connected to the S2 of the color module
#define PIN_S3 5 // The ESP32 C3 SuperMini pin connected to the S3 of the color module
#define PIN_sensorOut 7 // The ESP32 C3 SuperMini 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 C3 Mini? Absolvieren Sie zuerst unser Tutorial Erste Schritte mit dem ESP32 C3 Mini, um Ihre Entwicklungsumgebung einzurichten.
- Bauteile verdrahten: Folgen Sie dem obigen Schaltplan, um alle Pins korrekt zu verbinden.
- Board anschließen: Verbinden Sie den ESP32 C3 Super Mini ü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ü Werkzeuge den ESP32 C3 Super Mini 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 hellem weißem Papier oder hellen 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-Zahlen kaum noch.
- Werte notieren: Schreiben Sie alle sechs Zahlen auf (redMin, redMax, greenMin, greenMax, blueMin, blueMax).
- Profi-Tipp: Halten Sie den Sensorabstand während der Kalibrierung konstant (2-3 cm), um möglichst genaue Ergebnisse zu erzielen.
8
Serial.println("Hello World!");
Message (Enter to send message to 'ESP32C3 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 C3 Super Mini Code - RGB-Farbwerte auslesen
Verwenden Sie diesen Code, um nach der Kalibrierung genaue RGB-Farbwerte auszulesen.
Was dieser Code macht:
- Wendet Ihre Kalibrierungswerte an, um die Sensorwerte zu normalisieren
- Misst nacheinander den roten, grünen und blauen Kanal
- Wandelt rohe 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 C3 Super Mini Code wurde von newbiely.de entwickelt
* Dieser ESP32 C3 Super Mini 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-c3/esp32-c3-super-mini-tcs3200d-tcs230-color-sensor
*/
// Define color sensor pins
#define PIN_S0 4 // The ESP32 C3 SuperMini pin connected to the S0 of the color module
#define PIN_S1 3 // The ESP32 C3 SuperMini pin connected to the S1 of the color module
#define PIN_S2 6 // The ESP32 C3 SuperMini pin connected to the S2 of the color module
#define PIN_S3 5 // The ESP32 C3 SuperMini pin connected to the S3 of the color module
#define PIN_sensorOut 7 // The ESP32 C3 SuperMini 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 C3 Mini? Absolvieren Sie zuerst unser Tutorial Erste Schritte mit dem ESP32 C3 Mini, um Ihre Entwicklungsumgebung einzurichten.
- 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 C3 Super Mini 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 Farbmesswerte im Seriellen Monitor in Echtzeit aktualisieren.
- Profi-Tipp: Für gleichbleibende Ergebnisse halten Sie stets denselben Abstand und dieselben Lichtverhältnisse ein, die Sie bei der Kalibrierung verwendet haben.
8
Serial.println("Hello World!");
Message (Enter to send message to 'ESP32C3 Dev Module' on 'COM15')
New Line
9600 baud
Red = 210 - Green = 35 - Blue = 20
Red = 215 - Green = 38 - Blue = 22
Red = 208 - Green = 33 - Blue = 18
Red = 25 - Green = 200 - Blue = 40
Red = 28 - Green = 205 - Blue = 42
Red = 22 - Green = 198 - Blue = 38
Red = 30 - Green = 45 - Blue = 215
Red = 33 - Green = 48 - Blue = 220
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
Bauen Sie kreative Farberkennungsprojekte mit Ihrem ESP32 C3 Super Mini und dem TCS3200 Sensor:
- Automatischer Farbsortierer: Sortieren Sie M&Ms, LEGO-Steine oder Perlen mit einem Servo-Mechanismus nach Farbe
- Farbzuordnungsspiel: Fordern Sie Benutzer heraus, Objekte zu finden, die einem Ziel-RGB-Wert entsprechen
- Linienfolger-Roboter: Bauen Sie einen Roboter, der farbigen Klebebandpfaden auf dem Boden folgt
- Qualitätskontrollsystem: Erkennen Sie fehlerhafte Produkte durch Vergleich der Farben mit Referenzstandards
- Intelligente Lichtsteuerung: Passen Sie RGB-LED-Farben automatisch an erkannte Umgebungsfarben an
- Farbton-Erkenner: Bauen Sie ein Handgerät, das Wandfarben für die Wohnungsgestaltung erkennt
- Lehrreicher Farbmischer: Veranschaulichen Sie die additive Farbtheorie, indem Sie RGB-Werte gemischter Farben anzeigen
Video-Abschnitt
Sehen Sie sich das folgende Video für eine visuelle Schritt-für-Schritt-Anleitung zu diesem Projekt an.
Fordern Sie sich heraus
Erweitern Sie Ihre Fähigkeiten mit dem TCS3200 Farbsensor mit diesen Projektaufgaben:
- Einfach: Fügen Sie eine RGB-LED hinzu, die in derselben Farbe leuchtet, die der Sensor erkennt
- Einfach: Zeigen Sie Farbnamen ("Rot", "Grün", "Blau") statt nur Zahlen an, wenn Grundfarben erkannt werden
- Mittel: Bauen Sie ein Farb-Memory-Spiel, das zufällige Farben zeigt und prüft, ob Benutzer sie zuordnen können
- Mittel: Erstellen Sie ein farbbasiertes Sicherheitssystem, das nur entriegelt, wenn ein bestimmtes farbiges Objekt gezeigt wird
- Fortgeschritten: Bauen Sie einen vollständigen Farbsortierer mit Servomotoren, die Objekte physisch nach Farbe in Behälter trennen
- Fortgeschritten: Entwickeln Sie eine Smartphone-App, die RGB-Werte vom ESP32 C3 Super Mini über Bluetooth empfängt und die tatsächliche Farbe auf dem Bildschirm anzeigt