TCS34725 Arduino: I2C RGB Renk Sensörü, Lüks ve Renk Sıcaklığı
TCS34725 Arduino bağlantısı, entegrasyon süresi ve kazanç ayarı, renk sıcaklığı ve lüks hesabı, TCS3200 farkı, renk ayıklayan makine, ESP32 ve Pico kodları.
TCS34725, Arduino ile renk algılamanın en doğru ve en kolay yollarından biri olan, I2C ile haberleşen dijital bir RGB renk sensörüdür. Önüne tuttuğun nesnenin ya da ortam ışığının kırmızı, yeşil, mavi ve toplam (clear) ışık miktarını 16 bitlik sayılar olarak verir. Yonganın üzerinde kızılötesi engelleyici bir filtre de bulunduğu için ölçümler, gün ışığından ve ampullerden gelen görünmez ışıktan çok daha az etkilenir. TCS34725 Arduino bağlantısı yalnızca iki veri kablosuyla (SDA ve SCL) yapılır ve Adafruit kütüphanesiyle birkaç satırda ilk değerleri okursun.
Bu yazıda sensörün içinde neler olduğunu, entegrasyon süresi ve kazanç ayarlarının ölçümü nasıl değiştirdiğini, ham sayılardan renk sıcaklığı (Kelvin) ve lüks hesaplamayı adım adım öğreneceksin. Ardından eski ama yaygın TCS3200 ile karşılaştırma yapacak, kalibrasyonlu bir renk ayıklama makinesi kuracak ve aynı sensörü ESP32 ile Raspberry Pi Pico'da (MicroPython) da kullanacaksın.

