Capteur de couleur TCS34725 Arduino : RGB I2C, lux et température
Capteur TCS34725 avec Arduino : câblage, temps d'intégration et gain, calcul du lux et de la température de couleur, différence avec le TCS3200, trieuse, ESP32 et Pico.
Le TCS34725 est un capteur de couleur RGB numérique communiquant en I2C, l'un des moyens les plus précis et les plus simples de détecter les couleurs avec Arduino. Il renvoie, sous forme de nombres 16 bits, la quantité de lumière rouge, verte, bleue et totale (clear) de l'objet placé devant lui ou de la lumière ambiante. Un filtre bloquant les infrarouges est intégré à la puce : les mesures sont donc bien moins perturbées par la lumière invisible du soleil et des ampoules. Le câblage du TCS34725 avec Arduino ne demande que deux fils de données (SDA et SCL), et avec la bibliothèque Adafruit tu lis tes premières valeurs en quelques lignes.
Dans cet article, tu vas découvrir ce qu'il y a dans le capteur, comment les réglages de temps d'intégration et de gain modifient la mesure, et comment calculer pas à pas la température de couleur (Kelvin) et le lux à partir des valeurs brutes. Ensuite, tu le compareras au TCS3200, plus ancien mais très répandu, tu construiras une trieuse de couleurs calibrée et tu utiliseras le même capteur avec l'ESP32 et le Raspberry Pi Pico (MicroPython).

