ESP8266 - TCS3200D/TCS230 Farbsensor
Dieses Tutorial führt Sie durch die Verwendung des ESP8266 mit dem TCS3200D/TCS230 Farbsensor für präzise Farberkennung und RGB-Messung.
Im Detail lernen wir:
- Wie Sie den TCS3200D/TCS230 Sensor mit ESP8266 verbinden
- Wie Sie den Sensor für genaue Messwerte kalibrieren
- Wie Sie ESP8266 programmieren, um RGB-Werte zu lesen und anzuzeigen
Hardware Erforderlich
Oder Sie können die folgenden Kits kaufen:
| 1 | × | DIYables Sensor-Kit (30 Sensoren/Displays) | |
| 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.
Über den TCS3200D/TCS230 Farbsensor
Der TCS3200D/TCS230 Farbsensor verwendet ein Raster von 64 Fotodioden, die in einer 8×8-Matrix angeordnet sind, zur Farberkennung durch wellenlängenspezifische Filterung. Innerhalb dieser Anordnung verwenden 16 Fotodioden rote Wellenlängenfilter, 16 verwenden grüne Wellenlängenfilter, 16 verwenden blaue Wellenlängenfilter, und 16 arbeiten ohne Filterung (klare Antwort). Die Farbmessung erfolgt durch Auswahl bestimmter Filtersätze und Bewertung der Frequenz des Ausgangssignals.
Gängige TCS3200D-Module verfügen über integrierte weiße LED-Beleuchtungsanordnungen, die konsistente Zielbeleuchtung bereitstellen, wodurch Messstabilität unabhängig von externen Beleuchtungsschwankungen gewährleistet und die Empfindlichkeit bei schwachen Lichtverhältnissen verbessert wird.
Pinbelegung
Pin-Konfiguration des TCS3200D/TCS230 Sensormoduls:
- VCC-Pin: Versorgungsspannung (+5V).
- GND-Pin: Massebezug (0V).
- S0, S1-Pins: Ausgangsfrequenz-Skalierungswähler.
- S2, S3-Pins: Farbkanal-Filterwähler.
- OUT-Pin: Frequenzmodulierter Rechteckwellenausgang.
- OE-Pin: Ausgangsfreigabe-Eingang (aktiviert bei LOW). Standardmodule verdrahten dies typischerweise intern fest mit GND. Falls nicht verbunden, manuell mit GND verbinden.
Funktionsweise
Die Sensorfunktion hängt von zwei Hauptsteuerelementen ab: welche Fotodioden-Filtergruppe aktiviert werden soll und welcher Ausgangsfrequenzbereich erzeugt werden soll. Zwei Steuerpinpaare verwalten diese Funktionen:
Frequenzskalierungssteuerung (S0- und S1-Pins):
- S0=LOW, S1=LOW: Ausschaltzustand
- S0=LOW, S1=HIGH: 2% Skalierungsfaktor
- S0=HIGH, S1=LOW: 20% Skalierungsfaktor
- S0=HIGH, S1=HIGH: 100% Skalierungsfaktor (Vollgeschwindigkeit)
Farbkanalauswahl (S2- und S3-Pins):
- S2=LOW, S3=LOW: Rote Fotodioden aktiv
- S2=LOW, S3=HIGH: Blaue Fotodioden aktiv
- S2=HIGH, S3=LOW: Klare Fotodioden aktiv (keine Filterung)
- S2=HIGH, S3=HIGH: Grüne Fotodioden aktiv
Der OUT-Pin liefert Rechteckwellenfrequenzen von etwa 2 Hz bis 500 kHz. Höhere Lichtintensität erzeugt höhere Ausgangsfrequenz. ESP8266s pulseIn()-Funktion misst die Impulsdauer, die umgekehrt korreliert—hellere Beleuchtung erzeugt kürzere Dauern. Kalibrierte Messungen übersetzen in das konventionelle 0-255 RGB-Format.
Optimale Präzision erreichen
- Halten Sie den Sensor 1-3 cm vom Messziel entfernt mit stabiler Winkelausrichtung.
- Nutzen Sie die integrierte weiße LED-Beleuchtung für wiederholbare Beleuchtung.
- Schirmen Sie den Sensor vor variablem Umgebungslicht ab, um die Messkonsistenz zu verbessern.
Schaltplan
Verbinden Sie den TCS3200 Farbsensor mit ESP8266 wie folgt:
| TCS3200 Farbsensor | ESP8266 |
|---|---|
| VCC | 3V3 |
| GND | GND |
| S0 | D6 (GPIO12) |
| S1 | D7 (GPIO13) |
| S2 | D2 (GPIO4) |
| S3 | D5 (GPIO14) |
| OUT | D1 (GPIO5) |
Dieses Bild wurde mit Fritzing erstellt. Klicken Sie, um das Bild zu vergrößern.
Weitere Informationen finden Sie unter ESP8266-Pinbelegung und wie man ESP8266 und andere Komponenten mit Strom versorgt.
ESP8266 Code - Sensorkalibrierung
Die Kalibrierung eliminiert Umgebungseinflüsse aus Rohmessungen. Variablen wie LED-Ausgangsstärke, Zielabstand, Materialreflexion und Raumbeleuchtung beeinflussen alle Messwerte. Die Kalibrierungsroutine identifiziert minimale und maximale Impulsbreiten über alle Farbkanäle und etabliert Referenzgrenzen für die Umwandlung von Rohdaten in genaue 0–255 RGB-Werte, die zu Ihrer Einsatzumgebung passen.
/*
* Dieser ESP8266 NodeMCU Code wurde von newbiely.de entwickelt
* Dieser ESP8266 NodeMCU 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/esp8266/esp8266-tcs3200d-tcs230-color-sensor
*/
// Define color sensor pins
#define PIN_S0 D6 // The ESP8266 pin GPIO12 connected to the S0 of the color module
#define PIN_S1 D7 // The ESP8266 pin GPIO13 connected to the S1 of the color module
#define PIN_S2 D2 // The ESP8266 pin GPIO4 connected to the S2 of the color module
#define PIN_S3 D5 // The ESP8266 pin GPIO14 connected to the S3 of the color module
#define PIN_sensorOut D1 // The ESP8266 pin GPIO5 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(9600);
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
Um mit ESP8266 in der Arduino IDE zu beginnen, folgen Sie diesen Schritten:
- Schauen Sie sich das Anleitung zur Einrichtung der Umgebung für ESP8266 in Arduino IDE Tutorial an, falls Sie ESP8266 zum ersten Mal verwenden.
- Verdrahten Sie die Komponenten wie im Diagramm gezeigt.
- Verbinden Sie das ESP8266-Board mit Ihrem Computer über ein USB-Kabel.
- Öffnen Sie Arduino IDE auf Ihrem Computer.
- Wählen Sie das richtige ESP8266-Board, wie z.B. (z.B. NodeMCU 1.0 (ESP-12E Module)), und dessen jeweiligen COM-Port.
- Kopieren Sie den Kalibrierungscode und öffnen Sie ihn in Arduino IDE.
- Klicken Sie auf die Upload-Schaltfläche, um zu kompilieren und auf ESP8266 hochzuladen.
- Öffnen Sie den Serial Monitor.
- Richten Sie den Sensor auf verschiedene Oberflächen: weiß (Papier), schwarz und verschiedene Farben.
- Beobachten Sie, wie sich die Min/Max-Werte automatisch aktualisieren.
- Wenn sich die Werte stabilisiert haben (typischerweise 10-20 Sekunden), notieren Sie alle sechs Kalibrierungsparameter.
COM6
=== 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
------------------------------------------
Autoscroll
Clear output
9600 baud
Newline
Beispiel-Kalibrierungsparameter aus der obigen Ausgabe:
- RedMin = 42, redMax = 210
- GreenMin = 55, greenMax = 185
- BlueMin = 60, blueMax = 172
ESP8266 Code - RGB-Werte auslesen
/*
* Dieser ESP8266 NodeMCU Code wurde von newbiely.de entwickelt
* Dieser ESP8266 NodeMCU 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/esp8266/esp8266-tcs3200d-tcs230-color-sensor
*/
// Define color sensor pins
#define PIN_S0 D6 // The ESP8266 pin GPIO12 connected to the S0 of the color module
#define PIN_S1 D7 // The ESP8266 pin GPIO13 connected to the S1 of the color module
#define PIN_S2 D2 // The ESP8266 pin GPIO4 connected to the S2 of the color module
#define PIN_S3 D5 // The ESP8266 pin GPIO14 connected to the S3 of the color module
#define PIN_sensorOut D1 // The ESP8266 pin GPIO5 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(9600);
}
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
- Lokalisieren Sie die Kalibrierungsvariablen am Code-Anfang:
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
- Ersetzen Sie alle sechs Null-Platzhalter mit den gemessenen Kalibrierungsdaten. Beispiel mit Werten redMin = 42, redMax = 210, greenMin = 55, greenMax = 185, blueMin = 60, blueMax = 172:
int redMin = 42;
int redMax = 210;
int greenMin = 55;
int greenMax = 185;
int blueMin = 60;
int blueMax = 172;
- Laden Sie den aktualisierten Code auf ESP8266 hoch.
- Positionieren Sie ein farbiges Objekt vor dem Sensor.
- Öffnen Sie Serial Monitor, um RGB-Messungen zu betrachten.
COM6
Red = 210 - Green = 35 - Blue = 20
Red = 25 - Green = 200 - Blue = 40
Red = 30 - Green = 45 - Blue = 215
Autoscroll
Clear output
9600 baud
Newline
Angezeigte RGB-Werte entsprechen der Standard-0-255-Skalierung. Reduzierte Impulsbreiten (die hellere Reflexionen anzeigen) erzeugen höhere RGB-Ausgaben; erweiterte Impulsbreiten (schwächere Reflexionen) ergeben niedrigere Werte.
Aus den RGB-Werten können Sie:
- Spezifische Farben durch Vergleich von RGB-Verhältnissen identifizieren
- Objekte nach Farberkennung sortieren
- Farben zwischen verschiedenen Proben abgleichen
- Aktionen basierend auf erkannten Farben auslösen
Projektanwendungen
Mit funktionsfähiger RGB-Messfunktion können Sie entwickeln:
- Chromatisches Sortiersystem: Objekte nach Farben kategorisieren (Rot/Grün/Blau-Unterscheidung)
- Farbverifikationsgerät: Farbkonsistenz zwischen Proben bestätigen
- Farbiger Pfadfolger: Roboter, die entlang chromatischer Markierungen navigieren
- Visuelle Qualitätsinspektion: Produktionsdefekte durch Farbanalyse erkennen
- Farbausgelöste Automatisierung: Aktionen ausführen, wenn spezifische Farbtöne erkannt werden
Video Tutorial
Wir erwägen die Erstellung von Video-Tutorials. Wenn Sie Video-Tutorials für wichtig halten, abonnieren Sie bitte unseren YouTube-Kanal , um uns zu motivieren, die Videos zu erstellen.