TCS3200 rəng sensoru: Arduino ilə rəng aşkarlama və kalibrləmə
TCS3200 rəng sensoru necə işləyir? S0–S3 ayarları, pulseIn ilə R, G, B oxuma, ağ-qara kalibrləmə, rəng ayırma alqoritmi, ESP32, Pico və TCS34725 kodu.
TCS3200 rəng sensoru qarşısındakı səthin rəngini qırmızı, yaşıl və mavi komponentlərə ayıraraq ölçən və Arduino layihələrində ən çox istifadə olunan rəng aşkarlama moduludur. Fotodiod massivinin tutduğu işığı birbaşa tezliyə çevirir: səth nə qədər çox qırmızı işıq əks etdirirsə, qırmızı kanalın tezliyi o qədər yüksəlir. Analoq oxuma və ya xüsusi rabitə protokolu lazım deyil; Arduino-nun pulseIn() komandası ilə bir neçə sətirdə R, G və B dəyərlərini oxuya bilərsən. Rəngli şirniyyat ayıran maşınlar, rəng tanıyan robotlar, yerdəki rəngli işarələrə görə istiqamətini dəyişən nəqliyyat vasitələri və qarşısına tutulan obyektin rəngini kopyalayan lampalar bu sensorla hazırlanır.
Bu bələdçidə sensorun içində nələr olduğunu, S0–S3 pinlərinin nə işə yaradığını, Arduino Uno, ESP32 və Raspberry Pi Pico ilə qoşulmanı, xam oxumanı, ağ-qara kalibrləməni və oxunan dəyərdən hansı rəng olduğunu tapan alqoritmi addım-addım görəcəksən. Ardınca obyektləri rənginə görə ayıran maşının məntiqini quracaq, sonda isə I2C ilə işləyən TCS34725 sensoru ilə müqayisə edəcəyik.

