Komponen · 10 mnt baca

TCS34725 Arduino: Sensor Warna RGB I2C, Lux, dan Suhu Warna

Pengkabelan TCS34725 ke Arduino, waktu integrasi dan penguatan, suhu warna dan lux, perbandingan dengan TCS3200, mesin pemilah warna, plus kode ESP32 dan Pico.

TCS34725 adalah sensor warna RGB digital yang berkomunikasi lewat I2C dan termasuk cara paling akurat sekaligus paling mudah untuk mendeteksi warna dengan Arduino. Sensor ini memberimu jumlah cahaya merah, hijau, biru, dan total (clear) dari benda yang kamu pegang di depannya, atau dari cahaya sekitar, dalam bentuk angka 16-bit. Karena chip-nya juga punya filter penghalang inframerah, pembacaannya jauh lebih sedikit terpengaruh oleh cahaya tak terlihat dari sinar matahari dan bohlam. Pengkabelan TCS34725 ke Arduino cukup dengan dua kabel data (SDA dan SCL), dan dengan library Adafruit kamu sudah bisa membaca nilai pertamamu dalam beberapa baris kode.

Di artikel ini kamu akan belajar langkah demi langkah apa saja isi sensor ini, bagaimana pengaturan waktu integrasi dan penguatan mengubah hasil pengukuran, serta cara menghitung suhu warna (Kelvin) dan lux dari angka mentah. Setelah itu kamu akan membandingkannya dengan TCS3200 yang lebih lama tapi masih banyak dipakai, membuat mesin pemilah warna yang terkalibrasi, dan memakai sensor yang sama di ESP32 dan Raspberry Pi Pico (MicroPython).

Modul sensor warna RGB TCS34725
Modul sensor warna TCS34725: chip sensor kecil mengukur warna, sedangkan LED putih di sebelahnya menerangi benda.

Apa itu TCS34725 dan bagaimana cara kerjanya?

Chip ini memiliki 12 fotodioda kecil dengan susunan 3×4. Tiga di antaranya ditutup filter merah, tiga filter hijau, dan tiga filter biru; tiga sisanya tanpa filter dan melihat cahaya total (clear, C). Arus yang dihasilkan tiap kelompok dikumpulkan selama waktu tertentu di konverter analog-ke-digital 16-bit yang terpisah. Waktu ini disebut waktu integrasi. Begitu waktunya habis, keempat hasil (R, G, B, C) ditulis ke register dan kamu membacanya lewat I2C. Filter penghalang inframerah di atas fotodioda sebagian besar memotong cahaya di atas 700 nm yang tidak bisa dilihat mata kita. Dengan begitu, TCS34725 mengukur warna lebih mirip dengan cara mata manusia melihatnya. Sebagian besar modul juga punya LED putih netral di sebelah chip. Ketika kamu membaca warna sebuah benda, sebenarnya yang kamu ukur adalah bagian cahaya LED ini yang memantul dari benda dan kembali ke sensor.

FiturNilai
Kanal yang diukurMerah (R), hijau (G), biru (B), tanpa filter (C)
Susunan fotodioda3×4, total 12 fotodioda
Resolusi16 bit per kanal (0–65535)
AntarmukaI2C, hingga 400 kHz
Alamat I2C0x29 (tetap)
Catu dayaChip 2,7–3,6 V; modul dengan regulator 3,3–5 V
ArusSekitar 235 µA selama mengukur, 2,5 µA ketika sleep (tanpa LED)
Filter IRDi chip, penghalang inframerah
Rentang dinamis3.800.000:1
Waktu integrasi2,4 ms – 614 ms (dengan langkah 2,4 ms)
Penguatan1x, 4x, 16x, 60x
LED di boardPutih netral, sekitar 4150 K

Pengaturan waktu integrasi dan penguatan

