Hissələr · 10 dəq oxu

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 modulu
TCS3200 rəng sensoru modulu: ortada 8 ayaqlı TCS3200 çipi, dörd küncdə səthi işıqlandıran ağ LED-lər; bir tərəfdə S0, S1, OE, GND, digər tərəfdə VCC, OUT, S2, S3 pinləri.

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ətDəyər
ÇipTCS3200 (köhnə versiyası TCS230, pinlərə görə uyğundur)
Fotodiod massivi8×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ərginliyi2,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əriS0, S1 (tezlik şkalası), S2, S3 (rəng filtri), OE (çıxış aktivdir, aktiv LOW)
Tövsiyə olunan ölçmə məsafəsiTəxminən 1–3 sm, hər ölçmədə eyni
İşıqlandırmaModulda 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.

S0S1Çıxış tezliyi şkalasıNə vaxt istifadə olunur?
LOWLOWQidanın kəsilməsi (power-down)Batareyalı layihədə sensoru yatızdırmaq üçün
LOWHIGH2% (tipik olaraq maksimum 12 kHz)Yavaş prosessorlar, MicroPython və kəsmə ilə say
HIGHLOW20% (tipik olaraq maksimum 120 kHz)Arduino və pulseIn üçün ən uyğun ayar
HIGHHIGH100% (tipik olaraq maksimum 600 kHz)Aparat sayğaclı sürətli ölçmələr
S2S3Oxunan fotodiod qrupu
LOWLOWQırmızı filtrli
LOWHIGHMavi filtrli
HIGHLOWFiltrsiz (clear, ümumi işıq)
HIGHHIGHYaşıl filtrli
İmpuls müddəti ilə tezlik arasındakı əlaqə sadədir: doldurma əmsalı 50% olduğu üçün LOW hissənin müddəti periodun yarısıdır. f = 1 / (2 × t) düsturu ilə pulseIn-in verdiyi mikrosaniyəni tezliyə çevirə bilərsən. Məsələn, t = 25 µs olarsa, f = 1 / (2 × 0,000025 s) = 20 kHz edir. 20% şkalada, moduldakı LED-lər yanarkən 10 ilə 200 µs arasında dəyərlər görmək normaldır.

TCS3200 qoşulması: Arduino Uno, ESP32 və Pico

Modul piniArduino UnoESP32Raspberry Pi Pico
VCC5V3V33V3(OUT), pin 36
GNDGNDGNDGND
S0D4GPIO 32GP2
S1D5GPIO 33GP3
S2D6GPIO 25GP4
S3D7GPIO 26GP5
OUTD8GPIO 27GP6
OEGNDGNDGND
OE pinini boş qoyma. Bu pin aktiv LOW-dur; HIGH olarsa və ya boş qalarsa çıxış yüksək impedansa keçir və pulseIn daim 0 qaytarır. Bundan başqa, ESP32 və Pico-nun pinləri 3,3 V ilə işləyir: modulu 5 V ilə qidalandırsan, OUT pini 5 V-luq impulslar verir və platanın girişini yükləyir. Bu platalarda modulu 3V3-dən qidalandır və ya OUT xəttinə gərginlik bölücü yaxud səviyyə çeviricisi qoy.

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

  1. Modulu yuxarıdakı cədvəldəki kimi qoş; OE-ni GND-yə, VCC-ni 5V-a qoş.
  2. S0-ı HIGH, S1-i LOW edərək 20% tezlik şkalasını seç.
  3. Qırmızı üçün S2 və S3-ü LOW et və çıxışın oturuşması üçün bir neçə millisaniyə gözlə.
  4. 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.
  5. Eyni əməliyyatı yaşıl (S2 HIGH, S3 HIGH) və mavi (S2 LOW, S3 HIGH) üçün təkrarla.
  6. Nəticələri Serial Monitor-da 9600 baud ilə izlə və sensorun qarşısına fərqli rəngli kağızlar tut.
C++ (Arduino IDE)
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.

  1. 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ə.
  2. 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.
  3. 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.
  4. Bu altı ədədi aşağıdakı kodun əvvəlindəki WHITE_ və BLACK_ sabitlərinə yaz və kodu yüklə.
  5. 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.

C++ (Arduino IDE)
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əsiVə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_DISTBu məsafəni aşan ölçmələr "Naməlum" sayılır
Referans dəyərlərini təxmin etmə, ölç: hər rəngdən obyekti sensorun qarşısına 5–10 dəfə qoy, Serial Monitor-da yazılan r, g, b nisbətlərinin ortasını götür və refs[] massivinə yaz. Ölçmələri maşının işləyəcəyi işıqda və məsafədə apar. Oxumalar titrəyirsə, bir neçə ölçmənin ortasını götürmək və ya median filtr tətbiq etmək kömək edir; təfərrüatlar üçün sensor verilənlərinin filtrlənməsi yazısına baxa bilərsən.

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.

  1. 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.
  2. 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.
  3. 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ş.
  4. 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°).
  5. 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.
