Capteur TCRT5000 Arduino : câblage, code et compte-tours IR

Le TCRT5000 est un petit capteur infrarouge à réflexion utilisé dans les projets Arduino pour détecter une ligne noire au sol, un repère sur un arbre qui tourne ou une surface à quelques millimètres devant lui. Utiliser le TCRT5000 avec Arduino est très simple : tu branches le module sur 5V, GND et une seule broche de signal ; aucune bibliothèque n'est nécessaire, analogRead() ou digitalRead() suffisent. Comme un même boîtier contient une LED infrarouge qui émet la lumière et un phototransistor qui mesure la lumière réfléchie, c'est l'œil commun des robots suiveurs de ligne, des imprimantes qui détectent le papier et des compte-tours.

Dans cet article, tu vas apprendre comment la LED IR et le phototransistor du TCRT5000 travaillent ensemble, pourquoi il distingue si facilement une surface noire d'une surface blanche, quelle est la différence entre la sortie analogique (AO) et la sortie numérique (DO) du module, et comment régler le seuil au potentiomètre et par logiciel. Tu verras aussi, étape par étape et avec du code pour Arduino Uno, ESP32 et Raspberry Pi Pico, la distance de travail de 1–15 mm, l'effet de la lumière ambiante et une technique de mesure qui l'élimine, la différence avec le capteur d'obstacles FC-51 et comment fabriquer un compte-tours (tachymètre) avec le TCRT5000.

Qu'est-ce que le TCRT5000 et comment fonctionne-t-il ?

Le TCRT5000 est un capteur optique à réflexion développé par Vishay. D'un côté du boîtier se trouve une LED qui émet de la lumière infrarouge, de l'autre un phototransistor sensible à cette lumière ; les deux regardent dans la même direction, vers l'avant du capteur. La paroi en plastique qui les sépare empêche la lumière de la LED d'atteindre directement le phototransistor ; la lumière n'est détectée que si elle frappe une surface devant et rebondit. Un phototransistor laisse passer d'autant plus de courant dans son collecteur que la lumière qui tombe sur sa zone de base est forte : plus une surface réfléchit de lumière, plus le courant de collecteur est grand. La lentille noire est un filtre lumière du jour ; elle bloque la majeure partie de la lumière visible et ne laisse passer que les longueurs d'onde proches de l'infrarouge.

L'Arduino ne peut pas lire directement le courant du phototransistor ; pour le transformer en tension, on relie une résistance de charge au collecteur. Sur les modules, elle vaut en général 10 kΩ et tire le collecteur vers VCC. La tension au collecteur se calcule avec V = VCC − Ic × R. Si une surface blanche fait circuler environ 0,4 mA dans le phototransistor, la chute dans les 10 kΩ est de 4 V et la sortie descend à 1 V. Si, sur du noir, le courant tombe à 20 µA, la chute n'est que de 0,2 V et la sortie reste à 4,8 V. Autrement dit, sur un module TCRT5000, le blanc donne une tension basse et le noir une tension haute ; cette logique inversée déroute au début, mais c'est la conséquence naturelle du circuit. Avec une résistance de charge plus grande, le capteur est plus sensible mais plus lent ; avec une plus petite, il est plus rapide mais ne distingue plus les faibles réflexions.

Comment le TCRT5000 distingue-t-il le noir du blanc ?

Le papier blanc renvoie la majeure partie de la lumière infrarouge qu'il reçoit en la diffusant dans toutes les directions ; la peinture noire mate, le toner ou le ruban noir absorbent presque toute la lumière et la transforment en chaleur. Le TCRT5000 convertit cette différence en un grand écart de courant dans le phototransistor. Mais le capteur ne voit pas les couleurs comme l'œil humain ; ce qui compte pour lui, c'est ce que la surface réfléchit à 950 nm. D'où quelques surprises : certaines impressions jet d'encre paraissent bien noires à l'œil mais sont presque transparentes dans l'infrarouge, et le capteur les prend pour du blanc. Le ruban isolant noir brillant peut renvoyer la lumière comme un miroir quand le capteur le regarde de face. Les surfaces rouges, orange et jaunes se lisent souvent presque comme du blanc. Teste donc toujours le matériau de la ligne et du sol avec le capteur avant de te décider. Le tableau donne des valeurs d'exemple relevées à 5 V et à environ 3 mm de hauteur ; tes propres mesures peuvent varier selon le capteur et l'environnement.

Le module TCRT5000 : sortie analogique (AO) et numérique (DO)