Waktu integrasi mirip dengan waktu eksposur di kamera. Makin lama waktunya, makin banyak cahaya yang dikumpulkan sensor, angkanya makin besar, dan derau di lingkungan gelap berkurang. Sebaliknya, setiap pembacaan jadi lebih lama dan kanal lebih mudah jenuh di cahaya terang. Waktu ini diatur dengan langkah 2,4 ms lewat register ATIME. Angka terbesar yang bisa dicapai sebuah kanal dihitung dengan rumus (256 − ATIME) × 1024, dan hasilnya tidak bisa melebihi 65535. Tabel di bawah menunjukkan nilai yang paling sering dipakai dan kapan sebaiknya memilihnya.

ATIMESiklusWaktuHitungan maks.Kapan?
0xFF12,4 ms1024Cahaya sangat terang, pembacaan sangat cepat
0xF61024 ms10240Di bawah sinar matahari, benda yang bergerak cepat
0xEB2150 ms21504Titik awal yang bagus untuk membaca warna dengan LED
0xD642101 ms43008Mengukur cahaya sekitar di dalam ruangan
0xC064154 ms65535Lingkungan redup, resolusi penuh 16-bit
0x00256614 ms65535Lingkungan sangat gelap, pembacaan lambat

Penguatan (gain) memperkuat sinyal yang terkumpul secara analog. Pilihannya 1x, 4x, 16x, dan 60x. Menaikkan penguatan meningkatkan sensitivitas tanpa memperpanjang waktu, tapi deraunya juga ikut naik. Aturan praktisnya: selalu terangi benda dengan LED dari jarak yang sama, lalu mulai dengan 50 ms dan 4x. Kalau nilai C jauh di bawah hitungan maksimum (misalnya di bawah 1000), naikkan penguatan ke 16x. Kalau C mendekati jenuh, turunkan penguatan atau perpendek waktunya. Begitu sebuah kanal menyentuh batas atas, pembacaan itu sudah tidak benar lagi, karena angkanya tidak bisa bertambah meskipun cahaya bertambah, sehingga rasio warnanya rusak. Datasheet juga menyebutkan bahwa untuk waktu di bawah 150 ms, kejenuhan bisa mulai terjadi di sekitar 75% dari hitungan maksimum karena riak (ripple). Jadi pada 50 ms, anggap sekitar 16000 sebagai batas atas yang aman.

Pengkabelan TCS34725 (Arduino Uno, ESP32, Pico)

Pin TCS34725Arduino UnoESP32Raspberry Pi Pico
VIN5V3V33V3(OUT) (pin 36)
GNDGNDGNDGND
SDAA4GPIO 21GP4 (pin 6)
SCLA5GPIO 22GP5 (pin 7)
LEDMengambang: LED nyala / GND: LED matiMengambang atau GNDMengambang atau GND
INTMengambang (output interrupt opsional)MengambangMengambang
3V3Jangan dihubungkan (output regulator)Jangan dihubungkanJangan dihubungkan
Sebagian besar modul punya regulator 3,3 V, jadi kamu bisa memberi 5 V ke pin VIN. Tapi jangan pernah menghubungkan 5 V ke pin 3V3; chip-nya hanya tahan maksimal 3,6 V. Kalau kamu tidak melihat chip regulator kecil di board-nya, beri daya modul dengan 3,3 V. Pin LED juga bisa dihubungkan ke pin digital: menulis LOW mematikan LED dan HIGH menyalakannya. Pin INT adalah output interrupt open-drain yang menjadi LOW ketika ambang yang diatur terlewati. Cara kerja jalur I2C bisa kamu temukan di Apa Itu I2C?, dan kecocokan antara 5 V dan 3,3 V di konverter level logika.

Langkah demi langkah: pembacaan warna pertamamu dengan Arduino Uno

  1. Hubungkan modul seperti di tabel: VIN ke 5V, GND ke GND, SDA ke A4, SCL ke A5. Biarkan pin LED dan INT tidak terhubung dulu.
  2. Di Arduino IDE, buka Library Manager, cari library Adafruit TCS34725 lalu instal; kalau ditanya soal dependensi, instal juga Adafruit BusIO. Kalau mentok, lihat Cara Instal Library Arduino.
  3. Upload kode di bawah dan buka Serial Monitor pada 9600 baud.
  4. Pegang kertas merah, hijau, dan biru 1–2 cm di depan sensor dan perhatikan kanal mana yang naik untuk tiap warna.
  5. Dekatkan dan jauhkan kertasnya untuk melihat bagaimana angkanya berubah, dan pastikan nilai C tidak mencapai batas jenuh.
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}

