Bauteile · 10 Min. Lesezeit

TCS34725 Arduino: I2C-Farbsensor, Lux und Farbtemperatur

TCS34725 am Arduino anschließen: Integrationszeit und Gain, Farbtemperatur und Lux berechnen, Unterschied zum TCS3200, Farbsortierer, ESP32 und Pico.

Der TCS34725 ist ein digitaler RGB-Farbsensor mit I2C-Schnittstelle und einer der genauesten und einfachsten Wege, mit dem Arduino Farben zu erkennen. Er liefert dir die Menge an rotem, grünem, blauem und Gesamtlicht (Clear) des Objekts vor ihm oder des Umgebungslichts als 16-Bit-Zahlen. Weil auf dem Chip ein Infrarot-Sperrfilter sitzt, werden die Messungen vom unsichtbaren Licht des Tageslichts und von Glühlampen deutlich weniger beeinflusst. Der TCS34725 wird am Arduino nur mit zwei Datenleitungen (SDA und SCL) angeschlossen, und mit der Adafruit-Bibliothek liest du in wenigen Zeilen die ersten Werte aus.

In diesem Beitrag lernst du Schritt für Schritt, was im Sensor steckt, wie die Einstellungen Integrationszeit und Gain die Messung verändern und wie du aus den Rohwerten die Farbtemperatur (Kelvin) und den Lux-Wert berechnest. Danach vergleichst du ihn mit dem älteren, aber verbreiteten TCS3200, baust einen kalibrierten Farbsortierer und nutzt denselben Sensor auch mit dem ESP32 und dem Raspberry Pi Pico (MicroPython).

TCS34725 RGB-Farbsensor-Modul
TCS34725-Farbsensor-Modul: Der kleine Sensorchip misst die Farben, die danebenliegende weiße LED beleuchtet das Objekt.

Was ist der TCS34725 und wie funktioniert er?

Auf dem Chip sitzen 12 kleine Fotodioden in einer 3×4-Anordnung. Drei davon haben einen Rotfilter, drei einen Grünfilter, drei einen Blaufilter; die übrigen drei sind ungefiltert und erfassen das Gesamtlicht (Clear, C). Der Strom jeder Gruppe wird in einem eigenen 16-Bit-Analog-Digital-Wandler über eine bestimmte Zeit aufsummiert. Diese Zeit heißt Integrationszeit. Ist sie abgelaufen, werden die vier Ergebnisse (R, G, B, C) in Register geschrieben, und du liest sie über I2C aus. Der Infrarot-Sperrfilter über den Fotodioden blockt Licht oberhalb von 700 nm, das unser Auge nicht sieht, weitgehend ab. So misst der TCS34725 Farben näher an dem, was das menschliche Auge wahrnimmt. Bei den meisten Modulen sitzt neben dem Chip eine neutralweiße LED. Wenn du die Farbe eines Objekts liest, misst du eigentlich den Teil des LED-Lichts, der vom Objekt zurückgeworfen wird.

EigenschaftWert
Gemessene KanäleRot (R), Grün (G), Blau (B), ungefiltert (C)
Fotodioden-Array3×4, insgesamt 12 Fotodioden
Auflösung16 Bit pro Kanal (0–65535)
SchnittstelleI2C, bis 400 kHz
I2C-Adresse0x29 (fest)
VersorgungChip 2,7–3,6 V; Modul mit Regler 3,3–5 V
Stromca. 235 µA beim Messen, 2,5 µA im Schlaf (ohne LED)
IR-FilterAuf dem Chip, Infrarot-Sperrfilter
Dynamikbereich3.800.000:1
Integrationszeit2,4 ms – 614 ms (in 2,4-ms-Schritten)
Gain1x, 4x, 16x, 60x
LED auf dem BoardNeutralweiß, ca. 4150 K

Integrationszeit und Gain einstellen

Die Integrationszeit entspricht der Belichtungszeit bei einer Kamera. Je länger sie ist, desto mehr Licht sammelt der Sensor, die Zahlen werden größer und das Rauschen in dunkler Umgebung sinkt. Dafür dauert jede Messung länger, und die Kanäle laufen bei hellem Licht leichter in die Sättigung. Die Zeit wird über das Register ATIME in 2,4-ms-Schritten eingestellt. Die größtmögliche Zahl eines Kanals ergibt sich aus der Formel (256 − ATIME) × 1024 und kann 65535 nicht überschreiten. Die folgende Tabelle zeigt die gebräuchlichsten Werte und wann du sie wählst.

ATIMEZyklenZeitMaximalwertWann?
0xFF12,4 ms1024Sehr helles Licht, sehr schnelles Auslesen
0xF61024 ms10240In der Sonne, schnell bewegte Objekte
0xEB2150 ms21504Guter Startpunkt für Farbmessung mit LED
0xD642101 ms43008Umgebungslichtmessung in Innenräumen
0xC064154 ms65535Schwaches Licht, volle 16-Bit-Auflösung
0x00256614 ms65535Sehr dunkle Umgebung, langsames Auslesen

