Componenti · 11 min di lettura

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

Modulo sensore di colore RGB TCS34725
Modulo sensore di colore TCS34725: il piccolo chip misura i colori, il LED bianco accanto illumina l'oggetto.

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.

CaratteristicaValore
Canali misuratiRosso (R), verde (G), blu (B), senza filtro (C)
Matrice di fotodiodi3×4, 12 fotodiodi in totale
Risoluzione16 bit per canale (0–65535)
InterfacciaI2C, fino a 400 kHz
Indirizzo I2C0x29 (fisso)
AlimentazioneChip 2,7–3,6 V; modulo con regolatore 3,3–5 V
CorrenteCirca 235 µA in misura, 2,5 µA in standby (LED escluso)
Filtro IRSul chip, blocca gli infrarossi
Gamma dinamica3.800.000:1
Tempo di integrazione2,4 ms – 614 ms (a passi di 2,4 ms)
Guadagno1x, 4x, 16x, 60x
LED sulla schedaBianco 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.

ATIMECicliDurataConteggio massimoQuando?
0xFF12,4 ms1024Luce molto forte, lettura velocissima
0xF61024 ms10240Sotto il sole, oggetto in rapido movimento
0xEB2150 ms21504Buon punto di partenza per leggere colori con il LED
0xD642101 ms43008Misura della luce ambiente al chiuso
0xC064154 ms65535Ambiente poco luminoso, piena risoluzione a 16 bit
0x00256614 ms65535Ambiente 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 TCS34725Arduino UnoESP32Raspberry Pi Pico
VIN5V3V33V3(OUT) (pin 36)
GNDGNDGNDGND
SDAA4GPIO 21GP4 (pin 6)
SCLA5GPIO 22GP5 (pin 7)
LEDLibero: LED acceso / GND: LED spentoLibero o GNDLibero o GND
INTLibero (uscita di interrupt opzionale)LiberoLibero
3V3Non collegare (uscita del regolatore)Non collegareNon collegare
La maggior parte dei moduli ha un regolatore a 3,3 V e sul pin VIN si possono dare 5 V. Però non collegare mai 5 V al pin 3V3: il chip sopporta al massimo 3,6 V. Se sulla scheda non vedi un piccolo chip regolatore, alimenta il modulo a 3,3 V. Il pin LED si può collegare anche a un pin digitale: con LOW il LED si spegne, con HIGH si accende. Il pin INT è un'uscita di interrupt open-drain che va a LOW quando si supera la soglia impostata. Il funzionamento del bus I2C lo trovi nell'articolo Cos'è l'I2C, mentre la compatibilità tra 5 V e 3,3 V è spiegata in convertitore di livello logico.

Passo dopo passo: la prima lettura di colore con Arduino Uno

  1. 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.
  2. 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.
  3. Carica il codice qui sotto e apri il Monitor seriale a 9600 baud.
  4. Tieni davanti al sensore, a 1–2 cm, fogli rossi, verdi e blu; osserva quale canale cresce per ogni colore.
  5. Avvicina e allontana il foglio per vedere come cambiano i numeri e assicurati che C non raggiunga il limite di saturazione.
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}

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:

PassoFormula
1. Componente infrarossaIR = (R + G + B − C) / 2 (se negativa, 0)
2. Canali senza IRR' = R − IR, G' = G − IR, B' = B − IR
3. Conteggi per luxCPL = (ATIME_ms × Guadagno) / (GA × 310)
4. LuxLux = (0,136 × R' + 1,000 × G' − 0,444 × B') / CPL
5. Temperatura coloreCCT = 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.

Quando misuri la luce ambiente, spegni sempre il LED sulla scheda; altrimenti il sensore misura il proprio LED e la temperatura colore resta sempre intorno ai 4000 K. Per misurare lux e CCT rivolgi il sensore verso la sorgente luminosa o la stanza, non verso un oggetto, e con luce intensa scegli guadagno 1x e tempo breve. Se ti serve solo la luminosità, il sensore di luce BH1750, che dà direttamente i lux, è una scelta più semplice.

Confronto tra TCS34725 e TCS3200

CaratteristicaTCS34725TCS3200
UscitaI2C, numero digitale a 16 bitOnda quadra, frequenza proporzionale alla luce
Pin usati2 (SDA, SCL)5–6 (S0–S3, OUT, OE)
Fotodiodi3×4 = 128×8 = 64
Filtro IRPresente sul chipAssente, sensibile agli infrarossi
ImpostazioniTempo 2,4–614 ms, guadagno 1x–60xScala di frequenza 2%, 20%, 100%
AlimentazioneModulo 3,3–5 V (chip 2,7–3,6 V)2,7–5,5 V
LED sulla scheda1 bianco neutro4 bianchi
Metodo di letturaQuattro canali insieme, da registroSelezione filtro per filtro e misura della frequenza con pulseIn
Lux e temperatura coloreCalcolabili direttamente con formuleDifficili, 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.

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}

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.

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

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)

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

SintomoCausa probabileSoluzione
Compare "TCS34725 bulunamadi" (sensore non trovato)SDA e SCL invertiti, manca l'alimentazione o un cavo è lentoControlla che su Uno SDA=A4 e SCL=A5; cerca l'indirizzo 0x29 con uno scanner I2C
Tutti i canali sono altissimi e non cambianoSaturazione: troppa luce per tempo e guadagno sceltiPorta il guadagno a 1x, accorcia il tempo o allontana un po' l'oggetto
I numeri sono molto bassi e i colori ballanoLuce insufficienteAccendi il LED, porta il guadagno a 16x o 60x, allunga il tempo
Lo stesso oggetto dà colori diversi a distanze diverseIl confronto è stato fatto con valori grezziUsa i rapporti R/(R+G+B) e mantieni fissa la distanza
Aprendo la finestra i risultati cambianoLa luce ambiente si mescola alla misuraCirconda il sensore con un tubo o una copertura nera
La temperatura colore resta sempre intorno ai 4000 KIl LED sulla scheda è rimasto accesoCollega il pin LED a GND o spegnilo con un pin digitale
Le letture sono molto lenteTempo di integrazione lungo (es. 614 ms)getRawData() attende quel tempo; scegli 24–50 ms
Rosso e arancione si confondonoI rapporti di riferimento sono troppo viciniCalibra 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.

Vedi tutti i progetti
Misurare l'intensità luminosa con LDR
AR-11Principiante

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…

4.6(83)
143
Lettura dell'intensità luminosa con il modulo LDR ESP32
ES-11Principiante

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.

4.6(36)
55
Utilizzo dei LED RGB
AR-39Principiante
Premium

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.

4.9(73)
100
Transizione cromatica omogenea con LED RGB
AR-40Principiante
Premium

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.

4.8(58)
78
Controllo LED RGB ESP32
ES-9Principiante

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.

4.6(29)
52
Lampada con miscelatore di colori ESP32 (3 potenziometri + LED RGB + OLED)
ES-36Avanzato
Premium

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

4.7(6)
10
TCRT5000 Rilevamento di superfici bianche e nere
AR-78Intermedio
Premium

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.

4.7(40)
49
Raspberry Pi Pico LED RGB Ciclo di Colori (PWM a 3 Canali)
PI-15Principiante

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.

6