Waktu integrasi dan penguatan diberikan bersamaan ketika objek dibuat; kalau mau, kamu bisa mengubahnya nanti dengan tcs.setIntegrationTime() dan tcs.setGain(). getRawData() menunggu selama satu waktu integrasi lalu membaca keempat kanal. Jadi kalau kamu memilih 614 ms, kamu bahkan tidak bisa membaca dua kali per detik. Untuk suhu warna, kita memakai fungsi calculateColorTemperature_dn40() dari library; fungsi ini mengembalikan nilai tidak valid (65535) ketika jenuh. Perhitungan lux kita lakukan sendiri, karena fungsi calculateLux() di library tidak memperhitungkan waktu dan penguatan, sehingga hasilnya melenceng ketika kamu mengubah pengaturan. Selalu samakan konstanta ATIME_MS dan GAIN di kode dengan pengaturan yang kamu pilih.

Perhitungan suhu warna dan lux

Lux (lx) menunjukkan seberapa terang cahaya yang jatuh ke sebuah permukaan menurut mata manusia. Ruangan redup sekitar 50–100 lx dan kantor yang terang sekitar 300–500 lx; di luar ruangan ketika langit mendung kamu akan mengukur beberapa ribu lx, sedangkan matahari tengah hari bisa mencapai 100.000 lx. Suhu warna (CCT) menggambarkan nada cahaya putih dalam satuan Kelvin. Nyala lilin sekitar 1900 K, bohlam pijar 2700 K, LED putih hangat 3000 K, matahari tengah hari 5500 K, dan langit mendung sekitar 6500–7500 K. Makin kecil nilainya, cahaya makin bergeser ke kuning-oranye, dan makin besar nilainya, makin ke biru. ams, pembuat TCS34725, menyarankan langkah-langkah berikut di catatan aplikasi DN40 untuk menghitung kedua besaran ini dari angka mentah:

LangkahRumus
1. Komponen inframerahIR = (R + G + B − C) / 2 (0 jika negatif)
2. Kanal tanpa IRR' = R − IR, G' = G − IR, B' = B − IR
3. Hitungan per luxCPL = (ATIME_ms × Penguatan) / (GA × 310)
4. LuxLux = (0,136 × R' + 1,000 × G' − 0,444 × B') / CPL
5. Suhu warnaCCT = 3810 × (B' / R') + 1391

Mari lihat contohnya: misalnya kamu membaca R = 1200, G = 1000, B = 800, C = 2800 dengan 50,4 ms dan penguatan 4x. IR = (1200 + 1000 + 800 − 2800) / 2 = 100; nilai tanpa IR adalah 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. Suhu warnanya 3810 × 700 / 1100 + 1391 ≈ 3816 K. GA di rumus menunjukkan seberapa besar kaca atau penutup plastik di depan sensor melemahkan cahaya; untuk sensor tanpa penutup pakai 1. Kalau kamu menaruh sensor di balik penutup, kamu perlu menaikkan GA di atas 1 dan mengkalibrasinya dengan membandingkan hasilnya dengan lux meter yang sudah diketahui akurasinya.

Ketika mengukur cahaya sekitar, selalu matikan LED di board; kalau tidak, sensor akan mengukur LED-nya sendiri dan suhu warnanya akan terus tertahan di sekitar 4000 K. Ketika mengukur lux dan CCT, arahkan sensor ke sumber cahaya atau ke ruangan, bukan ke sebuah benda, dan pilih penguatan 1x serta waktu yang pendek di cahaya terang. Kalau kamu hanya perlu mengukur kecerahan, sensor cahaya BH1750 yang langsung memberi nilai lux adalah pilihan yang lebih sederhana.

TCS34725 vs TCS3200

FiturTCS34725TCS3200
OutputI2C, angka digital 16-bitGelombang kotak, frekuensinya sebanding dengan cahaya
Pin yang dipakai2 (SDA, SCL)5–6 (S0–S3, OUT, OE)
Fotodioda3×4 = 128×8 = 64
Filter IRAda, di chipTidak ada, peka terhadap inframerah
PengaturanWaktu 2,4–614 ms, penguatan 1x–60xPenskalaan frekuensi 2%, 20%, 100%
Catu dayaModul 3,3–5 V (chip 2,7–3,6 V)2,7–5,5 V
LED di board1 putih netral4 putih
Cara membacaEmpat kanal sekaligus, dari registerPilih filter satu per satu dan ukur frekuensi dengan pulseIn
Lux dan suhu warnaDihitung langsung dengan rumusSulit, butuh kalibrasi yang detail

TCS3200 masih sangat umum di proyek sekolah karena keempat LED-nya menerangi benda dengan kuat dan sensor ini berjalan nyaman di 5 V. Tapi mengganti filter untuk tiap warna dengan pin S2 dan S3 lalu mengukur frekuensi menghabiskan pin sekaligus waktu. Karena tidak punya filter IR, pembacaannya juga lebih terpengaruh cahaya sekitar. Sebaliknya, TCS34725 terhubung dengan dua kabel, membaca empat kanal sekaligus, dan berkat waktu dan penguatan yang bisa diatur, bisa bekerja dari kondisi gelap sampai di bawah terik matahari. Kalau kamu memulai proyek baru, pilih TCS34725; kalau kamu sudah punya TCS3200, artikel sensor warna TCS3200 akan memandumu. Kalau kamu juga ingin mendeteksi gestur dan jarak dekat selain warna, APDS-9960 juga alternatif yang bagus.

Contoh mesin pemilah warna

Proyek klasik untuk sekolah dan lomba sains: hentikan permen atau manik-manik berwarna yang meluncur dari jalur miring di depan sensor, lalu arahkan ke wadah yang berbeda sesuai warnanya. Di sini sensor mengukur warna, dan sebuah motor servo memutar saluran luncur ke sudut wadah yang sesuai. Trik paling penting adalah memakai rasio, bukan angka mentah. Ketika benda bergeser sedikit lebih jauh, R, G, dan B turun bersamaan, tapi rasio R/(R+G+B) hampir tidak berubah. Untuk kalibrasi, taruh satu benda dari tiap warna di depan sensor, catat nilai nr, ng, dan nb yang tercetak di Serial Monitor, lalu tulis ke tabel ref di kode; nilai di kode hanyalah contoh. Kalau kamu menaruh sensor di dalam tabung hitam dan selalu menahan benda di jarak yang sama (idealnya 5–10 mm), pengaruh cahaya sekitar hilang dan akurasinya meningkat jauh.

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}

Di setiap pembacaan, kode pertama-tama melihat nilai C. Ketika tabung kosong, cahaya LED tidak dipantulkan kembali, jadi C tetap kecil dan mesin menunggu; kalau cahaya sekitar masuk ke tabung, sesuaikan nilai BOS_ESIK (ambang kosong) dengan susunanmu sendiri. Begitu ada benda datang, rasio warna didapat dengan membagi R, G, dan B dengan jumlah ketiganya. Lalu kuadrat jarak ke tiap warna referensi dihitung dan warna terdekat dipilih. Ambang jarak 0.004 menggolongkan benda yang tidak mirip warna mana pun sebagai tidak dikenal; kalau ambangnya kamu turunkan, mesin jadi lebih selektif. Untuk menambah warna baru, cukup tambahkan satu baris ke array ref, renkAd (nama warna), dan aci (sudut), lalu perbarui RENK_SAYISI (jumlah warna). Memberi daya servo dari catu 5 V terpisah mencegah pembacaan I2C rusak selama motor bergerak. Merata-ratakan beberapa pengukuran juga membuat pembacaan lebih stabil; untuk itu, lihat artikel menyaring data sensor.