La plupart du temps, on utilise un module tout prêt plutôt qu'un TCRT5000 nu. À côté du capteur, la carte porte un comparateur LM393, un potentiomètre de réglage bleu, une résistance qui limite le courant de la LED IR, la résistance de charge de 10 kΩ du phototransistor et deux petites LED : l'une indique l'alimentation, l'autre l'état de la sortie DO. La broche AO est reliée directement au collecteur du phototransistor et fournit la tension brute calculée plus haut. Le LM393 compare cette tension à celle du curseur du potentiomètre et écrit le résultat sur la broche DO. Sur les modules courants, DO passe à LOW au-dessus du blanc et la LED d'état s'allume ; au-dessus du noir, ou quand il n'y a rien devant, DO passe à HIGH et la LED s'éteint. Comme la logique est inversée sur certaines cartes, vérifie d'abord le comportement de ton module dans le moniteur série. La plupart des modules à un canal ont 4 broches (VCC, GND, DO, AO) ; il existe aussi des versions à 3 broches avec DO seulement, ainsi que des barrettes de 3 ou 5 capteurs pour suiveurs de ligne. Un module consomme environ 15–40 mA sous 5 V, selon la résistance de sa LED IR.

Distance de travail : bien utiliser la plage de 1–15 mm

D'après la fiche technique du TCRT5000, le signal atteint son maximum à 2,5 mm et reste au-dessus de 20 % de cette valeur entre 0,2 et 15 mm. En pratique, le capteur fonctionne de 1 à 15 mm, mais l'écart entre noir et blanc diminue vite quand la distance augmente. La courbe distance-signal n'est pas non plus à sens unique : sous 2 mm, le signal rechute, car le cône de lumière de la LED et le champ de vision du phototransistor ne se recouvrent sur la surface qu'à partir d'une certaine distance. Si tu colles le capteur contre une surface, même le papier blanc paraît sombre. La même valeur analogique peut donc apparaître à 1 mm et à 5 mm ; pour estimer une distance, n'utilise que la zone à sens unique au-delà de 3 mm.

Tu peux aussi mesurer de courtes distances avec le TCRT5000 : comme, sur une même surface, la valeur analogique varie régulièrement avec la distance, tu peux faire des mesures en quelques points, par exemple 3, 5, 8 et 12 mm, construire un tableau et interpoler linéairement entre eux. Mais cette mesure dépend de la couleur de la surface : un capteur étalonné sur du papier blanc croira qu'une surface grise est plus loin qu'elle ne l'est. Considère donc le TCRT5000 non pas comme une règle, mais comme un capteur de proximité qui répond à la question « ça se rapproche ou ça s'éloigne ? » sur une même surface. Pour mesurer des centimètres, le capteur de distance HC-SR04 convient bien mieux.

Câblage du module TCRT5000 : Arduino Uno, ESP32 et Pico

Comment câbler un TCRT5000 nu, sans module ?

Le capteur nu a quatre pattes : les deux du côté bleu sont l'anode et la cathode de la LED IR, les deux du côté noir le collecteur et l'émetteur du phototransistor. Le moyen le plus simple de les identifier est le mode diode du multimètre : sur les deux pattes du côté bleu, tu lis environ 1,0–1,2 V dans un seul sens ; la patte touchée par la pointe rouge à ce moment-là est l'anode. Brancher le phototransistor à l'envers ne l'abîme pas, car la résistance de 10 kΩ limite le courant ; il ne fonctionne simplement pas. Si la mesure ne change pas avec la lumière, inverse les deux pattes du côté noir.

Tu dois limiter le courant de la LED IR avec une résistance. On la calcule avec R = (VCC − VF) / I : pour 5 V, une tension directe de 1,2 V et 20 mA, on obtient (5 − 1,2) / 0,02 = 190 Ω ; la valeur normalisée la plus proche, 220 Ω, laisse passer environ 17 mA, un courant qu'une broche Arduino fournit sans problème. Tu peux aussi faire ce calcul avec l'outil résistance de LED. Relie l'émetteur du phototransistor à GND, son collecteur au 5V à travers une résistance de 10 kΩ et amène le collecteur sur A0. Pour distinguer des surfaces plus lointaines ou plus sombres, tu peux monter la résistance de charge à 47 kΩ ; le blanc sature alors vite, mais les petites différences dans les zones sombres deviennent plus grandes.

Pas à pas : détecter le noir et le blanc avec Arduino

