TCS3200-kleurensensor met Arduino: aansluiten, kalibreren en code
Zo werkt de TCS3200-kleurensensor: S0–S3-instellingen, R, G en B uitlezen met pulseIn, kalibratie op wit en zwart, kleuren sorteren, code voor ESP32, Pico en TCS34725.
De TCS3200-kleurensensor is de meestgebruikte module voor kleurherkenning in Arduino-projecten: hij meet de kleur van het oppervlak voor de sensor door die op te splitsen in rode, groene en blauwe componenten. Het licht dat een array van fotodiodes opvangt, zet hij direct om in een frequentie: hoe meer rood licht een oppervlak weerkaatst, hoe hoger de frequentie op het rode kanaal. Er is geen analoge meting of speciaal communicatieprotocol nodig; je leest de R-, G- en B-waarden in een paar regels uit met het Arduino-commando pulseIn(). Snoepsorteermachines, robots die kleuren herkennen, voertuigen die van richting veranderen bij gekleurde markeringen op de vloer en lampen die de kleur kopiëren van een voorwerp dat je ervoor houdt: ze zijn allemaal met deze sensor te bouwen.
In deze gids zie je stap voor stap wat er in de sensor zit, wat de S0–S3-pins doen, hoe je hem aansluit op een Arduino Uno, ESP32 en Raspberry Pi Pico, hoe je ruwe waarden uitleest, hoe je een kalibratie op wit en zwart uitvoert en welk algoritme bepaalt bij welke kleur een meting hoort. Daarna bouwen we de logica van een machine die voorwerpen op kleur sorteert en vergelijken we de sensor tot slot met de TCS34725, een sensor die via I2C werkt.