TCS34725 dengan ESP32: menampilkan ulang warna di LED RGB

Di ESP32, library Adafruit yang sama langsung jalan tanpa perubahan. Pin I2C secara default adalah GPIO 21 (SDA) dan GPIO 22 (SCL), dan memberi daya modul dari pin 3V3 adalah cara paling aman. Contoh di bawah meniru warna yang dilihat sensor dengan LED RGB common cathode dan mencetak kode warnanya dalam format #RRGGBB ke Serial Monitor. Fungsi getRGB() membagi warna dengan kanal C agar masuk ke rentang 0–255; kode ini menskalakan kanal terkuat ke 255 dan menerapkan koreksi gamma supaya warna yang pucat jadi lebih hidup. Karena fungsi PWM berbeda antara core Arduino ESP32 versi 2.x dan 3.x, kodenya dipisah untuk kedua versi. Resistor yang cocok untuk tiap kaki LED bisa kamu cari dengan kalkulator resistor 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 dengan TCS34725 (MicroPython)

Di MicroPython kamu tidak wajib menginstal library siap pakai; struktur register TCS34725 sederhana, jadi kamu bisa berkomunikasi langsung dengannya dalam beberapa baris. Bit perintah (0x80) ditambahkan ke setiap alamat register, dan untuk pembacaan multi-byte dipakai juga bit auto-increment (0x20). Kode ini pertama membaca register ID (0x12): hasilnya harus 0x44 untuk TCS34725 dan 0x4D untuk TCS34727. Lalu kode mengatur ATIME ke 0xEB (sekitar 50 ms) dan penguatan ke 4x, menyalakan sensor, dan menghitung lux serta suhu warna dengan rumus DN40 di setiap pengukuran. Kalau kamu baru mengenal Pico dan MicroPython, kamu bisa membaca Apa Itu Raspberry Pi Pico? dulu.

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)

Ide proyek dengan TCS34725

  • Mesin pemilah warna: Pilah permen atau manik-manik ke wadah sesuai warnanya dengan bantuan servo dan jalur miring (contoh di atas).
  • Lampu peniru warna: Baca warna sebuah kain atau kertas lalu tampilkan persis sama di LED strip WS2812B NeoPixel.
  • Pengukur pencahayaan: Ukur lux dan suhu warna sebuah ruangan lalu tampilkan di layar; cek apakah meja belajarmu mencapai target 500 lx.
  • Robot dengan aturan warna: Tambahkan TCS34725 ke robot pengikut garis dan buat aturan seperti berhenti di tanda merah dan belok di tanda hijau.
  • Alat yang mengucapkan warna: Buat alat bantu untuk tunanetra yang menyebutkan warna yang terdeteksi dengan suara lewat DFPlayer Mini.
  • Indikator kematangan buah: Pantau tomat atau pisang yang berubah dari hijau ke merah atau kuning menggunakan rasio warna.

Kesalahan umum dan cara mengatasinya

GejalaKemungkinan penyebabSolusi
Muncul tulisan “TCS34725 not found”SDA dan SCL tertukar, tidak ada daya, atau kabel longgarCek apakah SDA=A4 dan SCL=A5 di Uno; cari alamat 0x29 dengan scanner I2C
Semua kanal sangat besar dan tidak berubahJenuh: cahaya terlalu banyak untuk waktu dan penguatan yang dipilihTurunkan penguatan ke 1x, perpendek waktu, atau jauhkan benda sedikit
Angkanya sangat kecil dan warnanya melompat-lompatCahaya kurangNyalakan LED, atur penguatan ke 16x atau 60x, perpanjang waktu
Benda yang sama menunjukkan warna berbeda di jarak berbedaPerbandingan dilakukan dengan nilai mentahPakai rasio R/(R+G+B) dan tetapkan jaraknya
Hasil berubah ketika jendela dibukaCahaya sekitar ikut tercampur ke pengukuranKelilingi sensor dengan tabung hitam atau penutup
Suhu warna selalu di sekitar 4000 KLED di board masih menyalaHubungkan pin LED ke GND atau matikan dengan pin digital
Pembacaan sangat lambatWaktu integrasi panjang (mis. 614 ms)getRawData() menunggu selama waktu itu; pilih 24–50 ms
Merah dan oranye tertukarRasio referensi terlalu berdekatanKalibrasi di susunan akhir, turunkan ambang, rata-ratakan beberapa pembacaan

