TCRT5000 Arduino: Infrarot-Sensor anschließen, Code, Drehzahl

Der TCRT5000 ist ein kleiner Infrarot-Reflexsensor, mit dem man in Arduino-Projekten eine schwarze Linie auf dem Boden, eine Markierung auf einer drehenden Welle oder eine Oberfläche wenige Millimeter vor dem Sensor erkennt. Den TCRT5000 am Arduino zu nutzen ist ganz einfach: Du schließt das fertige Modul an 5V, GND und einen einzigen Signalpin an; eine Bibliothek brauchst du nicht, analogRead() oder digitalRead() genügen. Weil in einem einzigen Gehäuse sowohl eine Infrarot-LED steckt, die Licht aussendet, als auch ein Fototransistor, der das reflektierte Licht misst, ist er das gemeinsame Auge von Linienfolger-Robotern, Druckern mit Papiererkennung und Drehzahlmessern.

In diesem Artikel lernst du, wie IR-LED und Fototransistor im TCRT5000 zusammenarbeiten, warum er schwarze und weiße Flächen so leicht unterscheidet, worin sich der analoge (AO) und der digitale (DO) Ausgang des Moduls unterscheiden und wie du den Schwellwert mit dem Potentiometer und per Software einstellst. Außerdem siehst du Schritt für Schritt mit Code für Arduino Uno, ESP32 und Raspberry Pi Pico den Arbeitsabstand von 1–15 mm, den Einfluss des Umgebungslichts samt einer Messtechnik, die ihn beseitigt, den Unterschied zum Hindernissensor FC-51 und wie du mit dem TCRT5000 einen Drehzahlmesser (Tachometer) baust.

Was ist der TCRT5000 und wie funktioniert er?

Der TCRT5000 ist ein von Vishay entwickelter reflektiver optischer Sensor (Reflexlichtschranke). Auf der einen Seite des Gehäuses sitzt eine LED, die Infrarotlicht aussendet, auf der anderen ein lichtempfindlicher Fototransistor; beide schauen in dieselbe Richtung, nach vorne. Die Kunststoffwand dazwischen verhindert, dass das Licht der LED den Fototransistor direkt erreicht; erkannt wird es nur, wenn es auf eine Fläche davor trifft und zurückgeworfen wird. Ein Fototransistor lässt umso mehr Strom durch seinen Kollektor fließen, je mehr Licht auf seine Basiszone fällt: Je mehr Licht eine Fläche reflektiert, desto größer ist der Kollektorstrom. Die schwarze Linse ist ein Tageslichtfilter; sie sperrt den größten Teil des sichtbaren Lichts und lässt nur Wellenlängen nahe dem Infrarot durch.

Den Strom des Fototransistors kann der Arduino nicht direkt lesen; um ihn in eine Spannung umzuwandeln, hängt man einen Lastwiderstand an den Kollektor. Auf fertigen Modulen sind das meist 10 kΩ, die den Kollektor auf VCC ziehen. Die Spannung am Kollektor ergibt sich aus U = VCC − Ic × R. Lässt eine weiße Fläche etwa 0,4 mA durch den Fototransistor fließen, fallen am 10-kΩ-Widerstand 4 V ab und der Ausgang sinkt auf 1 V. Fällt der Strom über Schwarz auf 20 µA, fallen nur 0,2 V ab und der Ausgang bleibt bei 4,8 V. Beim TCRT5000-Modul gilt also: Weiß ergibt eine niedrige, Schwarz eine hohe Spannung. Diese umgekehrte Logik verwirrt am Anfang, ist aber einfach die Folge der Schaltung. Ein größerer Lastwiderstand macht den Sensor empfindlicher, aber langsamer; ein kleinerer macht ihn schneller, doch schwache Reflexionen lassen sich dann nicht mehr unterscheiden.

Wie unterscheidet der TCRT5000 Schwarz und Weiß?

Weißes Papier streut den größten Teil des auftreffenden Infrarotlichts in alle Richtungen zurück; matte schwarze Farbe, Toner oder Klebeband schlucken dagegen den Großteil und wandeln ihn in Wärme um. Der TCRT5000 macht aus diesem Unterschied einen großen Unterschied im Fototransistorstrom. Allerdings sieht der Sensor keine Farben wie das menschliche Auge; für ihn zählt nur, wie stark die Fläche bei 950 nm reflektiert. Das führt zu Überraschungen: Manche Tintenstrahldrucke wirken für das Auge tiefschwarz, sind im Infrarot aber fast durchsichtig, und der Sensor hält sie für Weiß. Glänzendes schwarzes Isolierband kann das Licht wie ein Spiegel zurückwerfen, wenn der Sensor senkrecht darauf schaut. Rote, orange und gelbe Flächen werden oft fast wie Weiß gelesen. Teste deshalb Linien- und Bodenmaterial immer mit dem Sensor, bevor du dich festlegst. Die Tabelle zeigt Beispielwerte bei 5 V und etwa 3 mm Höhe; deine eigenen Messungen können je nach Sensor und Umgebung abweichen.

