Sensor de color TCS34725 con Arduino: RGB I2C, lux y temperatura
Sensor de color TCS34725 con Arduino: conexión, tiempo de integración y ganancia, temperatura de color y lux, diferencia con el TCS3200, clasificadora, ESP32 y Pico.
El TCS34725 es un sensor de color RGB digital con interfaz I2C, una de las formas más precisas y sencillas de detectar color con Arduino. Te da la cantidad de luz roja, verde, azul y total (clear) del objeto que acercas, o de la luz ambiente, como números de 16 bits. Como el chip lleva un filtro bloqueador de infrarrojos, las medidas se ven mucho menos afectadas por la luz invisible del sol y de las bombillas. La conexión del TCS34725 con Arduino usa solo dos cables de datos (SDA y SCL) y con la librería de Adafruit lees los primeros valores en unas pocas líneas.
En este artículo verás qué hay dentro del sensor, cómo cambian la medida el tiempo de integración y la ganancia, y cómo calcular paso a paso la temperatura de color (Kelvin) y los lux a partir de los valores en bruto. Después lo compararás con el veterano y extendido TCS3200, montarás una clasificadora de colores calibrada y usarás el mismo sensor con ESP32 y Raspberry Pi Pico (MicroPython).

¿Qué es el TCS34725 y cómo funciona?
Sobre el chip hay 12 pequeños fotodiodos en una matriz de 3×4. Tres llevan un filtro rojo, tres uno verde y tres uno azul; los otros tres no tienen filtro y ven la luz total (clear, C). La corriente de cada grupo se acumula durante un tiempo determinado en un convertidor analógico-digital de 16 bits independiente. Ese tiempo se llama tiempo de integración. Cuando termina, los cuatro resultados (R, G, B, C) se escriben en registros y tú los lees por I2C. El filtro de infrarrojos sobre los fotodiodos corta en gran parte la luz por encima de 700 nm, que el ojo no ve, así que el TCS34725 mide los colores de forma más parecida a como los percibe el ojo humano. La mayoría de los módulos también llevan un LED blanco neutro junto al chip. Al leer el color de un objeto, en realidad mides la parte de la luz de ese LED que rebota en el objeto.
| Característica | Valor |
|---|---|
| Canales medidos | Rojo (R), verde (G), azul (B), sin filtro (C) |
| Matriz de fotodiodos | 3×4, 12 fotodiodos en total |
| Resolución | 16 bits por canal (0–65535) |
| Interfaz | I2C, hasta 400 kHz |
| Dirección I2C | 0x29 (fija) |
| Alimentación | Chip 2,7–3,6 V; módulo con regulador 3,3–5 V |
| Consumo | Unos 235 µA midiendo, 2,5 µA en reposo (sin LED) |
| Filtro IR | En el chip, bloqueador de infrarrojos |
| Rango dinámico | 3.800.000:1 |
| Tiempo de integración | 2,4 ms – 614 ms (pasos de 2,4 ms) |
| Ganancia | 1x, 4x, 16x, 60x |
| LED de la placa | Blanco neutro, unos 4150 K |
Tiempo de integración y ganancia
El tiempo de integración es parecido al tiempo de exposición de una cámara. Cuanto más largo, más luz recoge el sensor, los números crecen y se reduce el ruido en ambientes oscuros. A cambio, cada lectura tarda más y con luz intensa los canales se saturan con más facilidad. El tiempo se ajusta con el registro ATIME en pasos de 2,4 ms. El valor máximo que puede alcanzar un canal se calcula con la fórmula (256 − ATIME) × 1024 y no puede superar 65535. La tabla siguiente muestra los valores más usados y cuándo conviene cada uno.
| ATIME | Ciclos | Tiempo | Cuenta máxima | ¿Cuándo? |
|---|---|---|---|---|
| 0xFF | 1 | 2,4 ms | 1024 | Luz muy intensa, lectura muy rápida |
| 0xF6 | 10 | 24 ms | 10240 | Bajo el sol, objeto que se mueve rápido |
| 0xEB | 21 | 50 ms | 21504 | Buen punto de partida para leer color con LED |
| 0xD6 | 42 | 101 ms | 43008 | Medir la luz ambiente en interiores |
| 0xC0 | 64 | 154 ms | 65535 | Ambiente tenue, resolución completa de 16 bits |
| 0x00 | 256 | 614 ms | 65535 | Ambiente muy oscuro, lectura lenta |
La ganancia (gain) amplifica la señal acumulada de forma analógica. Tienes 1x, 4x, 16x y 60x. Subir la ganancia aumenta la sensibilidad sin alargar el tiempo, pero también el ruido. Regla práctica: ilumina siempre el objeto con el LED desde la misma distancia y empieza con 50 ms y 4x. Si C se queda muy por debajo de la cuenta máxima (por ejemplo, menos de 1000), sube la ganancia a 16x. Si C se acerca a la saturación, baja la ganancia o acorta el tiempo. Cuando un canal toca el techo, esa lectura ya no es válida, porque el número no puede crecer más aunque aumente la luz y las proporciones de color se estropean. Además, el datasheet indica que con tiempos inferiores a 150 ms la saturación puede empezar en torno al 75 % de la cuenta máxima por el rizado de la luz. Por eso, con 50 ms, toma unos 16000 como límite superior seguro.
Conexión del TCS34725 (Arduino Uno, ESP32, Pico)
| Pin del 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 | Libre: LED encendido / GND: LED apagado | Libre o GND | Libre o GND |
| INT | Libre (salida de interrupción opcional) | Libre | Libre |
| 3V3 | No conectar (salida del regulador) | No conectar | No conectar |
Paso a paso: primera lectura de color con Arduino Uno
- Conecta el módulo como en la tabla: VIN a 5V, GND a GND, SDA a A4, SCL a A5. Deja por ahora libres los pines LED e INT.
- En el IDE de Arduino abre el Gestor de bibliotecas, busca e instala la librería Adafruit TCS34725; si pregunta por dependencias, instala también Adafruit BusIO. Si te atascas, mira cómo añadir librerías a Arduino.
- Sube el código siguiente y abre el Monitor Serie a 9600 baudios.
- Acerca papeles rojo, verde y azul a 1–2 cm del sensor y observa qué canal crece con cada color.
- Acerca y aleja el papel para ver cómo cambian los números y comprueba que C no llegue al límite de saturación.
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}Al crear el objeto se indican a la vez el tiempo de integración y la ganancia; si quieres, luego puedes cambiarlos con tcs.setIntegrationTime() y tcs.setGain(). getRawData() espera un tiempo de integración y lee los cuatro canales. Por eso, si eliges 614 ms, no consigues ni dos lecturas por segundo. Para la temperatura de color usamos la función calculateColorTemperature_dn40() de la librería, que devuelve un valor no válido (65535) en caso de saturación. El cálculo de lux lo hicimos nosotros, porque la función calculateLux() de la librería no tiene en cuenta el tiempo ni la ganancia y su resultado se desvía al cambiar los ajustes. Mantén siempre las constantes ATIME_MS y GAIN del código iguales a los ajustes que elijas.
Temperatura de color y cálculo de lux
El lux (lx) indica cuán brillante es para el ojo humano la luz que cae sobre una superficie. Una habitación tenue ronda 50–100 lx y una oficina bien iluminada 300–500 lx; en exteriores con cielo nublado se miden unos miles de lx y el sol del mediodía llega hasta 100.000 lx. La temperatura de color (CCT) describe el tono de la luz blanca en Kelvin. La llama de una vela ronda 1900 K, una bombilla incandescente 2700 K, un LED blanco cálido 3000 K, el sol del mediodía 5500 K y el cielo nublado 6500–7500 K. Cuanto más baja, más amarillo-anaranjada es la luz; cuanto más alta, más azulada. Para calcular estas dos magnitudes a partir de los valores en bruto, ams, el fabricante del TCS34725, propone en la nota de aplicación DN40 estos pasos:
| Paso | Fórmula |
|---|---|
| 1. Componente infrarroja | IR = (R + G + B − C) / 2 (0 si es negativo) |
| 2. Canales sin IR | R' = R − IR, G' = G − IR, B' = B − IR |
| 3. Cuentas por lux | CPL = (ATIME_ms × Ganancia) / (GA × 310) |
| 4. Lux | Lux = (0,136 × R' + 1,000 × G' − 0,444 × B') / CPL |
| 5. Temperatura de color | CCT = 3810 × (B' / R') + 1391 |
Veamos un ejemplo: imagina que con 50,4 ms y ganancia 4x lees R = 1200, G = 1000, B = 800, C = 2800. IR = (1200 + 1000 + 800 − 2800) / 2 = 100; los valores sin IR son 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 de color es 3810 × 700 / 1100 + 1391 ≈ 3816 K. En la fórmula, GA indica cuánto atenúa la luz la tapa de cristal o plástico delante del sensor; con el sensor al descubierto vale 1. Si colocas el sensor detrás de una tapa, debes subir GA por encima de 1 y calibrarlo comparándolo con un luxómetro conocido.
Comparación entre TCS34725 y TCS3200
| Característica | TCS34725 | TCS3200 |
|---|---|---|
| Salida | I2C, número digital de 16 bits | Onda cuadrada, frecuencia proporcional a la luz |
| Pines usados | 2 (SDA, SCL) | 5–6 (S0–S3, OUT, OE) |
| Fotodiodos | 3×4 = 12 | 8×8 = 64 |
| Filtro IR | Sí, en el chip | No, sensible a infrarrojos |
| Ajustes | Tiempo 2,4–614 ms, ganancia 1x–60x | Escalado de frecuencia 2 %, 20 %, 100 % |
| Alimentación | Módulo 3,3–5 V (chip 2,7–3,6 V) | 2,7–5,5 V |
| LED de la placa | 1 blanco neutro | 4 blancos |
| Método de lectura | Cuatro canales a la vez, desde registros | Seleccionar filtro a filtro y medir la frecuencia con pulseIn |
| Lux y temperatura de color | Se calculan directamente con fórmula | Difícil, requiere calibración detallada |
El TCS3200 sigue siendo muy común en proyectos escolares porque sus cuatro LED iluminan con fuerza el objeto y funciona sin problemas a 5 V. Pero cambiar el filtro con los pines S2 y S3 para cada color y medir la frecuencia gasta pines y tiempo. Al no tener filtro IR, sus medidas también se ven más afectadas por la luz ambiente. El TCS34725, en cambio, se conecta con dos cables, lee los cuatro canales a la vez y, gracias al tiempo y la ganancia ajustables, funciona desde la oscuridad hasta pleno sol. Si empiezas un proyecto nuevo, elige el TCS34725; si ya tienes un TCS3200, el artículo del sensor de color TCS3200 te guiará. Si además del color quieres detectar gestos y proximidad, el APDS-9960 también es una buena alternativa.
Ejemplo de máquina clasificadora de colores
Un clásico de colegios y ferias de ciencias: detener caramelos o cuentas de colores que bajan por una rampa delante del sensor y dirigirlos a distintas cajas según su color. Aquí el sensor mide el color y un servomotor gira el canal hacia el ángulo de la caja correspondiente. El truco más importante es usar las proporciones y no los números en bruto. Si el objeto se aleja un poco, R, G y B bajan a la vez, pero la proporción R/(R+G+B) casi no cambia. Para calibrar, coloca un objeto de cada color delante del sensor, anota los valores nr, ng y nb que aparecen en el Monitor Serie y escríbelos en la tabla ref del código; los valores del código son solo un ejemplo. Si colocas el sensor dentro de un tubo negro y mantienes el objeto siempre a la misma distancia (idealmente 5–10 mm), desaparece el efecto de la luz ambiente y la precisión mejora de forma notable.
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}En cada lectura el código mira primero el valor de C. Con el tubo vacío, la luz del LED no rebota, así que C se queda pequeño y la máquina espera; si entra luz ambiente en el tubo, ajusta BOS_ESIK según tu montaje. Cuando llega un objeto, se dividen R, G y B entre su suma para obtener las proporciones de color. Luego se calcula el cuadrado de la distancia a cada color de referencia y se elige el más cercano. El umbral de distancia de 0,004 marca como desconocidos los objetos que no se parecen a ningún color; si lo reduces, la máquina será más selectiva. Para añadir un color nuevo basta con añadir una fila a los arrays ref, renkAd y aci y actualizar RENK_SAYISI. Alimentar el servo con una fuente de 5 V aparte evita que se estropeen las lecturas I2C mientras el motor se mueve. Para que las lecturas sean más estables también ayuda promediar varias medidas; mira el artículo filtrado de datos de sensores.
TCS34725 con ESP32: reflejar el color en un LED RGB
En el ESP32 la misma librería de Adafruit funciona sin cambios. Los pines I2C por defecto son GPIO 21 (SDA) y GPIO 22 (SCL), y lo más seguro es alimentar el módulo desde el pin 3V3. El ejemplo siguiente imita el color que ve el sensor con un LED RGB de cátodo común y escribe el código de color en formato #RRGGBB en el Monitor Serie. La función getRGB() divide los colores entre el canal C para llevarlos al rango 0–255; el código lleva el canal más fuerte a 255 y aplica corrección gamma para avivar los colores apagados. Como las funciones PWM difieren entre las versiones 2.x y 3.x del núcleo Arduino del ESP32, el código se divide según la versión. Puedes calcular la resistencia adecuada para cada pata del LED con la calculadora de resistencia 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 con TCS34725 (MicroPython)
En MicroPython no es obligatorio instalar una librería; como la estructura de registros del TCS34725 es simple, puedes hablar con él directamente en pocas líneas. A cada dirección de registro se le suma el bit de comando (0x80) y, en lecturas de varios bytes, también el bit de autoincremento (0x20). El código lee primero el registro de identificación (0x12): debe devolver 0x44 para el TCS34725 y 0x4D para el TCS34727. Después pone ATIME en 0xEB (unos 50 ms), la ganancia en 4x, enciende el sensor y en cada medida calcula lux y temperatura de color con la fórmula DN40. Si eres nuevo con la Pico y MicroPython, échale primero un vistazo a qué es la 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)Ideas de proyectos con el TCS34725
- Clasificadora de colores: separa caramelos o cuentas en cajas según su color con un servo y una rampa (el ejemplo de arriba).
- Lámpara que copia colores: lee el color de una tela o un papel y reprodúcelo tal cual en una tira WS2812B NeoPixel.
- Medidor de iluminación: mide los lux y la temperatura de color de una habitación y muéstralos en pantalla; comprueba si tu mesa de trabajo alcanza los 500 lx.
- Robot con reglas de color: añade un TCS34725 a un robot seguidor de línea para que se detenga ante una marca roja y gire en la verde.
- Dispositivo que dice el color en voz alta: una ayuda para personas ciegas que dice en voz alta el color leído con un DFPlayer Mini.
- Indicador de madurez de fruta: sigue con las proporciones de color cómo un tomate pasa de verde a rojo o un plátano a amarillo.
Errores comunes y cómo solucionarlos
| Síntoma | Causa probable | Solución |
|---|---|---|
| Aparece "TCS34725 bulunamadi" | SDA y SCL invertidos, sin alimentación o cable flojo | Comprueba que en el Uno SDA=A4 y SCL=A5; busca la dirección 0x29 con un escáner I2C |
| Todos los canales muy altos y sin cambios | Saturación: demasiada luz para el tiempo y la ganancia elegidos | Baja la ganancia a 1x, acorta el tiempo o aleja un poco el objeto |
| Números muy pequeños, colores que saltan | Luz insuficiente | Enciende el LED, sube la ganancia a 16x o 60x y alarga el tiempo |
| El mismo objeto da otro color a otra distancia | Se comparan valores en bruto | Usa las proporciones R/(R+G+B) y fija la distancia |
| Los resultados cambian al abrir la ventana | La luz ambiente se mezcla con la medida | Rodea el sensor con un tubo negro o una tapa |
| Temperatura de color siempre en torno a 4000 K | El LED de la placa se quedó encendido | Conecta el pin LED a GND o apágalo con un pin digital |
| Lecturas muy lentas | Tiempo de integración largo (p. ej. 614 ms) | getRawData() espera ese tiempo; elige 24–50 ms |
| Se confunden rojo y naranja | Proporciones de referencia demasiado parecidas | Calibra en el montaje final, reduce el umbral y promedia varias lecturas |
El TCS34725 es un sensor versátil que se conecta con dos cables y, gracias a su sensibilidad ajustable y a su filtro IR, mide con fiabilidad tanto el color de los objetos como la luz ambiente. El secreto de unos buenos resultados son tres cosas: elegir tiempo y ganancia que eviten la saturación, trabajar con proporciones en vez de números en bruto y calibrar en el montaje final. Si prefieres empezar a medir luz con un sensor más sencillo, el sensor de luz LDR es un buen primer paso. En la app de BlueGrays encontrarás paso a paso, con esquema y código, proyectos de medición de luz con LDR, transiciones de color con LED RGB, una lámpara mezcladora de colores con ESP32 y servos, y podrás construir encima tu propia máquina con sensor de color.
Preguntas frecuentes
¿Qué diferencia hay entre el TCS34725 y el TCS3200?
El TCS34725 entrega por I2C los cuatro canales a la vez como números de 16 bits y lleva un filtro bloqueador de infrarrojos en el chip. El TCS3200 selecciona el filtro de color uno a uno con los pines S2–S3 y genera una salida en frecuencia; necesita 5–6 pines y, al no tener filtro IR, le afecta más la luz ambiente. Para precisión y conexión sencilla, el TCS34725 es mejor opción.
¿Cuál es la dirección I2C del TCS34725 y se puede cambiar?
La dirección del TCS34725 es fija, 0x29, y no se puede cambiar. Si quieres conectar dos sensores a la misma placa, puedes usar un multiplexor I2C como el TCA9548A. En ESP32 y Pico también es posible conectar cada sensor a un bus I2C distinto.
¿El TCS34725 funciona a 5 V?
El chip funciona con 2,7–3,6 V. Pero como la mayoría de los módulos llevan un regulador de 3,3 V, se puede dar 5 V al pin VIN y conectar el módulo directamente a un Arduino Uno. Dar 5 V al pin 3V3 estropea el chip; si tu placa no tiene regulador, alimenta el módulo con 3,3 V.
¿Por qué el TCS34725 lee mal los colores?
Las causas más frecuentes son la saturación, la luz insuficiente, la mezcla con luz ambiente y comparar con números en bruto. Ilumina el objeto con el LED a distancia fija, asegúrate de que C se mantiene por debajo del límite de saturación y trabaja con proporciones como R/(R+G+B). Calibra también siempre los colores de referencia en tu montaje final.
¿Cómo se apaga el LED del TCS34725?
Si conectas el pin LED del módulo a GND, el LED blanco se apaga. Si lo conectas a una salida digital, puedes apagarlo escribiendo LOW y encenderlo con HIGH. Al medir la luz ambiente o la temperatura de color, el LED debe estar apagado.
¿Qué precisión tiene el TCS34725 midiendo lux?
El TCS34725 no es tan preciso como un luxómetro profesional, pero con la fórmula DN40 y un buen ajuste de tiempo y ganancia da valores aproximados bastante útiles en interiores. Si el sensor está detrás de una tapa de cristal o plástico, debes calibrarlo con el coeficiente GA. Si solo vas a medir brillo, el BH1750, que da lux directamente, es una opción más sencilla.
Proyectos para hacer después de leer esto
Ver todos los proyectos
Medir la intensidad de luz con LDR
¿Quieres ver en números cuánta luz hay en tu habitación? El LDR, una pequeña pieza sensible a la luz, mide la luz ambiente y el Arduino escribe el valor en la pantalla del ordenador cada medio…