TCS3200 rəng sensoru nədir, necə işləyir?
Modulun ürəyi olan TCS3200 çipinin (köhnə versiyasının adı TCS230) səthində 8×8 düzülüşündə 64 fotodiod yerləşir. Bunların 16-sının üstündə qırmızı, 16-sının üstündə yaşıl, 16-sının üstündə mavi filtr var; qalan 16-sı isə filtrsizdir (clear) və işığın ümumi miqdarını görür. Eyni rəngli 16 fotodiod bir-birinə paralel qoşulub və hansı qrupun ölçüləcəyini S2 və S3 pinləri seçir. Fərqli rəngli fotodiodlar massivdə iç-içə düzüldüyü üçün səthin bir küncünə düşən işıq bütün rəng qruplarına bərabər təsir edir.
Seçilmiş fotodiod qrupunun yaratdığı kiçik cərəyan çipin içindəki cərəyan-tezlik çeviricisinə gedir. Bu dövrə doldurma əmsalı 50% olan kvadrat dalğa yaradır və dalğanın tezliyi işığın şiddəti ilə düz mütənasibdir. Yəni ölçdüyün şey gərginlik deyil, saniyədəki impuls sayıdır: tam qaranlıqda bir neçə herts, ağ səthə yaxın tutulanda onlarla kiloherts görürsən. Tezlik çıxışının yaxşı tərəfi küyə davamlı olması və Arduino-nun istənilən rəqəmsal pininə qoşula bilməsidir. Yalnız işığın nə qədər güclü olduğunu ölçmək istəyirsənsə, LDR işıq sensoru daha sadə seçimdir; TCS3200 isə eyni işi üç rəng üçün ayrı-ayrılıqda görür.
| Xüsusiyyət | Dəyər |
|---|---|
| Çip | TCS3200 (köhnə versiyası TCS230, pinlərə görə uyğundur) |
| Fotodiod massivi | 8×8 = 64 ədəd: 16 qırmızı, 16 yaşıl, 16 mavi, 16 filtrsiz |
| Çıxış | 50% doldurma əmsallı kvadrat dalğa, tezlik işıqla düz mütənasib |
| Tam şkala tezliyi (tipik) | 600 kHz (100%), 120 kHz (20%), 12 kHz (2%) |
| Qida gərginliyi | 2,7–5,5 V |
| Çipin cərəyanı | Tipik 1,4 mA (moduldakı LED-lərin cərəyanı buna əlavə olunur) |
| İdarəetmə pinləri | S0, S1 (tezlik şkalası), S2, S3 (rəng filtri), OE (çıxış aktivdir, aktiv LOW) |
| Tövsiyə olunan ölçmə məsafəsi | Təxminən 1–3 sm, hər ölçmədə eyni |
| İşıqlandırma | Modulda 4 ağ LED |
S0–S3 pinləri: tezlik şkalası və rəng filtrinin seçilməsi
TCS3200-ün davranışını dörd idarəetmə pini müəyyən edir. S0 və S1 çıxış tezliyini kiçildir: 100% şkalada impulslar bir neçə mikrosaniyəyə qədər qısalır və Arduino Uno-nun ölçmə dəqiqliyini çətinləşdirir; 2% şkalada isə impulslar uzanır, amma eyni müddətdə daha az impuls gəlir. S2 və S3 isə hansı rəng filtrinin oxunacağını seçir. Bu pinləri Arduino-nun rəqəmsal çıxışlarına qoşur, hər ölçmədən əvvəl koddan tənzimləyirsən.
| S0 | S1 | Çıxış tezliyi şkalası | Nə vaxt istifadə olunur? |
|---|---|---|---|
| LOW | LOW | Qidanın kəsilməsi (power-down) | Batareyalı layihədə sensoru yatızdırmaq üçün |
| LOW | HIGH | 2% (tipik olaraq maksimum 12 kHz) | Yavaş prosessorlar, MicroPython və kəsmə ilə say |
| HIGH | LOW | 20% (tipik olaraq maksimum 120 kHz) | Arduino və pulseIn üçün ən uyğun ayar |
| HIGH | HIGH | 100% (tipik olaraq maksimum 600 kHz) | Aparat sayğaclı sürətli ölçmələr |
| S2 | S3 | Oxunan fotodiod qrupu |
|---|---|---|
| LOW | LOW | Qırmızı filtrli |
| LOW | HIGH | Mavi filtrli |
| HIGH | LOW | Filtrsiz (clear, ümumi işıq) |
| HIGH | HIGH | Yaşıl filtrli |
TCS3200 qoşulması: Arduino Uno, ESP32 və Pico
| Modul pini | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| VCC | 5V | 3V3 | 3V3(OUT), pin 36 |
| GND | GND | GND | GND |
| S0 | D4 | GPIO 32 | GP2 |
| S1 | D5 | GPIO 33 | GP3 |
| S2 | D6 | GPIO 25 | GP4 |
| S3 | D7 | GPIO 26 | GP5 |
| OUT | D8 | GPIO 27 | GP6 |
| OE | GND | GND | GND |
Moduldakı dörd ağ LED səthi hər ölçmədə eyni işıqla işıqlandırır; bu sayədə otaq işığı dəyişsə belə nəticələr daha sabit olur. Bəzi platalarda LED-ləri yandırıb söndürməyə yarayan ayrıca LED pini var, bəzilərində isə LED-lər qida verildiyi anda yanır; öz platandakı yazılara bax. Ən yaxşı nəticə üçün sensorun ətrafını qara boru və ya kartonla əhatə et, ölçüləcək obyekti hər dəfə eyni məsafəyə gətir və parlaq, əks etdirən səthlərdən qaç. Platanın pin düzülüşünü Pinout alətində yoxlaya bilərsən.
Addım-addım: pulseIn ilə R, G və B oxumaq
- Modulu yuxarıdakı cədvəldəki kimi qoş; OE-ni GND-yə, VCC-ni 5V-a qoş.
- S0-ı HIGH, S1-i LOW edərək 20% tezlik şkalasını seç.
- Qırmızı üçün S2 və S3-ü LOW et və çıxışın oturuşması üçün bir neçə millisaniyə gözlə.
- pulseIn(OUT, LOW) ilə impulsun LOW hissəsinin müddətini mikrosaniyə ilə ölç; küyü azaltmaq üçün 10 ölçmənin ortasını götür.
- Eyni əməliyyatı yaşıl (S2 HIGH, S3 HIGH) və mavi (S2 LOW, S3 HIGH) üçün təkrarla.
- Nəticələri Serial Monitor-da 9600 baud ilə izlə və sensorun qarşısına fərqli rəngli kağızlar tut.
1// TCS3200 ile ham R, G, B okuma / Raw R, G, B reading with the TCS3200
2const int S0 = 4;
3const int S1 = 5;
4const int S2 = 6;
5const int S3 = 7;
6const int OUT_PIN = 8;
7
8// Filtreyi seçer, 10 darbenin ortalama LOW süresini döndürür (µs) / Selects a filter, returns the average LOW time of 10 pulses (µs)
9unsigned long readPulse(bool s2, bool s3) {
10 digitalWrite(S2, s2 ? HIGH : LOW);
11 digitalWrite(S3, s3 ? HIGH : LOW);
12 delay(5); // çıkışın oturmasını bekle / let the output settle
13 unsigned long total = 0;
14 int count = 0;
15 for (int i = 0; i < 10; i++) {
16 unsigned long t = pulseIn(OUT_PIN, LOW, 50000UL); // 50 ms zaman aşımı / 50 ms timeout
17 if (t > 0) {
18 total += t;
19 count++;
20 }
21 }
22 return count > 0 ? total / count : 50000UL; // darbe yoksa çok karanlık / no pulse means very dark
23}
24
25void setup() {
26 pinMode(S0, OUTPUT);
27 pinMode(S1, OUTPUT);
28 pinMode(S2, OUTPUT);
29 pinMode(S3, OUTPUT);
30 pinMode(OUT_PIN, INPUT);
31 digitalWrite(S0, HIGH); // S0=HIGH, S1=LOW: %20 ölçek / 20% scaling
32 digitalWrite(S1, LOW);
33 Serial.begin(9600);
34}
35
36void loop() {
37 unsigned long r = readPulse(false, false); // kırmızı filtre / red filter
38 unsigned long g = readPulse(true, true); // yeşil filtre / green filter
39 unsigned long b = readPulse(false, true); // mavi filtre / blue filter
40 Serial.print("R: ");
41 Serial.print(r);
42 Serial.print(" G: ");
43 Serial.print(g);
44 Serial.print(" B: ");
45 Serial.println(b);
46 delay(500);
47}Bu kodda ən vacib nöqtə oxunan ədədin işıqla tərs mütənasib olmasıdır: dəyər kiçildikcə həmin rəngdən gələn işıq artır. Qırmızı kağız tutanda məsələn "R: 24 G: 68 B: 52" kimi çıxış görürsən; ən kiçik ədəd qırmızı kanaldadır. pulseIn-ə verilən 50.000 µs-lik zaman aşımı impuls gəlmədikdə kodun susmaya görə 1 saniyə gözləməsinin qarşısını alır; heç impuls tutulmazsa funksiya 50.000 qaytarır və bu "çox qaranlıq" deməkdir. Serial port çıxışını oxumaqda çətinlik çəkirsənsə, Arduino Serial Monitor bələdçisinə bax.
Ağ-qara kalibrləmə: xam dəyərləri 0–255-ə çevirmək
Xam dəyərlər tək başına yanıldıcıdır, çünki üç fotodiod qrupunun həssaslığı eyni deyil və moduldakı ağ LED-lər hər rəngi bərabər miqdarda yaymır. Buna görə ağappaq kağız belə üç kanalda fərqli ədədlər verir. Kalibrləmə bu fərqləri aradan qaldırıb hər kanalı 0 (qara) ilə 255 (ağ) arasına yerləşdirməkdir; fotoaparatlardakı ağ balansla eyni ideyadır. Kalibrləməni sensorun həqiqətən işləyəcəyi yerdə, eyni işıq və məsafədə aparmalısan; masada etdiyin kalibrləmə qutunun içində keçərli olmur.
- Sensoru sabit tutacağa yerləşdir və ölçmə məsafəsini (məsələn, 1,5 sm) dəyişməyəcək şəkildə tənzimlə.
- Qarşısına düz ağ kağız qoy, yuxarıdakı kodla R, G və B dəyərlərini bir neçə dəfə oxu və ortalarını ağ referans kimi qeyd et; bunlar ən kiçik dəyərlərdir.
- Eyni yerə mat qara kağız və ya keçə qoy və oxunan dəyərləri qara referans kimi qeyd et; bunlar ən böyük dəyərlərdir.
- Bu altı ədədi aşağıdakı kodun əvvəlindəki WHITE_ və BLACK_ sabitlərinə yaz və kodu yüklə.
- Ağ kağızda üç kanalın da 255-ə, qarada 0-a yaxın çıxdığını yoxla; çıxmırsa ölçməni eyni işıq və məsafədə təkrarla.
Burada bir çox nümunədə edilən xətaya diqqət et: impuls müddətini map() ilə birbaşa 0–255-ə çevirmək düzgün nəticə vermir, çünki işıq impuls müddəti ilə deyil, tezliklə mütənasibdir. Düzgün yol əvvəlcə müddəti tezliyə (1/t) çevirib sonra şkalalamaqdır: səviyyə = (f − f_black) / (f_white − f_black) × 255. Bir nümunəyə baxaq: ağda 20 µs, qarada 200 µs ölçdün və obyekt 40 µs verdi. map() bu dəyəri 226-ya çevirir; tezlik üsulu isə 113 tapır. Obyektin tezliyi ağdakının düz yarısıdır və qara səviyyə çıxıldıqda bu, şkalanın təxminən 44%-nə, yəni 113-ə uyğun gəlir; map() isə rəngləri olduğundan xeyli açıq göstərir və tünd tonları bir-birindən ayırmağı çətinləşdirir.
Rəng ayırma alqoritmi: oxunan dəyər hansı rəngdir?
Kalibrlənmiş R, G, B dəyərləri hələ də işığın miqdarından asılıdır: eyni qırmızı obyekt sensora bir az yaxınlaşanda üç dəyər birlikdə artır. Bunu həll etmək üçün hər dəyəri cəmə bölürük: r = R / (R + G + B), g və b də eyni qaydada. Bu rəng nisbətləri məsafə və parlaqlıq bir az dəyişsə belə demək olar ki, sabit qalır. Ardınca onları hər rəng üçün bir dəfə ölçüb yadda saxladığın referans nisbətlərlə müqayisə edir və ən yaxın qonşunu seçirsən. Müqayisə üçün nisbət fərqlərinin kvadratlarını toplamaq kifayətdir; bu ədəd nə qədər kiçikdirsə, rənglər bir o qədər oxşardır. Ən yaxın referans belə müəyyən həddən uzaqdırsa, nəticə "naməlum" olur. Ümumi işıq çox aşağıdırsa obyekt qara, üç kanal da çox yüksəkdirsə ağ sayılır; bu iki hal nisbətlərlə ayırd edilə bilmədiyi üçün əvvəlcə yoxlanılır.
1// TCS3200 ile kalibrasyonlu renk tanıma / Calibrated color recognition with the TCS3200
2const int S0 = 4, S1 = 5, S2 = 6, S3 = 7, OUT_PIN = 8;
3
4// Kalibrasyonda ölçtüğün süreler (µs), kendi değerlerinle değiştir / Pulse widths from your calibration (µs), use your own
5const float WHITE_R = 16, WHITE_G = 20, WHITE_B = 18; // beyaz kağıt / white paper
6const float BLACK_R = 140, BLACK_G = 170, BLACK_B = 150; // siyah kağıt / black paper
7
8struct ColorRef {
9 const char *name;
10 float r, g, b; // renk oranları, toplamı 1 / color ratios, sum is 1
11};
12
13// Örnek referanslar, kendi ölçümlerinle değiştir / Sample references, replace with your own measurements
14ColorRef refs[] = {
15 {"Kirmizi / Red", 0.58, 0.20, 0.22},
16 {"Turuncu / Orange", 0.55, 0.30, 0.15},
17 {"Sari / Yellow", 0.42, 0.40, 0.18},
18 {"Yesil / Green", 0.24, 0.46, 0.30},
19 {"Mavi / Blue", 0.18, 0.30, 0.52},
20 {"Mor / Purple", 0.40, 0.20, 0.40}
21};
22const int REF_COUNT = sizeof(refs) / sizeof(refs[0]);
23const float MAX_DIST = 0.02; // bundan uzaksa bilinmiyor / farther than this is unknown
24
25unsigned long readPulse(bool s2, bool s3) {
26 digitalWrite(S2, s2 ? HIGH : LOW);
27 digitalWrite(S3, s3 ? HIGH : LOW);
28 delay(5);
29 unsigned long total = 0;
30 int count = 0;
31 for (int i = 0; i < 10; i++) {
32 unsigned long t = pulseIn(OUT_PIN, LOW, 50000UL);
33 if (t > 0) {
34 total += t;
35 count++;
36 }
37 }
38 return count > 0 ? total / count : 50000UL;
39}
40
41// Süreyi frekansa çevirip 0-255 arasına ölçekler / Converts the pulse width to frequency and scales it to 0-255
42float toLevel(unsigned long t, float tWhite, float tBlack) {
43 float f = 1.0 / t; // ışık frekansla orantılı / light is proportional to frequency
44 float fWhite = 1.0 / tWhite;
45 float fBlack = 1.0 / tBlack;
46 float level = (f - fBlack) / (fWhite - fBlack) * 255.0;
47 return constrain(level, 0.0, 255.0);
48}
49
50// En yakın referans rengi bulur / Finds the nearest reference color
51const char *classify(float R, float G, float B) {
52 float sum = R + G + B;
53 if (sum < 90) return "Siyah / Black"; // çok az ışık / very little light
54 if (R > 200 && G > 200 && B > 200) return "Beyaz / White";
55 float r = R / sum, g = G / sum, b = B / sum; // parlaklıktan bağımsız oranlar / brightness-independent ratios
56 int best = 0;
57 float bestDist = 1e9;
58 for (int i = 0; i < REF_COUNT; i++) {
59 float d = sq(r - refs[i].r) + sq(g - refs[i].g) + sq(b - refs[i].b); // uzaklığın karesi / squared distance
60 if (d < bestDist) {
61 bestDist = d;
62 best = i;
63 }
64 }
65 if (bestDist > MAX_DIST) return "Bilinmiyor / Unknown";
66 return refs[best].name;
67}
68
69void setup() {
70 pinMode(S0, OUTPUT);
71 pinMode(S1, OUTPUT);
72 pinMode(S2, OUTPUT);
73 pinMode(S3, OUTPUT);
74 pinMode(OUT_PIN, INPUT);
75 digitalWrite(S0, HIGH); // %20 ölçek / 20% scaling
76 digitalWrite(S1, LOW);
77 Serial.begin(9600);
78}
79
80void loop() {
81 float R = toLevel(readPulse(false, false), WHITE_R, BLACK_R);
82 float G = toLevel(readPulse(true, true), WHITE_G, BLACK_G);
83 float B = toLevel(readPulse(false, true), WHITE_B, BLACK_B);
84 float sum = R + G + B;
85 Serial.print("R=");
86 Serial.print(R, 0);
87 Serial.print(" G=");
88 Serial.print(G, 0);
89 Serial.print(" B=");
90 Serial.print(B, 0);
91 if (sum > 0) { // referans için oranlar / ratios for your references
92 Serial.print(" r=");
93 Serial.print(R / sum, 2);
94 Serial.print(" g=");
95 Serial.print(G / sum, 2);
96 Serial.print(" b=");
97 Serial.print(B / sum, 2);
98 }
99 Serial.print(" -> ");
100 Serial.println(classify(R, G, B));
101 delay(500);
102}| Kod hissəsi | Vəzifəsi |
|---|---|
| WHITE_* və BLACK_* | Kalibrləmədə ölçdüyün ağ və qara impuls müddətləri (µs) |
| toLevel() | İmpuls müddətini tezliyə çevirib 0–255 arasına şkalalayır |
| refs[] | Hər rəngin referans r, g, b nisbətləri; öz ölçmələrinlə dəyiş |
| classify() | Əvvəlcə qaranı və ağı ayırır, sonra ən yaxın referansı tapır |
| MAX_DIST | Bu məsafəni aşan ölçmələr "Naməlum" sayılır |
Obyektləri rənginə görə ayıran maşın qurmaq
TCS3200-ün ən sevilən layihəsi rəngli şirniyyatları, muncuqları və ya LEGO hissələrini rənginə görə ayıran maşındır. Mexanizm iki servodan ibarətdir. Üstdəki qidalandırma servosu üzərində tək bir obyektin sığacağı dəlik olan diski fırladır: əvvəlcə huni borusunun altından bir obyekt götürür, sonra onu sensorun qarşısına gətirir və ölçmədən sonra aşağıdakı kanala buraxır. Aşağıdakı yönləndirmə servosu isə maili kanalı fırladaraq obyekti öz rənginə aid qutuya göndərir. Servolardan ilk dəfə istifadə edəcəksənsə, əvvəlcə Servo mühərrik nədir? yazısına bax.
- Huniyi və obyektlərdən bir az geniş borunu obyektləri tək-tək qidalandırma diskinə düşürəcək şəkildə yerləşdir.
- Sensoru diskin üstündəki obyekti 1–2 sm məsafədən görəcək şəkildə bərkit və ətrafını xarici işıq girməyəcək şəkildə bağla.
- Qidalandırma servosu üçün üç bucaq müəyyən et: yükləmə, sensor və buraxma. Bucaqları öz mexanizmində yoxlayaraq tap; qidalandırma servosunu D9-a, yönləndirmə servosunu D10-a qoş.
- Yönləndirmə servosu üçün hər rəng qutusuna bir bucaq ayır (məsələn, qırmızı 30°, yaşıl 75°, mavi 120°, digərləri 165°).
- Kalibrləməni maşının içində, maşının öz işığı ilə apar və hər rəngdən bir neçə obyektlə yoxla.
1// TCS3200 ve iki servoyla renk ayırıcı / Color sorter with a TCS3200 and two servos
2#include <Servo.h>
3
4const int S0 = 4, S1 = 5, S2 = 6, S3 = 7, OUT_PIN = 8;
5const int FEEDER_PIN = 9; // besleme servosu / feeder servo
6const int CHUTE_PIN = 10; // yönlendirme servosu / chute servo
7
8const int LOAD_ANGLE = 160; // huninin altı / under the hopper
9const int SENSOR_ANGLE = 95; // sensörün önü / in front of the sensor
10const int DROP_ANGLE = 30; // bırakma deliği / drop hole
11
12// Kalibrasyon süreleri (µs) / Calibration pulse widths (µs)
13const float WHITE_R = 16, WHITE_G = 20, WHITE_B = 18;
14const float BLACK_R = 140, BLACK_G = 170, BLACK_B = 150;
15
16Servo feeder;
17Servo chute;
18
19unsigned long readPulse(bool s2, bool s3) {
20 digitalWrite(S2, s2 ? HIGH : LOW);
21 digitalWrite(S3, s3 ? HIGH : LOW);
22 delay(5);
23 unsigned long total = 0;
24 int count = 0;
25 for (int i = 0; i < 10; i++) {
26 unsigned long t = pulseIn(OUT_PIN, LOW, 50000UL);
27 if (t > 0) {
28 total += t;
29 count++;
30 }
31 }
32 return count > 0 ? total / count : 50000UL;
33}
34
35float toLevel(unsigned long t, float tWhite, float tBlack) {
36 float f = 1.0 / t;
37 float level = (f - 1.0 / tBlack) / (1.0 / tWhite - 1.0 / tBlack) * 255.0;
38 return constrain(level, 0.0, 255.0);
39}
40
41// Baskın kanala göre kutu açısını seçer / Picks the bin angle from the dominant channel
42int binAngle(float R, float G, float B) {
43 if (R + G + B < 90) return 165; // çok koyu: diğer kutusu / too dark: "other" bin
44 if (R > G * 1.3 && R > B * 1.3) return 30; // kırmızı kutusu / red bin
45 if (G > R * 1.3 && G > B * 1.3) return 75; // yeşil kutusu / green bin
46 if (B > R * 1.3 && B > G * 1.3) return 120; // mavi kutusu / blue bin
47 return 165; // karar verilemedi / undecided
48}
49
50void setup() {
51 pinMode(S0, OUTPUT);
52 pinMode(S1, OUTPUT);
53 pinMode(S2, OUTPUT);
54 pinMode(S3, OUTPUT);
55 pinMode(OUT_PIN, INPUT);
56 digitalWrite(S0, HIGH); // %20 ölçek / 20% scaling
57 digitalWrite(S1, LOW);
58 feeder.attach(FEEDER_PIN);
59 chute.attach(CHUTE_PIN);
60 feeder.write(LOAD_ANGLE);
61 delay(500);
62}
63
64void loop() {
65 feeder.write(LOAD_ANGLE); // huniden bir nesne al / take one object from the hopper
66 delay(600);
67 feeder.write(SENSOR_ANGLE); // sensörün önüne getir / bring it to the sensor
68 delay(600); // servo dursun, titreşim geçsin / let the servo settle
69 float R = toLevel(readPulse(false, false), WHITE_R, BLACK_R);
70 float G = toLevel(readPulse(true, true), WHITE_G, BLACK_G);
71 float B = toLevel(readPulse(false, true), WHITE_B, BLACK_B);
72 chute.write(binAngle(R, G, B)); // kanalı doğru kutuya çevir / aim the chute at the right bin
73 delay(400);
74 feeder.write(DROP_ANGLE); // nesneyi kanala bırak / drop the object into the chute
75 delay(600);
76}ESP32 ilə TCS3200: kəsmə ilə tezlik ölçmək
ESP32-də eyni pulseIn kodu işləyir, amma daha sabit bir üsul da var: impuls müddətini tək-tək ölçmək əvəzinə müəyyən müddətdə neçə impuls gəldiyini saymaq. Kəsmə (interrupt) hər yüksələn cəbhədə sayğacı bir artırır; 50 ms sonunda sayğacdakı dəyəri 20-yə vuranda tezliyi hers ilə tapırsan. Bu üsul yüzlərlə impulsun ortasını götürdüyü üçün tək bir pozuq impulsdan təsirlənmir. ESP32-nin 240 MHz-lik prosessoru 20% şkalada saniyədə on minlərlə kəsməni rahatlıqla qarşılayır; çox parlaq işıqda say həddən artıq böyüsə, şkalanı 2%-ə endirə bilərsən. Eyni üsuldan Arduino Uno-da da OUT-u kəsməni dəstəkləyən D2 pininə köçürərək istifadə edə bilərsən. ESP32-də modulu 3V3 pinindən qidalandırmağı unutma.
1// ESP32: kesmeyle TCS3200 frekans ölçümü / ESP32: TCS3200 frequency measurement with an interrupt
2const int S0 = 32, S1 = 33, S2 = 25, S3 = 26, OUT_PIN = 27;
3
4volatile uint32_t pulseCount = 0;
5
6void IRAM_ATTR onPulse() {
7 pulseCount++; // her yükselen kenarda say / count every rising edge
8}
9
10// Seçilen filtrenin frekansını Hz olarak döndürür / Returns the frequency of the selected filter in Hz
11uint32_t readHz(bool s2, bool s3) {
12 digitalWrite(S2, s2 ? HIGH : LOW);
13 digitalWrite(S3, s3 ? HIGH : LOW);
14 delay(5); // çıkış otursun / let the output settle
15 pulseCount = 0;
16 delay(50); // 50 ms boyunca say / count for 50 ms
17 return pulseCount * 20; // 50 ms x 20 = 1 saniye / 1 second
18}
19
20void setup() {
21 Serial.begin(115200);
22 pinMode(S0, OUTPUT);
23 pinMode(S1, OUTPUT);
24 pinMode(S2, OUTPUT);
25 pinMode(S3, OUTPUT);
26 pinMode(OUT_PIN, INPUT);
27 digitalWrite(S0, HIGH); // %20 ölçek / 20% scaling
28 digitalWrite(S1, LOW);
29 attachInterrupt(digitalPinToInterrupt(OUT_PIN), onPulse, RISING);
30}
31
32void loop() {
33 uint32_t r = readHz(false, false); // kırmızı / red
34 uint32_t g = readHz(true, true); // yeşil / green
35 uint32_t b = readHz(false, true); // mavi / blue
36 Serial.print("R: ");
37 Serial.print(r);
38 Serial.print(" Hz G: ");
39 Serial.print(g);
40 Serial.print(" Hz B: ");
41 Serial.print(b);
42 Serial.println(" Hz");
43 delay(300);
44}Raspberry Pi Pico və MicroPython ilə TCS3200
Pico-da Arduino-dakı pulseIn-in qarşılığı machine.time_pulse_us() funksiyasıdır: istənilən səviyyədəki impulsun müddətini mikrosaniyə ilə verir, zaman aşımında isə mənfi ədəd qaytarır. Pin artıq istənilən səviyyədə olarkən çağırılarsa ölçməyə dərhal başlayır və yarımçıq impuls ölçə bilər; buna görə kod əvvəlcə HIGH hissənin bitməsini gözləyir, sonra LOW müddətini ölçür. MicroPython-da hər funksiya çağırışı bir neçə mikrosaniyə çəkdiyi üçün burada 2% şkalanı (S0=0, S1=1) seçdik: impulslar 10 dəfə uzanır və bu gecikmənin təsiri azalır. Kalibrləmə dəyərləri Hz ilə yazılır; 2% şkalada ağ kağızda bir neçə kHz, qarada bir neçə yüz Hz görmək normaldır. Modulu Pico-nun 3V3(OUT) pinindən qidalandır; Pico-dan ilk dəfə istifadə edirsənsə, Raspberry Pi Pico nədir? yazısı MicroPython quraşdırılmasını izah edir.
1# Pico + TCS3200: süreden frekansa ve 0-255 seviyesine / Pico + TCS3200: from pulse width to frequency and a 0-255 level
2from machine import Pin, time_pulse_us
3import time
4
5s0 = Pin(2, Pin.OUT)
6s1 = Pin(3, Pin.OUT)
7s2 = Pin(4, Pin.OUT)
8s3 = Pin(5, Pin.OUT)
9out = Pin(6, Pin.IN)
10
11s0.value(0) # S0=0, S1=1: %2 ölçek / 2% scaling
12s1.value(1)
13
14FILTERS = {"R": (0, 0), "G": (1, 1), "B": (0, 1)} # S2, S3 değerleri / S2, S3 values
15WHITE_HZ = {"R": 3125, "G": 2500, "B": 2778} # beyaz kağıtta Hz / Hz on white paper
16BLACK_HZ = {"R": 357, "G": 294, "B": 333} # siyah kağıtta Hz / Hz on black paper
17
18def read_hz(channel, samples=10):
19 s2.value(FILTERS[channel][0])
20 s3.value(FILTERS[channel][1])
21 time.sleep_ms(5) # çıkış otursun / let the output settle
22 total = 0
23 count = 0
24 for _ in range(samples):
25 time_pulse_us(out, 1, 50000) # HIGH bitsin, LOW başında ol / wait for HIGH to end
26 t = time_pulse_us(out, 0, 50000) # LOW süresi, µs / LOW time, µs
27 if t > 0: # negatif = zaman aşımı / negative = timeout
28 total += t
29 count += 1
30 if count == 0:
31 return 0
32 return 1000000 / (2 * total / count) # f = 1 / (2t)
33
34def level(channel, hz):
35 v = (hz - BLACK_HZ[channel]) / (WHITE_HZ[channel] - BLACK_HZ[channel]) * 255
36 return max(0, min(255, int(v)))
37
38while True:
39 r = level("R", read_hz("R"))
40 g = level("G", read_hz("G"))
41 b = level("B", read_hz("B"))
42 print("R:", r, "G:", g, "B:", b)
43 time.sleep(0.5)TCS3200 yoxsa TCS34725?
TCS34725 eyni işi I2C üzərindən görən daha yeni rəng sensorudur. Ölçməni çipin içində aparır və nəticələri hər kanal üçün 16 bitlik ədədlər kimi verir; Arduino-nun impuls ölçməsi lazım deyil. Ən vacib fərqi fotodiodlarının üstündə infraqırmızı (IR) bloklayıcı filtr olmasıdır. TCS3200-də bu filtr yoxdur; silisium fotodiodlar infraqırmızıya da həssas olduğu üçün günəş işığı və ya közərmə lampası kimi IR-i çox olan mühitlərdə ölçmələr sürüşür. TCS34725-in qazancı (1x, 4x, 16x, 60x) və inteqrasiya müddəti (2,4–614 ms) proqramla tənzimlənə bildiyi üçün çox zəif işıqdan parlaq işığa qədər geniş diapazonda işləyir. I2C-nin necə işlədiyi maraqlandırırsa, I2C nədir? yazısına baxa bilərsən.

