TCS34725 Arduino: sensor de cor RGB I2C, lux e temperatura de cor
Ligação do TCS34725 ao Arduino, tempo de integração e ganho, temperatura de cor e lux, comparação com o TCS3200, uma máquina separadora de cores e códigos para ESP32 e Pico.
O TCS34725 é um sensor de cor RGB digital que se comunica por I2C e é uma das formas mais precisas e fáceis de detectar cores com Arduino. Ele informa a quantidade de luz vermelha, verde, azul e total (clear) vinda de um objeto que você coloca na frente dele, ou da luz ambiente, como números de 16 bits. Como o chip também tem um filtro bloqueador de infravermelho, as leituras são muito menos afetadas pela luz invisível que vem da luz do dia e das lâmpadas. A ligação do TCS34725 ao Arduino usa apenas dois fios de dados (SDA e SCL), e com a biblioteca da Adafruit você lê os primeiros valores em poucas linhas.
Neste post você vai aprender, passo a passo, o que há dentro do sensor, como os ajustes de tempo de integração e ganho mudam a medição e como calcular a temperatura de cor (Kelvin) e o lux a partir dos números brutos. Depois, vai compará-lo com o antigo, mas comum, TCS3200, montar uma máquina separadora de cores calibrada e usar o mesmo sensor com o ESP32 e o Raspberry Pi Pico (MicroPython).