Das TCRT5000-Modul: analoger (AO) und digitaler (DO) Ausgang

Statt eines nackten TCRT5000 nutzt man meist ein fertiges Modul. Neben dem Sensor sitzen auf der Platine ein LM393-Komparator, ein blaues Einstellpotentiometer, ein Widerstand, der den Strom der IR-LED begrenzt, der 10-kΩ-Lastwiderstand des Fototransistors und zwei kleine LEDs: eine Betriebs-LED und eine Status-LED, die den DO-Ausgang anzeigt. Der AO-Pin ist direkt mit dem Kollektor des Fototransistors verbunden und liefert die oben berechnete Rohspannung. Der LM393 vergleicht diese Spannung mit der Spannung am Schleifer des Potentiometers und gibt das Ergebnis am DO-Pin aus. Bei gängigen Modulen geht DO über Weiß auf LOW und die Status-LED leuchtet; über Schwarz oder wenn nichts davor ist, geht er auf HIGH und die LED erlischt. Da die Logik bei manchen Platinen umgekehrt ist, prüfe zuerst im Seriellen Monitor, wie sich dein Modul verhält. Die meisten Einkanal-Module haben 4 Pins (VCC, GND, DO, AO); es gibt aber auch 3-Pin-Versionen nur mit DO sowie Linienfolger-Leisten mit 3 oder 5 Sensoren. Ein Modul zieht je nach Vorwiderstand der IR-LED bei 5 V etwa 15–40 mA.

Arbeitsabstand: den Bereich von 1–15 mm richtig nutzen

Laut Datenblatt erreicht das Signal des TCRT5000 bei 2,5 mm sein Maximum und bleibt zwischen 0,2 und 15 mm über 20 % dieses Werts. In der Praxis ist der Sensor von 1 bis 15 mm brauchbar, doch der Unterschied zwischen Schwarz und Weiß schrumpft mit wachsendem Abstand schnell. Die Abstand-Signal-Kurve ist auch nicht eindeutig: Unter 2 mm fällt das Signal wieder ab, weil sich der Lichtkegel der LED und das Blickfeld des Fototransistors erst ab einem bestimmten Abstand auf der Fläche überlappen. Drückst du den Sensor auf eine Fläche, liest sogar weißes Papier dunkel. Derselbe Analogwert kann also bei 1 mm und bei 5 mm auftreten; willst du Abstände schätzen, nutze nur den eindeutigen Bereich jenseits von 3 mm.

Mit dem TCRT5000 kannst du auch kurze Abstände messen: Da sich der Analogwert auf derselben Fläche gleichmäßig mit dem Abstand ändert, kannst du an einigen Punkten wie 3, 5, 8 und 12 mm messen, eine Tabelle anlegen und dazwischen linear interpolieren. Diese Messung hängt aber von der Farbe der Fläche ab: Ein auf weißes Papier kalibrierter Sensor hält eine graue Fläche für weiter entfernt, als sie ist. Betrachte den TCRT5000 deshalb nicht als Lineal, sondern als Näherungssensor, der auf derselben Fläche die Frage „näher oder weiter weg?“ beantwortet. Um Zentimeter zu messen, ist der HC-SR04 Abstandssensor viel besser geeignet.

TCRT5000-Modul anschließen: Arduino Uno, ESP32 und Pico

Wie schließt man einen nackten TCRT5000 ohne Modul an?

Der nackte Sensor hat vier Beinchen: Die beiden auf der blauen Seite sind Anode und Kathode der IR-LED, die beiden auf der schwarzen Seite Kollektor und Emitter des Fototransistors. Am einfachsten findest du sie mit dem Diodentest deines Multimeters: An den zwei Beinchen der blauen Seite misst du nur in einer Richtung etwa 1,0–1,2 V; das Beinchen, an dem dann die rote Messspitze liegt, ist die Anode. Den Fototransistor verkehrt herum anzuschließen schadet ihm nicht, weil der 10-kΩ-Widerstand den Strom begrenzt; er funktioniert dann einfach nicht. Ändert sich der Messwert nicht mit dem Licht, tausche die beiden Beinchen der schwarzen Seite.