Wat is de TCS3200-kleurensensor en hoe werkt hij?
De TCS3200-chip in het hart van de module (de oudere versie heet TCS230) heeft op zijn oppervlak 64 fotodiodes in een raster van 8×8. Zestien ervan zitten onder rode filters, 16 onder groene, 16 onder blauwe en de overige 16 hebben geen filter (clear) en zien de totale hoeveelheid licht. De 16 fotodiodes van elke kleur zijn parallel geschakeld en de pins S2 en S3 kiezen welke groep wordt gemeten. Omdat de fotodiodes van verschillende kleuren door elkaar over de array liggen, beïnvloedt licht dat op één hoek van het oppervlak valt alle kleurgroepen even sterk.
De kleine stroom die de gekozen fotodiodegroep levert, gaat naar een stroom-naar-frequentieomzetter in de chip. Dit circuit maakt een blokgolf met een duty cycle van 50% en de frequentie van die golf is recht evenredig met de lichtintensiteit. Wat je meet is dus geen spanning, maar het aantal pulsen per seconde: een paar hertz in volledige duisternis, tientallen kilohertz vlak bij een wit oppervlak. Het mooie van een frequentie-uitgang is dat hij goed bestand is tegen ruis en op elke digitale pin van de Arduino kan worden aangesloten. Wil je alleen weten hoe sterk het licht is, dan is een LDR-lichtsensor een eenvoudigere optie; de TCS3200 doet hetzelfde werk apart voor drie kleuren.
| Eigenschap | Waarde |
|---|---|
| Chip | TCS3200 (oudere versie TCS230, pincompatibel) |
| Fotodiode-array | 8×8 = 64: 16 rood, 16 groen, 16 blauw, 16 clear |
| Uitgang | Blokgolf met 50% duty cycle, frequentie evenredig met het licht |
| Maximale frequentie (typisch) | 600 kHz (100%), 120 kHz (20%), 12 kHz (2%) |
| Voedingsspanning | 2,7–5,5 V |
| Chipstroom | 1,4 mA typisch (de stroom van de module-leds komt daar nog bij) |
| Stuurpins | S0, S1 (frequentieschaling), S2, S3 (kleurfilter), OE (uitgang inschakelen, actief LOW) |
| Aanbevolen afstand | Ongeveer 1–3 cm, bij elke meting hetzelfde |
| Verlichting | 4 witte leds op de module |
S0–S3-pins: frequentieschaling en kleurfilterkeuze
Vier stuurpins bepalen hoe de TCS3200 zich gedraagt. S0 en S1 schalen de uitgangsfrequentie omlaag: bij 100% worden de pulsen maar een paar microseconden lang en komt de meetnauwkeurigheid van de Arduino Uno aan zijn grens, terwijl de pulsen bij 2% langer zijn maar er minder van binnenkomen in dezelfde tijd. S2 en S3 kiezen welk kleurfilter wordt uitgelezen. Je sluit deze pins aan op digitale uitgangen van de Arduino en stelt ze vóór elke meting in vanuit de code.
| S0 | S1 | Schaling van de uitgangsfrequentie | Wanneer gebruik je het |
|---|---|---|---|
| LOW | LOW | Power down | Om de sensor in batterijprojecten te laten slapen |
| LOW | HIGH | 2% (typisch tot 12 kHz) | Trage processors, MicroPython en tellen met interrupts |
| HIGH | LOW | 20% (typisch tot 120 kHz) | De beste instelling voor Arduino en pulseIn |
| HIGH | HIGH | 100% (typisch tot 600 kHz) | Snelle metingen met een hardwareteller |
| S2 | S3 | Uitgelezen fotodiodegroep |
|---|---|---|
| LOW | LOW | Rood filter |
| LOW | HIGH | Blauw filter |
| HIGH | LOW | Geen filter (clear, totaal licht) |
| HIGH | HIGH | Groen filter |
TCS3200 aansluiten: Arduino Uno, ESP32 en Pico
| Modulepin | 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 |
De vier witte leds op de module verlichten het oppervlak bij elke meting op dezelfde manier, zodat de resultaten consistenter blijven, ook als de verlichting in de kamer verandert. Sommige boards hebben een aparte LED-pin om de leds aan en uit te zetten, bij andere gaan de leds branden zodra er spanning op staat; kijk naar de opdruk op jouw eigen board. Voor de beste resultaten wikkel je de sensor in een zwarte buis of karton, breng je het voorwerp steeds op dezelfde afstand en vermijd je glimmende, reflecterende oppervlakken. De pinindeling van je board vind je in de Pinout-tool.
Stap voor stap: R, G en B uitlezen met pulseIn
- Sluit de module aan zoals in de tabel hierboven; verbind OE met GND en VCC met 5V.
- Kies 20% frequentieschaling door S0 HIGH en S1 LOW te zetten.
- Zet voor rood S2 en S3 LOW en wacht een paar milliseconden tot de uitgang is gestabiliseerd.
- Meet de lengte van het LOW-deel van de puls in microseconden met pulseIn(OUT, LOW); neem het gemiddelde van 10 metingen om ruis te verminderen.
- Herhaal hetzelfde voor groen (S2 HIGH, S3 HIGH) en blauw (S2 LOW, S3 HIGH).
- Bekijk de resultaten in de Serial Monitor op 9600 baud en houd vellen papier in verschillende kleuren voor de sensor.
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}Het belangrijkste punt in deze code is dat het getal dat je uitleest omgekeerd evenredig is met het licht: hoe kleiner de waarde, hoe meer licht er van die kleur komt. Houd je een rood vel voor de sensor, dan zie je uitvoer als "R: 24 G: 68 B: 52"; het kleinste getal staat op het rode kanaal. De time-out van 50.000 µs die je aan pulseIn meegeeft, voorkomt dat de code de standaardwachttijd van 1 seconde afwacht als er geen puls binnenkomt; wordt er helemaal geen puls opgevangen, dan geeft de functie 50.000 terug, wat "heel donker" betekent. Als je de seriële uitvoer lastig kunt lezen, bekijk dan de gids over de Arduino Serial Monitor.
Kalibratie op wit en zwart: ruwe waarden omzetten naar 0–255
Ruwe waarden zijn op zichzelf misleidend, want de drie fotodiodegroepen zijn niet even gevoelig en de witte leds van de module stralen niet elke kleur even sterk uit. Daarom geeft zelfs een volkomen wit vel op de drie kanalen verschillende getallen. Kalibratie haalt deze verschillen weg en plaatst elk kanaal tussen 0 (zwart) en 255 (wit); het is hetzelfde idee als de witbalans van een camera. Kalibreer op de plek waar de sensor echt gaat werken, onder hetzelfde licht en op dezelfde afstand; een kalibratie op je bureau houdt geen stand in de behuizing van de machine.
- Monteer de sensor in een vaste houder en stel de meetafstand in (bijvoorbeeld 1,5 cm) zodat die niet verandert.
- Houd een effen wit vel voor de sensor, lees de R-, G- en B-waarden meerdere keren uit met de code hierboven en noteer de gemiddelden als witreferentie; dit zijn de kleinste waarden.
- Leg een mat zwart vel of vilt op dezelfde plek en noteer de metingen als zwartreferentie; dit zijn de grootste waarden.
- Vul deze zes getallen in bij de constanten WHITE_ en BLACK_ bovenaan de onderstaande code en upload de code.
- Controleer of alle drie de kanalen op wit papier dicht bij 255 uitkomen en op zwart dicht bij 0; zo niet, herhaal dan de meting met hetzelfde licht en dezelfde afstand.
Let op een fout die in veel voorbeelden voorkomt: de pulsbreedte rechtstreeks met map() omzetten naar 0–255 geeft niet het juiste resultaat, omdat licht evenredig is met de frequentie en niet met de pulsbreedte. De juiste manier is om de breedte eerst om te rekenen naar frequentie (1/t) en die dan te schalen: niveau = (f − f_zwart) / (f_wit − f_zwart) × 255. Een voorbeeld: je mat 20 µs op wit, 200 µs op zwart en het voorwerp gaf 40 µs. map() maakt hier 226 van, terwijl de frequentiemethode 113 geeft. De frequentie van het voorwerp is precies de helft van die van wit en na aftrek van het zwartniveau komt dat overeen met ongeveer 44% van de schaal, ofwel 113; map() toont kleuren daarentegen veel lichter dan ze zijn en maakt het lastiger om donkere tinten uit elkaar te houden.
Kleursorteeralgoritme: welke kleur is deze meting?
De gekalibreerde R-, G-, B-waarden hangen nog steeds af van de hoeveelheid licht: als hetzelfde rode voorwerp iets dichter bij de sensor komt, stijgen alle drie de waarden samen. Om dat op te lossen delen we elke waarde door het totaal: r = R / (R + G + B), en hetzelfde voor g en b. Deze kleurverhoudingen blijven vrijwel constant, ook als afstand en helderheid een beetje veranderen. Daarna vergelijk je ze met referentieverhoudingen die je voor elke kleur één keer hebt gemeten en opgeslagen, en kies je de dichtstbijzijnde buur. Voor de vergelijking volstaat het om de kwadraten van de verschillen tussen de verhoudingen op te tellen; hoe kleiner dit getal, hoe meer de kleuren op elkaar lijken. Ligt zelfs de dichtstbijzijnde referentie verder weg dan een bepaalde drempel, dan is het resultaat "onbekend". Is het totale licht heel laag, dan wordt het voorwerp als zwart behandeld, en zijn alle drie de kanalen heel hoog, dan als wit; deze twee gevallen zijn met verhoudingen niet te onderscheiden, dus worden ze eerst gecontroleerd.
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}| Codedeel | Wat het doet |
|---|---|
| WHITE_* and BLACK_* | De pulsbreedtes voor wit en zwart die je tijdens de kalibratie hebt gemeten (µs) |
| toLevel() | Zet de pulsbreedte om naar frequentie en schaalt die naar 0–255 |
| refs[] | Referentieverhoudingen r, g, b voor elke kleur; vervang ze door je eigen metingen |
| classify() | Scheidt eerst zwart en wit en zoekt dan de dichtstbijzijnde referentie |
| MAX_DIST | Metingen die verder weg liggen dan deze afstand tellen als "Onbekend" |
Een machine bouwen die voorwerpen op kleur sorteert
Het populairste TCS3200-project is een machine die gekleurd snoep, kralen of LEGO-stukjes op kleur sorteert. Het mechanisme bestaat uit twee servo's. De bovenste aanvoerservo draait een schijf met een gat dat precies één voorwerp past: eerst pakt hij een voorwerp onder de trechterbuis vandaan, brengt het voor de sensor en laat het na de meting in de goot eronder vallen. De onderste goot-servo draait een schuine goot om het voorwerp naar de bak van zijn kleur te sturen. Gebruik je voor het eerst servo's, lees dan eerst Wat is een servomotor?
- Bouw de trechter en een buis die iets breder is dan de voorwerpen, zodat ze één voor één op de aanvoerschijf vallen.
- Monteer de sensor zo dat hij het voorwerp op de schijf van 1–2 cm afstand ziet, en sluit hem af zodat er geen buitenlicht bij kan.
- Kies drie hoeken voor de aanvoerservo: laden, sensor en afgeven. Zoek ze al proberend uit op je eigen mechanisme; sluit de aanvoerservo aan op D9 en de goot-servo op D10.
- Wijs voor de goot-servo aan elke kleurbak een hoek toe (bijvoorbeeld rood 30°, groen 75°, blauw 120°, al het andere 165°).
- Kalibreer in de machine, met de eigen verlichting van de machine, en test met meerdere voorwerpen van elke kleur.
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}TCS3200 met ESP32: frequentie meten met een interrupt
Dezelfde pulseIn-code draait op de ESP32, maar er is een stabielere methode: tel in plaats van de pulsen één voor één te timen hoeveel pulsen er in een vaste tijd binnenkomen. Een interrupt verhoogt bij elke stijgende flank een teller; vermenigvuldig de teller na 50 ms met 20 en je hebt de frequentie in hertz. Omdat deze methode honderden pulsen middelt, heeft één slechte puls geen invloed. De processor van de ESP32 op 240 MHz verwerkt bij 20% schaling moeiteloos tienduizenden interrupts per seconde; wordt de teller bij heel fel licht te groot, dan kun je de schaling terugbrengen naar 2%. Dezelfde methode werkt ook op de Arduino Uno als je OUT naar D2 verplaatst, dat interrupts ondersteunt. Vergeet op de ESP32 niet de module via de 3V3-pin te voeden.
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}TCS3200 met Raspberry Pi Pico en MicroPython
Op de Pico is het equivalent van pulseIn van Arduino de functie machine.time_pulse_us(): die geeft de lengte van een puls op het gevraagde niveau terug in microseconden en een negatief getal bij een time-out. Wordt hij aangeroepen terwijl de pin al op dat niveau staat, dan begint hij meteen te timen en kan hij een halve puls meten; daarom wacht de code eerst tot het HIGH-deel voorbij is en meet daarna de LOW-tijd. Omdat elke functieaanroep in MicroPython een paar microseconden kost, kozen we hier voor 2% schaling (S0=0, S1=1): de pulsen worden 10 keer zo lang en het effect van die vertraging wordt kleiner. De kalibratiewaarden staan in Hz; bij 2% schaling is het normaal om op wit papier een paar kHz te zien en op zwart een paar honderd Hz. Voed de module via de 3V3(OUT)-pin van de Pico; ben je nieuw met de Pico, dan legt Wat is de Raspberry Pi Pico? uit hoe je MicroPython installeert.
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 of TCS34725?
De TCS34725 is een nieuwere kleurensensor die hetzelfde werk doet via I2C. Hij voert de meting in de chip uit en geeft de resultaten als 16-bits-getallen per kanaal terug, zodat de Arduino geen pulsen hoeft te timen. Het belangrijkste verschil is het infrarood-(IR-)blokkeerfilter boven de fotodiodes. De TCS3200 heeft zo'n filter niet; omdat siliciumfotodiodes ook gevoelig zijn voor infrarood, drijven de metingen weg in licht dat rijk is aan IR, zoals zonlicht of gloeilampen. Omdat de versterking (1x, 4x, 16x, 60x) en de integratietijd (2,4–614 ms) van de TCS34725 in software zijn in te stellen, werkt hij in een breed bereik, van heel zwak tot fel licht. Ben je benieuwd hoe I2C werkt, lees dan het artikel Wat is I2C?

