Sensore colore TCS34725 Arduino: RGB I2C, lux e temperatura
Sensore TCS34725 con Arduino: collegamento I2C, tempo di integrazione e guadagno, lux e temperatura colore, differenza con TCS3200 e codice ESP32 e Pico.
Il TCS34725 è un sensore di colore RGB digitale con interfaccia I2C ed è uno dei modi più precisi e semplici per rilevare i colori con Arduino. Restituisce come numeri a 16 bit la quantità di luce rossa, verde, blu e totale (clear) dell'oggetto che gli avvicini o dell'ambiente. Sul chip c'è anche un filtro che blocca gli infrarossi, quindi le misure sono molto meno influenzate dalla luce invisibile del sole e delle lampadine. Il collegamento del TCS34725 con Arduino richiede solo due fili dati (SDA e SCL) e con la libreria Adafruit leggi i primi valori in poche righe.
In questo articolo scoprirai cosa c'è dentro il sensore, come le impostazioni di tempo di integrazione e guadagno cambiano la misura e come calcolare passo passo la temperatura colore (Kelvin) e i lux partendo dai valori grezzi. Poi lo confronterai con il vecchio ma diffuso TCS3200, costruirai una selezionatrice di colori calibrata e userai lo stesso sensore anche con ESP32 e Raspberry Pi Pico (MicroPython).