1. Relie la broche VCC du module à la broche 5V de l'Arduino et GND à GND.
2. Relie la broche AO à A0 et la broche DO à D2.
3. Pour tester, colle une bande de ruban noir mat de 2 cm de large sur une feuille de papier blanc.
4. Tiens ou fixe le capteur à environ 3 mm de la surface, perpendiculairement à elle.
5. Téléverse le code ci-dessous et ouvre le moniteur série à 9600 bauds.
6. Pendant les 5 premières secondes, passe plusieurs fois le capteur au-dessus du ruban noir et du papier blanc ; le code trouve la valeur la plus basse et la plus haute et calcule seul le seuil.
7. Déplace le capteur entre le noir et le blanc ; la LED L de la carte doit s'allumer sur le noir et s'éteindre sur le blanc.

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}

Le code calcule le seuil comme (minimum + maximum) / 2 : si tu lis 80 sur le blanc et 820 sur le noir, le seuil vaut 450. Au lieu d'un seuil unique, il utilise deux limites : il passe au noir quand la valeur dépasse 490 et revient au blanc quand elle descend sous 410. Grâce à cette hystérésis, la sortie ne clignote pas quand le capteur est pile au bord de la ligne. Si l'écart reste inférieur à 100 pendant l'étalonnage, le code prend le seuil par défaut de 450 et t'avertit ; en général, le capteur est trop haut ou n'a été passé que sur une seule couleur. La colonne DO montre la même décision prise par le potentiomètre du module ; voir les deux côte à côte est un bon moyen de vérifier le réglage du potentiomètre.

Réglage du seuil : potentiomètre ou logiciel ?

Si tu utilises la sortie DO, le seuil est fixé par le potentiomètre de la carte. La tension sur le curseur du potentiomètre sert de référence au comparateur ; dès que la tension AO la franchit, DO change d'état. Pour un bon réglage, suis ces étapes :

1. Place le capteur au-dessus d'une surface blanche, à la hauteur où tu vas l'utiliser, et tourne le potentiomètre jusqu'à ce que la LED d'état s'allume.
2. Fais glisser le capteur sur la ligne noire et vérifie que la LED s'éteint ; sinon, tourne un peu le potentiomètre dans l'autre sens.
3. Repère les deux positions extrêmes où la LED est franchement allumée sur le blanc et franchement éteinte sur le noir, puis place le potentiomètre au milieu.
4. Pour un réglage plus fin, mesure AO sur le blanc et sur le noir au multimètre et règle la tension du curseur à mi-chemin des deux valeurs ; par exemple environ 2,4 V pour 0,6 V et 4,2 V.
5. Fais toujours le réglage là où le robot ou le montage va fonctionner, sous le même éclairage.

L'effet de la lumière ambiante et comment s'en débarrasser

Le filtre lumière du jour de la lentille noire bloque la lumière visible, mais pas l'infrarouge, puisque le capteur fonctionne lui-même en infrarouge. Le soleil, les ampoules à incandescence et halogènes émettent beaucoup d'infrarouge autour de 950 nm ; quand cette lumière atteint le phototransistor, même une surface noire se lit comme du blanc. En plein soleil, le phototransistor peut saturer complètement et le capteur ne distingue plus rien. Les lampes LED et fluorescentes, elles, émettent très peu d'infrarouge ; c'est pourquoi le même robot peut fonctionner parfaitement en classe et se tromper près d'une fenêtre. Voici les solutions, de la plus simple à la plus élaborée :

• Fais de l'ombre : Ajoute autour du capteur une jupe noire, une gaine thermorétractable ou de la mousse noire ; cela bloque la lumière qui arrive par les côtés.
• Garde-le bas : Rapproche le capteur à 2–4 mm de la surface ; la lumière réfléchie augmente et la part de lumière ambiante diminue.
• Étalonne sur place : Fixe toujours le seuil dans l'environnement réel et refais la mesure au démarrage si l'éclairage change.
• Mesure la différence : Avec un capteur nu, pilote la LED IR depuis une broche de l'Arduino et fais deux mesures, LED éteinte puis LED allumée. La lumière ambiante est la même dans les deux mesures, donc la différence correspond uniquement à la réflexion de la 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}