Den Strom der IR-LED musst du mit einem Vorwiderstand begrenzen. Du berechnest ihn mit R = (VCC − UF) / I: Für 5 V, 1,2 V Durchlassspannung und 20 mA ergibt sich (5 − 1,2) / 0,02 = 190 Ω; der nächste Normwert, 220 Ω, lässt etwa 17 mA fließen, einen Strom, den ein Arduino-Pin bequem liefert. Diese Rechnung kannst du auch mit dem Werkzeug LED-Vorwiderstand erledigen. Verbinde den Emitter des Fototransistors mit GND, den Kollektor über 10 kΩ mit 5V und führe den Kollektor zu A0. Um weiter entfernte oder dunklere Flächen zu unterscheiden, kannst du den Lastwiderstand auf 47 kΩ erhöhen; weiße Flächen gehen dann schnell in Sättigung, kleine Unterschiede im dunklen Bereich werden aber größer.

Schritt für Schritt: Schwarz-Weiß-Erkennung mit dem Arduino

1. Verbinde VCC des Moduls mit dem 5V-Pin des Arduino und GND mit GND.
2. Verbinde den AO-Pin mit A0 und den DO-Pin mit D2.
3. Klebe zum Testen einen 2 cm breiten Streifen mattes schwarzes Klebeband auf ein weißes Blatt Papier.
4. Halte oder befestige den Sensor etwa 3 mm über der Fläche und senkrecht zu ihr.
5. Lade den folgenden Code hoch und öffne den Seriellen Monitor mit 9600 Baud.
6. Fahre in den ersten 5 Sekunden mehrmals mit dem Sensor über das schwarze Band und das weiße Papier; der Code ermittelt den kleinsten und den größten Wert und berechnet den Schwellwert selbst.
7. Bewege den Sensor zwischen Schwarz und Weiß; die L-LED auf dem Board sollte über Schwarz leuchten und über Weiß erlöschen.

1// TCRT5000 ile siyah-beyaz zemin algılama / Black-white surface detection with TCRT5000
2const int SENSOR_AO = A0;      // modülün AO pini / module AO pin
3const int SENSOR_DO = 2;       // modülün DO pini / module DO pin
4const int LED_PIN = 13;        // kart üzerindeki L LED'i / onboard L LED
5const int HYST = 40;           // histerezis payı / hysteresis margin
6
7int threshold = 450;           // varsayılan eşik / default threshold
8bool onBlack = false;
9
10void setup() {
11  Serial.begin(9600);
12  pinMode(SENSOR_DO, INPUT);   // modülde çekme direnci var / the module has its own pull-up
13  pinMode(LED_PIN, OUTPUT);
14
15  Serial.println(F("5 sn: sensoru siyah ve beyazin uzerinden gecir / sweep over black and white"));
16  digitalWrite(LED_PIN, HIGH);                // kalibrasyon sürüyor / calibrating
17  int lo = 1023, hi = 0;
18  unsigned long start = millis();
19  while (millis() - start < 5000) {
20    int v = analogRead(SENSOR_AO);
21    if (v < lo) lo = v;                       // en beyaz / whitest
22    if (v > hi) hi = v;                       // en siyah / blackest
23  }
24  digitalWrite(LED_PIN, LOW);
25  if (hi - lo >= 100) {
26    threshold = (lo + hi) / 2;                // eşik = (beyaz + siyah) / 2 / threshold = (white + black) / 2
27  } else {
28    Serial.println(F("Fark cok az, varsayilan esik / Too little contrast, default threshold"));
29  }
30  Serial.print(F("Beyaz/White: ")); Serial.print(lo);
31  Serial.print(F("  Siyah/Black: ")); Serial.print(hi);
32  Serial.print(F("  Esik/Threshold: ")); Serial.println(threshold);
33}
34
35void loop() {
36  int raw = analogRead(SENSOR_AO);            // beyazda düşük, siyahta yüksek / low on white, high on black
37  bool doBlack = digitalRead(SENSOR_DO) == HIGH;   // çoğu modülde siyahta HIGH / HIGH on black on most modules
38
39  if (!onBlack && raw > threshold + HYST) onBlack = true;    // siyaha geçti / moved onto black
40  if (onBlack && raw < threshold - HYST) onBlack = false;    // beyaza geçti / moved onto white
41
42  digitalWrite(LED_PIN, onBlack ? HIGH : LOW);
43  Serial.print(F("AO: ")); Serial.print(raw);
44  Serial.print(F("  DO: ")); Serial.print(doBlack ? F("SIYAH/BLACK") : F("BEYAZ/WHITE"));
45  Serial.print(F("  Kod/Code: ")); Serial.println(onBlack ? F("SIYAH/BLACK") : F("BEYAZ/WHITE"));
46  delay(100);
47}