O que é o TCS34725 e como ele funciona?
O chip tem 12 pequenos fotodiodos dispostos em 3×4. Três deles são cobertos por um filtro vermelho, três por um filtro verde e três por um filtro azul; os três restantes não têm filtro e enxergam a luz total (clear, C). A corrente produzida por cada grupo é acumulada durante um tempo definido em um conversor analógico-digital de 16 bits separado. Esse tempo se chama tempo de integração. Quando ele termina, os quatro resultados (R, G, B, C) são gravados em registradores e você os lê por I2C. O filtro bloqueador de infravermelho sobre os fotodiodos corta boa parte da luz acima de 700 nm, que nossos olhos não enxergam. Assim, o TCS34725 mede as cores de forma mais próxima de como o olho humano as percebe. A maioria dos módulos também tem um LED branco neutro ao lado do chip. Quando você lê a cor de um objeto, na verdade está medindo a parte da luz desse LED que bate no objeto e volta refletida.
| Característica | Valor |
|---|---|
| Canais medidos | Vermelho (R), verde (G), azul (B), sem filtro (C) |
| Matriz de fotodiodos | 3×4, 12 fotodiodos no total |
| Resolução | 16 bits por canal (0–65535) |
| Interface | I2C, até 400 kHz |
| Endereço I2C | 0x29 (fixo) |
| Alimentação | Chip 2,7–3,6 V; módulo com regulador 3,3–5 V |
| Corrente | Cerca de 235 µA durante a medição, 2,5 µA em repouso (sem contar o LED) |
| Filtro IR | No chip, bloqueador de infravermelho |
| Faixa dinâmica | 3.800.000:1 |
| Tempo de integração | 2,4 ms – 614 ms (em passos de 2,4 ms) |
| Ganho | 1x, 4x, 16x, 60x |
| LED na placa | Branco neutro, cerca de 4150 K |
Ajustes de tempo de integração e ganho
O tempo de integração é parecido com o tempo de exposição de uma câmera. Quanto maior ele for, mais luz o sensor acumula, os números ficam maiores e o ruído em ambientes escuros diminui. Por outro lado, cada leitura demora mais e os canais saturam com mais facilidade sob luz forte. O tempo é ajustado em passos de 2,4 ms com o registrador ATIME. O maior número que um canal pode atingir é dado pela fórmula (256 − ATIME) × 1024, e o resultado não pode passar de 65535. A tabela abaixo mostra os valores mais usados e quando escolher cada um.
| ATIME | Ciclos | Tempo | Contagem máx. | Quando? |
|---|---|---|---|---|
| 0xFF | 1 | 2,4 ms | 1024 | Luz muito forte, leitura muito rápida |
| 0xF6 | 10 | 24 ms | 10240 | Sob o sol, objetos em movimento rápido |
| 0xEB | 21 | 50 ms | 21504 | Um bom ponto de partida para ler cores com o LED |
| 0xD6 | 42 | 101 ms | 43008 | Medir a luz ambiente em ambientes internos |
| 0xC0 | 64 | 154 ms | 65535 | Ambientes com pouca luz, resolução total de 16 bits |
| 0x00 | 256 | 614 ms | 65535 | Ambientes muito escuros, leitura lenta |
O ganho amplifica o sinal acumulado no domínio analógico. As opções são 1x, 4x, 16x e 60x. Aumentar o ganho eleva a sensibilidade sem alongar o tempo, mas também aumenta o ruído. A regra prática: ilumine o objeto sempre com o LED e à mesma distância, e comece com 50 ms e 4x. Se o C ficar bem abaixo da contagem máxima (por exemplo, abaixo de 1000), aumente o ganho para 16x. Se o C se aproximar da saturação, diminua o ganho ou encurte o tempo. Quando um canal chega ao teto, aquela leitura deixa de ser correta, porque o número não consegue crescer mais conforme a luz aumenta e as proporções das cores se distorcem. O datasheet também observa que, em tempos menores que 150 ms, a saturação pode começar por volta de 75% da contagem máxima por causa da ondulação (ripple). Por isso, em 50 ms, considere cerca de 16000 como limite superior seguro.
Ligação do TCS34725 (Arduino Uno, ESP32, Pico)
| Pino do TCS34725 | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| VIN | 5V | 3V3 | 3V3(OUT) (pino 36) |
| GND | GND | GND | GND |
| SDA | A4 | GPIO 21 | GP4 (pino 6) |
| SCL | A5 | GPIO 22 | GP5 (pino 7) |
| LED | Desconectado: LED aceso / GND: LED apagado | Desconectado ou GND | Desconectado ou GND |
| INT | Desconectado (saída de interrupção opcional) | Desconectado | Desconectado |
| 3V3 | Não conectar (saída do regulador) | Não conectar | Não conectar |
Passo a passo: sua primeira leitura de cor com o Arduino Uno
- Ligue o módulo como na tabela: VIN no 5V, GND no GND, SDA no A4, SCL no A5. Por enquanto, deixe os pinos LED e INT desconectados.
- Na Arduino IDE, abra o Gerenciador de Bibliotecas, procure a biblioteca Adafruit TCS34725 e instale; se ela pedir dependências, instale também a Adafruit BusIO. Se travar em algum ponto, dê uma olhada em como instalar bibliotecas no Arduino.
- Carregue o código abaixo e abra o Monitor Serial em 9600 baud.
- Segure papéis vermelho, verde e azul a 1–2 cm na frente do sensor e observe qual canal cresce em cada cor.
- Aproxime e afaste o papel para ver como os números mudam e confira se o valor C não chega ao limite de saturação.
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}O tempo de integração e o ganho são informados juntos na criação do objeto; se quiser, você pode mudá-los depois com tcs.setIntegrationTime() e tcs.setGain(). A getRawData() espera um tempo de integração e depois lê os quatro canais. Por isso, se você escolher 614 ms, não consegue fazer nem duas leituras por segundo. Para a temperatura de cor usamos a função calculateColorTemperature_dn40() da biblioteca; ela retorna um valor inválido (65535) quando há saturação. O cálculo do lux fizemos por conta própria, porque a função calculateLux() da biblioteca não leva em conta o tempo e o ganho, e o resultado dela se desloca quando você muda os ajustes. Mantenha sempre as constantes ATIME_MS e GAIN do código iguais aos ajustes que você escolheu.
Cálculo da temperatura de cor e do lux
O lux (lx) indica o quanto a luz que incide sobre uma superfície parece brilhante ao olho humano. Um cômodo com pouca luz tem cerca de 50–100 lx e um escritório bem iluminado cerca de 300–500 lx; ao ar livre, com céu nublado, você mede alguns milhares de lx, enquanto o sol do meio-dia chega a 100.000 lx. A temperatura de cor (CCT) descreve o tom da luz branca em Kelvin. A chama de uma vela tem cerca de 1900 K, uma lâmpada incandescente 2700 K, um LED branco quente 3000 K, o sol do meio-dia 5500 K e um céu nublado por volta de 6500–7500 K. Quanto menor o valor, mais a luz puxa para o amarelo-alaranjado; quanto maior, mais para o azul. A ams, fabricante do TCS34725, recomenda na nota de aplicação DN40 os seguintes passos para calcular essas duas grandezas a partir dos números brutos:
| Passo | Fórmula |
|---|---|
| 1. Componente infravermelha | IR = (R + G + B − C) / 2 (0 se for negativo) |
| 2. Canais sem IR | R' = R − IR, G' = G − IR, B' = B − IR |
| 3. Contagens por lux | CPL = (ATIME_ms × Ganho) / (GA × 310) |
| 4. Lux | Lux = (0,136 × R' + 1,000 × G' − 0,444 × B') / CPL |
| 5. Temperatura de cor | CCT = 3810 × (B' / R') + 1391 |
Vamos a um exemplo: suponha que você leu R = 1200, G = 1000, B = 800, C = 2800 com 50,4 ms e ganho de 4x. IR = (1200 + 1000 + 800 − 2800) / 2 = 100; os valores sem IR são 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. A temperatura de cor é 3810 × 700 / 1100 + 1391 ≈ 3816 K. O GA da fórmula indica o quanto a tampa de vidro ou plástico na frente do sensor atenua a luz; para o sensor sem tampa, use 1. Se você colocar o sensor atrás de uma tampa, deve aumentar o GA acima de 1 e calibrá-lo comparando com um luxímetro conhecido.
TCS34725 vs TCS3200
| Característica | TCS34725 | TCS3200 |
|---|---|---|
| Saída | I2C, número digital de 16 bits | Onda quadrada, frequência proporcional à luz |
| Pinos usados | 2 (SDA, SCL) | 5–6 (S0–S3, OUT, OE) |
| Fotodiodos | 3×4 = 12 | 8×8 = 64 |
| Filtro IR | Sim, no chip | Não, sensível ao infravermelho |
| Ajustes | Tempo 2,4–614 ms, ganho 1x–60x | Escala de frequência 2%, 20%, 100% |
| Alimentação | Módulo 3,3–5 V (chip 2,7–3,6 V) | 2,7–5,5 V |
| LED na placa | 1 branco neutro | 4 brancos |
| Método de leitura | Quatro canais ao mesmo tempo, pelos registradores | Seleciona filtro por filtro e mede a frequência com pulseIn |
| Lux e temperatura de cor | Calculados diretamente com fórmulas | Difícil, exige calibração detalhada |
O TCS3200 ainda é muito comum em projetos escolares, porque seus quatro LEDs iluminam bem o objeto e ele funciona tranquilamente com 5 V. Mas trocar o filtro de cada cor com os pinos S2 e S3 e medir frequência custa pinos e tempo. Como não tem filtro IR, as leituras também são mais afetadas pela luz ambiente. O TCS34725, por outro lado, liga com dois fios, lê quatro canais de uma vez e, graças ao tempo e ganho ajustáveis, funciona da escuridão ao sol pleno. Se você está começando um projeto novo, escolha o TCS34725; se já tem um TCS3200, o post sensor de cor TCS3200 vai te orientar. Se você também quiser detectar gestos e proximidade além da cor, o APDS-9960 também é uma boa alternativa.
Exemplo de máquina separadora de cores
Um projeto clássico de escola e de feira de ciências: parar na frente do sensor balas ou miçangas coloridas que descem por uma rampa e direcioná-las para recipientes diferentes conforme a cor. Aqui o sensor mede a cor, e um servo motor gira a calha até o ângulo do recipiente correspondente. O truque mais importante é usar proporções, não números brutos. Quando o objeto se afasta um pouco, R, G e B caem juntos, mas a proporção R/(R+G+B) quase não muda. Para calibrar, coloque um objeto de cada cor na frente do sensor, anote os valores nr, ng e nb mostrados no Monitor Serial e escreva-os na tabela ref do código; os valores do código são só exemplos. Se você colocar o sensor dentro de um tubo preto e mantiver o objeto sempre à mesma distância (o ideal é 5–10 mm), o efeito da luz ambiente desaparece e a precisão melhora bastante.
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}A cada leitura, o código primeiro olha o valor C. Quando o tubo está vazio, a luz do LED não volta refletida, então o C fica pequeno e a máquina espera; se entrar luz ambiente no tubo, ajuste BOS_ESIK para a sua montagem. Quando chega um objeto, as proporções de cor são obtidas dividindo R, G e B pela soma deles. Depois, calcula-se o quadrado da distância até cada cor de referência e escolhe-se a cor mais próxima. O limite de distância de 0.004 classifica como desconhecidos os objetos que não se parecem com nenhuma cor; se você diminuir o limite, a máquina fica mais seletiva. Para adicionar uma cor nova, basta acrescentar uma linha aos arrays ref, renkAd e aci e atualizar RENK_SAYISI. Alimentar o servo com uma fonte de 5 V separada evita que as leituras I2C sejam corrompidas enquanto o motor se move. Tirar a média de algumas medições também deixa as leituras mais estáveis; veja o post filtragem de dados de sensores para isso.
TCS34725 com ESP32: reproduzindo a cor em um LED RGB
No ESP32, a mesma biblioteca da Adafruit funciona sem alterações. Os pinos I2C são, por padrão, GPIO 21 (SDA) e GPIO 22 (SCL), e alimentar o módulo pelo pino 3V3 é o mais seguro. O exemplo abaixo imita a cor que o sensor vê com um LED RGB de cátodo comum e mostra o código da cor no formato #RRGGBB no Monitor Serial. A função getRGB() divide as cores pelo canal C para trazê-las à faixa de 0–255; o código leva o canal mais forte a 255 e aplica correção gama para dar vida às cores fracas. Como as funções de PWM são diferentes nas versões 2.x e 3.x do core do Arduino para ESP32, o código está separado para as duas versões. Você encontra o resistor certo para cada perna do LED com a calculadora Resistor para 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 com TCS34725 (MicroPython)
No MicroPython você não precisa instalar uma biblioteca pronta; a estrutura de registradores do TCS34725 é simples, então dá para conversar com ele diretamente em poucas linhas. O bit de comando (0x80) é somado a cada endereço de registrador, e nas leituras de vários bytes também se usa o bit de autoincremento (0x20). O código primeiro lê o registrador de ID (0x12): ele deve retornar 0x44 para o TCS34725 e 0x4D para o TCS34727. Depois ajusta o ATIME para 0xEB (cerca de 50 ms) e o ganho para 4x, liga o sensor e, a cada medição, calcula o lux e a temperatura de cor com a fórmula DN40. Se você é novo no Pico e no MicroPython, pode dar uma olhada antes em O que é o 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)Ideias de projetos com o TCS34725
- Máquina separadora de cores: separe balas ou miçangas em recipientes por cor usando um servo e uma rampa (o exemplo acima).
- Luminária que copia cores: leia a cor de um tecido ou papel e reproduza-a exatamente em uma fita WS2812B NeoPixel.
- Medidor de iluminação: meça o lux e a temperatura de cor de um cômodo e mostre-os em um display; verifique se a sua mesa de estudos atinge a meta de 500 lx.
- Robô com regras de cor: adicione um TCS34725 a um robô seguidor de linha e crie regras como parar na marca vermelha e virar na verde.
- Dispositivo que fala a cor: monte uma ferramenta de apoio para pessoas com deficiência visual que diz em voz alta a cor detectada com um DFPlayer Mini.
- Indicador de maturação de frutas: acompanhe, pelas proporções de cor, o tomate ou a banana passando do verde para o vermelho ou o amarelo.
Erros comuns e como corrigi-los
| Sintoma | Causa provável | Solução |
|---|---|---|
| Aparece “TCS34725 not found” (TCS34725 não encontrado) | SDA e SCL invertidos, sem alimentação ou fio solto | Confira se SDA=A4 e SCL=A5 no Uno; procure o endereço 0x29 com um sketch scanner I2C |
| Todos os canais estão muito altos e não mudam | Saturação: luz demais para o tempo e o ganho escolhidos | Reduza o ganho para 1x, encurte o tempo ou afaste um pouco o objeto |
| Os números são muito pequenos e as cores ficam pulando | Luz insuficiente | Acenda o LED, ajuste o ganho para 16x ou 60x, aumente o tempo |
| O mesmo objeto mostra outra cor a outra distância | A comparação foi feita com valores brutos | Use as proporções R/(R+G+B) e fixe a distância |
| Os resultados mudam quando se abre uma janela | A luz ambiente está se misturando à medição | Envolva o sensor com um tubo preto ou uma capa |
| A temperatura de cor fica sempre em torno de 4000 K | O LED da placa ficou aceso | Ligue o pino LED ao GND ou apague-o com um pino digital |
| As leituras são muito lentas | Tempo de integração longo (ex.: 614 ms) | A getRawData() espera esse tempo; escolha 24–50 ms |
| Vermelho e laranja se confundem | As proporções de referência estão muito próximas entre si | Calibre na montagem final, diminua o limite, tire a média de algumas leituras |
O TCS34725 é um sensor versátil que liga com dois fios e, graças à sensibilidade ajustável e ao filtro IR, mede de forma confiável tanto a cor dos objetos quanto a luz ambiente. O segredo de resultados corretos são três coisas: escolher um tempo e um ganho que evitem a saturação, trabalhar com proporções em vez de números brutos e calibrar na montagem final. Se quiser começar a medir luz com um sensor mais simples, o sensor de luz LDR é um bom primeiro passo. No app BlueGrays você encontra, passo a passo e com esquema do circuito e código, projetos de medição de luz com LDR, transição de cores com LED RGB, luminária misturadora de cores com ESP32 e servos, e pode montar a sua própria máquina com sensor de cor a partir deles.
Perguntas frequentes
Qual é a diferença entre o TCS34725 e o TCS3200?
O TCS34725 entrega quatro canais ao mesmo tempo como números de 16 bits por I2C e tem um filtro bloqueador de infravermelho no chip. O TCS3200 seleciona o filtro de cor um por um com os pinos S2–S3 e gera uma saída em frequência; ele precisa de 5–6 pinos e, sem filtro IR, é mais afetado pela luz ambiente. Para precisão e ligação fácil, o TCS34725 é a melhor escolha.
Qual é o endereço I2C do TCS34725 e dá para mudá-lo?
O endereço do TCS34725 é fixo em 0x29 e não pode ser alterado. Se você quiser ligar dois sensores na mesma placa, pode usar um multiplexador I2C como o TCA9548A. No ESP32 e no Pico, também é possível ligar cada sensor a um barramento I2C separado.
O TCS34725 funciona com 5 V?
O chip em si funciona com 2,7–3,6 V. Porém, como a maioria dos módulos tem um regulador de 3,3 V, você pode ligar 5 V ao pino VIN e conectar o módulo diretamente a um Arduino Uno. Aplicar 5 V ao pino 3V3 danifica o chip; se a sua placa não tiver regulador, alimente o módulo com 3,3 V.
Por que o meu TCS34725 está lendo as cores errado?
As causas mais comuns são saturação, luz insuficiente, luz ambiente se misturando e comparação com números brutos. Ilumine o objeto com o LED a uma distância fixa, confira se o valor C fica abaixo do limite de saturação e trabalhe com proporções como R/(R+G+B). Calibre também as cores de referência na sua montagem final.
Como apagar o LED do TCS34725?
Quando você liga o pino LED do módulo ao GND, o LED branco apaga. Se ligar o pino a uma saída digital, pode apagá-lo escrevendo LOW e acendê-lo escrevendo HIGH. O LED precisa estar apagado quando você mede a luz ambiente ou a temperatura de cor.
Qual é a precisão da medição de lux com o TCS34725?
O TCS34725 não é tão preciso quanto um luxímetro profissional, mas com a fórmula DN40 e os ajustes certos de tempo e ganho ele dá valores aproximados bem úteis em ambientes internos. Se o sensor estiver atrás de uma tampa de vidro ou plástico, você precisa calibrá-lo com o fator GA. Se só precisa do brilho, o BH1750, que fornece o lux diretamente, é uma opção mais simples.
Projetos para montar depois desta leitura
Ver todos os projetos
Medição da intensidade da luz com LDR
Quer ver a luminosidade do seu quarto em números? O LDR, um pequeno componente sensível à luz, mede a luz ambiente, e o Arduino exibe o valor na tela do computador a cada meio segundo.