Der Gain verstärkt das gesammelte Signal analog. Du hast die Wahl zwischen 1x, 4x, 16x und 60x. Ein höherer Gain steigert die Empfindlichkeit, ohne die Zeit zu verlängern, verstärkt aber auch das Rauschen. Als Faustregel gilt: Beleuchte das Objekt immer mit der LED aus demselben Abstand und starte mit 50 ms und 4x. Liegt C weit unter dem Maximalwert (zum Beispiel unter 1000), erhöhe den Gain auf 16x. Nähert sich C der Sättigung, senke den Gain oder verkürze die Zeit. Erreicht ein Kanal die Obergrenze, stimmt die Messung nicht mehr, weil die Zahl bei mehr Licht nicht weiter wachsen kann und die Farbverhältnisse verfälscht werden. Laut Datenblatt kann die Sättigung bei Zeiten unter 150 ms wegen Lichtflackerns schon bei etwa 75 % des Maximalwerts einsetzen. Nimm deshalb bei 50 ms etwa 16000 als sichere Obergrenze an.

TCS34725 anschließen (Arduino Uno, ESP32, Pico)

TCS34725-PinArduino UnoESP32Raspberry Pi Pico
VIN5V3V33V3(OUT) (Pin 36)
GNDGNDGNDGND
SDAA4GPIO 21GP4 (Pin 6)
SCLA5GPIO 22GP5 (Pin 7)
LEDOffen: LED an / GND: LED ausOffen oder GNDOffen oder GND
INTOffen (optionaler Interrupt-Ausgang)OffenOffen
3V3Nicht anschließen (Reglerausgang)Nicht anschließenNicht anschließen
Die meisten Module haben einen 3,3-V-Regler, und an den VIN-Pin darfst du 5 V legen. Schließe aber niemals 5 V an den 3V3-Pin an; der Chip verträgt höchstens 3,6 V. Siehst du auf dem Board keinen kleinen Reglerchip, versorge das Modul mit 3,3 V. Der LED-Pin lässt sich auch an einen digitalen Pin legen: LOW schaltet die LED aus, HIGH schaltet sie an. Der INT-Pin ist ein Open-Drain-Interrupt-Ausgang, der auf LOW geht, wenn ein eingestellter Schwellwert überschritten wird. Wie der I2C-Bus funktioniert, erfährst du im Beitrag Was ist I2C, und zur Kompatibilität zwischen 5 V und 3,3 V findest du Infos im Beitrag Logikpegel-Wandler.

Schritt für Schritt: Die erste Farbmessung mit dem Arduino Uno

  1. Verbinde das Modul wie in der Tabelle: VIN an 5V, GND an GND, SDA an A4, SCL an A5. Lass die Pins LED und INT vorerst offen.
  2. Öffne in der Arduino IDE den Bibliotheksverwalter, suche nach der Bibliothek Adafruit TCS34725 und installiere sie; falls nach Abhängigkeiten gefragt wird, installiere auch Adafruit BusIO. Wenn du bei der Installation hängst, hilft dir der Beitrag Arduino-Bibliothek hinzufügen.
  3. Lade den folgenden Code hoch und öffne den Serial Monitor mit 9600 Baud.
  4. Halte rote, grüne und blaue Papiere aus 1–2 cm Abstand vor den Sensor und beobachte, welcher Kanal bei welcher Farbe größer wird.
  5. Bewege das Papier näher heran und weiter weg, schau, wie sich die Zahlen ändern, und stelle sicher, dass C die Sättigungsgrenze nicht erreicht.
C++ (Arduino IDE)
1#include <Wire.h>
2#include <Adafruit_TCS34725.h>
3
4// 50 ms entegrasyon, 4x kazanç / 50 ms integration, 4x gain
5Adafruit_TCS34725 tcs(TCS34725_INTEGRATIONTIME_50MS, TCS34725_GAIN_4X);
6
7const float ATIME_MS = 50.4;     // 21 döngü x 2,4 ms / 21 cycles x 2.4 ms
8const float GAIN = 4.0;          // kazanç katsayısı / gain factor
9const uint16_t DOYMA = 16128;    // 21504'ün %75'i / 75% of 21504 (ripple saturation)
10
11void setup() {
12  Serial.begin(9600);
13  if (tcs.begin()) {
14    Serial.println(F("TCS34725 bulundu / found"));
15  } else {
16    Serial.println(F("Sensor yok, kablolari kontrol et / No sensor, check wiring"));
17    while (1);
18  }
19}
20
21// ams DN40 formülü ile lüks / lux with the ams DN40 formula
22float luxHesapla(uint16_t r, uint16_t g, uint16_t b, uint16_t c) {
23  float ir = ((float)r + g + b - c) / 2.0;   // kızılötesi tahmini / IR estimate
24  if (ir < 0) ir = 0;
25  float r2 = r - ir;
26  float g2 = g - ir;
27  float b2 = b - ir;
28  float cpl = (ATIME_MS * GAIN) / 310.0;     // lüks başına sayım / counts per lux
29  float lux = (0.136 * r2 + 1.0 * g2 - 0.444 * b2) / cpl;
30  return lux < 0 ? 0 : lux;
31}
32
33void loop() {
34  uint16_t r, g, b, c;
35  tcs.getRawData(&r, &g, &b, &c);            // bir entegrasyon süresi bekler / waits one integration time
36  uint16_t cct = tcs.calculateColorTemperature_dn40(r, g, b, c);
37  float lux = luxHesapla(r, g, b, c);
38
39  Serial.print(F("R:")); Serial.print(r);
40  Serial.print(F(" G:")); Serial.print(g);
41  Serial.print(F(" B:")); Serial.print(b);
42  Serial.print(F(" C:")); Serial.print(c);
43  Serial.print(F(" CCT:")); Serial.print(cct); Serial.print(F(" K"));
44  Serial.print(F(" Lux:")); Serial.print(lux, 0);
45  if (c > DOYMA) Serial.print(F("  DOYMA! / SATURATED!"));
46  Serial.println();
47  delay(500);
48}