| Xüsusiyyət | TCS3200 | TCS34725 |
|---|---|---|
| Çıxış | Tezlik (kvadrat dalğa) | I2C, ünvan 0x29 |
| Siqnal naqilləri | S0–S3, OUT və OE | SDA və SCL (istəyə görə INT və LED) |
| Dəqiqlik | Ölçmə üsulundan və müddətindən asılıdır | Hər kanal üçün 16 bit |
| IR filtri | Yoxdur | Var (çipin üzərində) |
| Ayarlar | 3 tezlik şkalası və qidanın kəsilməsi | 4 qazanc, 2,4–614 ms inteqrasiya müddəti |
| Qida | 2,7–5,5 V | Çip 3,3 V; stabilizatorlu modullar 3–5 V |
| İşıqlandırma | Adətən 4 ağ LED | Adətən 1 ağ LED |
| Prosessor yükü | İmpuls ölçərkən məşğuldur | Çip ölçür, Arduino yalnız oxuyur |
| Kimə uyğundur? | Öyrənmə, sadə rəng ayırıcılar | Dəqiq rəng, rəng temperaturu və lüks ölçməsi |
1// TCS34725 ile ham RGBC, renk sıcaklığı ve lüks / Raw RGBC, color temperature and lux with the TCS34725
2#include <Wire.h>
3#include <Adafruit_TCS34725.h>
4
5// 50 ms entegrasyon süresi, 4x kazanç / 50 ms integration time, 4x gain
6Adafruit_TCS34725 tcs = Adafruit_TCS34725(TCS34725_INTEGRATIONTIME_50MS, TCS34725_GAIN_4X);
7
8void setup() {
9 Serial.begin(9600);
10 if (!tcs.begin()) { // 0x29 adresinde ara / look for it at 0x29
11 Serial.println("TCS34725 bulunamadi / not found");
12 while (true) {
13 delay(1000);
14 }
15 }
16}
17
18void loop() {
19 uint16_t r, g, b, c;
20 tcs.getRawData(&r, &g, &b, &c); // 16 bit ham değerler / 16-bit raw values
21 uint16_t kelvin = tcs.calculateColorTemperature_dn40(r, g, b, c);
22 uint16_t lux = tcs.calculateLux(r, g, b);
23 Serial.print("R: ");
24 Serial.print(r);
25 Serial.print(" G: ");
26 Serial.print(g);
27 Serial.print(" B: ");
28 Serial.print(b);
29 Serial.print(" C: ");
30 Serial.print(c);
31 Serial.print(" K: ");
32 Serial.print(kelvin);
33 Serial.print(" Lux: ");
34 Serial.println(lux);
35 delay(500);
36}Kodu yükləməzdən əvvəl Library Manager-dən Adafruit TCS34725 kitabxanasını quraşdır; asılılıqları soruşanda hamısını quraşdırmağı seç. Arduino Uno-da SDA-nı A4-ə, SCL-i A5-ə, ESP32-də isə GPIO 21 və 22-yə qoşursan. getRawData() inteqrasiya müddəti qədər gözləyib xam qırmızı, yaşıl, mavi və filtrsiz (C) dəyərləri qaytarır; calculateColorTemperature_dn40() rəng temperaturunu kelvinlə, calculateLux() isə təqribi işıqlanma səviyyəsini verir. Kalibrləmə və ən yaxın rəng məntiqi bu sensorda da eynilə keçərlidir. Rənglə yanaşı əl hərəkətlərini və yaxınlığı da aşkarlayan sensor istəyirsənsə, APDS-9960 yaxşı alternativdir.
TCS3200 ilə layihə ideyaları
- Rəng ayıran maşın: Şirniyyat, muncuq və ya LEGO hissələrini rənginə görə ayrı qutulara ayır.
- Rəng kopyalayan lampa: Sensorun qarşısına tutduğun obyektin rəngini RGB LED və ya WS2812B lent ilə yenidən yarat.
- Rəng oxuyan robot: Xətti izləyən robotuna yerdəki qırmızı işarədə dayanmağı, yaşılda yoluna davam etməyi öyrət.
- Rəng tanıyan robot qol: Robot qolla kubları götürüb hər rəngi öz qutusuna burax.
- Rəngi səsli deyən cihaz: Oxunan rəngi DFPlayer Mini ilə əvvəlcədən yazılmış səslə de; görmə qüsurlu insanlar üçün faydalı köməkçi olur.
- Su rənginin izlənməsi: Şəffaf qabdakı suyun rənginin zamanla dəyişməsini izləyib akvarium və ya suvarma çəni üçün xəbərdarlıq ver.
Tez-tez edilən xətalar və həlləri
| Əlamət | Ehtimal olunan səbəb | Həll |
|---|---|---|
| pulseIn həmişə 0 və ya zaman aşımı dəyərini qaytarır | OE boşdur və ya HIGH-dır, S0 və S1 ikisi də LOW-dur (qida kəsilib) və ya OUT yanlış pindədir | OE-ni GND-yə qoş, S0-ı HIGH, S1-i LOW et, OUT pinini kodla müqayisə et |
| Dəyərlər daim hoppanır | Otaq işığı, titrəyən lampa və ya dəyişən məsafə | Sensoru qara boru ilə bağla, məsafəni sabitlə, bir neçə ölçmənin ortasını götür |
| Hər obyekt eyni rəng çıxır | Kalibrləmə aparılmayıb; kanalların həssaslığı fərqlidir | Ağ-qara kalibrləmə apar, referansları yenidən ölç |
| Gün işığında rənglər sürüşür | TCS3200-də IR filtri yoxdur | Ölçməni qapalı qutuda apar və ya TCS34725 istifadə et |
| Səviyyələr həmişə 0-a və ya 255-ə yapışır | Obyekt kalibrləmədəkindən fərqli məsafədədir | Məsafəni kalibrləmədəki ilə eyni saxla, lazım olsa yenidən kalibrlə |
| ESP32 və ya Pico qəribə davranır | Modul 5 V ilə qidalandırılıb, OUT 5 V verir | Modulu 3V3-dən qidalandır və ya səviyyə çeviricisi istifadə et |
| Servo fırlananda ölçmələr pozulur | Servo cərəyanı qida gərginliyini aşağı salır | Servolar üçün ayrı 5 V mənbə istifadə et, GND-ləri birləşdir |
TCS3200 işığın tezliyə necə çevrildiyini, kalibrləmənin niyə lazım olduğunu və sadə təsnifat alqoritminin necə qurulduğunu öyrənmək üçün əla sensordur. Daha dəqiq ölçmə lazım olanda TCS34725-ə keçmək də asandır, çünki öyrəndiyin kalibrləmə və ən yaxın rəng məntiqi eynilə keçərlidir. BlueGrays tətbiqində RGB LED ilə rəng qarışdırma, ESP32 rəng mikser lampası, LDR ilə işıq ölçmə və servo mühərrik layihələrini dövrə sxemləri və addım-addım kodları ilə tapa, rəng sensorunu bu layihələrlə birləşdirərək öz maşınını qura bilərsən.
Tez-tez verilən suallar
TCS3200 rəng sensoru neçə sm məsafədən oxuyur?
Ən sabit nəticələr təxminən 1–3 sm məsafədə alınır, çünki moduldakı LED-lərin işığı uzaqlaşdıqca sürətlə zəifləyir. Məsafədən daha vacibi onu hər ölçmədə eyni saxlamaqdır; kalibrləməni də eyni məsafədə aparmalısan. Uzaqdakı böyük səthlərin rəngini oxumaq üçün bu sensor uyğun deyil.
TCS230 ilə TCS3200 arasındakı fərq nədir?
TCS230 eyni istehsalçının daha köhnə rəng sensorudur; TCS3200 onun təkmilləşdirilmiş versiyasıdır. İkisi də 8×8 fotodiod massivi, tezlik çıxışı və eyni S0–S3 idarəetmə məntiqindən istifadə edir, buna görə qoşulma və kodlar ortaqdır. Bu gün satılan modulların böyük əksəriyyətində TCS3200 olur.
TCS3200 ilə pulseIn niyə 0 qaytarır?
pulseIn verilən zaman aşımı daxilində impuls görə bilməsə, 0 qaytarır. Ən çox rast gəlinən səbəblər OE pininin GND-yə qoşulmaması, S0 və S1-in ikisinin də LOW qalması (sensor qidanın kəsilməsi rejiminə keçir) və OUT-un koddakından fərqli pinə qoşulmasıdır. Sensorun qarşısı tam qaranlıqdırsa, tezlik bir neçə herts-ə düşür və qısa zaman aşımında impuls tutula bilmir.
TCS3200 ESP32 və Raspberry Pi Pico ilə işləyirmi?
Bəli. TCS3200 2,7–5,5 V arasında işlədiyi üçün modulu platanın 3V3 pinindən qidalandıra bilərsən; beləliklə OUT pini də 3,3 V səviyyəsində impuls verir. Modulu 5 V ilə qidalandırsan, OUT xəttinə gərginlik bölücü və ya səviyyə çeviricisi qoymalısan. Pico-da MicroPython ilə ölçmə aparanda 2% tezlik şkalası daha dəqiq nəticə verir.
TCS3200 yoxsa TCS34725 daha yaxşıdır?
Dəqiq rəng ölçməsi üçün TCS34725 daha yaxşıdır: IR bloklayıcı filtri, hər kanal üçün 16 bitlik dəqiqliyi və tənzimlənən qazancı var, üstəlik yalnız iki I2C naqili ilə qoşulur. TCS3200 isə tezlik ölçməsini və kalibrləməni öyrənmək və sadə rəng ayırıcılar hazırlamaq üçün kifayət edən və geniş yayılmış seçimdir.
TCS3200 neçə fərqli rəngi ayırd edə bilər?
Nəzarət olunan işıqda və sabit məsafədə TCS3200 qırmızı, narıncı, sarı, yaşıl, mavi, bənövşəyi, qara və ağ kimi bir-birindən nəzərəçarpacaq dərəcədə fərqli 6–8 rəngi etibarlı şəkildə ayırır. Açıq və tünd yaşıl kimi yaxın tonları ayırmaq da mümkündür, amma daha diqqətli kalibrləmə, hər ton üçün çoxlu referans ölçmələri və sıx hədd tələb edir.
Bu yazıdan sonra edə biləcəyin layihələr
Bütün layihələrə bax
LDR ilə işıq intensivliyinin oxunması
Otağın nə qədər işıqlı olduğunu rəqəmlə görmək istəyirsən? İşığa həssas kiçik hissə olan LDR ətraf işığı ölçür, Arduino isə bu dəyəri yarım saniyədən bir kompüter ekranına yazır.