Lectura de la intensidad luminosa con el módulo LDR del ESP32
Visualización en tiempo real en el monitor serie del valor bruto del ADC del módulo LDR y del porcentaje relativo de luz calculado a partir de referencias de oscuridad y claridad. Este porcentaje no es una medición en lux. Explica el funcionamiento de la calibración del módulo. Es recomendable realizarlo antes del Proyecto 10, ya que se utiliza para determinar el valor umbral.

Uso de Led RGB
Dentro de un solo LED se esconden tres colores: el LED RGB se enciende en rojo, luego en verde y luego en azul, cada color medio segundo encendido y medio segundo apagado, y la secuencia vuelve a…

Transición de color suave con Led RGB
Un solo LED RGB pasa lentamente del rojo al verde, del verde al azul y vuelve al rojo, en un bucle de arcoíris que nunca se detiene.

Control de LED RGB con ESP32
Generación ilimitada de colores con un solo LED RGB en lugar de 3 LEDs separados. Hacemos transición arco iris estableciendo valores R/G/B con analogWrite() como en Arduino. La teoría del color (como rojo+verde=amarillo) se ve de forma práctica.

Lámpara con mezclador de colores ESP32 (3 potenciómetros + LED RGB + OLED)
Una lámpara mezcladora de colores inteligente: gira 3 potenciómetros en el ESP32 y mezcla el color que quieras. Al girar los potenciómetros rojo, verde y azul, el LED RGB de cátodo común cambia de color al instante. La pantalla OLED SSD1306 muestra en vivo el valor de 0-255 de cada color, barras de relleno y el código de color web HEX (como #FF8040).

TCRT5000 Detección de superficie blanca y negra
Con el pequeño sensor que hace de ojo en los robots sigue líneas, sabrás si el suelo es negro o blanco.

Raspberry Pi Pico LED RGB Ciclo de Colores (PWM de 3 Canales)
¡Un LED, millones de colores! Un LED RGB contiene 3 LEDs: rojo, verde y azul. Con un canal PWM del Pico para cada uno, los colores se mezclan: rojo + verde = amarillo, verde + azul = cian, los tres = blanco. El LED recorre 8 colores. Aprende múltiples canales PWM, funciones (def), mezcla RGB, conversión de 8 a 16 bits (x257) y cátodo común vs ánodo común.
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