Beim Erzeugen des Objekts werden Integrationszeit und Gain gemeinsam angegeben; später kannst du sie mit tcs.setIntegrationTime() und tcs.setGain() ändern. getRawData() wartet eine Integrationszeit lang und liest dann die vier Kanäle. Wählst du 614 ms, schaffst du deshalb nicht einmal zwei Messungen pro Sekunde. Für die Farbtemperatur haben wir die Funktion calculateColorTemperature_dn40() der Bibliothek benutzt; bei Sättigung liefert sie einen ungültigen Wert (65535). Den Lux-Wert haben wir selbst berechnet, denn die Funktion calculateLux() der Bibliothek berücksichtigt Zeit und Gain nicht. Ändern sich die Einstellungen, verschiebt sich auch ihr Ergebnis. Halte die Konstanten ATIME_MS und GAIN im Code unbedingt identisch mit deinen gewählten Einstellungen.

Farbtemperatur und Lux berechnen

Lux (lx) gibt an, wie hell das auf eine Fläche fallende Licht für das menschliche Auge ist. Ein schwach beleuchteter Raum hat 50–100 lx, ein gut beleuchtetes Büro etwa 300–500 lx; bei bedecktem Himmel misst du draußen einige tausend lx, die Mittagssonne erreicht bis zu 100.000 lx. Die Farbtemperatur (CCT) beschreibt den Farbton von weißem Licht in Kelvin. Eine Kerzenflamme hat etwa 1900 K, eine Glühlampe 2700 K, eine warmweiße LED 3000 K, die Mittagssonne 5500 K und ein bewölkter Himmel 6500–7500 K. Je kleiner der Wert, desto gelb-oranger das Licht, je größer, desto bläulicher. Der Hersteller ams empfiehlt in der Applikationsschrift DN40 diese Schritte, um beide Größen aus den Rohzahlen zu berechnen:

SchrittFormel
1. InfrarotanteilIR = (R + G + B − C) / 2 (bei negativem Ergebnis 0)
2. Kanäle ohne IRR' = R − IR, G' = G − IR, B' = B − IR
3. Counts pro LuxCPL = (ATIME_ms × Gain) / (GA × 310)
4. LuxLux = (0,136 × R' + 1,000 × G' − 0,444 × B') / CPL
5. FarbtemperaturCCT = 3810 × (B' / R') + 1391

Schauen wir uns ein Beispiel an: Du liest bei 50,4 ms und 4x Gain R = 1200, G = 1000, B = 800, C = 2800. Dann ist IR = (1200 + 1000 + 800 − 2800) / 2 = 100; die IR-bereinigten Werte sind R' = 1100, G' = 900, B' = 700. CPL = 50,4 × 4 / 310 ≈ 0,650. Lux = (0,136 × 1100 + 900 − 0,444 × 700) / 0,650 = 738,8 / 0,650 ≈ 1136 lx. Die Farbtemperatur ergibt 3810 × 700 / 1100 + 1391 ≈ 3816 K. GA in der Formel gibt an, wie stark eine Glas- oder Kunststoffabdeckung vor dem Sensor das Licht abschwächt; beim offenen Sensor nimmst du 1. Setzt du den Sensor hinter eine Abdeckung, solltest du GA über 1 anheben und durch den Vergleich mit einem bekannten Luxmeter kalibrieren.

Schalte beim Messen des Umgebungslichts unbedingt die LED auf dem Board aus; sonst misst der Sensor seine eigene LED, und die Farbtemperatur hängt immer bei etwa 4000 K fest. Richte den Sensor für Lux und CCT nicht auf ein Objekt, sondern auf die Lichtquelle oder den Raum, und wähle bei hellem Licht 1x Gain und eine kurze Zeit. Musst du nur die Helligkeit messen, ist der BH1750-Lichtsensor, der direkt Lux ausgibt, die einfachere Wahl.

TCS34725 und TCS3200 im Vergleich

EigenschaftTCS34725TCS3200
AusgangI2C, digitale 16-Bit-ZahlRechtecksignal, Frequenz proportional zum Licht
Benötigte Pins2 (SDA, SCL)5–6 (S0–S3, OUT, OE)
Fotodioden3×4 = 128×8 = 64
IR-FilterAuf dem Chip vorhandenNicht vorhanden, infrarotempfindlich
EinstellungenZeit 2,4–614 ms, Gain 1x–60xFrequenzskalierung 2 %, 20 %, 100 %
VersorgungModul 3,3–5 V (Chip 2,7–3,6 V)2,7–5,5 V
LED auf dem Board1 neutralweiße4 weiße
AusleseverfahrenVier Kanäle gleichzeitig aus dem RegisterFilter einzeln wählen und Frequenz mit pulseIn messen
Lux und FarbtemperaturDirekt per Formel berechenbarSchwierig, aufwendige Kalibrierung nötig

Der TCS3200 ist in Schulprojekten noch sehr verbreitet, weil seine vier LEDs das Objekt kräftig beleuchten und er problemlos mit 5 V läuft. Für jede Farbe den Filter über die Pins S2 und S3 umzuschalten und die Frequenz zu messen, kostet aber Pins und Zeit. Da ihm der IR-Filter fehlt, wird er vom Umgebungslicht auch stärker beeinflusst. Der TCS34725 dagegen braucht nur zwei Leitungen, liest alle vier Kanäle gleichzeitig und arbeitet dank einstellbarer Zeit und einstellbarem Gain von der Dunkelheit bis in die Sonne. Wenn du ein neues Projekt startest, nimm den TCS34725; hast du einen TCS3200, hilft dir der Beitrag TCS3200-Farbsensor. Willst du neben der Farbe auch Gesten und Nähe erkennen, ist der APDS-9960 eine gute Alternative.

Beispiel: Farbsortiermaschine

Ein klassisches Schul- und Wissenschaftsmesse-Projekt: Bunte Bonbons oder Perlen rutschen eine Rampe hinunter, werden vor dem Sensor angehalten und nach Farbe in verschiedene Behälter geleitet. Der Sensor misst die Farbe, und ein Servomotor dreht die Rutsche auf den Winkel des passenden Behälters. Der wichtigste Kniff: Nutze nicht die Rohzahlen, sondern die Verhältnisse. Entfernt sich das Objekt etwas, nehmen R, G und B gemeinsam ab, aber das Verhältnis R/(R+G+B) bleibt fast gleich. Lege zur Kalibrierung von jeder Farbe ein Objekt vor den Sensor, notiere die im Serial Monitor ausgegebenen Werte nr, ng und nb und trage sie in die ref-Tabelle im Code ein; die Werte im Code sind nur Beispiele. Setzt du den Sensor in ein schwarzes Rohr und hältst das Objekt immer im gleichen Abstand (ideal 5–10 mm), verschwindet der Einfluss des Umgebungslichts, und die Genauigkeit steigt deutlich.

C++ (Arduino IDE)
1#include <Wire.h>
2#include <Adafruit_TCS34725.h>
3#include <Servo.h>
4
5Adafruit_TCS34725 tcs(TCS34725_INTEGRATIONTIME_50MS, TCS34725_GAIN_4X);
6Servo oluk;                                        // yönlendirme oluğu / sorting chute
7
8const int RENK_SAYISI = 4;
9const char* renkAd[RENK_SAYISI] = {"KIRMIZI", "YESIL", "MAVI", "SARI"};
10// Kalibrasyonla bul: her renk için nr, ng, nb / find by calibration: nr, ng, nb per color
11const float ref[RENK_SAYISI][3] = {
12  {0.52, 0.26, 0.22},
13  {0.27, 0.44, 0.29},
14  {0.20, 0.31, 0.49},
15  {0.42, 0.39, 0.19}
16};
17const int aci[RENK_SAYISI] = {20, 65, 110, 155};   // her kutunun servo açısı / servo angle of each bin
18const uint16_t BOS_ESIK = 300;                     // tüp boşken C bunun altında / C stays below this when empty
19
20void setup() {
21  Serial.begin(9600);
22  if (!tcs.begin()) {
23    Serial.println(F("TCS34725 bulunamadi / not found"));
24    while (1);
25  }
26  oluk.attach(9);                                  // servo sinyali D9 / servo signal on D9
27  oluk.write(90);                                  // bekleme konumu / idle position
28}
29
30int renkBul(float nr, float ng, float nb) {
31  int enIyi = -1;
32  float enKucuk = 1000.0;
33  for (int i = 0; i < RENK_SAYISI; i++) {
34    float d = sq(nr - ref[i][0]) + sq(ng - ref[i][1]) + sq(nb - ref[i][2]);
35    if (d < enKucuk) {
36      enKucuk = d;
37      enIyi = i;
38    }
39  }
40  if (enKucuk > 0.004) return -1;                  // hiçbir renge yakın değil / not close to any color
41  return enIyi;
42}
43
44void loop() {
45  uint16_t r, g, b, c;
46  tcs.getRawData(&r, &g, &b, &c);
47  if (c < BOS_ESIK) {                              // önünde nesne yok / no object in front
48    delay(50);
49    return;
50  }
51  float top = (float)r + g + b;
52  float nr = r / top;
53  float ng = g / top;
54  float nb = b / top;
55  Serial.print(F("nr=")); Serial.print(nr, 3);
56  Serial.print(F(" ng=")); Serial.print(ng, 3);
57  Serial.print(F(" nb=")); Serial.print(nb, 3);
58
59  int renk = renkBul(nr, ng, nb);
60  if (renk >= 0) {
61    Serial.print(F(" -> "));
62    Serial.println(renkAd[renk]);
63    oluk.write(aci[renk]);                         // oluğu kutuya çevir / turn chute to the bin
64    delay(800);                                    // nesnenin kaymasını bekle / wait for the object to slide
65    oluk.write(90);
66  } else {
67    Serial.println(F(" -> bilinmiyor / unknown"));
68  }
69  delay(300);
70}

Bei jedem Durchlauf prüft der Code zuerst den Wert C. Ist das Rohr leer, wird das LED-Licht nicht zurückgeworfen, C bleibt klein, und die Maschine wartet; dringt Umgebungslicht in das Rohr, passe BOS_ESIK an deinen Aufbau an. Kommt ein Objekt, werden R, G und B durch ihre Summe geteilt, um die Farbverhältnisse zu erhalten. Danach wird für jede Referenzfarbe das Quadrat des Abstands berechnet und die nächstliegende Farbe gewählt. Die Abstandsschwelle von 0,004 stuft Objekte, die keiner Farbe ähneln, als unbekannt ein; verkleinerst du die Schwelle, wird die Maschine wählerischer. Um eine neue Farbe hinzuzufügen, ergänze die Arrays ref, renkAd und aci um eine Zeile und aktualisiere RENK_SAYISI. Versorgst du den Servo aus einer separaten 5-V-Quelle, verhinderst du, dass die I2C-Messungen beim Bewegen des Motors gestört werden. Auch der Mittelwert mehrerer Messungen macht die Werte stabiler; dazu findest du Infos im Beitrag Sensordaten filtern.

TCS34725 mit dem ESP32: Farbe auf einer RGB-LED wiedergeben

Auf dem ESP32 läuft dieselbe Adafruit-Bibliothek ohne Änderungen. Die I2C-Pins sind standardmäßig GPIO 21 (SDA) und GPIO 22 (SCL), und am sichersten versorgst du das Modul über den 3V3-Pin. Das folgende Beispiel bildet die vom Sensor gesehene Farbe mit einer RGB-LED mit gemeinsamer Kathode nach und gibt den Farbcode im Format #RRGGBB im Serial Monitor aus. Die Funktion getRGB() teilt die Farben durch den C-Kanal und bringt sie in den Bereich 0–255; der Code zieht den stärksten Kanal auf 255 und belebt blasse Farben durch eine Gamma-Korrektur. Da sich die PWM-Funktionen in den Versionen 2.x und 3.x des ESP32-Arduino-Cores unterscheiden, ist der Code für beide Versionen aufgeteilt. Den passenden Widerstand für jedes LED-Bein findest du mit dem LED-Widerstandsrechner.

C++ (Arduino IDE)
1#include <Wire.h>
2#include <Adafruit_TCS34725.h>
3
4Adafruit_TCS34725 tcs(TCS34725_INTEGRATIONTIME_50MS, TCS34725_GAIN_4X);
5
6const int PIN_R = 25;   // RGB LED kırmızı / red
7const int PIN_G = 26;   // RGB LED yeşil / green
8const int PIN_B = 27;   // RGB LED mavi / blue
9
10void pwmBaslat() {
11#if ESP_ARDUINO_VERSION_MAJOR >= 3
12  ledcAttach(PIN_R, 5000, 8);    // core 3.x: pin, frekans, çözünürlük / pin, frequency, resolution
13  ledcAttach(PIN_G, 5000, 8);
14  ledcAttach(PIN_B, 5000, 8);
15#else
16  ledcSetup(0, 5000, 8);         // core 2.x: kanal, frekans, çözünürlük / channel, frequency, resolution
17  ledcSetup(1, 5000, 8);
18  ledcSetup(2, 5000, 8);
19  ledcAttachPin(PIN_R, 0);
20  ledcAttachPin(PIN_G, 1);
21  ledcAttachPin(PIN_B, 2);
22#endif
23}
24
25void ledYaz(uint8_t r, uint8_t g, uint8_t b) {
26#if ESP_ARDUINO_VERSION_MAJOR >= 3
27  ledcWrite(PIN_R, r);
28  ledcWrite(PIN_G, g);
29  ledcWrite(PIN_B, b);
30#else
31  ledcWrite(0, r);
32  ledcWrite(1, g);
33  ledcWrite(2, b);
34#endif
35}
36
37uint8_t duzelt(float v, float enBuyuk) {
38  float x = v / enBuyuk;         // en güçlü kanal 1 olur / strongest channel becomes 1
39  x = powf(x, 2.5f);             // gama: renkleri canlandır / gamma: make colors vivid
40  return (uint8_t)(x * 255.0f);
41}
42
43void setup() {
44  Serial.begin(115200);
45  Wire.begin(21, 22);            // SDA, SCL
46  if (!tcs.begin(TCS34725_ADDRESS, &Wire)) {
47    Serial.println("TCS34725 bulunamadi / not found");
48    while (true) delay(10);
49  }
50  pwmBaslat();
51}
52
53void loop() {
54  float r, g, b;
55  tcs.getRGB(&r, &g, &b);        // C kanalına göre 0-255 / normalized to clear, 0-255
56  float enBuyuk = fmaxf(r, fmaxf(g, b));
57  if (enBuyuk < 1.0f) enBuyuk = 1.0f;
58  uint8_t R = duzelt(r, enBuyuk);
59  uint8_t G = duzelt(g, enBuyuk);
60  uint8_t B = duzelt(b, enBuyuk);
61  ledYaz(R, G, B);
62  Serial.printf("#%02X%02X%02X\n", R, G, B);
63  delay(100);
64}

Raspberry Pi Pico mit TCS34725 (MicroPython)

In MicroPython musst du keine fertige Bibliothek installieren; da der Registeraufbau des TCS34725 einfach ist, kannst du mit wenigen Zeilen direkt mit ihm sprechen. Zu jeder Registeradresse kommt das Befehlsbit (0x80), bei Mehrbyte-Lesevorgängen wird zusätzlich das Auto-Increment-Bit (0x20) benutzt. Der Code liest zuerst das Kennungsregister (0x12): Für den TCS34725 muss 0x44 zurückkommen, für den TCS34727 0x4D. Danach setzt er ATIME auf 0xEB (etwa 50 ms) und den Gain auf 4x, schaltet den Sensor ein und berechnet bei jeder Messung mit der DN40-Formel Lux und Farbtemperatur. Bist du neu bei Pico und MicroPython, wirf zuerst einen Blick auf den Beitrag Was ist der Raspberry Pi Pico.

MicroPython
1from machine import Pin, I2C
2import time
3
4ADDR = 0x29          # sabit I2C adresi / fixed I2C address
5CMD = 0x80           # komut biti / command bit
6AUTO = 0x20          # otomatik artırma / auto-increment
7ATIME_MS = 50.4      # 0xEB = 21 döngü x 2,4 ms / 21 cycles x 2.4 ms
8GAIN = 4
9
10i2c = I2C(0, sda=Pin(4), scl=Pin(5), freq=400000)
11
12def yaz(reg, deger):
13    i2c.writeto_mem(ADDR, CMD | reg, bytes([deger]))
14
15def oku(reg):
16    return i2c.readfrom_mem(ADDR, CMD | reg, 1)[0]
17
18print("ID:", hex(oku(0x12)))   # 0x44 = TCS34725, 0x4D = TCS34727
19
20yaz(0x01, 0xEB)      # ATIME: yaklaşık 50 ms / about 50 ms
21yaz(0x0F, 0x01)      # kazanç 4x (0=1x, 1=4x, 2=16x, 3=60x) / gain 4x
22yaz(0x00, 0x01)      # PON: güç aç / power on
23time.sleep_ms(3)
24yaz(0x00, 0x03)      # PON + AEN: ölçümü başlat / start measuring
25
26def rgbc_oku():
27    while not (oku(0x13) & 0x01):    # AVALID: veri hazır mı? / data ready?
28        time.sleep_ms(5)
29    d = i2c.readfrom_mem(ADDR, CMD | AUTO | 0x14, 8)
30    c = d[0] | (d[1] << 8)
31    r = d[2] | (d[3] << 8)
32    g = d[4] | (d[5] << 8)
33    b = d[6] | (d[7] << 8)
34    return r, g, b, c
35
36def lux_cct(r, g, b, c):
37    ir = max(0, (r + g + b - c) / 2)         # kızılötesi tahmini / IR estimate
38    r2, g2, b2 = r - ir, g - ir, b - ir
39    cpl = (ATIME_MS * GAIN) / 310            # lüks başına sayım / counts per lux
40    lux = max(0, (0.136 * r2 + g2 - 0.444 * b2) / cpl)
41    cct = 3810 * b2 / r2 + 1391 if r2 > 0 else 0
42    return lux, cct
43
44while True:
45    r, g, b, c = rgbc_oku()
46    lux, cct = lux_cct(r, g, b, c)
47    print("R:", r, "G:", g, "B:", b, "C:", c, "Lux: %.0f" % lux, "CCT: %.0f K" % cct)
48    time.sleep(0.5)

Projektideen mit dem TCS34725

  • Farbsortiermaschine: Sortiere Bonbons oder Perlen mit Servo und Rampe nach Farbe in Behälter (das Beispiel oben).
  • Lampe, die Farben kopiert: Lies die Farbe eines Stoffs oder Papiers und gib sie 1:1 auf einem WS2812B-NeoPixel-Streifen wieder.
  • Beleuchtungsmesser: Miss Lux und Farbtemperatur eines Raums und zeige sie auf dem Display an; prüfe am Schreibtisch, ob du das Ziel von 500 lx erreichst.
  • Roboter mit Farbregeln: Ergänze einen Linienfolger-Roboter um den TCS34725 und lege Regeln fest, etwa bei Rot anhalten und bei Grün abbiegen.
  • Gerät, das die Farbe ansagt: Baue mit dem DFPlayer Mini ein Hilfsmittel für Sehbehinderte, das die gelesene Farbe per Sprache ausgibt.
  • Reifeanzeige für Obst: Verfolge anhand der Farbverhältnisse, wie eine Tomate oder Banane von Grün zu Rot oder Gelb wechselt.

Häufige Fehler und Lösungen

SymptomMögliche UrsacheLösung
Ausgabe "TCS34725 bulunamadi" (Sensor nicht gefunden)SDA und SCL vertauscht, keine Versorgung oder Kabel lockerPrüfe, ob beim Uno SDA=A4 und SCL=A5 ist; suche mit einem I2C-Scanner nach der Adresse 0x29
Alle Kanäle sehr groß und ändern sich nichtSättigung: zu viel Licht für die gewählte Zeit und den GainSenke den Gain auf 1x, verkürze die Zeit oder rücke das Objekt etwas weg
Zahlen sehr klein, Farben springenZu wenig LichtSchalte die LED ein, erhöhe den Gain auf 16x oder 60x und verlängere die Zeit
Dasselbe Objekt zeigt bei anderem Abstand eine andere FarbeMit Rohwerten verglichenNutze die Verhältnisse R/(R+G+B) und halte den Abstand konstant
Ergebnisse ändern sich, wenn das Fenster geöffnet wirdUmgebungslicht fließt in die Messung einUmgib den Sensor mit einem schwarzen Rohr oder einer Abschirmung
Farbtemperatur hängt immer bei etwa 4000 KDie LED auf dem Board ist an gebliebenLege den LED-Pin auf GND oder schalte sie mit einem digitalen Pin aus
Auslesen sehr langsamLange Integrationszeit (z. B. 614 ms)getRawData() wartet die ganze Zeit; wähle 24–50 ms
Rot und Orange werden verwechseltReferenzverhältnisse liegen zu nah beieinanderKalibriere im endgültigen Aufbau, verkleinere die Schwelle und mittle mehrere Messungen

Der TCS34725 ist ein vielseitiger Sensor, der sich mit zwei Leitungen anschließen lässt und dank einstellbarer Empfindlichkeit und IR-Filter sowohl Objektfarben als auch Umgebungslicht zuverlässig misst. Für richtige Ergebnisse brauchst du drei Dinge: eine Wahl von Zeit und Gain, die Sättigung vermeidet, Verhältnisse statt Rohzahlen und eine Kalibrierung im endgültigen Aufbau. Möchtest du mit einem einfacheren Sensor zur Lichtmessung beginnen, ist der LDR-Lichtsensor ein guter erster Schritt. In der BlueGrays-App findest du Lichtmessung mit LDR, RGB-LED-Farbverläufe, eine ESP32-Farbmischlampe und Servo-Projekte Schritt für Schritt mit Schaltplan und Code, und darauf kannst du deine eigene Maschine mit Farbsensor aufbauen.

Häufige Fragen

Was ist der Unterschied zwischen TCS34725 und TCS3200?

Der TCS34725 liefert über I2C alle vier Kanäle gleichzeitig als 16-Bit-Zahlen und hat einen Infrarot-Sperrfilter auf dem Chip. Beim TCS3200 wählst du den Farbfilter einzeln über die Pins S2–S3 und erhältst einen Frequenzausgang; er braucht 5–6 Pins und wird mangels IR-Filter stärker vom Umgebungslicht beeinflusst. Für Genauigkeit und einfachen Anschluss ist der TCS34725 die bessere Wahl.

Welche I2C-Adresse hat der TCS34725 und kann man sie ändern?

Die Adresse des TCS34725 ist fest 0x29 und lässt sich nicht ändern. Willst du zwei Sensoren am selben Board betreiben, kannst du einen I2C-Multiplexer wie den TCA9548A verwenden. Beim ESP32 und Pico ist es auch möglich, jeden Sensor an einen eigenen I2C-Bus anzuschließen.

Läuft der TCS34725 mit 5 V?

Der Chip selbst arbeitet mit 2,7–3,6 V. Da die meisten Module aber einen 3,3-V-Regler haben, darfst du an den VIN-Pin 5 V legen und das Modul direkt an den Arduino Uno anschließen. 5 V am 3V3-Pin zerstören den Chip; hat dein Board keinen Regler, versorge das Modul mit 3,3 V.

Warum liest der TCS34725 die Farben falsch?

Die häufigsten Ursachen sind Sättigung, zu wenig Licht, einfallendes Umgebungslicht und der Vergleich mit Rohzahlen. Beleuchte das Objekt mit der LED aus festem Abstand, achte darauf, dass C unter der Sättigungsgrenze bleibt, und arbeite mit Verhältnissen wie R/(R+G+B). Kalibriere die Referenzfarben außerdem unbedingt in deinem endgültigen Aufbau.

Wie schalte ich die LED auf dem TCS34725 aus?

Verbindest du den LED-Pin des Moduls mit GND, geht die weiße LED aus. Hängst du den Pin an einen digitalen Ausgang, schaltest du sie mit LOW aus und mit HIGH an. Beim Messen von Umgebungslicht oder Farbtemperatur muss die LED aus sein.

Wie genau ist die Lux-Messung mit dem TCS34725?

Der TCS34725 ist nicht so präzise wie ein professionelles Luxmeter, liefert mit der DN40-Formel und der richtigen Zeit-Gain-Einstellung in Innenräumen aber brauchbare Näherungswerte. Sitzt der Sensor hinter einer Glas- oder Kunststoffabdeckung, musst du mit dem Faktor GA kalibrieren. Willst du nur die Helligkeit messen, ist der BH1750, der direkt Lux ausgibt, die einfachere Wahl.

Alle Projekte ansehen
Lichtstärke messen mit LDR
AR-11Anfänger

Lichtstärke messen mit LDR

Willst du sehen, wie hell dein Zimmer ist, und zwar als Zahl? Der LDR, ein kleines lichtempfindliches Bauteil, misst das Umgebungslicht, und der Arduino schreibt den Wert jede halbe Sekunde auf…

4.6(83)
143
Messung der Lichtintensität mit dem ESP32-LDR-Modul
ES-11Anfänger

Messung der Lichtintensität mit dem ESP32-LDR-Modul

Echtzeit-Anzeige des ADC-Rohwerts des LDR-Moduls und des anhand von Dunkel- und Hellreferenzwerten berechneten relativen Lichtwerts in Prozent im Serial Monitor. Dieser Prozentwert ist keine Lux-Messung. Vermittelt die Kalibrierungslogik des Moduls. Sollte idealerweise vor Projekt 10 durchgeführt werden, da es zur Festlegung des Schwellenwerts dient.

4.6(36)
55
RGB-LED verwenden
AR-39Anfänger
Premium

RGB-LED verwenden

In einer einzigen LED stecken drei Farben: Die RGB-LED leuchtet erst rot, dann grün, dann blau, jede Farbe eine halbe Sekunde an und eine halbe Sekunde aus, und dann geht es von vorne los.

4.9(73)
100
Sanfte Farbübergänge mit RGB-Led
AR-40Anfänger
Premium

Sanfte Farbübergänge mit RGB-Led

Eine einzige RGB-LED wandert langsam von Rot zu Grün, von Grün zu Blau und wieder zurück zu Rot, eine Regenbogenschleife ohne Ende.

4.8(58)
78
ESP32 RGB-LED-Steuerung
ES-9Anfänger

ESP32 RGB-LED-Steuerung

Unbegrenzte Farberzeugung mit einer einzigen RGB-LED anstelle von 3 separaten LEDs. Wie in Arduino machen wir Regenbogenübergänge, indem wir R/G/B-Werte mit analogWrite() setzen. Die Farbtheorie (z. B. Rot+Grün=Gelb) wird praktisch umgesetzt.

4.6(29)
52
ESP32-Farbmischerlampe (3 Potentiometer + RGB-LED + OLED)
ES-36Fortgeschritten
Premium

ESP32-Farbmischerlampe (3 Potentiometer + RGB-LED + OLED)

Eine smarte Farbmischer-Lampe: Dreh an 3 Potentiometern am ESP32 und misch dir jede Farbe! Während du die Potis für Rot, Grün und Blau drehst, wechselt die RGB-LED mit gemeinsamer Kathode sofort die Farbe. Das SSD1306-OLED zeigt live für jede Farbe den Wert von 0-255, Füllbalken und den HEX-Webfarbcode (etwa #FF8040).

4.7(6)
10
TCRT5000 Schwarz-Weiß-Untergrunderkennung
AR-78Mittel
Premium

TCRT5000 Schwarz-Weiß-Untergrunderkennung

Mit dem kleinen Sensor, der bei Linienfolger-Robotern als Auge dient, erkennst du, ob der Boden schwarz oder weiß ist.

4.7(40)
49
Raspberry Pi Pico RGB-LED Farbwechsel (3-Kanal-PWM)
PI-15Anfänger

Raspberry Pi Pico RGB-LED Farbwechsel (3-Kanal-PWM)

Eine LED, Millionen Farben! Eine RGB-LED enthält 3 LEDs: Rot, Grün und Blau. Mit je einem PWM-Kanal des Pico mischst du Farben: Rot + Grün = Gelb, Grün + Blau = Cyan, alle drei = Weiß. Die LED wechselt durch 8 Farben. Lerne mehrere PWM-Kanäle, Funktionen (def), RGB-Farbmischung, 8-Bit → 16-Bit-Umrechnung (x257) und gemeinsame Kathode vs. Anode.

6