ESP32 LDR modulu ilə işıq şiddətinin oxunması
LDR modulunun xam ADC dəyərini və qaranlıq/işıqlı istinadlara görə hesablanan nisbi işıq faizini Serial Monitor-da real vaxtda izləmək. Bu faiz lux ölçməsi deyil. Modulun kalibrləmə məntiqini öyrədir. 10-cu layihədən əvvəl etmək idealdır; çünki hədd dəyərini müəyyən etmək üçün istifadə olunur.

RGB LED-dən istifadə
Tək LED-in içində üç rəng gizlənib: RGB LED əvvəl qırmızı, sonra yaşıl, sonra göy yanır; hər rəng yarım saniyə yanıb yarım saniyə sönür və sıra yenidən başlayır.

RGB LED ilə yumşaq rəng keçidi
Tək RGB LED qırmızıdan yaşıla, yaşıldan göyə, göydən yenidən qırmızıya yavaşca keçir və bu göy qurşağı dövrü heç dayanmır.

ESP32 rəng mikser lampası (3 potensiometr + RGB LED + OLED)
ESP32 ilə 3 potensiometri çevirərək istədiyin rəngi qarışdıran ağıllı rəng mikser lampası! Qırmızı, yaşıl və göy potensiometrləri çevirdikcə ortaq katodlu RGB LED dərhal rəngini dəyişir. SSD1306 OLED ekranda hər rəng üçün 0-255 arası dəyər, doldurma çubuqları və HEX veb rəng kodu (#FF8040 kimi) canlı göstərilir.

ESP32 RGB LED idarəsi
3 ayrı LED əvəzinə tək RGB LED ilə qeyri-məhdud rəng yaratmaq. Arduino-dakı kimi analogWrite() ilə R/G/B dəyərlərini tənzimləyərək göy qurşağı keçidi edirik. Rəng nəzəriyyəsi (red+green=yellow kimi) praktik olaraq görünür.

Servo mühərrikdən istifadə
Kiçik servo mühərrikin qolu ardıcıl üç vəziyyətə dönür: ən əvvələ, tam ortaya və ən sona, hər dayanacaqda iki saniyə gözləyərək.

TCRT5000 ilə qara-ağ zəmin aşkarlanması
Xətt izləyən robotların gözü olan kiçik bir sensorla zəminin qara, yoxsa ağ olduğunu müəyyən edirsən.
Digər yazılar
BlueGrays tətbiqi
Bu dövrəni telefonunda addım-addım qur
Dövrə sxemi, kod və hissə siyahısı bir ekranda. 500-dən çox Arduino, ESP32 və Pico layihəsi səni gözləyir.
Telefonunla skan et
Kameranı koda tut; telefonunun tətbiq mağazası açılır.
ya da mağazada aç