C++ (Arduino IDE)
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}
Servoları Arduino-nun 5V pinindən qidalandırmaq hərəkət anında gərginliyin düşməsinə və platanın yenidən başlamasına səbəb ola bilər; bu düşmə rəng ölçmələrini də pozur. İki servonu ayrı 5 V mənbədən qidalandır və mənbənin GND-sini Arduino-nun GND-si ilə birləşdir. Servo hərəkət edərkən ölçmə aparma; koddakı kimi servo yerinə oturandan sonra qısa gözləmə əlavə et.

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.

C++ (Arduino IDE)
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.

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

TCS34725 I2C rəng sensoru modulu
TCS34725 rəng sensoru modulu: ortada IR filtrli rəng sensoru çipi, yanında ağ LED; LED, INT, SDA, SCL, 3V3, GND və VIN pinləri.
XüsusiyyətTCS3200TCS34725
ÇıxışTezlik (kvadrat dalğa)I2C, ünvan 0x29
Siqnal naqilləriS0–S3, OUT və OESDA və SCL (istəyə görə INT və LED)
DəqiqlikÖlçmə üsulundan və müddətindən asılıdırHər kanal üçün 16 bit
IR filtriYoxdurVar (çipin üzərində)
Ayarlar3 tezlik şkalası və qidanın kəsilməsi4 qazanc, 2,4–614 ms inteqrasiya müddəti
Qida2,7–5,5 VÇip 3,3 V; stabilizatorlu modullar 3–5 V
İşıqlandırmaAdətən 4 ağ LEDAdə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ılarDəqiq rəng, rəng temperaturu və lüks ölçməsi
C++ (Arduino IDE)
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ətEhtimal olunan səbəbHəll
pulseIn həmişə 0 və ya zaman aşımı dəyərini qaytarırOE boşdur və ya HIGH-dır, S0 və S1 ikisi də LOW-dur (qida kəsilib) və ya OUT yanlış pindədirOE-ni GND-yə qoş, S0-ı HIGH, S1-i LOW et, OUT pinini kodla müqayisə et
Dəyərlər daim hoppanırOtaq 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ırKalibrləmə aparılmayıb; kanalların həssaslığı fərqlidirAğ-qara kalibrləmə apar, referansları yenidən ölç
Gün işığında rənglər sürüşürTCS3200-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ışırObyekt kalibrləmədəkindən fərqli məsafədədirMəsafəni kalibrləmədəki ilə eyni saxla, lazım olsa yenidən kalibrlə
ESP32 və ya Pico qəribə davranırModul 5 V ilə qidalandırılıb, OUT 5 V verirModulu 3V3-dən qidalandır və ya səviyyə çeviricisi istifadə et
Servo fırlananda ölçmələr pozulurServo cərəyanı qida gərginliyini aşağı salırServolar üçün ayrı 5 V mənbə istifadə et, GND-ləri birləşdir
Parlaq və əks etdirən səthlər (metal, cilalı plastik, parlaq kağız) LED işığını birbaşa sensora geri əks etdirir və rəngləri olduğundan solğun göstərir. Sensoru səthə tam dik deyil, yüngül bucaqla tutmaq və ya mat obyektlərlə işləmək bu problemi xeyli azaldır. Yalnız qara ilə ağı ayırmalısansa, TCRT5000 daha sadə və sürətli seçimdir.

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.

Bütün layihələrə bax
LDR ilə işıq intensivliyinin oxunması
AR-11Başlanğıc

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.

4.6(83)
143
ESP32 LDR modulu ilə işıq şiddətinin oxunması
ES-11Başlanğıc

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.

4.6(36)
55
RGB LED-dən istifadə
AR-39Başlanğıc
Premium

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.

4.9(73)
100
RGB LED ilə yumşaq rəng keçidi
AR-40Başlanğıc
Premium

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.

4.8(58)
78
ESP32 rəng mikser lampası (3 potensiometr + RGB LED + OLED)
ES-36Qabaqcıl
Premium

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.

4.7(6)
10
ESP32 RGB LED idarəsi
ES-9Başlanğıc

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.

4.6(29)
51
Servo mühərrikdən istifadə
AR-35Başlanğıc
Premium

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.

4.7(48)
67
TCRT5000 ilə qara-ağ zəmin aşkarlanması
AR-78Orta
Premium

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.

4.7(40)
49