Der Code berechnet den Schwellwert als (kleinster + größter Wert) / 2: Liest du über Weiß 80 und über Schwarz 820, liegt der Schwellwert bei 450. Statt eines einzigen Schwellwerts gibt es zwei Grenzen: Über 490 wird auf Schwarz umgeschaltet, unter 410 zurück auf Weiß. Dank dieser Hysterese flackert der Ausgang nicht, wenn der Sensor genau auf der Linienkante steht. Bleibt der Unterschied bei der Kalibrierung unter 100, nimmt der Code den Standardwert 450 und warnt dich; meist ist der Sensor dann zu hoch montiert oder wurde nur über eine Farbe bewegt. Die DO-Spalte zeigt dieselbe Entscheidung, getroffen vom Potentiometer des Moduls; beides nebeneinander zu sehen ist eine gute Kontrolle der Poti-Einstellung.

Schwellwert einstellen: Potentiometer oder Software?

Nutzt du den DO-Ausgang, wird der Schwellwert mit dem Potentiometer auf der Platine eingestellt. Die Spannung am Schleifer des Potis ist die Referenz des Komparators; sobald die AO-Spannung sie überschreitet, wechselt DO seinen Zustand. So stellst du ihn richtig ein:

1. Lege den Sensor in der späteren Einbauhöhe über eine weiße Fläche und drehe das Potentiometer, bis die Status-LED leuchtet.
2. Schiebe den Sensor über die schwarze Linie und prüfe, ob die LED erlischt; wenn nicht, drehe das Poti ein Stück zurück.
3. Suche die beiden Endstellungen, in denen die LED über Weiß sicher leuchtet und über Schwarz sicher aus ist, und stelle das Poti in die Mitte dazwischen.
4. Für eine feinere Einstellung misst du AO mit dem Multimeter über Weiß und über Schwarz und stellst die Spannung am Schleifer auf die Mitte der beiden Werte ein, bei 0,6 V und 4,2 V also etwa 2,4 V.
5. Stelle immer dort und unter derselben Beleuchtung ein, wo der Roboter oder Aufbau später arbeitet.

Einfluss des Umgebungslichts und wie du ihn beseitigst

Der Tageslichtfilter in der schwarzen Linse sperrt sichtbares Licht, aber kein Infrarot, denn der Sensor selbst arbeitet ja mit Infrarot. Sonnenlicht sowie Glüh- und Halogenlampen strahlen um 950 nm kräftig im Infrarot; erreicht dieses Licht den Fototransistor, liest sogar eine schwarze Fläche wie Weiß. In direkter Sonne kann der Fototransistor komplett in Sättigung gehen, und der Sensor unterscheidet gar nichts mehr. LED- und Leuchtstofflampen geben dagegen sehr wenig Infrarot ab; deshalb kann derselbe Roboter im Klassenzimmer perfekt fahren und am Fenster durcheinanderkommen. Die Lösungen, von einfach bis aufwendig:

• Abschatten: Bringe um den Sensor eine schwarze Schürze, einen Schrumpfschlauch oder schwarzen Schaumstoff an; das hält seitliches Licht ab.
• Tief montieren: Bringe den Sensor auf 2–4 mm an die Fläche heran; das reflektierte Licht wird stärker, der Anteil des Umgebungslichts kleiner.
• Vor Ort kalibrieren: Lege den Schwellwert immer in der echten Umgebung fest und miss beim Start neu, wenn sich das Licht ändert.
• Differenz messen: Steuere beim nackten Sensor die IR-LED über einen Arduino-Pin und miss zweimal, einmal mit ausgeschalteter und einmal mit eingeschalteter LED. Das Umgebungslicht ist in beiden Messungen gleich, die Differenz ist also allein die Reflexion der LED.

