Componentes · 12 min de leitura

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

Módulo sensor de cor RGB TCS34725
Módulo sensor de cor TCS34725: o pequeno chip sensor mede as cores, e o LED branco ao lado ilumina o objeto.

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ísticaValor
Canais medidosVermelho (R), verde (G), azul (B), sem filtro (C)
Matriz de fotodiodos3×4, 12 fotodiodos no total
Resolução16 bits por canal (0–65535)
InterfaceI2C, até 400 kHz
Endereço I2C0x29 (fixo)
AlimentaçãoChip 2,7–3,6 V; módulo com regulador 3,3–5 V
CorrenteCerca de 235 µA durante a medição, 2,5 µA em repouso (sem contar o LED)
Filtro IRNo chip, bloqueador de infravermelho
Faixa dinâmica3.800.000:1
Tempo de integração2,4 ms – 614 ms (em passos de 2,4 ms)
Ganho1x, 4x, 16x, 60x
LED na placaBranco 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.

ATIMECiclosTempoContagem máx.Quando?
0xFF12,4 ms1024Luz muito forte, leitura muito rápida
0xF61024 ms10240Sob o sol, objetos em movimento rápido
0xEB2150 ms21504Um bom ponto de partida para ler cores com o LED
0xD642101 ms43008Medir a luz ambiente em ambientes internos
0xC064154 ms65535Ambientes com pouca luz, resolução total de 16 bits
0x00256614 ms65535Ambientes 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 TCS34725Arduino UnoESP32Raspberry Pi Pico
VIN5V3V33V3(OUT) (pino 36)
GNDGNDGNDGND
SDAA4GPIO 21GP4 (pino 6)
SCLA5GPIO 22GP5 (pino 7)
LEDDesconectado: LED aceso / GND: LED apagadoDesconectado ou GNDDesconectado ou GND
INTDesconectado (saída de interrupção opcional)DesconectadoDesconectado
3V3Não conectar (saída do regulador)Não conectarNão conectar
A maioria dos módulos tem um regulador de 3,3 V, então você pode ligar 5 V ao pino VIN. Mas nunca ligue 5 V ao pino 3V3; o chip suporta no máximo 3,6 V. Se você não encontrar um pequeno chip regulador na placa, alimente o módulo com 3,3 V. O pino LED também pode ser ligado a um pino digital: escrever LOW apaga o LED e HIGH o acende. O pino INT é uma saída de interrupção de dreno aberto (open-drain) que vai para LOW quando o limite configurado é ultrapassado. Você encontra como funciona o barramento I2C em O que é I2C, e a compatibilidade entre 5 V e 3,3 V em conversor de nível lógico.

Passo a passo: sua primeira leitura de cor com o Arduino Uno

  1. 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.
  2. 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.
  3. Carregue o código abaixo e abra o Monitor Serial em 9600 baud.
  4. Segure papéis vermelho, verde e azul a 1–2 cm na frente do sensor e observe qual canal cresce em cada cor.
  5. 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.
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}

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:

PassoFórmula
1. Componente infravermelhaIR = (R + G + B − C) / 2 (0 se for negativo)
2. Canais sem IRR' = R − IR, G' = G − IR, B' = B − IR
3. Contagens por luxCPL = (ATIME_ms × Ganho) / (GA × 310)
4. LuxLux = (0,136 × R' + 1,000 × G' − 0,444 × B') / CPL
5. Temperatura de corCCT = 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.

Ao medir a luz ambiente, sempre apague o LED da placa; caso contrário, o sensor mede o próprio LED e a temperatura de cor fica presa em torno de 4000 K. Ao medir lux e CCT, aponte o sensor para a fonte de luz ou para o cômodo, não para um objeto, e escolha ganho de 1x e um tempo curto sob luz forte. Se você só precisa medir o brilho, o sensor de luz BH1750, que fornece o lux diretamente, é uma opção mais simples.

TCS34725 vs TCS3200

CaracterísticaTCS34725TCS3200
SaídaI2C, número digital de 16 bitsOnda quadrada, frequência proporcional à luz
Pinos usados2 (SDA, SCL)5–6 (S0–S3, OUT, OE)
Fotodiodos3×4 = 128×8 = 64
Filtro IRSim, no chipNão, sensível ao infravermelho
AjustesTempo 2,4–614 ms, ganho 1x–60xEscala de frequência 2%, 20%, 100%
AlimentaçãoMódulo 3,3–5 V (chip 2,7–3,6 V)2,7–5,5 V
LED na placa1 branco neutro4 brancos
Método de leituraQuatro canais ao mesmo tempo, pelos registradoresSeleciona filtro por filtro e mede a frequência com pulseIn
Lux e temperatura de corCalculados diretamente com fórmulasDifí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.

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}

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.

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

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)

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

SintomaCausa provávelSolução
Aparece “TCS34725 not found” (TCS34725 não encontrado)SDA e SCL invertidos, sem alimentação ou fio soltoConfira 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 mudamSaturação: luz demais para o tempo e o ganho escolhidosReduza o ganho para 1x, encurte o tempo ou afaste um pouco o objeto
Os números são muito pequenos e as cores ficam pulandoLuz insuficienteAcenda o LED, ajuste o ganho para 16x ou 60x, aumente o tempo
O mesmo objeto mostra outra cor a outra distânciaA comparação foi feita com valores brutosUse as proporções R/(R+G+B) e fixe a distância
Os resultados mudam quando se abre uma janelaA luz ambiente está se misturando à mediçãoEnvolva o sensor com um tubo preto ou uma capa
A temperatura de cor fica sempre em torno de 4000 KO LED da placa ficou acesoLigue o pino LED ao GND ou apague-o com um pino digital
As leituras são muito lentasTempo de integração longo (ex.: 614 ms)A getRawData() espera esse tempo; escolha 24–50 ms
Vermelho e laranja se confundemAs proporções de referência estão muito próximas entre siCalibre 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.

Ver todos os projetos
Medição da intensidade da luz com LDR
AR-11Iniciante

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.

4.6(83)
143
Leitura da intensidade da luz com módulo LDR e ESP32
ES-11Iniciante

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.

4.6(36)
55
Uso de LED RGB
AR-39Iniciante
Premium

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.

4.9(73)
100
Transição suave de cores com LED RGB
AR-40Iniciante
Premium

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.

4.8(58)
78
Controle de LED RGB com ESP32
ES-9Iniciante

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.

4.6(29)
52
Luminária com mistura de cores e ESP32 (3 potenciômetros + LED RGB + OLED)
ES-36Avançado
Premium

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.

4.7(6)
10
Detecção de superfícies pretas e brancas com TCRT5000
AR-78Intermediário
Premium

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.

4.7(40)
49
Ciclo de cores com LED RGB no Raspberry Pi Pico (PWM de 3 canais)
PI-15Iniciante

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.

6