| Eigenschap | TCS3200 | TCS34725 |
|---|---|---|
| Uitgang | Frequentie (blokgolf) | I2C, adres 0x29 |
| Signaaldraden | S0–S3, OUT en OE | SDA en SCL (optioneel INT en LED) |
| Resolutie | Hangt af van meetmethode en meettijd | 16 bits per kanaal |
| IR-filter | Nee | Ja (op de chip) |
| Instellingen | 3 frequentieschalen en power down | 4 versterkingen, integratietijd 2,4–614 ms |
| Voeding | 2,7–5,5 V | Chip 3,3 V; modules met regelaar 3–5 V |
| Verlichting | Meestal 4 witte leds | Meestal 1 witte led |
| Processorbelasting | Bezig tijdens het timen van pulsen | De chip meet, de Arduino leest alleen uit |
| Het best voor | Leren, eenvoudige kleursorteerders | Nauwkeurige kleur-, kleurtemperatuur- en luxmetingen |
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}Installeer vóór het uploaden van de code de bibliotheek Adafruit TCS34725 via de Library Manager; kies bij de vraag over afhankelijkheden om ze allemaal te installeren. Verbind op de Arduino Uno SDA met A4 en SCL met A5; gebruik op de ESP32 GPIO 21 en 22. getRawData() wacht op de integratietijd en geeft de ruwe waarden voor rood, groen, blauw en clear (C) terug; calculateColorTemperature_dn40() geeft de kleurtemperatuur in kelvin en calculateLux() een bij benadering bepaald lichtniveau. De kalibratie en de logica voor de dichtstbijzijnde kleur gelden net zo goed voor deze sensor. Wil je een sensor die naast kleur ook handgebaren en nabijheid herkent, dan is de APDS-9960 een goed alternatief.
Projectideeën met de TCS3200
- Kleursorteermachine: Sorteer snoep, kralen of LEGO-stukjes op kleur in aparte bakken.
- Kleurkopieerlamp: Maak de kleur na van het voorwerp dat je voor de sensor houdt met een RGB-led of een WS2812B-strip.
- Kleurlezende robot: Leer je lijnvolgrobot te stoppen bij een rode markering op de vloer en door te rijden bij een groene.
- Robotarm die kleuren herkent: Gebruik een robotarm om blokjes op te pakken en elke kleur in een eigen bak te laten vallen.
- Pratende kleurdetector: Kondig de herkende kleur aan met een vooraf opgenomen geluid op een DFPlayer Mini; het is een handig hulpmiddel voor slechtziende mensen.
- Watertintmonitor: Volg veranderingen in de kleur van water in een doorzichtige bak in de tijd en geef een melding voor een aquarium of een irrigatietank.
Veelgemaakte fouten en hoe je ze oplost
| Symptoom | Waarschijnlijke oorzaak | Oplossing |
|---|---|---|
| pulseIn geeft altijd 0 of de time-outwaarde terug | OE zweeft of is HIGH, S0 en S1 beide LOW (power down) of OUT op de verkeerde pin | Verbind OE met GND, zet S0 HIGH en S1 LOW, vergelijk de OUT-pin met de code |
| Waarden blijven springen | Kamerlicht, een flikkerende lamp of een veranderende afstand | Schermaf de sensor met een zwarte buis, leg de afstand vast, neem het gemiddelde van meerdere metingen |
| Elk voorwerp geeft dezelfde kleur | Geen kalibratie; de kanalen hebben verschillende gevoeligheden | Voer een kalibratie op wit en zwart uit, meet de referenties opnieuw |
| Kleuren drijven weg in daglicht | De TCS3200 heeft geen IR-filter | Meet in een gesloten doos of gebruik een TCS34725 |
| Niveaus blijven steken op 0 of 255 | Het voorwerp staat op een andere afstand dan tijdens de kalibratie | Houd dezelfde afstand aan als tijdens de kalibratie, kalibreer zo nodig opnieuw |
| ESP32 of Pico gedraagt zich vreemd | Module gevoed met 5 V, OUT geeft 5 V af | Voed de module via 3V3 of gebruik een niveauconverter |
| Metingen gaan fout als de servo beweegt | De servostroom trekt de voedingsspanning omlaag | Gebruik een aparte voeding van 5 V voor de servo's en verbind de GND's |
De TCS3200 is een prima sensor om te leren hoe licht in frequentie verandert, waarom kalibratie ertoe doet en hoe je een eenvoudig classificatie-algoritme bouwt. Overstappen op de TCS34725 als je meer nauwkeurigheid nodig hebt, is ook eenvoudig, want de kalibratie en de logica voor de dichtstbijzijnde kleur die je hebt geleerd, blijven ongewijzigd bruikbaar. In de BlueGrays-app vind je projecten met RGB-ledkleurmenging, een ESP32-kleurmenglamp, LDR-lichtmeting en servomotoren, met schakelschema's en code stap voor stap; combineer de kleurensensor ermee om je eigen machine te bouwen.
Veelgestelde vragen
Op welke afstand kan de TCS3200-kleurensensor kleur herkennen?
De stabielste resultaten krijg je op ongeveer 1–3 cm, omdat het licht van de module-leds snel zwakker wordt met de afstand. Belangrijker dan de afstand zelf is dat je hem bij elke meting hetzelfde houdt, en ook op die afstand moet je kalibreren. Deze sensor is niet geschikt om de kleur van grote oppervlakken op afstand te lezen.
Wat is het verschil tussen de TCS230 en de TCS3200?
De TCS230 is de oudere kleurensensor van dezelfde fabrikant en de TCS3200 is de verbeterde versie. Beide gebruiken een fotodiode-array van 8×8, een frequentie-uitgang en dezelfde S0–S3-stuurlogica, dus de bedrading en de code zijn hetzelfde. De meeste modules die nu verkocht worden, hebben de TCS3200.
Waarom geeft pulseIn 0 terug met de TCS3200?
pulseIn geeft 0 terug als er binnen de opgegeven time-out geen puls te zien is. De meest voorkomende oorzaken zijn dat de OE-pin niet met GND is verbonden, dat S0 en S1 allebei LOW zijn gelaten (waardoor de sensor in power-downmodus komt) en dat OUT op een andere pin is aangesloten dan in de code. Is het gebied voor de sensor volledig donker, dan zakt de frequentie naar een paar hertz en wordt er binnen een korte time-out geen puls opgevangen.
Werkt de TCS3200 met de ESP32 en de Raspberry Pi Pico?
Ja. Omdat de TCS3200 werkt op 2,7–5,5 V, kun je de module voeden via de 3V3-pin van het board, zodat de OUT-pin ook pulsen van 3,3 V geeft. Voed je de module met 5 V, dan heb je een spanningsdeler of een niveauconverter op de OUT-lijn nodig. Bij meten met MicroPython op de Pico geeft 2% frequentieschaling nauwkeurigere resultaten.
Wat is beter, de TCS3200 of de TCS34725?
Voor nauwkeurige kleurmeting is de TCS34725 beter: hij heeft een IR-blokkeerfilter, een resolutie van 16 bits per kanaal en instelbare versterking, en hij sluit je aan met slechts twee I2C-draden. De TCS3200 is een gangbare en prima keuze om frequentiemeting en kalibratie te leren en om eenvoudige kleursorteerders te bouwen.
Hoeveel kleuren kan de TCS3200 onderscheiden?
Bij gecontroleerde verlichting en een vaste afstand scheidt de TCS3200 betrouwbaar 6–8 duidelijk verschillende kleuren, zoals rood, oranje, geel, groen, blauw, paars, zwart en wit. Ook dicht bij elkaar liggende tinten, zoals licht- en donkergroen, zijn te onderscheiden, maar dat vraagt nauwkeuriger kalibratie, veel referentiemetingen per tint en een krappe drempel.
Projecten om hierna te bouwen
Alle projecten bekijken
Lichtsterkte meten met een LDR
Wil je zien hoe licht je kamer is, als getal? De LDR, een klein onderdeel dat op licht reageert, meet het licht om je heen en de Arduino schrijft de waarde elke halve seconde naar je computerscherm.