1// Ortam ışığını çıkaran ölçüm (çıplak TCRT5000) / Ambient-light-cancelling reading (bare TCRT5000)
2const int IR_LED = 7;          // 220 Ω üzerinden IR LED anoduna / to the IR LED anode via 220 Ω
3const int SENSOR = A0;         // kolektör, 10 kΩ ile 5V'a / collector, 10 kΩ pull-up to 5V
4const int SETTLE_US = 500;     // fototransistörün oturma süresi / phototransistor settling time
5
6int readReflection() {
7  digitalWrite(IR_LED, LOW);
8  delayMicroseconds(SETTLE_US);
9  int ambient = analogRead(SENSOR);           // yalnız ortam ışığı / ambient light only
10  digitalWrite(IR_LED, HIGH);
11  delayMicroseconds(SETTLE_US);
12  int lit = analogRead(SENSOR);               // ortam + yansıma / ambient + reflection
13  digitalWrite(IR_LED, LOW);
14  return ambient - lit;                       // ışık arttıkça gerilim düşer / voltage drops as light rises
15}
16
17void setup() {
18  Serial.begin(115200);
19  pinMode(IR_LED, OUTPUT);
20}
21
22void loop() {
23  long sum = 0;
24  for (int i = 0; i < 8; i++) sum += readReflection();   // 8 ölçümün ortalaması / average of 8 readings
25  int reflection = sum / 8;
26  Serial.println(reflection);                 // büyük değer = beyaz ya da yakın / large = white or near
27  delay(50);
28}

Ein Fototransistor reagiert nicht sofort; mit einem 10-kΩ-Lastwiderstand kann es Hunderte Mikrosekunden dauern, bis er seinen neuen Wert erreicht, deshalb wartet der Code vor jeder Messung 500 µs. Sind die Werte unruhig, erhöhe SETTLE_US auf 1000. Je größer die Differenz, desto weißer oder näher ist die Fläche. Gegen die Sonne kommt auch diese Methode nicht ganz an: Ist der Fototransistor durch das Umgebungslicht bereits gesättigt, ändert das Einschalten der LED nichts und die Differenz fällt auf null; dann hilft nur Abschatten. Fernbedienungen setzen dieselbe Idee viel schneller um, indem sie das Licht in 38-kHz-Pulsen senden, und der Empfänger hört nur auf diese Frequenz; mehr dazu im Artikel IR-Empfänger und Fernbedienung.

TCRT5000 vs. FC-51 Hindernissensor: Was ist der Unterschied?

Die beiden werden oft verwechselt, weil beide aus einer Infrarot-LED und einem Empfänger für das reflektierte Licht bestehen und beide einen LM393-Komparator haben. Der Unterschied liegt im Einsatzzweck: Der TCRT5000 vereint Sender und Empfänger in einem Gehäuse, ausgerichtet auf einen kleinen Punkt wenige Millimeter davor. Der FC-51 nutzt dagegen eine separate IR-LED und einen separaten Empfänger nebeneinander und sucht nach Licht, das von einem mehrere Zentimeter entfernten Hindernis zurückkommt. Deshalb kann der FC-51 eine dünne Linie auf dem Boden nicht zuverlässig erkennen, und der TCRT5000 sieht keine Wand in 10 cm Entfernung.

Drehzahl messen mit dem TCRT5000 (Tachometer)

Eine der nützlichsten, aber wenig bekannten Aufgaben des TCRT5000 ist es, die Drehzahl von etwas Rotierendem zu messen; sogar Vishays Datenblatt nennt Positionssensor für Wellenencoder als erste Anwendung. Das Prinzip ist einfach: Du klebst eine weiße Markierung auf eine schwarz lackierte Scheibe oder Welle; jedes Mal, wenn die Markierung am Sensor vorbeikommt, geht der DO-Ausgang einmal auf LOW. Durch Zählen dieser Impulse kannst du die Drehzahl auf zwei Arten berechnen:

• Zählmethode: U/min = Anzahl Impulse × 60 / (Anzahl Markierungen × Messzeit in Sekunden). Wurden in 1 Sekunde 25 Impulse gezählt und hat die Scheibe 1 Markierung, ergibt das 25 × 60 = 1500 U/min. Bei hohen Drehzahlen sehr genau, doch mit 1-Sekunden-Fenster und einer Markierung beträgt die Auflösung nur 60 U/min.
• Periodenmethode: U/min = 60.000.000 / (Mikrosekunden zwischen zwei Impulsen × Anzahl Markierungen). Vergehen zwischen zwei Impulsen 40.000 µs (40 ms), ergibt das 60.000.000 / 40.000 = 1500 U/min. Sie liefert bei jedem Impuls ein neues, genaues Ergebnis, auch bei niedriger Drehzahl.
• Anzahl der Markierungen: 2 oder 4 gleichmäßig verteilte Markierungen verbessern die Auflösung der Zählmethode; vergiss nicht, die Anzahl in der Formel anzupassen.

