Parçalar · 9 dk okuma

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 RGB renk sensörü modülü
TCS34725 renk sensörü modülü: küçük sensör yongası renkleri ölçer, yanındaki beyaz LED ise nesneyi aydınlatır.

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.

ÖzellikDeğer
Ölçülen kanallarKırmızı (R), yeşil (G), mavi (B), filtresiz (C)
Fotodiyot dizisi3×4, toplam 12 fotodiyot
ÇözünürlükHer kanal için 16 bit (0–65535)
ArayüzI2C, 400 kHz'e kadar
I2C adresi0x29 (sabit)
BeslemeYonga 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 filtresiYonga üzerinde, kızılötesi engelleyici
Dinamik aralık3.800.000:1
Entegrasyon süresi2,4 ms – 614 ms (2,4 ms adımlarla)
Kazanç1x, 4x, 16x, 60x
Kart üzeri LEDNö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.

ATIMEDöngüSüreEn büyük sayımNe zaman?
0xFF12,4 ms1024Çok parlak ışık, çok hızlı okuma
0xF61024 ms10240Güneş altı, hızlı hareket eden nesne
0xEB2150 ms21504LED'li renk okuma için iyi başlangıç
0xD642101 ms43008İç mekânda ortam ışığı ölçümü
0xC064154 ms65535Loş ortam, tam 16 bit çözünürlük
0x00256614 ms65535Ç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 piniArduino UnoESP32Raspberry Pi Pico
VIN5V3V33V3(OUT) (pin 36)
GNDGNDGNDGND
SDAA4GPIO 21GP4 (pin 6)
SCLA5GPIO 22GP5 (pin 7)
LEDBoş: LED yanar / GND: LED sönerBoş ya da GNDBoş ya da GND
INTBoş (isteğe bağlı kesme çıkışı)BoşBoş
3V3Bağlama (regülatör çıkışı)BağlamaBağlama
Modüllerin çoğunda 3,3 V regülatör bulunur ve VIN pinine 5 V verilebilir. Ancak 3V3 pinine asla 5 V bağlama; yonga en fazla 3,6 V'a dayanır. Kartın üzerinde küçük bir regülatör yongası göremiyorsan modülü 3,3 V ile besle. LED pini bir dijital pine de bağlanabilir: LOW yazınca LED söner, HIGH yazınca yanar. INT pini, ayarlanan eşik aşıldığında LOW olan açık-akaçlı (open-drain) bir kesme çıkışıdır. I2C hattının çalışma mantığını I2C nedir yazısında, 5 V ile 3,3 V arasındaki uyumu ise lojik seviye dönüştürücü yazısında bulabilirsin.

Adım adım: Arduino Uno ile ilk renk okuması

  1. 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.
  2. 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.
  3. Aşağıdaki kodu yükle ve Seri Monitörü 9600 baud hızında aç.
  4. 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.
  5. 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.
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}

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ımFormül
1. Kızılötesi bileşenIR = (R + G + B − C) / 2 (negatifse 0)
2. IR'siz kanallarR' = R − IR, G' = G − IR, B' = B − IR
3. Lüks başına sayımCPL = (ATIME_ms × Kazanç) / (GA × 310)
4. LüksLux = (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.

Ortam ışığını ölçerken kart üzerindeki LED'i mutlaka kapat; aksi halde sensör kendi LED'ini ölçer ve renk sıcaklığı hep 4000 K civarında takılı kalır. Lüks ve CCT ölçerken sensörü bir nesneye değil ışık kaynağına ya da odaya doğru çevir, parlak ışıkta 1x kazanç ve kısa süre seç. Yalnızca parlaklık ölçmen gerekiyorsa doğrudan lüks veren BH1750 ışık sensörü daha basit bir seçenektir.

TCS34725 ile TCS3200 karşılaştırması

ÖzellikTCS34725TCS3200
ÇıkışI2C, 16 bitlik dijital sayıKare dalga, frekansı ışıkla orantılı
Kullanılan pin2 (SDA, SCL)5–6 (S0–S3, OUT, OE)
Fotodiyot3×4 = 128×8 = 64
IR filtresiYonga üzerinde varYok, kızılötesine duyarlı
AyarlarSüre 2,4–614 ms, kazanç 1x–60xFrekans ölçekleme %2, %20, %100
BeslemeModül 3,3–5 V (yonga 2,7–3,6 V)2,7–5,5 V
Kart üzeri LED1 adet nötr beyaz4 adet beyaz
Okuma yöntemiDört kanal aynı anda, yazmaçtanFiltre filtre seçip pulseIn ile frekans ölçme
Lüks ve renk sıcaklığıFormülle doğrudan hesaplanırZor, 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.

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}

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.

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

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)

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

BelirtiOlası sebepÇözüm
"TCS34725 bulunamadi" yazıyorSDA ve SCL ters, besleme yok ya da kablo gevşekUno'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şmiyorDoyma: ışık, seçilen süre ve kazanç için fazlaKazancı 1x'e indir, süreyi kısalt ya da nesneyi biraz uzaklaştır
Sayılar çok küçük, renkler zıplıyorIşık yetersizLED'i aç, kazancı 16x ya da 60x yap, süreyi uzat
Aynı nesne farklı mesafede farklı renkHam 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şiyorOrtam ışığı ölçüme karışıyorSensörü siyah bir tüp ya da kapakla çevrele
Renk sıcaklığı hep 4000 K civarındaKart ü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ışıyorReferans oranlar birbirine çok yakınKalibrasyonu 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.

Tüm projeleri gör
Ldr İle Işık Şiddeti Okuma
AR-11Başlangıç

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.

4.6(83)
143
ESP32 LDR Modülü ile Işık Şiddeti Okuma
ES-11Başlangıç

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.

4.6(36)
55
RGB Led Kullanımı
AR-39Başlangıç
Premium

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.

4.9(73)
100
RGB Led İle Yumuşak Renk Geçişi
AR-40Başlangıç
Premium

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.

4.8(58)
78
ESP32 RGB LED Kontrolü
ES-9Başlangıç

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.

4.6(29)
52
ESP32 Renk Mikser Lambası (3 Pot + RGB LED + OLED)
ES-36İleri
Premium

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.

4.7(6)
10
TCRT5000 Siyah Beyaz Zemin Tespiti
AR-78Orta
Premium

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.

4.7(40)
49
Raspberry Pi Pico RGB LED Renk Çevrimi (3 Kanal PWM)
PI-15Başlangıç

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.

6