Le phototransistor ne réagit pas instantanément ; avec une résistance de charge de 10 kΩ, il peut lui falloir des centaines de microsecondes pour se stabiliser à sa nouvelle valeur, c'est pourquoi le code attend 500 µs avant chaque mesure. Si les mesures sont instables, passe SETTLE_US à 1000. Plus la différence est grande, plus la surface est blanche ou proche. Cette méthode ne peut pas battre complètement le soleil : si la lumière ambiante a déjà saturé le phototransistor, allumer la LED ne change rien et la différence tombe à zéro ; il ne reste alors qu'à mettre le capteur à l'ombre. Les télécommandes appliquent la même idée bien plus vite en envoyant la lumière par salves à 38 kHz, et le récepteur n'écoute que cette fréquence ; c'est expliqué dans l'article récepteur IR et télécommande.

TCRT5000 ou capteur d'obstacles FC-51 : quelle différence ?

On les confond souvent, car tous deux se composent d'une LED infrarouge et d'un récepteur qui mesure la lumière réfléchie, et tous deux ont un comparateur LM393. La différence tient à leur usage : le TCRT5000 réunit émetteur et récepteur dans un seul boîtier, visant un petit point à quelques millimètres devant eux. Le FC-51, lui, utilise une LED IR et un récepteur séparés, côte à côte, et cherche la lumière renvoyée par un obstacle situé à plusieurs centimètres. C'est pourquoi le FC-51 ne repère pas de façon fiable une fine ligne au sol, et le TCRT5000 ne voit pas un mur à 10 cm.

Compter les tours avec le TCRT5000 (compte-tours)

L'un des usages les plus pratiques mais les moins connus du TCRT5000 est de mesurer la vitesse de rotation d'un objet ; même la fiche technique de Vishay place le capteur de position pour codeur d'arbre en tête de ses applications. Le principe est simple : tu colles un repère blanc sur un disque ou un arbre peint en noir ; à chaque passage du repère devant le capteur, la sortie DO passe une fois à LOW. En comptant ces impulsions, tu peux calculer la vitesse de deux façons :

• Méthode par comptage : tr/min = nombre d'impulsions × 60 / (nombre de repères × durée de mesure en secondes). Si 25 impulsions ont été comptées en 1 seconde et que le disque porte 1 repère, on obtient 25 × 60 = 1500 tr/min. Très précise aux vitesses élevées, mais avec une fenêtre de 1 seconde et un seul repère, sa résolution est de 60 tr/min.
• Méthode par période : tr/min = 60 000 000 / (microsecondes entre deux impulsions × nombre de repères). Si 40 000 µs (40 ms) s'écoulent entre deux impulsions, on obtient 60 000 000 / 40 000 = 1500 tr/min. Elle donne un résultat neuf et précis à chaque impulsion, même à basse vitesse.
• Nombre de repères : Mettre 2 ou 4 repères régulièrement espacés sur le disque améliore la résolution de la méthode par comptage ; n'oublie pas de modifier le nombre de repères dans la formule.

1. Peins en noir mat l'arbre ou la roue à mesurer, ou recouvre-le de ruban noir mat.
2. Colle dessus une étiquette en papier blanc d'environ 5 × 5 mm ; le repère doit être plus large que le point visé par le capteur.
3. Fixe le capteur à 3–5 mm du repère, de façon qu'il ne puisse pas vibrer.
4. Fais tourner l'arbre lentement à la main et vérifie que la LED DO clignote à chaque passage du repère ; ajuste le potentiomètre si besoin.
5. Relie la broche DO à l'une des broches d'interruption de l'Uno (D2 ou D3) et téléverse le code ci-dessous.

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}

Les impulsions sont capturées avec attachInterrupt() : quoi que fasse le processeur dans loop(), onPulse() s'exécute dès que DO descend, et aucune impulsion n'est perdue. Les variables partagées entre la routine d'interruption et loop() sont déclarées volatile, et loop() les copie entre noInterrupts() et interrupts() ; sinon, l'interruption pourrait survenir pendant la lecture d'un nombre de 4 octets et tu obtiendrais une valeur à moitié mise à jour. La sortie du LM393 peut osciller plusieurs fois à la frontière noir-blanc ; MIN_GAP_US filtre ces rebonds en ignorant les impulsions espacées de moins de 500 µs. Avec un seul repère, ce filtre autorise des mesures jusqu'à 120 000 tr/min, ce qui ne limite en rien les moteurs de loisir. Pour en savoir plus sur les interruptions, consulte l'article interruptions Arduino.

Utiliser le TCRT5000 avec l'ESP32