1. Lackiere die Welle oder das Rad, das du messen willst, matt schwarz oder beklebe es mit mattem schwarzem Klebeband.
2. Klebe ein weißes Papieretikett von etwa 5 × 5 mm darauf; die Markierung sollte breiter sein als der Punkt, auf den der Sensor schaut.
3. Befestige den Sensor 3–5 mm von der Markierung entfernt so, dass er nicht vibrieren kann.
4. Drehe die Welle langsam von Hand und prüfe, ob die DO-LED bei jedem Vorbeilauf der Markierung blinkt; justiere bei Bedarf das Potentiometer.
5. Verbinde den DO-Pin mit einem der Interrupt-Pins des Uno (D2 oder D3) und lade den folgenden Code hoch.

1// TCRT5000 ile takometre (devir ölçer) / Tachometer with TCRT5000
2const byte SENSOR_DO = 2;                // DO -> D2 (kesme pini / interrupt pin)
3const byte MARKS = 1;                    // diskteki beyaz işaret sayısı / white marks on the disc
4const unsigned long MIN_GAP_US = 500;    // daha sık darbeler titreşimdir / closer pulses are glitches
5
6volatile unsigned long pulseCount = 0;
7volatile unsigned long lastPulseUs = 0;
8volatile unsigned long periodUs = 0;
9
10void onPulse() {
11  unsigned long now = micros();
12  unsigned long gap = now - lastPulseUs;
13  if (gap < MIN_GAP_US) return;          // sınırdaki titreşimi ele / filter edge chatter
14  if (lastPulseUs != 0) periodUs = gap;  // iki darbe arası süre / time between pulses
15  lastPulseUs = now;
16  pulseCount++;
17}
18
19void setup() {
20  Serial.begin(115200);
21  pinMode(SENSOR_DO, INPUT);
22  attachInterrupt(digitalPinToInterrupt(SENSOR_DO), onPulse, FALLING);   // beyaz işarette LOW olur / goes LOW on the white mark
23}
24
25void loop() {
26  static unsigned long lastPrint = 0;
27  if (millis() - lastPrint < 1000) return;   // saniyede bir hesapla / calculate once per second
28  lastPrint = millis();
29
30  noInterrupts();                        // paylaşılan değişkenleri güvenle kopyala / copy shared variables safely
31  unsigned long count = pulseCount;
32  pulseCount = 0;
33  unsigned long period = periodUs;
34  unsigned long last = lastPulseUs;
35  interrupts();
36
37  float rpmCount = count * 60.0 / MARKS;                 // sayma yöntemi / counting method
38  float rpmPeriod = 0;
39  if (period > 0 && micros() - last < 2000000UL) {       // 2 sn darbe yoksa durmuş say / stopped after 2 s without pulses
40    rpmPeriod = 60000000.0 / (period * (float)MARKS);    // periyot yöntemi / period method
41  }
42  Serial.print(F("Sayma/Count: "));
43  Serial.print(rpmCount, 0);
44  Serial.print(F(" rpm   Periyot/Period: "));
45  Serial.print(rpmPeriod, 1);
46  Serial.println(F(" rpm"));
47}

Die Impulse werden mit attachInterrupt() erfasst: Egal, was der Prozessor gerade in loop() tut, onPulse() läuft in dem Moment, in dem DO fällt, und kein Impuls geht verloren. Variablen, die sich Interrupt-Routine und loop() teilen, werden als volatile deklariert, und loop() kopiert sie zwischen noInterrupts() und interrupts(); sonst könnte der Interrupt mitten im Lesen einer 4-Byte-Zahl auslösen und du bekämst einen halb aktualisierten Wert. Der Ausgang des LM393 kann an der Schwarz-Weiß-Kante ein paarmal schnell prellen; MIN_GAP_US filtert das heraus, indem Impulse mit weniger als 500 µs Abstand ignoriert werden. Mit einer Markierung erlaubt dieser Filter Messungen bis 120.000 U/min und ist für Hobbymotoren damit praktisch keine Grenze. Mehr über Interrupts erfährst du im Artikel Arduino Interrupts.

Den TCRT5000 mit dem ESP32 verwenden