Lichtsterkte meten met de ESP32 en een LDR-module
Volg in de Serial Monitor in realtime de ruwe ADC-waarde van de LDR-module en het relatieve lichtpercentage, berekend uit referentiewaarden voor donker en licht. Dit percentage is geen luxmeting. Je leert hoe de module gekalibreerd wordt. Ideaal om vóór Project 10 te doen, want je gebruikt het om de drempelwaarde te bepalen.

Een RGB-led gebruiken
In één enkele led zitten drie kleuren verstopt: de RGB-led licht eerst rood op, dan groen, dan blauw, elke kleur een halve seconde aan en een halve seconde uit, waarna de cyclus opnieuw begint.

Vloeiende kleurovergang met een RGB-led
Een enkele RGB-led gaat langzaam van rood naar groen, van groen naar blauw en weer terug naar rood, en doorloopt zo zonder te stoppen de regenboog.

ESP32 kleurenmixlamp (3 potmeters + RGB-led + OLED)
Een slimme kleurenmixlamp: draai aan 3 potmeters op de ESP32 en mix elke kleur die je wilt! Terwijl je aan de rode, groene en blauwe potmeter draait, verandert de RGB-led met gemeenschappelijke kathode meteen van kleur. Het SSD1306 OLED-display toont per kanaal de waarde van 0-255, vulbalken en de HEX-webkleurcode (zoals #FF8040) live.

ESP32 RGB-led aansturen
Onbeperkt kleuren maken met één RGB-led in plaats van 3 aparte leds. Net als op Arduino stel je met analogWrite() de R/G/B-waarden in en maak je een regenboogovergang. Kleurtheorie (zoals red+green=yellow) zie je in de praktijk.

Een servomotor gebruiken
De arm van een kleine servomotor draait na elkaar naar drie standen: helemaal naar het begin, precies naar het midden en helemaal naar het einde, en wacht bij elke stop twee seconden.

Zwart-wit ondergrond herkennen met TCRT5000
Met de kleine sensor die de ogen van lijnvolgrobots vormt, merk je of de ondergrond zwart of wit is.
Meer artikelen
BlueGrays-app
Bouw deze schakeling stap voor stap op je telefoon
Schakelschema, code en onderdelenlijst op één scherm. Meer dan 500 Arduino-, ESP32- en Pico-projecten om te bouwen.
Scan met je telefoon
Richt je camera op de code en de appstore van je telefoon opent.
of open de store