Cos'è il TCS34725 e come funziona?
Sul chip ci sono 12 piccoli fotodiodi disposti in una matrice 3×4. Tre hanno un filtro rosso, tre uno verde, tre uno blu; gli ultimi tre non hanno filtro e vedono la luce totale (clear, C). La corrente prodotta da ciascun gruppo viene accumulata per un certo tempo in un convertitore analogico-digitale a 16 bit dedicato. Questo tempo si chiama tempo di integrazione. Allo scadere, i quattro risultati (R, G, B, C) vengono scritti nei registri e tu li leggi via I2C. Il filtro anti-infrarosso sopra i fotodiodi taglia in gran parte la luce oltre i 700 nm che l'occhio non vede, perciò il TCS34725 misura i colori in modo più vicino alla percezione umana. Sulla maggior parte dei moduli accanto al chip c'è anche un LED bianco neutro. Quando leggi il colore di un oggetto, in realtà misuri la parte della luce di questo LED che rimbalza sull'oggetto e torna indietro.
| Caratteristica | Valore |
|---|---|
| Canali misurati | Rosso (R), verde (G), blu (B), senza filtro (C) |
| Matrice di fotodiodi | 3×4, 12 fotodiodi in totale |
| Risoluzione | 16 bit per canale (0–65535) |
| Interfaccia | I2C, fino a 400 kHz |
| Indirizzo I2C | 0x29 (fisso) |
| Alimentazione | Chip 2,7–3,6 V; modulo con regolatore 3,3–5 V |
| Corrente | Circa 235 µA in misura, 2,5 µA in standby (LED escluso) |
| Filtro IR | Sul chip, blocca gli infrarossi |
| Gamma dinamica | 3.800.000:1 |
| Tempo di integrazione | 2,4 ms – 614 ms (a passi di 2,4 ms) |
| Guadagno | 1x, 4x, 16x, 60x |
| LED sulla scheda | Bianco neutro, circa 4150 K |
Tempo di integrazione e guadagno
Il tempo di integrazione è simile al tempo di posa di una fotocamera. Più è lungo, più luce raccoglie il sensore, i numeri crescono e il rumore al buio diminuisce. In compenso ogni lettura dura di più e con luce intensa i canali saturano più facilmente. Il tempo si imposta con il registro ATIME a passi di 2,4 ms. Il valore massimo che un canale può raggiungere si ottiene con la formula (256 − ATIME) × 1024 e non può superare 65535. La tabella seguente mostra i valori più usati e quando sceglierli.
| ATIME | Cicli | Durata | Conteggio massimo | Quando? |
|---|---|---|---|---|
| 0xFF | 1 | 2,4 ms | 1024 | Luce molto forte, lettura velocissima |
| 0xF6 | 10 | 24 ms | 10240 | Sotto il sole, oggetto in rapido movimento |
| 0xEB | 21 | 50 ms | 21504 | Buon punto di partenza per leggere colori con il LED |
| 0xD6 | 42 | 101 ms | 43008 | Misura della luce ambiente al chiuso |
| 0xC0 | 64 | 154 ms | 65535 | Ambiente poco luminoso, piena risoluzione a 16 bit |
| 0x00 | 256 | 614 ms | 65535 | Ambiente molto buio, lettura lenta |
Il guadagno (gain) amplifica invece in modo analogico il segnale raccolto. Le opzioni sono 1x, 4x, 16x e 60x. Aumentare il guadagno alza la sensibilità senza allungare il tempo, ma aumenta anche il rumore. Regola pratica: illumina sempre l'oggetto con il LED alla stessa distanza e parti da 50 ms e 4x. Se C resta molto sotto il conteggio massimo (per esempio sotto 1000), porta il guadagno a 16x. Se C si avvicina alla saturazione, riduci il guadagno o accorcia il tempo. Quando un canale raggiunge il tetto, quella lettura non è più corretta, perché con più luce il numero non può crescere e i rapporti tra i colori si alterano. Il datasheet indica inoltre che per tempi inferiori a 150 ms la saturazione, a causa dell'ondulazione, può iniziare intorno al 75% del conteggio massimo. Per questo con 50 ms considera un limite superiore sicuro di circa 16000.
Collegamento del TCS34725 (Arduino Uno, ESP32, Pico)
| Pin TCS34725 | 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 | Libero: LED acceso / GND: LED spento | Libero o GND | Libero o GND |
| INT | Libero (uscita di interrupt opzionale) | Libero | Libero |
| 3V3 | Non collegare (uscita del regolatore) | Non collegare | Non collegare |
Passo dopo passo: la prima lettura di colore con Arduino Uno
- Collega il modulo come nella tabella: VIN a 5V, GND a GND, SDA ad A4, SCL ad A5. Per ora lascia liberi i pin LED e INT.
- Nell'Arduino IDE apri il Gestore delle librerie, cerca e installa la libreria Adafruit TCS34725; se chiede le dipendenze, installa anche Adafruit BusIO. Se hai problemi, dai un'occhiata a come aggiungere librerie ad Arduino.
- Carica il codice qui sotto e apri il Monitor seriale a 9600 baud.
- Tieni davanti al sensore, a 1–2 cm, fogli rossi, verdi e blu; osserva quale canale cresce per ogni colore.
- Avvicina e allontana il foglio per vedere come cambiano i numeri e assicurati che C non raggiunga il limite di saturazione.
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}Quando crei l'oggetto, tempo di integrazione e guadagno si passano insieme; se vuoi, puoi cambiarli in seguito con tcs.setIntegrationTime() e tcs.setGain(). getRawData() attende un tempo di integrazione e poi legge i quattro canali. Perciò, scegliendo 614 ms, non riesci a fare nemmeno due letture al secondo. Per la temperatura colore abbiamo usato la funzione calculateColorTemperature_dn40() della libreria, che in caso di saturazione restituisce un valore non valido (65535). I lux invece li calcoliamo noi, perché la funzione calculateLux() della libreria non tiene conto di tempo e guadagno: se cambi le impostazioni, anche il suo risultato si sposta. Mantieni le costanti ATIME_MS e GAIN del codice sempre uguali alle impostazioni scelte.
Temperatura colore e calcolo dei lux
I lux (lx) indicano quanto è luminosa, per l'occhio umano, la luce che cade su una superficie. Una stanza poco illuminata ha 50–100 lx, un ufficio ben illuminato circa 300–500 lx; all'aperto con cielo coperto si misurano alcune migliaia di lx, mentre il sole di mezzogiorno arriva fino a 100.000 lx. La temperatura colore (CCT) descrive invece in Kelvin la tonalità della luce bianca. La fiamma di una candela è circa 1900 K, una lampadina a incandescenza 2700 K, un LED bianco caldo 3000 K, il sole di mezzogiorno 5500 K, il cielo nuvoloso 6500–7500 K. Più il valore è basso, più la luce vira al giallo-arancio; più è alto, più vira al blu. Per calcolare queste due grandezze dai numeri grezzi, ams, il produttore del TCS34725, propone nella nota applicativa DN40 i passaggi seguenti:
| Passo | Formula |
|---|---|
| 1. Componente infrarossa | IR = (R + G + B − C) / 2 (se negativa, 0) |
| 2. Canali senza IR | R' = R − IR, G' = G − IR, B' = B − IR |
| 3. Conteggi per lux | CPL = (ATIME_ms × Guadagno) / (GA × 310) |
| 4. Lux | Lux = (0,136 × R' + 1,000 × G' − 0,444 × B') / CPL |
| 5. Temperatura colore | CCT = 3810 × (B' / R') + 1391 |
Vediamo un esempio: con 50,4 ms e guadagno 4x leggi R = 1200, G = 1000, B = 800, C = 2800. IR = (1200 + 1000 + 800 − 2800) / 2 = 100; i valori senza IR sono 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 temperatura colore è 3810 × 700 / 1100 + 1391 ≈ 3816 K. Nella formula GA indica quanto il vetro o la plastica davanti al sensore attenua la luce; con il sensore scoperto si usa 1. Se metti il sensore dietro una copertura, devi portare GA sopra 1 e calibrarlo confrontandolo con un luxmetro noto.
Confronto tra TCS34725 e TCS3200
| Caratteristica | TCS34725 | TCS3200 |
|---|---|---|
| Uscita | I2C, numero digitale a 16 bit | Onda quadra, frequenza proporzionale alla luce |
| Pin usati | 2 (SDA, SCL) | 5–6 (S0–S3, OUT, OE) |
| Fotodiodi | 3×4 = 12 | 8×8 = 64 |
| Filtro IR | Presente sul chip | Assente, sensibile agli infrarossi |
| Impostazioni | Tempo 2,4–614 ms, guadagno 1x–60x | Scala di frequenza 2%, 20%, 100% |
| Alimentazione | Modulo 3,3–5 V (chip 2,7–3,6 V) | 2,7–5,5 V |
| LED sulla scheda | 1 bianco neutro | 4 bianchi |
| Metodo di lettura | Quattro canali insieme, da registro | Selezione filtro per filtro e misura della frequenza con pulseIn |
| Lux e temperatura colore | Calcolabili direttamente con formule | Difficili, serve una calibrazione accurata |
Il TCS3200 è ancora molto diffuso nei progetti scolastici perché i suoi quattro LED illuminano bene l'oggetto e funziona tranquillamente a 5 V. Però cambiare il filtro con i pin S2 e S3 e misurare la frequenza per ogni colore costa pin e tempo. Senza filtro IR, le sue misure sono inoltre più disturbate dalla luce ambiente. Il TCS34725 invece si collega con due fili, legge i quattro canali insieme e, grazie a tempo e guadagno regolabili, funziona dal buio al pieno sole. Se inizi un nuovo progetto scegli il TCS34725; se hai già un TCS3200, l'articolo sensore di colore TCS3200 ti guiderà. Se oltre al colore vuoi rilevare anche gesti e prossimità, anche l'APDS-9960 è una buona alternativa.
Esempio di selezionatrice di colori
Un classico progetto da scuola e da fiera della scienza: fermare davanti al sensore caramelle o perline colorate che scivolano su una rampa e indirizzarle in scatole diverse in base al colore. Qui il sensore misura il colore e un servomotore orienta lo scivolo verso l'angolo della scatola giusta. Il trucco più importante è usare i rapporti e non i numeri grezzi. Quando l'oggetto si allontana un po', R, G e B calano insieme, ma il rapporto R/(R+G+B) resta quasi uguale. Per la calibrazione, metti davanti al sensore un oggetto per ogni colore, annota i valori nr, ng e nb mostrati sul Monitor seriale e scrivili nella tabella ref del codice; i valori nel codice sono solo di esempio. Se metti il sensore dentro un tubo nero e tieni l'oggetto sempre alla stessa distanza (idealmente 5–10 mm), l'effetto della luce ambiente sparisce e la precisione aumenta nettamente.
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}Il codice a ogni lettura controlla prima il valore C. Con il tubo vuoto la luce del LED non torna indietro, quindi C resta piccolo e la macchina aspetta; se la luce ambiente entra nel tubo, regola BOS_ESIK in base al tuo montaggio. Quando arriva un oggetto, R, G e B vengono divisi per la loro somma per ottenere i rapporti di colore. Poi si calcola il quadrato della distanza da ogni colore di riferimento e si sceglie il più vicino. La soglia di distanza di 0,004 classifica come sconosciuti gli oggetti che non somigliano a nessun colore; se la riduci, la macchina diventa più selettiva. Per aggiungere un colore basta aggiungere una riga agli array ref, renkAd e aci e aggiornare RENK_SAYISI. Alimentare il servo da un'alimentazione a 5 V separata evita che le letture I2C si disturbino mentre il motore si muove. Per rendere le letture più stabili aiuta anche fare la media di alcune misure; su questo vedi l'articolo filtraggio dei dati dei sensori.
TCS34725 con ESP32: riprodurre il colore su un LED RGB
Su ESP32 la stessa libreria Adafruit funziona senza modifiche. I pin I2C predefiniti sono GPIO 21 (SDA) e GPIO 22 (SCL), e la cosa più sicura è alimentare il modulo dal pin 3V3. L'esempio seguente imita il colore visto dal sensore con un LED RGB a catodo comune e scrive il codice colore nel formato #RRGGBB sul Monitor seriale. La funzione getRGB() porta i colori nell'intervallo 0–255 dividendoli per il canale C; il codice porta a 255 il canale più forte e applica la correzione gamma per ravvivare i colori spenti. Poiché le funzioni PWM sono diverse tra le versioni 2.x e 3.x del core Arduino per ESP32, il codice è diviso per le due versioni. Il resistore giusto per ogni gamba del LED lo trovi con il calcolatore di resistenza per 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}Raspberry Pi Pico con TCS34725 (MicroPython)
Con MicroPython non è obbligatorio installare una libreria: i registri del TCS34725 sono semplici, quindi puoi comunicare direttamente con poche righe. A ogni indirizzo di registro si aggiunge il bit di comando (0x80), e per le letture multi-byte si usa anche il bit di auto-incremento (0x20). Il codice legge prima il registro ID (0x12): deve restituire 0x44 per il TCS34725 e 0x4D per il TCS34727. Poi imposta ATIME a 0xEB (circa 50 ms) e il guadagno a 4x, accende il sensore e a ogni misura calcola lux e temperatura colore con la formula DN40. Se sei nuovo con Pico e MicroPython, dai prima un'occhiata a Cos'è 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)Idee per progetti con il TCS34725
- Selezionatrice di colori: separa caramelle o perline per colore in scatole con servo e rampa (l'esempio qui sopra).
- Lampada copia-colore: leggi il colore di un tessuto o di un foglio e riproducilo identico su una striscia WS2812B NeoPixel.
- Misuratore di illuminazione: misura lux e temperatura colore della stanza e mostrali su uno schermo; controlla se sulla scrivania raggiungi l'obiettivo di 500 lx.
- Robot con regole di colore: aggiungi un TCS34725 a un robot segui-linea per regole come fermarsi sul segno rosso e girare sul verde.
- Dispositivo che dice il colore a voce: costruisci un aiuto per persone non vedenti che pronuncia il colore letto con un DFPlayer Mini.
- Indicatore di maturazione della frutta: segui con i rapporti di colore il passaggio di un pomodoro o di una banana dal verde al rosso o al giallo.
Errori comuni e soluzioni
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| Compare "TCS34725 bulunamadi" (sensore non trovato) | SDA e SCL invertiti, manca l'alimentazione o un cavo è lento | Controlla che su Uno SDA=A4 e SCL=A5; cerca l'indirizzo 0x29 con uno scanner I2C |
| Tutti i canali sono altissimi e non cambiano | Saturazione: troppa luce per tempo e guadagno scelti | Porta il guadagno a 1x, accorcia il tempo o allontana un po' l'oggetto |
| I numeri sono molto bassi e i colori ballano | Luce insufficiente | Accendi il LED, porta il guadagno a 16x o 60x, allunga il tempo |
| Lo stesso oggetto dà colori diversi a distanze diverse | Il confronto è stato fatto con valori grezzi | Usa i rapporti R/(R+G+B) e mantieni fissa la distanza |
| Aprendo la finestra i risultati cambiano | La luce ambiente si mescola alla misura | Circonda il sensore con un tubo o una copertura nera |
| La temperatura colore resta sempre intorno ai 4000 K | Il LED sulla scheda è rimasto acceso | Collega il pin LED a GND o spegnilo con un pin digitale |
| Le letture sono molto lente | Tempo di integrazione lungo (es. 614 ms) | getRawData() attende quel tempo; scegli 24–50 ms |
| Rosso e arancione si confondono | I rapporti di riferimento sono troppo vicini | Calibra nel montaggio finale, riduci la soglia, fai la media di più letture |
Il TCS34725 è un sensore versatile, collegato con due fili, che grazie alla sensibilità regolabile e al filtro IR misura in modo affidabile sia il colore degli oggetti sia la luce ambiente. Il segreto di buoni risultati è nelle tre cose: scegliere tempo e guadagno che evitano la saturazione, lavorare con i rapporti invece che con i numeri grezzi e calibrare nel montaggio finale. Se vuoi iniziare a misurare la luce con un sensore più semplice, il sensore di luce LDR è un buon primo passo. Nell'app BlueGrays trovi passo passo, con schema e codice, la misura della luce con LDR, le transizioni di colore con LED RGB, la lampada mixer di colori con ESP32 e i progetti con servo, su cui puoi costruire la tua macchina con sensore di colore.
Domande frequenti
Qual è la differenza tra TCS34725 e TCS3200?
Il TCS34725 fornisce via I2C i quattro canali insieme come numeri a 16 bit e ha sul chip un filtro che blocca gli infrarossi. Il TCS3200 invece seleziona uno per uno i filtri di colore con i pin S2–S3 e produce un'uscita in frequenza; richiede 5–6 pin e, senza filtro IR, è più sensibile alla luce ambiente. Per precisione e facilità di collegamento il TCS34725 è la scelta migliore.
Qual è l'indirizzo I2C del TCS34725 e si può cambiare?
L'indirizzo del TCS34725 è fisso a 0x29 e non si può cambiare. Se vuoi collegare due sensori alla stessa scheda, puoi usare un multiplexer I2C come il TCA9548A. Su ESP32 e Pico è possibile anche collegare ogni sensore a un bus I2C separato.
Il TCS34725 funziona a 5 V?
Il chip in sé funziona a 2,7–3,6 V. Però, poiché la maggior parte dei moduli ha un regolatore a 3,3 V, sul pin VIN si possono dare 5 V e il modulo si collega direttamente ad Arduino Uno. Dare 5 V al pin 3V3 danneggia il chip; se la tua scheda non ha il regolatore, alimenta il modulo a 3,3 V.
Perché il TCS34725 legge i colori sbagliati?
Le cause più frequenti sono saturazione, luce insufficiente, luce ambiente che si mescola e confronto con numeri grezzi. Illumina l'oggetto con il LED a distanza fissa, assicurati che C resti sotto il limite di saturazione e lavora con rapporti come R/(R+G+B). Calibra sempre i colori di riferimento nel montaggio finale.
Come si spegne il LED sul TCS34725?
Collegando il pin LED del modulo a GND, il LED bianco si spegne. Se colleghi il pin a un'uscita digitale, puoi spegnerlo scrivendo LOW e accenderlo scrivendo HIGH. Quando misuri la luce ambiente o la temperatura colore, il LED deve essere spento.
Quanto è precisa la misura dei lux con il TCS34725?
Il TCS34725 non è preciso come un luxmetro professionale, ma con la formula DN40 e una corretta impostazione di tempo e guadagno dà valori approssimativi molto utili al chiuso. Se il sensore sta dietro un vetro o una plastica, devi calibrarlo con il coefficiente GA. Se devi solo misurare la luminosità, il BH1750, che dà direttamente i lux, è più semplice.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
Misurare l'intensità luminosa con LDR
Vuoi vedere quanto è luminosa la tua stanza sotto forma di numero? L'LDR, un piccolo componente sensibile alla luce, misura la luce ambiente e l'Arduino scrive il valore sullo schermo del computer…

Lettura dell'intensità luminosa con il modulo LDR ESP32
Monitoraggio in tempo reale sul Serial Monitor del valore grezzo dell'ADC del modulo LDR e della percentuale relativa di luce calcolata dai valori di riferimento al buio e alla luce. Questa percentuale non è una misurazione in lux. Spiega il principio di calibrazione del modulo. È consigliabile eseguirlo prima del Progetto 10, poiché serve a determinare il valore di soglia.

Utilizzo dei LED RGB
Dentro un solo LED si nascondono tre colori: il LED RGB si accende rosso, poi verde, poi blu, ogni colore acceso per mezzo secondo e spento per mezzo secondo, e poi il giro ricomincia.

Transizione cromatica omogenea con LED RGB
Un solo LED RGB passa lentamente dal rosso al verde, dal verde al blu e torna al rosso, in un giro di arcobaleno che non si ferma mai.

Controllo LED RGB ESP32
Generazione illimitata di colori con un singolo LED RGB invece di 3 LED separati. La transizione arcobaleno avviene impostando i valori R/G/B con analogWrite() come in Arduino. La teoria dei colori (come rosso+verde=giallo) viene vista in pratica.

Lampada con miscelatore di colori ESP32 (3 potenziometri + LED RGB + OLED)
Una lampada mixer di colori smart: gira 3 potenziometri sull'ESP32 e mescola il colore che vuoi! Mentre ruoti i potenziometri rosso, verde e blu, il LED RGB a catodo comune cambia colore all'istante. Il display OLED SSD1306 mostra in tempo reale il valore 0-255 di ogni colore, barre di riempimento e il codice colore web HEX (come #FF8040).

TCRT5000 Rilevamento di superfici bianche e nere
Con il piccolo sensore che fa da occhio ai robot seguilinea capisci se il pavimento è nero o bianco.

Raspberry Pi Pico LED RGB Ciclo di Colori (PWM a 3 Canali)
Un LED, milioni di colori! Un LED RGB contiene 3 LED: rosso, verde e blu. Con un canale PWM del Pico per ciascuno, i colori si mescolano: rosso + verde = giallo, verde + blu = ciano, tutti e tre = bianco. Il LED scorre 8 colori. Impara più canali PWM, funzioni (def), miscelazione RGB, conversione da 8 a 16 bit (x257) e catodo comune vs anodo comune.
Altri articoli
App BlueGrays
Costruisci questo circuito passo passo sul telefono
Schema, codice ed elenco componenti in un’unica schermata. Oltre 500 progetti Arduino, ESP32 e Pico da realizzare.
Inquadra con il telefono
Punta la fotocamera sul codice: si apre lo store del tuo telefono.
oppure apri lo store