TCS34725 nedir, nasıl çalışır?
Yonganın üzerinde 3×4 düzeninde 12 küçük fotodiyot bulunur. Bunların üçünün üzerinde kırmızı, üçünün üzerinde yeşil, üçünün üzerinde mavi filtre vardır; kalan üçü filtresizdir ve toplam ışığı (clear, C) görür. Her grubun ürettiği akım, ayrı bir 16 bitlik analog-dijital dönüştürücüde belirli bir süre boyunca toplanır. Bu süreye entegrasyon süresi denir. Süre dolunca dört sonuç (R, G, B, C) yazmaçlara yazılır ve sen bunları I2C üzerinden okursun. Fotodiyotların üzerindeki kızılötesi engelleyici filtre, gözümüzün görmediği 700 nm üstündeki ışığı büyük ölçüde keser. Bu sayede TCS34725 renkleri insan gözünün algıladığına daha yakın ölçer. Modüllerin çoğunda yonganın yanında nötr beyaz bir LED de bulunur. Bir nesnenin rengini okurken aslında bu LED'in ışığının nesneye çarpıp geri yansıyan kısmını ölçersin.
| Özellik | Değer |
|---|---|
| Ölçülen kanallar | Kırmızı (R), yeşil (G), mavi (B), filtresiz (C) |
| Fotodiyot dizisi | 3×4, toplam 12 fotodiyot |
| Çözünürlük | Her kanal için 16 bit (0–65535) |
| Arayüz | I2C, 400 kHz'e kadar |
| I2C adresi | 0x29 (sabit) |
| Besleme | Yonga 2,7–3,6 V; regülatörlü modül 3,3–5 V |
| Akım | Ölçüm sırasında yaklaşık 235 µA, uykuda 2,5 µA (LED hariç) |
| IR filtresi | Yonga üzerinde, kızılötesi engelleyici |
| Dinamik aralık | 3.800.000:1 |
| Entegrasyon süresi | 2,4 ms – 614 ms (2,4 ms adımlarla) |
| Kazanç | 1x, 4x, 16x, 60x |
| Kart üzeri LED | Nötr beyaz, yaklaşık 4150 K |
Entegrasyon süresi ve kazanç ayarı
Entegrasyon süresi, fotoğraf makinesindeki pozlama süresine benzer. Süre uzadıkça sensör daha çok ışık toplar, sayılar büyür ve karanlık ortamdaki gürültü azalır. Buna karşılık her okuma daha uzun sürer ve parlak ışıkta kanallar daha kolay doyar. Süre, ATIME yazmacıyla 2,4 ms'lik adımlarla ayarlanır. Bir kanalın ulaşabileceği en büyük sayı (256 − ATIME) × 1024 formülüyle bulunur ve sonuç 65535'i aşamaz. Aşağıdaki tablo en sık kullanılan değerleri ve ne zaman tercih edileceklerini gösterir.
| ATIME | Döngü | Süre | En büyük sayım | Ne zaman? |
|---|---|---|---|---|
| 0xFF | 1 | 2,4 ms | 1024 | Çok parlak ışık, çok hızlı okuma |
| 0xF6 | 10 | 24 ms | 10240 | Güneş altı, hızlı hareket eden nesne |
| 0xEB | 21 | 50 ms | 21504 | LED'li renk okuma için iyi başlangıç |
| 0xD6 | 42 | 101 ms | 43008 | İç mekânda ortam ışığı ölçümü |
| 0xC0 | 64 | 154 ms | 65535 | Loş ortam, tam 16 bit çözünürlük |
| 0x00 | 256 | 614 ms | 65535 | Çok karanlık ortam, yavaş okuma |
Kazanç (gain) ise toplanan sinyali analog olarak yükseltir. 1x, 4x, 16x ve 60x seçenekleri vardır. Kazancı artırmak, süreyi uzatmadan hassasiyeti yükseltir ama gürültüyü de büyütür. Pratik kural şöyle: nesneyi her zaman aynı mesafeden LED ile aydınlat, 50 ms ve 4x ile başla. C değeri en büyük sayımın çok altında kalıyorsa (örneğin 1000'in altındaysa) kazancı 16x'e çıkar. C doymaya yaklaşıyorsa kazancı düşür ya da süreyi kısalt. Bir kanal tavana ulaştığında o okuma artık doğru değildir, çünkü ışık arttıkça sayı daha fazla büyüyemez ve renk oranları bozulur. Datasheet ayrıca 150 ms'den kısa sürelerde, dalgalanma nedeniyle doymanın en büyük sayımın yaklaşık %75'inde başlayabileceğini belirtir. Bu yüzden 50 ms'de güvenli üst sınırı 16000 civarı kabul et.
TCS34725 bağlantısı (Arduino Uno, ESP32, Pico)
| TCS34725 pini | 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 | Boş: LED yanar / GND: LED söner | Boş ya da GND | Boş ya da GND |
| INT | Boş (isteğe bağlı kesme çıkışı) | Boş | Boş |
| 3V3 | Bağlama (regülatör çıkışı) | Bağlama | Bağlama |
Adım adım: Arduino Uno ile ilk renk okuması
- Modülü tablodaki gibi bağla: VIN 5V'a, GND GND'ye, SDA A4'e, SCL A5'e. LED ve INT pinlerini şimdilik boş bırak.
- Arduino IDE'de Kütüphane Yöneticisi'ni aç, Adafruit TCS34725 kütüphanesini ara ve kur; bağımlılık sorulursa Adafruit BusIO'yu da kur. Kurulumda takılırsan Arduino kütüphane ekleme yazısına göz at.
- Aşağıdaki kodu yükle ve Seri Monitörü 9600 baud hızında aç.
- Sensörün önüne 1–2 cm mesafeden kırmızı, yeşil ve mavi kâğıtlar tut; her renkte hangi kanalın büyüdüğünü izle.
- Kâğıdı yaklaştırıp uzaklaştırarak sayıların nasıl değiştiğine bak ve C değerinin doyma sınırına ulaşmadığından emin ol.
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}Nesne oluşturulurken entegrasyon süresi ve kazanç birlikte verilir; istersen sonradan tcs.setIntegrationTime() ve tcs.setGain() ile değiştirebilirsin. getRawData() bir entegrasyon süresi kadar bekleyip dört kanalı okur. Bu yüzden 614 ms seçersen saniyede iki okuma bile yapamazsın. Renk sıcaklığı için kütüphanenin calculateColorTemperature_dn40() fonksiyonunu kullandık; bu fonksiyon doyma durumunda geçersiz bir değer (65535) döndürür. Lüks hesabını ise kendimiz yaptık, çünkü kütüphanedeki calculateLux() fonksiyonu süreyi ve kazancı hesaba katmaz. Ayarları değiştirdiğinde onun sonucu da kayar. Koddaki ATIME_MS ve GAIN sabitlerini, seçtiğin ayarlarla mutlaka aynı tut.
Renk sıcaklığı ve lüks hesabı
Lüks (lx), bir yüzeye düşen ışığın insan gözüne göre ne kadar parlak olduğunu gösterir. Loş bir oda 50–100 lx, iyi aydınlatılmış bir ofis 300–500 lx civarındadır; kapalı havada dışarıda birkaç bin lx ölçülür, öğle güneşi ise 100.000 lx'e kadar çıkar. Renk sıcaklığı (CCT) ise beyaz ışığın tonunu Kelvin cinsinden anlatır. Mum alevi yaklaşık 1900 K, akkor ampul 2700 K, sıcak beyaz LED 3000 K, öğle güneşi 5500 K, bulutlu gökyüzü ise 6500–7500 K civarındadır. Değer küçüldükçe ışık sarı-turuncuya, büyüdükçe maviye kayar. TCS34725'in üreticisi ams, ham sayılardan bu iki büyüklüğü hesaplamak için DN40 uygulama notunda şu adımları önerir:
| Adım | Formül |
|---|---|
| 1. Kızılötesi bileşen | IR = (R + G + B − C) / 2 (negatifse 0) |
| 2. IR'siz kanallar | R' = R − IR, G' = G − IR, B' = B − IR |
| 3. Lüks başına sayım | CPL = (ATIME_ms × Kazanç) / (GA × 310) |
| 4. Lüks | Lux = (0,136 × R' + 1,000 × G' − 0,444 × B') / CPL |
| 5. Renk sıcaklığı | CCT = 3810 × (B' / R') + 1391 |
Bir örnekle bakalım: 50,4 ms ve 4x kazançla R = 1200, G = 1000, B = 800, C = 2800 okuduğunu düşün. IR = (1200 + 1000 + 800 − 2800) / 2 = 100 olur; IR'siz değerler R' = 1100, G' = 900, B' = 700'dür. CPL = 50,4 × 4 / 310 ≈ 0,650 bulunur. Lüks = (0,136 × 1100 + 900 − 0,444 × 700) / 0,650 = 738,8 / 0,650 ≈ 1136 lx çıkar. Renk sıcaklığı ise 3810 × 700 / 1100 + 1391 ≈ 3816 K olur. Formüldeki GA, sensörün önündeki cam ya da plastik kapağın ışığı ne kadar zayıflattığını gösterir; açık sensörde 1 alınır. Sensörü bir kapağın arkasına koyarsan GA'yı 1'in üzerine çıkarıp bilinen bir lüksmetreyle karşılaştırarak kalibre etmelisin.
TCS34725 ile TCS3200 karşılaştırması
| Özellik | TCS34725 | TCS3200 |
|---|---|---|
| Çıkış | I2C, 16 bitlik dijital sayı | Kare dalga, frekansı ışıkla orantılı |
| Kullanılan pin | 2 (SDA, SCL) | 5–6 (S0–S3, OUT, OE) |
| Fotodiyot | 3×4 = 12 | 8×8 = 64 |
| IR filtresi | Yonga üzerinde var | Yok, kızılötesine duyarlı |
| Ayarlar | Süre 2,4–614 ms, kazanç 1x–60x | Frekans ölçekleme %2, %20, %100 |
| Besleme | Modül 3,3–5 V (yonga 2,7–3,6 V) | 2,7–5,5 V |
| Kart üzeri LED | 1 adet nötr beyaz | 4 adet beyaz |
| Okuma yöntemi | Dört kanal aynı anda, yazmaçtan | Filtre filtre seçip pulseIn ile frekans ölçme |
| Lüks ve renk sıcaklığı | Formülle doğrudan hesaplanır | Zor, ayrıntılı kalibrasyon gerekir |
TCS3200, dört LED'i nesneyi güçlü aydınlattığı ve 5 V ile rahat çalıştığı için okul projelerinde hâlâ çok yaygındır. Ancak her renk için filtreyi S2 ve S3 pinleriyle değiştirip frekans ölçmek hem pin hem zaman harcar. IR filtresi olmadığından ölçümleri ortam ışığından da daha çok etkilenir. TCS34725 ise iki kabloyla bağlanır, dört kanalı aynı anda okur ve ayarlanabilir süre-kazanç sayesinde karanlıktan güneş altına kadar çalışır. Yeni bir projeye başlıyorsan TCS34725'i seç; elinde TCS3200 varsa TCS3200 renk sensörü yazısı sana yol gösterir. Renge ek olarak jest ve yakınlık da algılamak istersen APDS-9960 da iyi bir alternatiftir.
Renk ayıklayan makine örneği
Klasik bir okul ve bilim fuarı projesi: rampadan kayan renkli şekerleri ya da boncukları sensörün önünde durdurup renklerine göre farklı kutulara yönlendirmek. Burada sensör rengi ölçer, bir servo motor da oluğu ilgili kutunun açısına çevirir. En önemli püf noktası ham sayıları değil oranları kullanmaktır. Nesne biraz uzaklaşınca R, G ve B birlikte azalır ama R/(R+G+B) oranı neredeyse aynı kalır. Kalibrasyon için her renkten bir nesneyi sensörün önüne koy, Seri Monitörde yazan nr, ng ve nb değerlerini not al ve koddaki ref tablosuna yaz; koddaki değerler yalnızca örnektir. Sensörü siyah bir tüpün içine yerleştirip nesneyi hep aynı mesafede (ideali 5–10 mm) tutarsan ortam ışığının etkisi ortadan kalkar ve doğruluk ciddi biçimde artar.
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}Kod her okumada önce C değerine bakar. Tüp boşken LED'in ışığı geri yansımadığı için C küçük kalır ve makine bekler; ortam ışığı tüpe giriyorsa BOS_ESIK değerini kendi düzeneğine göre ayarla. Nesne gelince R, G ve B değerleri toplamlarına bölünerek renk oranları bulunur. Ardından her referans renge olan uzaklığın karesi hesaplanır ve en yakın renk seçilir. 0,004'lük uzaklık eşiği, hiçbir renge benzemeyen nesneleri bilinmeyen olarak ayırır; eşiği küçültürsen makine daha seçici olur. Yeni renk eklemek için ref, renkAd ve aci dizilerine satır ekleyip RENK_SAYISI değerini güncellemen yeterli. Servoyu ayrı bir 5 V kaynaktan beslemek, motor hareket ederken I2C okumalarının bozulmasını önler. Okumaları daha kararlı hale getirmek için birkaç ölçümün ortalamasını almak da işe yarar; bu konuda sensör verisi filtreleme yazısına bakabilirsin.
ESP32 ile TCS34725: rengi RGB LED'de yansıtmak
ESP32'de aynı Adafruit kütüphanesi değişiklik yapmadan çalışır. I2C pinleri varsayılan olarak GPIO 21 (SDA) ve GPIO 22 (SCL)'dir ve modülü 3V3 pininden beslemek en güvenlisidir. Aşağıdaki örnek, sensörün gördüğü rengi ortak katotlu bir RGB LED ile taklit eder ve renk kodunu #RRGGBB biçiminde Seri Monitöre yazar. getRGB() fonksiyonu renkleri C kanalına bölerek 0–255 aralığına getirir; kod, en güçlü kanalı 255'e çekip gama düzeltmesi uygulayarak soluk renkleri canlandırır. PWM fonksiyonları ESP32 Arduino çekirdeğinin 2.x ve 3.x sürümlerinde farklı olduğu için kod iki sürüme göre ayrılmıştır. Her LED bacağına uygun direnci LED direnç hesaplayıcı ile bulabilirsin.
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 ile TCS34725 (MicroPython)
MicroPython'da hazır bir kütüphane kurman şart değil; TCS34725'in yazmaç yapısı basit olduğu için birkaç satırla doğrudan konuşabilirsin. Her yazmaç adresine komut biti (0x80) eklenir, çok baytlı okumalarda otomatik artırma biti (0x20) de kullanılır. Kod önce kimlik yazmacını (0x12) okur: TCS34725 için 0x44, TCS34727 için 0x4D dönmelidir. Ardından ATIME'ı 0xEB (yaklaşık 50 ms), kazancı 4x yapar, sensörü açar ve her ölçümde DN40 formülüyle lüks ile renk sıcaklığını hesaplar. Pico'ya ve MicroPython'a yeniysen önce Raspberry Pi Pico nedir yazısına göz atabilirsin.
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)TCS34725 ile proje fikirleri
- Renk ayıklama makinesi: Şekerleri ya da boncukları servo ve rampa yardımıyla renklerine göre kutulara ayır (yukarıdaki örnek).
- Renk kopyalayan lamba: Bir kumaşın ya da kâğıdın rengini okuyup WS2812B NeoPixel şeride aynen yansıt.
- Aydınlatma ölçer: Odanın lüksünü ve renk sıcaklığını ölçüp ekranda göster; çalışma masasında 500 lx hedefine ulaşıp ulaşmadığını kontrol et.
- Renk kurallı robot: Bir çizgi izleyen robota TCS34725 ekleyerek kırmızı işarette durma, yeşilde dönme gibi kurallar koy.
- Rengi sesli söyleyen cihaz: Okunan rengi DFPlayer Mini ile sesli olarak söyleyen, görme engelliler için yardımcı bir alet yap.
- Meyve olgunluk göstergesi: Domatesin ya da muzun yeşilden kırmızıya veya sarıya dönüşünü renk oranlarıyla izle.
Sık yapılan hatalar ve çözümleri
| Belirti | Olası sebep | Çözüm |
|---|---|---|
| "TCS34725 bulunamadi" yazıyor | SDA ve SCL ters, besleme yok ya da kablo gevşek | Uno'da SDA=A4, SCL=A5 olduğunu kontrol et; I2C tarayıcıyla 0x29 adresini ara |
| Bütün kanallar çok büyük ve değişmiyor | Doyma: ışık, seçilen süre ve kazanç için fazla | Kazancı 1x'e indir, süreyi kısalt ya da nesneyi biraz uzaklaştır |
| Sayılar çok küçük, renkler zıplıyor | Işık yetersiz | LED'i aç, kazancı 16x ya da 60x yap, süreyi uzat |
| Aynı nesne farklı mesafede farklı renk | Ham değerlerle karşılaştırma yapılmış | R/(R+G+B) oranlarını kullan ve mesafeyi sabitle |
| Pencere açılınca sonuçlar değişiyor | Ortam ışığı ölçüme karışıyor | Sensörü siyah bir tüp ya da kapakla çevrele |
| Renk sıcaklığı hep 4000 K civarında | Kart üzerindeki LED açık kalmış | LED pinini GND'ye bağla ya da dijital pinle söndür |
| Okumalar çok yavaş | Uzun entegrasyon süresi (ör. 614 ms) | getRawData() süre kadar bekler; 24–50 ms seç |
| Kırmızı ile turuncu karışıyor | Referans oranlar birbirine çok yakın | Kalibrasyonu son düzenekte yap, eşiği küçült, birkaç okumanın ortalamasını al |
TCS34725, iki kabloyla bağlanan, ayarlanabilir hassasiyeti ve IR filtresi sayesinde hem nesne rengini hem de ortam ışığını güvenilir biçimde ölçen çok yönlü bir sensördür. Doğru sonuçların sırrı üç şeydir: doymayı önleyen süre-kazanç seçimi, ham sayılar yerine oranlarla çalışmak ve kalibrasyonu son düzenekte yapmak. Işık ölçmeye daha basit bir sensörle başlamak istersen LDR ışık sensörü iyi bir ilk adımdır. BlueGrays uygulamasında LDR ile ışık ölçme, RGB LED renk geçişi, ESP32 renk mikser lambası ve servo projelerini adım adım devre şeması ve koduyla bulabilir, renk sensörlü kendi makineni bunların üzerine kurabilirsin.
Sıkça sorulan sorular
TCS34725 ile TCS3200 arasındaki fark nedir?
TCS34725, I2C üzerinden dört kanalı aynı anda 16 bitlik sayılar olarak verir ve yonganın üzerinde kızılötesi engelleyici filtre bulunur. TCS3200 ise renk filtresini S2–S3 pinleriyle tek tek seçip frekans çıkışı üretir; 5–6 pin ister ve IR filtresi olmadığı için ortam ışığından daha çok etkilenir. Doğruluk ve kolay bağlantı için TCS34725 daha iyi bir tercihtir.
TCS34725'in I2C adresi nedir, değiştirilebilir mi?
TCS34725'in adresi sabit olarak 0x29'dur ve değiştirilemez. Aynı karta iki sensör bağlamak istersen TCA9548A gibi bir I2C çoklayıcı kullanabilirsin. ESP32 ve Pico'da ise her sensörü ayrı bir I2C hattına bağlamak da mümkündür.
TCS34725 5 V ile çalışır mı?
Yonganın kendisi 2,7–3,6 V ile çalışır. Ancak modüllerin çoğunda 3,3 V regülatör olduğu için VIN pinine 5 V verilebilir ve modül Arduino Uno'ya doğrudan bağlanabilir. 3V3 pinine 5 V vermek yongayı bozar; kartında regülatör yoksa modülü 3,3 V ile besle.
TCS34725 renkleri neden yanlış okuyor?
En sık sebepler doyma, yetersiz ışık, ortam ışığının karışması ve ham sayılarla karşılaştırma yapmaktır. Nesneyi LED ile sabit mesafeden aydınlat, C değerinin doyma sınırının altında kaldığından emin ol ve R/(R+G+B) gibi oranlarla çalış. Referans renkleri de mutlaka son düzeneğinde kalibre et.
TCS34725 üzerindeki LED nasıl kapatılır?
Modüldeki LED pinini GND'ye bağladığında beyaz LED söner. Pini bir dijital çıkışa bağlarsan LOW yazarak söndürüp HIGH yazarak yakabilirsin. Ortam ışığını ya da renk sıcaklığını ölçerken LED'in kapalı olması gerekir.
TCS34725 ile lüks ölçümü ne kadar doğru?
TCS34725 profesyonel bir lüksmetre kadar hassas değildir, ancak DN40 formülü ve doğru süre-kazanç ayarıyla iç mekânda gayet kullanışlı yaklaşık değerler verir. Sensör bir cam ya da plastik kapağın arkasındaysa GA katsayısıyla kalibre etmen gerekir. Yalnızca parlaklık ölçeceksen doğrudan lüks veren BH1750 daha basit bir seçenektir.
Bu yazıdan sonra yapabileceğin projeler
Tüm projeleri gör
Ldr İle Işık Şiddeti Okuma
Odanın ne kadar aydınlık olduğunu sayıyla görmek ister misin? Işığa duyarlı küçük bir parça olan LDR ortam ışığını ölçer ve Arduino bu değeri yarım saniyede bir bilgisayar ekranına yazar.