Sur l'ESP32, la même logique fonctionne, mais attention à trois différences. D'abord, le module est alimenté en 3V3. Ensuite, l'entrée analogique est sur 12 bits et donne des valeurs de 0 à 4095 ; ne relie AO qu'aux broches ADC1 (GPIO 32–39), car les broches ADC2 ne sont pas lisibles quand le Wi-Fi est actif. Enfin, la routine d'interruption est marquée IRAM_ATTR et, comme l'ESP32 a deux cœurs, les variables partagées sont protégées par une section critique portMUX. Le code ci-dessous compte les deux repères du disque et affiche toutes les demi-secondes la vitesse et la valeur analogique. Si tu débutes avec l'ESP32, jette d'abord un œil à Qu'est-ce que l'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}

Comme la fenêtre de mesure dure une demi-seconde, le code mesure précisément le temps écoulé avec millis() et l'utilise dans la formule : tr/min = impulsions × 60 000 / (ms écoulées × nombre de repères). Afficher la vitesse sur une page web en Wi-Fi ou envoyer une notification sur ton téléphone quand elle passe sous un certain seuil, voilà ce que l'ESP32 apporte vraiment à ce projet. Comme la valeur analogique est lue en même temps, tu peux aussi surveiller si la distance entre le disque et le capteur varie, c'est-à-dire si l'arbre a du voile.

Utiliser le TCRT5000 avec le Raspberry Pi Pico et MicroPython

Sur le Pico, alimente le module par la broche 3V3(OUT), relie AO à GP26 (ADC0) et DO à GP15. read_u16() renvoie une valeur de 0 à 65535 ; elle est basse sur le blanc et haute sur le noir. Le code ci-dessous détecte la surface et calcule aussi la vitesse en comptant par interruption les impulsions sur la ligne DO. Les interruptions MicroPython ne sont pas aussi rapides qu'en C ; elles fonctionnent de façon fiable jusqu'à quelques centaines d'impulsions par seconde, donc pour des moteurs très rapides, préfère un Arduino ou un ESP32. Pour l'installation et les premiers pas, consulte Qu'est-ce que le 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)

Idées de projets avec le TCRT5000

• Robot suiveur de ligne : Un robot qui suit une ligne noire avec une barrette de 2, 3 ou 5 capteurs ; le placement des capteurs et le réglage PID sont expliqués dans l'article Robot suiveur de ligne.
• Robot qui repère le bord de la table : Place à l'avant un TCRT5000 orienté vers le bas ; au bord de la table, le signal bascule sur « noir » et le robot s'arrête avant de tomber. Pour le châssis et les moteurs, consulte le guide Fabriquer une voiture robot Arduino.
• Affichage de la vitesse d'un moteur : Associe le code du compte-tours à un écran OLED et affiche la vitesse en gros chiffres.
• Codeur de roue et odomètre : Colle 8 à 20 secteurs noirs et blancs sur la face intérieure d'une roue, compte les impulsions, divise par le nombre de secteurs et multiplie par la circonférence de la roue pour obtenir la distance parcourue. Si tu as aussi besoin du sens, place deux capteurs décalés d'un demi-secteur, comme dans un encodeur rotatif.
• Compteur de pièces : Compte les boîtes blanches ou les feuilles qui passent sur un petit convoyeur et affiche le total sur un écran.
• Alerte fin de papier : Oriente le capteur vers l'arrière d'un rouleau d'étiquettes ou d'imprimante ; dès que le papier est épuisé, la réflexion disparaît et un buzzer retentit.
• Le même principe, en boîtier fermé : Compare le TCRT5000 à un optocoupleur, où une LED et un phototransistor sont scellés ensemble dans un boîtier opaque, pour mieux comprendre la transmission d'un signal par la lumière.

Erreurs fréquentes et solutions

Le TCRT5000 est un capteur bon marché, petit et très formateur : avec une seule pièce, tu découvres le phototransistor, le comparateur, le seuil et l'hystérésis, les interruptions et la lutte contre la lumière ambiante. Commence par apprendre les valeurs de ton capteur avec le code de détection de surface, mesure ensuite des vitesses avec le compte-tours, puis combine plusieurs capteurs sous un robot. Si une autre façon simple de mesurer avec la lumière t'intéresse, jette aussi un œil à l'article capteur de lumière LDR. Dans l'application BlueGrays, tu trouveras les projets TCRT5000 détection de sol noir et blanc et TCRT5000 mesure de distance, ainsi que la voiture pilotée en Bluetooth avec L298N et le robot éviteur d'obstacles, chacun pas à pas avec schéma de câblage et code.