Qu'est-ce que le TCS34725 et comment fonctionne-t-il ?
La puce contient 12 petites photodiodes disposées en 3×4. Trois sont recouvertes d'un filtre rouge, trois d'un filtre vert, trois d'un filtre bleu ; les trois restantes n'ont pas de filtre et voient la lumière totale (clear, C). Le courant produit par chaque groupe est accumulé pendant un certain temps dans un convertisseur analogique-numérique 16 bits dédié. Ce temps s'appelle le temps d'intégration. Une fois écoulé, les quatre résultats (R, G, B, C) sont écrits dans les registres et tu les lis via I2C. Le filtre infrarouge placé sur les photodiodes coupe en grande partie la lumière au-delà de 700 nm que notre œil ne voit pas, ce qui rapproche les mesures de la perception humaine. La plupart des modules ont aussi une LED blanche neutre à côté de la puce. Quand tu lis la couleur d'un objet, tu mesures en fait la part de la lumière de cette LED qui se réfléchit sur lui.
| Caractéristique | Valeur |
|---|---|
| Canaux mesurés | Rouge (R), vert (G), bleu (B), sans filtre (C) |
| Réseau de photodiodes | 3×4, soit 12 photodiodes |
| Résolution | 16 bits par canal (0–65535) |
| Interface | I2C, jusqu'à 400 kHz |
| Adresse I2C | 0x29 (fixe) |
| Alimentation | Puce 2,7–3,6 V ; module avec régulateur 3,3–5 V |
| Courant | Environ 235 µA en mesure, 2,5 µA en veille (hors LED) |
| Filtre IR | Sur la puce, bloque les infrarouges |
| Plage dynamique | 3 800 000:1 |
| Temps d'intégration | 2,4 ms – 614 ms (par pas de 2,4 ms) |
| Gain | 1x, 4x, 16x, 60x |
| LED sur la carte | Blanc neutre, environ 4150 K |
Temps d'intégration et réglage du gain
Le temps d'intégration ressemble au temps de pose d'un appareil photo. Plus il est long, plus le capteur collecte de lumière, plus les nombres sont grands et moins il y a de bruit dans l'obscurité. En contrepartie, chaque lecture dure plus longtemps et les canaux saturent plus facilement en pleine lumière. Le temps se règle avec le registre ATIME par pas de 2,4 ms. Le nombre maximal qu'un canal peut atteindre est donné par la formule (256 − ATIME) × 1024, sans pouvoir dépasser 65535. Le tableau ci-dessous montre les valeurs les plus courantes et quand les choisir.
| ATIME | Cycles | Durée | Comptage max | Quand ? |
|---|---|---|---|---|
| 0xFF | 1 | 2,4 ms | 1024 | Lumière très forte, lecture très rapide |
| 0xF6 | 10 | 24 ms | 10240 | Plein soleil, objet en mouvement rapide |
| 0xEB | 21 | 50 ms | 21504 | Bon point de départ pour lire une couleur avec LED |
| 0xD6 | 42 | 101 ms | 43008 | Mesure de la lumière ambiante en intérieur |
| 0xC0 | 64 | 154 ms | 65535 | Environnement sombre, pleine résolution 16 bits |
| 0x00 | 256 | 614 ms | 65535 | Très sombre, lecture lente |
Le gain amplifie de façon analogique le signal collecté. Les options sont 1x, 4x, 16x et 60x. Augmenter le gain accroît la sensibilité sans allonger le temps, mais amplifie aussi le bruit. La règle pratique : éclaire toujours l'objet avec la LED à la même distance et commence avec 50 ms et 4x. Si C reste très en dessous du comptage maximal (par exemple sous 1000), passe le gain à 16x. Si C approche de la saturation, baisse le gain ou raccourcis le temps. Quand un canal atteint le plafond, la lecture n'est plus fiable : le nombre ne peut plus augmenter avec la lumière et les rapports de couleurs sont faussés. La fiche technique précise aussi que pour des temps inférieurs à 150 ms, la saturation peut commencer vers 75 % du comptage maximal à cause de l'ondulation. À 50 ms, considère donc environ 16000 comme limite haute sûre.
Câblage du TCS34725 (Arduino Uno, ESP32, Pico)
| Broche TCS34725 | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| VIN | 5V | 3V3 | 3V3(OUT) (broche 36) |
| GND | GND | GND | GND |
| SDA | A4 | GPIO 21 | GP4 (broche 6) |
| SCL | A5 | GPIO 22 | GP5 (broche 7) |
| LED | Libre : LED allumée / GND : LED éteinte | Libre ou GND | Libre ou GND |
| INT | Libre (sortie d'interruption facultative) | Libre | Libre |
| 3V3 | Ne pas connecter (sortie du régulateur) | Ne pas connecter | Ne pas connecter |
Pas à pas : première lecture de couleur avec Arduino Uno
- Branche le module comme dans le tableau : VIN sur 5V, GND sur GND, SDA sur A4, SCL sur A5. Laisse pour l'instant les broches LED et INT libres.
- Dans l'IDE Arduino, ouvre le Gestionnaire de bibliothèques, cherche et installe Adafruit TCS34725 ; si on te demande les dépendances, installe aussi Adafruit BusIO. Si tu bloques, jette un œil à l'article ajouter une bibliothèque Arduino.
- Téléverse le code ci-dessous et ouvre le moniteur série à 9600 bauds.
- Place des feuilles rouge, verte et bleue à 1–2 cm du capteur et observe quel canal augmente pour chaque couleur.
- Approche et éloigne la feuille pour voir comment les nombres changent, et vérifie que la valeur C n'atteint pas la limite de saturation.
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}Le temps d'intégration et le gain sont donnés ensemble à la création de l'objet ; tu peux ensuite les modifier avec tcs.setIntegrationTime() et tcs.setGain(). getRawData() attend un temps d'intégration complet avant de lire les quatre canaux. Si tu choisis 614 ms, tu n'obtiens donc même pas deux lectures par seconde. Pour la température de couleur, nous avons utilisé la fonction calculateColorTemperature_dn40() de la bibliothèque ; en cas de saturation, elle renvoie une valeur invalide (65535). Le lux, nous l'avons calculé nous-mêmes, car la fonction calculateLux() de la bibliothèque ne tient pas compte du temps ni du gain : son résultat dérive quand tu changes les réglages. Garde toujours les constantes ATIME_MS et GAIN du code identiques aux réglages choisis.
Calcul de la température de couleur et du lux
Le lux (lx) indique la luminosité de la lumière qui tombe sur une surface, telle que l'œil humain la perçoit. Une pièce tamisée fait 50–100 lx, un bureau bien éclairé 300–500 lx ; dehors par temps couvert on mesure quelques milliers de lx, et le soleil de midi monte jusqu'à 100 000 lx. La température de couleur (CCT) décrit la teinte de la lumière blanche en Kelvin. Une bougie fait environ 1900 K, une ampoule à incandescence 2700 K, une LED blanc chaud 3000 K, le soleil de midi 5500 K et un ciel nuageux 6500–7500 K. Plus la valeur est basse, plus la lumière tire vers le jaune-orangé ; plus elle est haute, plus elle tire vers le bleu. Pour calculer ces deux grandeurs à partir des valeurs brutes, ams, le fabricant du TCS34725, recommande dans la note d'application DN40 les étapes suivantes :
| Étape | Formule |
|---|---|
| 1. Composante infrarouge | IR = (R + G + B − C) / 2 (0 si négatif) |
| 2. Canaux sans IR | R' = R − IR, G' = G − IR, B' = B − IR |
| 3. Comptages par lux | CPL = (ATIME_ms × Gain) / (GA × 310) |
| 4. Lux | Lux = (0,136 × R' + 1,000 × G' − 0,444 × B') / CPL |
| 5. Température de couleur | CCT = 3810 × (B' / R') + 1391 |
Prenons un exemple : avec 50,4 ms et un gain de 4x, imagine que tu lises R = 1200, G = 1000, B = 800, C = 2800. IR = (1200 + 1000 + 800 − 2800) / 2 = 100 ; les valeurs sans IR sont 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. La température de couleur vaut 3810 × 700 / 1100 + 1391 ≈ 3816 K. Dans la formule, GA représente l'atténuation de la lumière par le verre ou le plastique devant le capteur ; on prend 1 pour un capteur à nu. Si tu places le capteur derrière un cache, tu dois augmenter GA au-dessus de 1 et le calibrer en le comparant à un luxmètre connu.
Comparaison TCS34725 et TCS3200
| Caractéristique | TCS34725 | TCS3200 |
|---|---|---|
| Sortie | I2C, nombre numérique 16 bits | Signal carré, fréquence proportionnelle à la lumière |
| Broches utilisées | 2 (SDA, SCL) | 5–6 (S0–S3, OUT, OE) |
| Photodiodes | 3×4 = 12 | 8×8 = 64 |
| Filtre IR | Présent sur la puce | Absent, sensible à l'infrarouge |
| Réglages | Temps 2,4–614 ms, gain 1x–60x | Échelle de fréquence 2 %, 20 %, 100 % |
| Alimentation | Module 3,3–5 V (puce 2,7–3,6 V) | 2,7–5,5 V |
| LED sur la carte | 1 blanche neutre | 4 blanches |
| Méthode de lecture | Quatre canaux en même temps, depuis un registre | Sélection filtre par filtre et mesure de fréquence avec pulseIn |
| Lux et température de couleur | Calculés directement par formule | Difficile, calibration détaillée nécessaire |
Le TCS3200 reste très courant dans les projets scolaires, car ses quatre LED éclairent fortement l'objet et il fonctionne sans souci en 5 V. Mais changer le filtre avec les broches S2 et S3 puis mesurer la fréquence pour chaque couleur coûte des broches et du temps. Faute de filtre IR, ses mesures sont aussi plus perturbées par la lumière ambiante. Le TCS34725, lui, se branche avec deux fils, lit les quatre canaux en même temps et, grâce au temps et au gain réglables, fonctionne de l'obscurité au plein soleil. Si tu démarres un nouveau projet, choisis le TCS34725 ; si tu as déjà un TCS3200, l'article capteur de couleur TCS3200 te guidera. Si tu veux détecter en plus les gestes et la proximité, l'APDS-9960 est aussi une bonne alternative.
Exemple de trieuse de couleurs
Un projet classique pour l'école et les salons scientifiques : arrêter devant le capteur des bonbons ou des perles colorés qui glissent sur une rampe et les diriger vers différentes boîtes selon leur couleur. Ici, le capteur mesure la couleur et un servomoteur tourne la goulotte vers l'angle de la boîte correspondante. L'astuce la plus importante est d'utiliser les rapports et non les valeurs brutes. Quand l'objet s'éloigne un peu, R, G et B baissent ensemble, mais le rapport R/(R+G+B) reste presque le même. Pour la calibration, place un objet de chaque couleur devant le capteur, note les valeurs nr, ng et nb affichées dans le moniteur série et inscris-les dans le tableau ref du code ; les valeurs du code ne sont que des exemples. Si tu places le capteur dans un tube noir et gardes l'objet toujours à la même distance (idéalement 5–10 mm), l'effet de la lumière ambiante disparaît et la précision augmente nettement.
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}À chaque lecture, le code regarde d'abord la valeur C. Quand le tube est vide, la lumière de la LED ne se réfléchit pas, C reste petite et la machine attend ; si de la lumière ambiante entre dans le tube, ajuste BOS_ESIK selon ton montage. Quand un objet arrive, R, G et B sont divisés par leur somme pour obtenir les rapports de couleur. Ensuite, le carré de la distance à chaque couleur de référence est calculé et la plus proche est choisie. Le seuil de distance de 0,004 classe comme inconnus les objets qui ne ressemblent à aucune couleur ; si tu le réduis, la machine devient plus sélective. Pour ajouter une couleur, il suffit d'ajouter une ligne aux tableaux ref, renkAd et aci et de mettre à jour RENK_SAYISI. Alimenter le servo avec une source 5 V séparée évite que les lectures I2C soient perturbées quand le moteur bouge. Faire la moyenne de plusieurs mesures rend aussi les lectures plus stables ; consulte pour cela l'article filtrage des données de capteur.
TCS34725 avec ESP32 : reproduire la couleur sur une LED RGB
Sur l'ESP32, la même bibliothèque Adafruit fonctionne sans modification. Les broches I2C par défaut sont GPIO 21 (SDA) et GPIO 22 (SCL), et le plus sûr est d'alimenter le module par la broche 3V3. L'exemple suivant imite la couleur vue par le capteur avec une LED RGB à cathode commune et écrit le code couleur au format #RRGGBB dans le moniteur série. La fonction getRGB() ramène les couleurs à l'intervalle 0–255 en les divisant par le canal C ; le code ramène le canal le plus fort à 255 et applique une correction gamma pour raviver les couleurs pâles. Comme les fonctions PWM diffèrent entre les versions 2.x et 3.x du cœur Arduino pour ESP32, le code est séparé selon la version. Tu trouveras la bonne résistance pour chaque patte de LED avec le calculateur de résistance LED.
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}TCS34725 avec Raspberry Pi Pico (MicroPython)
En MicroPython, tu n'es pas obligé d'installer une bibliothèque ; la structure des registres du TCS34725 est simple et tu peux lui parler directement en quelques lignes. À chaque adresse de registre, on ajoute le bit de commande (0x80), et pour les lectures multi-octets on utilise aussi le bit d'auto-incrément (0x20). Le code lit d'abord le registre d'identification (0x12) : il doit renvoyer 0x44 pour le TCS34725 et 0x4D pour le TCS34727. Ensuite, il règle ATIME sur 0xEB (environ 50 ms) et le gain sur 4x, active le capteur et calcule à chaque mesure le lux et la température de couleur avec la formule DN40. Si tu débutes avec le Pico et MicroPython, jette d'abord un œil à l'article Qu'est-ce que le 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)Idées de projets avec le TCS34725
- Trieuse de couleurs : sépare bonbons ou perles dans des boîtes selon leur couleur avec un servo et une rampe (l'exemple ci-dessus).
- Lampe qui copie les couleurs : lis la couleur d'un tissu ou d'un papier et reproduis-la à l'identique sur un ruban WS2812B NeoPixel.
- Mesureur d'éclairage : mesure le lux et la température de couleur d'une pièce et affiche-les à l'écran ; vérifie si ton bureau atteint l'objectif de 500 lx.
- Robot à règles de couleur : ajoute un TCS34725 à un robot suiveur de ligne pour qu'il s'arrête sur un repère rouge et tourne sur un vert.
- Appareil qui annonce la couleur à voix haute : fabrique un outil d'aide pour les personnes malvoyantes qui annonce la couleur lue avec un DFPlayer Mini.
- Indicateur de maturité des fruits : suis le passage d'une tomate ou d'une banane du vert au rouge ou au jaune grâce aux rapports de couleurs.
Erreurs fréquentes et solutions
| Symptôme | Cause probable | Solution |
|---|---|---|
| Message "TCS34725 bulunamadi" | SDA et SCL inversés, pas d'alimentation ou fil mal serré | Vérifie que SDA=A4 et SCL=A5 sur l'Uno ; cherche l'adresse 0x29 avec un scanner I2C |
| Tous les canaux sont très grands et ne bougent pas | Saturation : trop de lumière pour le temps et le gain choisis | Baisse le gain à 1x, raccourcis le temps ou éloigne un peu l'objet |
| Les nombres sont très petits, les couleurs sautent | Lumière insuffisante | Allume la LED, passe le gain à 16x ou 60x, allonge le temps |
| Le même objet donne une couleur différente selon la distance | Comparaison faite avec des valeurs brutes | Utilise les rapports R/(R+G+B) et fixe la distance |
| Les résultats changent quand on ouvre la fenêtre | La lumière ambiante se mêle à la mesure | Entoure le capteur d'un tube noir ou d'un cache |
| La température de couleur reste vers 4000 K | La LED de la carte est restée allumée | Relie la broche LED à GND ou éteins-la avec une broche numérique |
| Les lectures sont très lentes | Temps d'intégration long (ex. 614 ms) | getRawData() attend toute la durée ; choisis 24–50 ms |
| Le rouge et l'orange se confondent | Les rapports de référence sont trop proches | Calibre sur le montage final, réduis le seuil, fais la moyenne de plusieurs lectures |
Le TCS34725 est un capteur polyvalent, branché avec deux fils, qui mesure de façon fiable aussi bien la couleur des objets que la lumière ambiante grâce à sa sensibilité réglable et à son filtre IR. Le secret de bons résultats tient en trois points : choisir temps et gain pour éviter la saturation, travailler avec des rapports plutôt qu'avec des valeurs brutes, et calibrer sur le montage final. Si tu veux commencer la mesure de lumière avec un capteur plus simple, la photorésistance LDR est un bon premier pas. Dans l'application BlueGrays, tu trouveras pas à pas, avec schémas et code, la mesure de lumière avec une LDR, les dégradés de couleur d'une LED RGB, la lampe mélangeuse de couleurs ESP32 et des projets de servo, sur lesquels tu pourras construire ta propre machine à capteur de couleur.
Questions fréquentes
Quelle est la différence entre le TCS34725 et le TCS3200 ?
Le TCS34725 donne les quatre canaux en même temps sous forme de nombres 16 bits via I2C et a un filtre infrarouge sur la puce. Le TCS3200 sélectionne les filtres un par un avec les broches S2–S3 et produit une sortie en fréquence ; il demande 5–6 broches et, sans filtre IR, il est plus sensible à la lumière ambiante. Pour la précision et la simplicité de câblage, le TCS34725 est le meilleur choix.
Quelle est l'adresse I2C du TCS34725, peut-on la changer ?
L'adresse du TCS34725 est fixe, 0x29, et ne peut pas être modifiée. Pour brancher deux capteurs sur la même carte, tu peux utiliser un multiplexeur I2C comme le TCA9548A. Sur l'ESP32 et le Pico, il est aussi possible de brancher chaque capteur sur un bus I2C distinct.
Le TCS34725 fonctionne-t-il en 5 V ?
La puce elle-même fonctionne en 2,7–3,6 V. Mais comme la plupart des modules ont un régulateur 3,3 V, tu peux appliquer 5 V sur la broche VIN et brancher le module directement sur un Arduino Uno. Mettre 5 V sur la broche 3V3 détruit la puce ; si ta carte n'a pas de régulateur, alimente le module en 3,3 V.
Pourquoi mon TCS34725 lit-il mal les couleurs ?
Les causes les plus fréquentes sont la saturation, une lumière insuffisante, la lumière ambiante qui se mêle à la mesure et la comparaison avec des valeurs brutes. Éclaire l'objet avec la LED à distance fixe, vérifie que C reste sous la limite de saturation et travaille avec des rapports comme R/(R+G+B). Calibre aussi toujours les couleurs de référence sur ton montage final.
Comment éteindre la LED du TCS34725 ?
Quand tu relies la broche LED du module à GND, la LED blanche s'éteint. Si tu la branches sur une sortie numérique, tu peux l'éteindre avec LOW et l'allumer avec HIGH. Pour mesurer la lumière ambiante ou la température de couleur, la LED doit être éteinte.
Quelle est la précision de la mesure de lux avec le TCS34725 ?
Le TCS34725 n'est pas aussi précis qu'un luxmètre professionnel, mais avec la formule DN40 et un bon réglage temps-gain, il donne en intérieur des valeurs approchées tout à fait utilisables. Si le capteur est derrière un verre ou un plastique, tu dois le calibrer avec le coefficient GA. Si tu veux seulement la luminosité, le BH1750, qui donne directement le lux, est plus simple.
Projets à réaliser après cet article
Voir tous les projets
Mesurer l'intensité lumineuse avec une LDR
Envie de voir en chiffres à quel point ta chambre est lumineuse ? Le LDR, une petite pièce sensible à la lumière, mesure la lumière ambiante, et l'Arduino écrit la valeur sur l'écran de ton…

Mesure de l'intensité lumineuse avec le module LDR ESP32
Suivi en temps réel sur le moniteur série de la valeur brute de l'ADC du module LDR et du pourcentage relatif de luminosité calculé à partir de références dans l'obscurité et à la lumière. Ce pourcentage n'est pas une mesure en lux. Permet de comprendre le principe de calibrage du module. Il est préférable de réaliser cet exercice avant le projet 10, car il sert à déterminer la valeur seuil.

Utilisation d'une LED RVB
Trois couleurs se cachent dans une seule LED : la LED RGB s'allume en rouge, puis en vert, puis en bleu, chaque couleur allumée une demi-seconde puis éteinte une demi-seconde, avant que tout…

Transition douce des couleurs avec une LED RVB
Une seule LED RGB glisse doucement du rouge au vert, du vert au bleu, puis revient au rouge, dans une boucle arc-en-ciel qui ne s'arrête jamais.

Contrôle d'une LED RVB avec ESP32
Génération illimitée de couleurs avec une seule LED RVB au lieu de 3 LED séparées. Comme dans Arduino, nous réalisons une transition arc-en-ciel en réglant les valeurs R/G/B avec analogWrite(). La théorie des couleurs (telle que rouge+vert=jaune) est mise en pratique.

Lampe à mélangeur de couleurs ESP32 (3 potentiomètres + LED RVB + écran OLED)
Une lampe mélangeuse de couleurs intelligente : tourne 3 potentiomètres sur l'ESP32 et mélange la couleur de ton choix ! Quand tu tournes les potentiomètres rouge, vert et bleu, la LED RGB à cathode commune change de couleur aussitôt. L'écran OLED SSD1306 affiche en direct la valeur 0-255 de chaque couleur, des barres de remplissage et le code couleur web HEX (comme #FF8040).

TCRT5000 Détection de surface noire et blanche
Avec le petit capteur qui sert d'œil aux robots suiveurs de ligne, tu sais si le sol est noir ou blanc.

Raspberry Pi Pico LED RVB Cycle de Couleurs (PWM 3 Canaux)
Une LED, des millions de couleurs ! Une LED RVB contient 3 LEDs : rouge, verte et bleue. Avec un canal PWM du Pico pour chacune, les couleurs se mélangent : rouge + vert = jaune, vert + bleu = cyan, les trois = blanc. La LED parcourt 8 couleurs. Apprends plusieurs canaux PWM, les fonctions (def), le mélange RVB, la conversion 8 bits → 16 bits (x257) et cathode commune vs anode commune.
Autres articles
Application BlueGrays
Réalise ce montage pas à pas sur ton téléphone
Schéma, code et liste des composants sur un seul écran. Plus de 500 projets Arduino, ESP32 et Pico à réaliser.
Scanne avec ton téléphone
Pointe l’appareil photo vers le code : la boutique d’applications de ton téléphone s’ouvre.
ou ouvre la boutique