TCS34725 adalah sensor serbaguna yang terhubung dengan dua kabel dan, berkat sensitivitas yang bisa diatur serta filter IR-nya, mengukur warna benda maupun cahaya sekitar dengan andal. Rahasia hasil yang benar ada tiga: memilih waktu dan penguatan yang mencegah kejenuhan, bekerja dengan rasio alih-alih angka mentah, dan melakukan kalibrasi di susunan akhir. Kalau kamu ingin mulai mengukur cahaya dengan sensor yang lebih sederhana, sensor cahaya LDR adalah langkah pertama yang bagus. Di aplikasi BlueGrays kamu akan menemukan proyek langkah demi langkah lengkap dengan skema rangkaian dan kode untuk mengukur cahaya dengan LDR, transisi warna LED RGB, lampu pencampur warna ESP32, dan servo, lalu kamu bisa membangun mesin pendeteksi warnamu sendiri di atasnya.

Pertanyaan umum

Apa bedanya TCS34725 dan TCS3200?

TCS34725 memberikan empat kanal sekaligus sebagai angka 16-bit lewat I2C dan punya filter penghalang inframerah di chip-nya. TCS3200 memilih filter warna satu per satu dengan pin S2–S3 dan menghasilkan output frekuensi; sensor ini butuh 5–6 pin dan, karena tidak punya filter IR, lebih terpengaruh cahaya sekitar. Untuk akurasi dan pengkabelan yang mudah, TCS34725 adalah pilihan yang lebih baik.

Berapa alamat I2C TCS34725, dan apakah bisa diubah?

Alamat TCS34725 tetap di 0x29 dan tidak bisa diubah. Kalau kamu ingin menghubungkan dua sensor ke board yang sama, kamu bisa memakai multiplexer I2C seperti TCA9548A. Di ESP32 dan Pico, kamu juga bisa menghubungkan tiap sensor ke jalur I2C yang terpisah.

Apakah TCS34725 bisa bekerja di 5 V?

Chip-nya sendiri bekerja di 2,7–3,6 V. Namun, karena sebagian besar modul punya regulator 3,3 V, kamu bisa memberi 5 V ke pin VIN dan menghubungkan modul langsung ke Arduino Uno. Memberi 5 V ke pin 3V3 akan merusak chip; kalau board-mu tidak punya regulator, beri daya modul dengan 3,3 V.

Kenapa TCS34725-ku salah membaca warna?

Penyebab paling umum adalah kejenuhan, cahaya kurang, cahaya sekitar yang ikut tercampur, dan membandingkan dengan angka mentah. Terangi benda dengan LED dari jarak yang tetap, pastikan nilai C tetap di bawah batas jenuh, dan bekerjalah dengan rasio seperti R/(R+G+B). Kalibrasi juga warna referensinya di susunan akhirmu.

Bagaimana cara mematikan LED di TCS34725?

Ketika kamu menghubungkan pin LED modul ke GND, LED putihnya mati. Kalau pin itu kamu hubungkan ke output digital, kamu bisa mematikannya dengan menulis LOW dan menyalakannya dengan menulis HIGH. LED harus mati ketika kamu mengukur cahaya sekitar atau suhu warna.

Seberapa akurat pengukuran lux dengan TCS34725?

TCS34725 tidak setepat lux meter profesional, tapi dengan rumus DN40 serta pengaturan waktu dan penguatan yang tepat, sensor ini memberi nilai perkiraan yang cukup berguna di dalam ruangan. Kalau sensornya berada di balik penutup kaca atau plastik, kamu perlu mengkalibrasinya dengan faktor GA. Kalau kamu hanya butuh kecerahan, BH1750 yang langsung memberi nilai lux adalah pilihan yang lebih sederhana.