ESP32 LDR Modülü ile Işık Şiddeti Okuma
LDR modülünün ham ADC değerini ve karanlık/aydınlık referanslarına göre hesaplanan göreli ışık yüzdesini Serial Monitor'da gerçek zamanlı izleme. Bu yüzde lux ölçümü değildir. Modülün kalibrasyon mantığını öğretir. Proje 10'un öncesinde yapılması ideal; çünkü eşik değerini belirlemek için kullanılır.

RGB Led Kullanımı
Tek bir LED'in içinde üç renk saklı: RGB LED önce kırmızı, sonra yeşil, sonra mavi yanar; her renk yarım saniye yanıp yarım saniye söner ve sıra baştan başlar.

RGB Led İle Yumuşak Renk Geçişi
Tek bir RGB LED kırmızıdan yeşile, yeşilden maviye, maviden yeniden kırmızıya yavaşça geçer ve bu gökkuşağı döngüsü hiç durmaz.

ESP32 RGB LED Kontrolü
3 ayrı LED yerine tek RGB LED ile sınırsız renk üretme. Arduino'daki gibi analogWrite() ile R/G/B değerlerini ayarlayarak gökkuşağı geçişi yaparız. Renk teorisi (red+green=yellow gibi) pratik olarak görülür.

ESP32 Renk Mikser Lambası (3 Pot + RGB LED + OLED)
ESP32 ile 3 potansiyometreyi çevirerek istediğin rengi karıştıran akıllı bir renk mikser lambası! Kırmızı, yeşil ve mavi potansiyometreleri çevirdikçe ortak katotlu RGB LED anında renk değiştirir. SSD1306 OLED ekranda her renk için 0-255 arası değer, dolgu çubukları ve HEX web renk kodu (#FF8040 gibi) canlı olarak gösterilir.

TCRT5000 Siyah Beyaz Zemin Tespiti
Çizgi izleyen robotların gözü olan küçük bir sensörle zeminin siyah mı beyaz mı olduğunu anlarsın.

Raspberry Pi Pico RGB LED Renk Çevrimi (3 Kanal PWM)
Tek LED, milyonlarca renk! RGB LED'in içinde aslında 3 ayrı LED var: kırmızı, yeşil ve mavi. Pico'nun 3 ayrı PWM kanalıyla her birinin parlaklığını ayrı ayrı ayarlayınca renkler karışır: kırmızı + yeşil = sarı, yeşil + mavi = camgöbeği, üçü birden = beyaz. Bu projede LED 8 renk arasında sırayla dönüyor.
Diğer yazılar
BlueGrays uygulaması
Bu devreyi telefonunda adım adım kur
Devre şeması, kod ve parça listesi tek ekranda. 500'den fazla Arduino, ESP32 ve Pico projesi seni bekliyor.
Telefonunla tara
Kamerayı koda tut; telefonunun uygulama mağazası açılır.
ya da mağazada aç