Auf dem ESP32 funktioniert dieselbe Logik, achte aber auf drei Unterschiede. Erstens wird das Modul mit 3V3 versorgt. Zweitens hat der Analogeingang 12 Bit und liefert Werte von 0 bis 4095; schließe AO nur an ADC1-Pins (GPIO 32–39) an, denn ADC2-Pins lassen sich bei eingeschaltetem WLAN nicht lesen. Drittens wird die Interrupt-Routine mit IRAM_ATTR gekennzeichnet, und weil der ESP32 zwei Kerne hat, schützt ein kritischer Abschnitt mit portMUX die gemeinsamen Variablen. Der folgende Code zählt die zwei Markierungen auf der Scheibe und gibt jede halbe Sekunde Drehzahl und Analogwert aus. Wenn der ESP32 neu für dich ist, wirf zuerst einen Blick auf Was ist der ESP32?.

1// ESP32 + TCRT5000: devir ölçer ve analog okuma / tachometer and analog reading
2const int SENSOR_DO = 27;                // DO -> GPIO 27
3const int SENSOR_AO = 34;                // AO -> GPIO 34 (ADC1)
4const int MARKS = 2;                     // diskteki beyaz işaret sayısı / white marks on the disc
5const uint32_t MIN_GAP_US = 300;         // daha sık darbeler titreşimdir / closer pulses are glitches
6
7volatile uint32_t pulseCount = 0;
8volatile uint32_t lastPulseUs = 0;
9portMUX_TYPE mux = portMUX_INITIALIZER_UNLOCKED;
10
11void IRAM_ATTR onPulse() {               // kesme kodu IRAM'de durur / ISR lives in IRAM
12  uint32_t now = micros();
13  portENTER_CRITICAL_ISR(&mux);
14  if (now - lastPulseUs >= MIN_GAP_US) {
15    lastPulseUs = now;
16    pulseCount++;
17  }
18  portEXIT_CRITICAL_ISR(&mux);
19}
20
21void setup() {
22  Serial.begin(115200);
23  pinMode(SENSOR_DO, INPUT);
24  analogReadResolution(12);              // 0-4095
25  attachInterrupt(digitalPinToInterrupt(SENSOR_DO), onPulse, FALLING);
26}
27
28void loop() {
29  static uint32_t lastMs = 0;
30  uint32_t nowMs = millis();
31  if (nowMs - lastMs < 500) return;      // yarım saniyede bir / every half second
32  uint32_t elapsed = nowMs - lastMs;
33  lastMs = nowMs;
34
35  portENTER_CRITICAL(&mux);              // iki çekirdeğe karşı koruma / protection across both cores
36  uint32_t pulses = pulseCount;
37  pulseCount = 0;
38  portEXIT_CRITICAL(&mux);
39
40  float rpm = pulses * 60000.0 / (elapsed * (float)MARKS);   // dev/dk / revolutions per minute
41  int raw = analogRead(SENSOR_AO);       // siyahta yüksek, beyazda düşük / high on black, low on white
42  Serial.printf("RPM: %.0f   AO: %d\n", rpm, raw);
43}

Da das Messfenster eine halbe Sekunde beträgt, misst der Code die verstrichene Zeit genau mit millis() und setzt sie in die Formel ein: U/min = Impulse × 60.000 / (verstrichene ms × Anzahl Markierungen). Die Drehzahl per WLAN auf einer Webseite anzuzeigen oder eine Benachrichtigung aufs Handy zu schicken, wenn sie unter einen Wert fällt, ist der eigentliche Mehrwert des ESP32 in diesem Projekt. Da der Analogwert gleichzeitig gelesen wird, kannst du außerdem beobachten, ob sich der Abstand der Scheibe zum Sensor ändert, also ob die Welle eiert.

Den TCRT5000 mit Raspberry Pi Pico und MicroPython verwenden

Versorge das Modul am Pico über den Pin 3V3(OUT), verbinde AO mit GP26 (ADC0) und DO mit GP15. read_u16() liefert Werte von 0 bis 65535; über Weiß niedrig, über Schwarz hoch. Der folgende Code erkennt die Oberfläche und berechnet zugleich die Drehzahl, indem er die Impulse auf der DO-Leitung per Interrupt zählt. MicroPython-Interrupts sind nicht so schnell wie in C; bis zu einigen hundert Impulsen pro Sekunde arbeiten sie zuverlässig, für sehr schnelle Motoren nimmst du besser einen Arduino oder ESP32. Für Installation und erste Schritte siehe Was ist der Raspberry Pi Pico?.