Leitura da intensidade da luz com módulo LDR e ESP32
Acompanhe em tempo real no Monitor Serial o valor bruto do ADC do módulo LDR e a porcentagem relativa de luz calculada a partir de referências de escuridão e claridade. Essa porcentagem não é uma medida em lux. O projeto ensina a lógica de calibração do módulo. É ideal fazê-lo antes do projeto 10, pois ajuda a determinar o valor do limiar.

Uso de LED RGB
Três cores se escondem em um único LED: o LED RGB acende primeiro em vermelho, depois em verde e, por fim, em azul.

Transição suave de cores com LED RGB
Um único LED RGB muda lentamente do vermelho para o verde, do verde para o azul e de volta para o vermelho, repetindo esse ciclo de arco-íris sem parar.

Controle de LED RGB com ESP32
Gere inúmeras cores com um único LED RGB em vez de 3 LEDs separados. Como no Arduino, ajustamos os valores R/G/B com analogWrite() para criar uma transição de arco-íris. Você vê a teoria das cores na prática, como vermelho + verde = amarelo.

Luminária com mistura de cores e ESP32 (3 potenciômetros + LED RGB + OLED)
Uma luminária inteligente que permite misturar a cor que você quiser girando três potenciômetros com o ESP32! Ao girar os potenciômetros de vermelho, verde e azul, o LED RGB de cátodo comum muda de cor em tempo real. O display OLED SSD1306 mostra os valores de cada cor na faixa de 0–255, barras de preenchimento e o código HEX da cor para a web, como #FF8040.

Detecção de superfícies pretas e brancas com TCRT5000
Com o pequeno sensor que funciona como o olho dos robôs seguidores de linha, você identifica se o piso é preto ou branco.

Ciclo de cores com LED RGB no Raspberry Pi Pico (PWM de 3 canais)
Um LED, milhões de cores! Um LED RGB guarda, na verdade, três LEDs: vermelho, verde e azul. Com os 3 canais PWM do Pico, você ajusta o brilho de cada um e as cores se misturam: vermelho + verde = amarelo, verde + azul = ciano, os três = branco. O LED passa por 8 cores, meio segundo cada, e você aprende a usar vários canais PWM, criar uma função com def set_color(...) e converter valores de 8 para 16 bits (x257), a mesma ideia usada nas telas.
Mais artigos
App BlueGrays
Monte este circuito passo a passo pelo celular
Esquema do circuito, código e lista de componentes em uma só tela. Mais de 500 projetos com Arduino, ESP32 e Pico prontos para montar.
Escaneie com seu celular
Aponte a câmera para o código para abrir a loja de aplicativos do seu celular.
ou abrir a loja

