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).

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.
| Eigenschaft | Wert |
|---|---|
| Gemessene Kanäle | Rot (R), Grün (G), Blau (B), ungefiltert (C) |
| Fotodioden-Array | 3×4, insgesamt 12 Fotodioden |
| Auflösung | 16 Bit pro Kanal (0–65535) |
| Schnittstelle | I2C, bis 400 kHz |
| I2C-Adresse | 0x29 (fest) |
| Versorgung | Chip 2,7–3,6 V; Modul mit Regler 3,3–5 V |
| Strom | ca. 235 µA beim Messen, 2,5 µA im Schlaf (ohne LED) |
| IR-Filter | Auf dem Chip, Infrarot-Sperrfilter |
| Dynamikbereich | 3.800.000:1 |
| Integrationszeit | 2,4 ms – 614 ms (in 2,4-ms-Schritten) |
| Gain | 1x, 4x, 16x, 60x |
| LED auf dem Board | Neutralweiß, 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.
| ATIME | Zyklen | Zeit | Maximalwert | Wann? |
|---|---|---|---|---|
| 0xFF | 1 | 2,4 ms | 1024 | Sehr helles Licht, sehr schnelles Auslesen |
| 0xF6 | 10 | 24 ms | 10240 | In der Sonne, schnell bewegte Objekte |
| 0xEB | 21 | 50 ms | 21504 | Guter Startpunkt für Farbmessung mit LED |
| 0xD6 | 42 | 101 ms | 43008 | Umgebungslichtmessung in Innenräumen |
| 0xC0 | 64 | 154 ms | 65535 | Schwaches Licht, volle 16-Bit-Auflösung |
| 0x00 | 256 | 614 ms | 65535 | Sehr 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-Pin | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| VIN | 5V | 3V3 | 3V3(OUT) (Pin 36) |
| GND | GND | GND | GND |
| SDA | A4 | GPIO 21 | GP4 (Pin 6) |
| SCL | A5 | GPIO 22 | GP5 (Pin 7) |
| LED | Offen: LED an / GND: LED aus | Offen oder GND | Offen oder GND |
| INT | Offen (optionaler Interrupt-Ausgang) | Offen | Offen |
| 3V3 | Nicht anschließen (Reglerausgang) | Nicht anschließen | Nicht anschließen |
Schritt für Schritt: Die erste Farbmessung mit dem Arduino Uno
- 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.
- Ö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.
- Lade den folgenden Code hoch und öffne den Serial Monitor mit 9600 Baud.
- 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.
- 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.
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:
| Schritt | Formel |
|---|---|
| 1. Infrarotanteil | IR = (R + G + B − C) / 2 (bei negativem Ergebnis 0) |
| 2. Kanäle ohne IR | R' = R − IR, G' = G − IR, B' = B − IR |
| 3. Counts pro Lux | CPL = (ATIME_ms × Gain) / (GA × 310) |
| 4. Lux | Lux = (0,136 × R' + 1,000 × G' − 0,444 × B') / CPL |
| 5. Farbtemperatur | CCT = 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.
TCS34725 und TCS3200 im Vergleich
| Eigenschaft | TCS34725 | TCS3200 |
|---|---|---|
| Ausgang | I2C, digitale 16-Bit-Zahl | Rechtecksignal, Frequenz proportional zum Licht |
| Benötigte Pins | 2 (SDA, SCL) | 5–6 (S0–S3, OUT, OE) |
| Fotodioden | 3×4 = 12 | 8×8 = 64 |
| IR-Filter | Auf dem Chip vorhanden | Nicht vorhanden, infrarotempfindlich |
| Einstellungen | Zeit 2,4–614 ms, Gain 1x–60x | Frequenzskalierung 2 %, 20 %, 100 % |
| Versorgung | Modul 3,3–5 V (Chip 2,7–3,6 V) | 2,7–5,5 V |
| LED auf dem Board | 1 neutralweiße | 4 weiße |
| Ausleseverfahren | Vier Kanäle gleichzeitig aus dem Register | Filter einzeln wählen und Frequenz mit pulseIn messen |
| Lux und Farbtemperatur | Direkt per Formel berechenbar | Schwierig, 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.
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.
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.
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
| Symptom | Mögliche Ursache | Lösung |
|---|---|---|
| Ausgabe "TCS34725 bulunamadi" (Sensor nicht gefunden) | SDA und SCL vertauscht, keine Versorgung oder Kabel locker | Prü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 nicht | Sättigung: zu viel Licht für die gewählte Zeit und den Gain | Senke den Gain auf 1x, verkürze die Zeit oder rücke das Objekt etwas weg |
| Zahlen sehr klein, Farben springen | Zu wenig Licht | Schalte die LED ein, erhöhe den Gain auf 16x oder 60x und verlängere die Zeit |
| Dasselbe Objekt zeigt bei anderem Abstand eine andere Farbe | Mit Rohwerten verglichen | Nutze die Verhältnisse R/(R+G+B) und halte den Abstand konstant |
| Ergebnisse ändern sich, wenn das Fenster geöffnet wird | Umgebungslicht fließt in die Messung ein | Umgib den Sensor mit einem schwarzen Rohr oder einer Abschirmung |
| Farbtemperatur hängt immer bei etwa 4000 K | Die LED auf dem Board ist an geblieben | Lege den LED-Pin auf GND oder schalte sie mit einem digitalen Pin aus |
| Auslesen sehr langsam | Lange Integrationszeit (z. B. 614 ms) | getRawData() wartet die ganze Zeit; wähle 24–50 ms |
| Rot und Orange werden verwechselt | Referenzverhältnisse liegen zu nah beieinander | Kalibriere 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.
Projekte, die du danach bauen kannst
Alle Projekte ansehen
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…

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.

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.

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.

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.

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).

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

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.
Weitere Artikel
BlueGrays-App
Diese Schaltung Schritt für Schritt auf dem Handy nachbauen
Schaltplan, Code und Teileliste auf einem Bildschirm. Über 500 Arduino-, ESP32- und Pico-Projekte zum Nachbauen.
Mit dem Handy scannen
Richte die Kamera auf den Code, dann öffnet sich der App-Store deines Handys.
oder im Store öffnen