1# Raspberry Pi Pico: TCRT5000 ile zemin algılama ve devir sayma
2# Raspberry Pi Pico: surface detection and RPM counting with TCRT5000
3from machine import Pin, ADC
4import machine
5import time
6
7ao = ADC(26)                     # AO -> GP26 (ADC0)
8do = Pin(15, Pin.IN)             # DO -> GP15
9led = Pin("LED", Pin.OUT)        # kart üzerindeki LED / onboard LED
10
11MARKS = 1                        # diskteki beyaz işaret sayısı / white marks on the disc
12MIN_GAP_US = 500                 # daha sık darbeler titreşimdir / closer pulses are glitches
13count = 0
14last_us = time.ticks_us()
15
16def on_pulse(pin):
17    global count, last_us
18    now = time.ticks_us()
19    if time.ticks_diff(now, last_us) < MIN_GAP_US:
20        return                   # sınırdaki titreşimi ele / filter edge chatter
21    last_us = now
22    count += 1
23
24do.irq(trigger=Pin.IRQ_FALLING, handler=on_pulse)   # beyaz işarette DO LOW olur / DO goes LOW on white
25
26while True:
27    time.sleep(1)
28    state = machine.disable_irq()   # sayacı güvenle oku / read the counter safely
29    pulses = count
30    count = 0
31    machine.enable_irq(state)
32
33    raw = ao.read_u16()             # 0-65535: beyazda düşük, siyahta yüksek / low on white, high on black
34    on_white = do.value() == 0      # çoğu modülde beyazda LOW / LOW on white on most modules
35    led.value(on_white)
36    rpm = pulses * 60 / MARKS
37    print("AO:", raw, "Zemin/Surface:", "BEYAZ/WHITE" if on_white else "SIYAH/BLACK", "RPM:", rpm)

Projektideen mit dem TCRT5000

• Linienfolger-Roboter: Ein Roboter, der mit einer Leiste aus 2, 3 oder 5 Sensoren einer schwarzen Linie folgt; Sensoranordnung und PID-Abstimmung findest du im Artikel Linienfolger-Roboter.
• Roboter, der die Tischkante erkennt: Setze vorne einen nach unten schauenden TCRT5000 ein; an der Tischkante springt das Signal auf „Schwarz“ und der Roboter hält an, bevor er fällt. Für Chassis und Motoren siehe die Anleitung Arduino-Roboterauto bauen.
• Drehzahlanzeige für Motoren: Kombiniere den Tachometer-Code mit einem OLED-Display und zeige die Drehzahl in großen Ziffern an.
• Radencoder und Wegzähler: Klebe 8–20 schwarz-weiße Segmente auf die Innenseite eines Rades, zähle die Impulse, teile durch die Segmentzahl und multipliziere mit dem Radumfang, um die zurückgelegte Strecke zu erhalten. Brauchst du auch die Richtung, versetze zwei Sensoren um ein halbes Segment, wie bei einem Drehencoder.
• Stückzähler: Zähle weiße Kartons oder Blätter, die über ein kleines Förderband laufen, und zeige die Summe auf einem Display.
• Papier-leer-Alarm: Richte den Sensor auf die Rückseite einer Etiketten- oder Druckerrolle; sobald das Papier zu Ende ist, verschwindet die Reflexion und ein Summer ertönt.
• Dasselbe Prinzip, geschlossen: Vergleiche den TCRT5000 mit einem Optokoppler, in dem LED und Fototransistor lichtdicht in einem Gehäuse sitzen, um die Signalübertragung per Licht besser zu verstehen.

Häufige Fehler und ihre Lösungen

Der TCRT5000 ist ein günstiger, kleiner und sehr lehrreicher Sensor: An einem einzigen Bauteil lernst du Fototransistor, Komparator, Schwellwert und Hysterese, Interrupts und den Umgang mit Umgebungslicht kennen. Lerne zuerst mit dem Code zur Oberflächenerkennung die Werte deines Sensors kennen, miss dann mit dem Tachometer die Drehzahl und kombiniere schließlich mehrere Sensoren unter einem Roboter. Wenn dich eine weitere einfache Art interessiert, mit Licht zu messen, lies auch den Artikel LDR-Lichtsensor. In der BlueGrays-App findest du die Projekte TCRT5000 Schwarz-Weiß-Untergrunderkennung und TCRT5000 Abstandsmessung sowie das per Bluetooth gesteuerte Auto mit L298N und den hindernisausweichenden Roboter, jeweils Schritt für Schritt mit Schaltplan und Code.