Lihat semua proyek
Mengukur Intensitas Cahaya dengan LDR
AR-11Pemula

Mengukur Intensitas Cahaya dengan LDR

Ingin melihat seberapa terang kamarmu dalam bentuk angka? LDR, komponen kecil yang bereaksi terhadap cahaya, mengukur cahaya di sekitarnya, dan Arduino menulis nilainya ke layar komputermu setiap…

4.6(83)
143
Membaca Intensitas Cahaya dengan Modul LDR ESP32
ES-11Pemula

Membaca Intensitas Cahaya dengan Modul LDR ESP32

Memantau secara real-time di Serial Monitor nilai ADC mentah modul LDR dan persentase cahaya relatif yang dihitung dari nilai acuan gelap dan terang. Persentase ini bukan pengukuran lux. Mengajarkan logika kalibrasi modul. Ideal dikerjakan sebelum Proyek 10, karena dipakai untuk menentukan nilai ambang.

4.6(36)
55
Menggunakan LED RGB
AR-39Pemula
Premium

Menggunakan LED RGB

Tiga warna tersembunyi di dalam satu LED: LED RGB menyala merah, lalu hijau, lalu biru, setiap warna menyala setengah detik dan mati setengah detik, sebelum siklusnya dimulai lagi.

4.9(73)
100
Transisi Warna Halus dengan LED RGB
AR-40Pemula
Premium

Transisi Warna Halus dengan LED RGB

Satu LED RGB perlahan bergeser dari merah ke hijau, hijau ke biru, lalu kembali ke merah, berputar melewati warna pelangi tanpa pernah berhenti.

4.8(58)
78
Kendali LED RGB ESP32
ES-9Pemula

Kendali LED RGB ESP32

Menghasilkan warna tanpa batas dengan satu LED RGB alih-alih 3 LED terpisah. Seperti di Arduino, kita membuat transisi pelangi dengan mengatur nilai R/G/B lewat analogWrite(). Teori warna (seperti merah+hijau=kuning) terlihat secara praktis.

4.6(29)
52
Lampu Pencampur Warna ESP32 (3 Potensiometer + LED RGB + OLED)
ES-36Mahir
Premium

Lampu Pencampur Warna ESP32 (3 Potensiometer + LED RGB + OLED)

Lampu pencampur warna pintar: campur warna apa pun dengan memutar tiga potensiometer di ESP32! Ketika potensiometer merah, hijau, dan biru diputar, LED RGB katoda bersama berubah warna secara real-time. OLED SSD1306 menampilkan nilai setiap warna dalam rentang 0–255, bar pengisi, dan kode warna web HEX (seperti #FF8040). Studio warna mini yang mengajarkan teori warna RGB, pembacaan ADC, pengaturan kecerahan dengan PWM, dan desain layar I2C sekaligus.

4.7(6)
10
Deteksi Permukaan Hitam dan Putih TCRT5000
AR-78Menengah
Premium

Deteksi Permukaan Hitam dan Putih TCRT5000

Dengan sensor kecil yang menjadi mata robot pengikut garis, kamu bisa tahu apakah lantainya hitam atau putih.

4.7(40)
49
Siklus Warna LED RGB Raspberry Pi Pico (PWM 3 Kanal)
PI-15Pemula

Siklus Warna LED RGB Raspberry Pi Pico (PWM 3 Kanal)

Satu LED, jutaan warna! LED RGB berisi 3 LED: merah, hijau, dan biru. Masing-masing digerakkan dengan kanal PWM Pico sendiri: merah + hijau = kuning, hijau + biru = cyan, ketiganya = putih. LED berputar melewati 8 warna. Pelajari beberapa kanal PWM, mendefinisikan fungsi (def set_color(...)), pencampuran warna RGB (cara kerja layar), konversi 8-bit → 16-bit (x257 memetakan 0–255 ke 0–65535), dan LED katoda bersama vs anoda bersama.

6