Module Laser Arduino KY-008 : Barrière Laser, Alarme et Compteur

Le module laser est l'un des composants les plus spectaculaires à utiliser avec Arduino : il produit un faisceau rouge et fin qui parcourt plusieurs mètres sans presque s'élargir. Le module laser KY-008 que l'on trouve dans de nombreux kits réunit sur une petite carte une diode laser de 650 nm d'environ 5 mW ; il se branche sur une seule broche numérique de l'Arduino et s'allume ou s'éteint avec digitalWrite(). Seul, ce n'est qu'un pointeur, mais avec un capteur de lumière en face, il devient une alarme à barrière laser digne d'un film, un compteur de personnes qui passent une porte ou un chronomètre précis à la milliseconde.

Dans cet article, tu découvriras les caractéristiques du KY-008, le danger réel d'un laser de 5 mW pour tes yeux et les règles à respecter, puis comment brancher correctement le module sur un Arduino Uno, un ESP32 et un Raspberry Pi Pico. Ensuite, tu construiras une barrière laser avec une LDR, tu laisseras l'Arduino mesurer le seuil automatiquement au lieu de le deviner, tu transformeras un seul laser en plusieurs faisceaux grâce à des miroirs, tu compteras les passages, tu mesureras des vitesses et, avec un ESP32, tu enverras une notification sur ton téléphone dès que le faisceau est coupé.

Qu'est-ce que le module laser KY-008 et comment fonctionne-t-il ?

Le cœur du module est une petite diode laser logée dans un tube en laiton. Contrairement à une LED ordinaire, une diode laser émet, dès que le courant dépasse un certain seuil, une lumière d'une seule longueur d'onde et de manière ordonnée (cohérente) ; une minuscule lentille au bout du tube transforme cette lumière en un faisceau presque parallèle. C'est pourquoi la lumière d'une LED s'étale en quelques centimètres, alors que le point laser ne mesure que quelques millimètres même à plusieurs mètres. 650 nm correspond à un rouge profond que l'œil voit facilement. La résistance montée sur la petite carte derrière la tête laser limite le courant dans la diode. Les diodes laser sont bien plus sensibles aux surintensités que les LED ; si tu contournes cette résistance pour alimenter la diode directement, elle peut griller en quelques secondes.

Sécurité oculaire : un laser de 5 mW est-il dangereux ?

Le danger d'un laser ne vient pas de sa puissance totale, mais du fait que cette puissance est concentrée sur un point minuscule. Le cristallin focalise un faisceau parallèle en un point de quelques microns sur la rétine ; ainsi, 5 mW qui semblent inoffensifs sur un mur peuvent devenir sur la rétine un point plus intense que le soleil regardé en face. Les lasers sont répartis en classes selon ce risque. Pour les lasers de classe 2, sous 1 mW, le réflexe de clignement (environ 0,25 seconde) suffit généralement à protéger l'œil. La classe 3R, à laquelle appartient le KY-008, monte jusqu'à cinq fois cette limite : un bref coup d'œil accidentel présente peu de risque, mais regarder le faisceau directement ou via un miroir peut abîmer l'œil.

• Ne regarde jamais le faisceau : N'approche pas de ton œil l'extrémité d'où sort le laser et ne promène pas le module allumé à la main.
• Garde le faisceau sous le niveau des yeux : Installe les faisceaux d'alarme et de comptage à 20–50 cm du sol. Cette hauteur correspond aux yeux d'un bébé à quatre pattes, d'un jeune enfant, d'un chat ou d'un chien : ne laisse pas le laser allumé quand ils sont dans la pièce.
• Attention aux reflets : Miroirs, vitres, cadrans de montre et métaux brillants renvoient le faisceau dans des directions inattendues. Vérifie tout le trajet du faisceau et termine-le sur une surface mate et sombre.
• Pas d'utilisation par des enfants seuls : Un laser n'est pas un jouet ; pour les projets scolaires et les concours scientifiques, travaille sous la surveillance d'un adulte.
• Ne te fie pas aveuglément à l'étiquette : Sur les modules bon marché, la puissance réelle peut différer de celle annoncée ; traite chaque module au minimum comme un laser de classe 3R.
• Aligne avec une feuille de papier : Tiens une feuille blanche devant le faisceau et suis le point sur le papier ; ne regarde jamais dans le faisceau pour voir où il va.

Branchement du KY-008 : Arduino Uno, ESP32 et Raspberry Pi Pico

Le KY-008 a trois broches : S est la broche de signal et allume le laser à l'état HIGH, − est la masse (GND) et la broche centrale, sans marquage, va au +5V sur la plupart des cartes ou n'est reliée à rien. Le laser est placé entre S et −, donc la broche de l'Arduino reliée à S fournit directement son courant. Sur un Arduino Uno, ce n'est pas gênant pour de courts essais, mais le courant du module varie d'une carte à l'autre et peut approcher 40 mA. C'est la limite absolue par broche de l'ATmega328P ; la valeur recommandée est de 20 mA. Si le laser doit rester allumé pendant des heures, si tu utilises plusieurs lasers ou si tu travailles avec un ESP32 ou un Pico, alimente le laser en 5V et commute-le avec un transistor NPN (BC547, S8050 ou 2N2222). Tu trouveras le brochage du transistor dans le guide des transistors.

Avant de passer aux programmes, teste le laser et la LDR ensemble avec le petit programme ci-dessous. Il allume et éteint le laser toutes les demi-secondes et affiche dans le moniteur série la valeur lue dans les deux états. Plus l'écart entre les deux valeurs est grand, plus ta barrière sera fiable : sur un Uno, un écart supérieur à 300 est très bon ; en dessous de 100, le faisceau ne tombe pas bien sur la LDR ou la lumière ambiante est trop forte.

1// KY-008 + LDR ilk test: lazer açıkken ve kapalıyken değerleri gör / First test: see readings with the laser on and off
2const int LASER_PIN = 7;   // KY-008 S pini / KY-008 S pin
3const int LDR_PIN = A0;    // LDR bölücü çıkışı / LDR divider output
4
5void setup() {
6  Serial.begin(9600);
7  pinMode(LASER_PIN, OUTPUT);
8}
9
10void loop() {
11  digitalWrite(LASER_PIN, HIGH);   // lazer açık / laser on
12  delay(500);                      // LDR'nin oturmasını bekle / let the LDR settle
13  int onValue = analogRead(LDR_PIN);
14
15  digitalWrite(LASER_PIN, LOW);    // lazer kapalı / laser off
16  delay(500);
17  int offValue = analogRead(LDR_PIN);
18
19  Serial.print(F("Isin var / beam: "));
20  Serial.print(onValue);
21  Serial.print(F("  Isin yok / no beam: "));
22  Serial.print(offValue);
23  Serial.print(F("  Fark / gap: "));
24  Serial.println(onValue - offValue);
25}

Comment fonctionne une barrière laser avec une LDR ?

Le principe d'une barrière laser est simple : le faisceau laser éclaire en permanence une LDR (photorésistance) placée en face. Avec le point laser dessus, la résistance de la LDR descend à quelques centaines d'ohms ; quand le faisceau est coupé, elle remonte à plusieurs dizaines de kilo-ohms. Si tu montes la LDR avec une résistance fixe en pont diviseur de tension, cette variation de résistance devient une variation de tension sur l'entrée analogique : avec 5V → LDR → A0 → résistance → GND, A0 lit une valeur haute tant que le faisceau est là et basse quand il est coupé. Dès que quelqu'un traverse le faisceau, la valeur chute et l'Arduino déclenche l'alarme.

Un petit calcul montre pourquoi le laser agit si fortement sur la LDR : quand le faisceau de 5 mW est concentré sur un point d'environ 3 mm de diamètre, on obtient près de 700 W par mètre carré. C'est du même ordre que le soleil de midi et des centaines de fois plus qu'une pièce bien éclairée. Malgré cela, le pire ennemi de la barrière est la lumière ambiante : devant une fenêtre ensoleillée, la LDR reste éclairée même quand le faisceau est coupé et l'alarme ne remarque rien. La solution ne coûte presque rien : place la LDR au fond d'un tube noir de 3 à 5 cm (corps de stylo vide, paille noire ou gaine thermorétractable). Le tube ne laisse entrer que le laser arrivant de face et bloque la lumière latérale.

Pas à pas : alarme à barrière laser avec Arduino

1. Relie la broche S du KY-008 à D7 et la broche − à GND ; laisse la broche centrale libre (relie-la au 5V si le laser ne s'allume pas).
2. Relie une patte de la LDR au 5V et l'autre à A0 ; place une résistance de 3,3 kΩ ou 10 kΩ entre A0 et GND.
3. Place la LDR au fond d'un tube noir et oriente l'ouverture du tube vers le laser.
4. Relie la patte + du buzzer actif à D8 et la patte − à GND. Place le bouton de silence entre D4 et GND ; aucune résistance supplémentaire n'est nécessaire, car le pull-up interne est utilisé.
5. Fixe le laser et la LDR sur un support stable ; repère d'abord le point laser avec une feuille blanche, puis fais-le entrer dans le tube.
6. Téléverse le programme et ouvre le moniteur série à 9600 bauds. Au démarrage, personne ne doit se trouver dans le faisceau ; l'Arduino se calibre en éteignant puis en rallumant le laser une fois.

1// KY-008 lazer + LDR ile lazerli alarm / Laser tripwire alarm with KY-008 + LDR
2const int LASER_PIN = 7;       // KY-008 S pini ya da transistör bazı / KY-008 S pin or transistor base
3const int LDR_PIN = A0;        // LDR bölücü çıkışı / LDR divider output
4const int BUZZER_PIN = 8;      // aktif buzzer / active buzzer
5const int LED_PIN = 13;        // kart üzerindeki LED / on-board LED
6const int RESET_PIN = 4;       // susturma butonu, diğer ucu GND / silence button, other leg to GND
7
8const int BREAK_PCT = 40;                // %40'ın altı = ışın kesik / below 40% = beam broken
9const int RESTORE_PCT = 60;              // %60'ın üstü = ışın sağlam / above 60% = beam intact
10const unsigned long CONFIRM_MS = 30;     // en az bu kadar kesik kalmalı / must stay broken this long
11const unsigned long ALARM_MS = 10000;    // alarm süresi / alarm duration
12
13int onLevel = 0, offLevel = 0;           // ışınlı ve ışınsız ölçüm / reading with and without the beam
14bool beamOk = true;
15bool alarmOn = false;
16unsigned long brokenSince = 0;
17unsigned long alarmStart = 0;
18
19int readAvg() {
20  long sum = 0;
21  for (int i = 0; i < 8; i++) sum += analogRead(LDR_PIN);  // 8 ölçüm ortalaması / average of 8 readings
22  return sum / 8;
23}
24
25void calibrate() {
26  while (true) {
27    digitalWrite(LASER_PIN, LOW);        // lazer kapalı = kesik ışın / laser off = broken beam
28    delay(300);                          // LDR yavaştır, bekle / the LDR is slow, wait
29    offLevel = readAvg();
30    digitalWrite(LASER_PIN, HIGH);       // lazer açık = sağlam ışın / laser on = intact beam
31    delay(300);
32    onLevel = readAvg();
33    Serial.print(F("Isinli / beam: "));
34    Serial.print(onLevel);
35    Serial.print(F("  Isinsiz / no beam: "));
36    Serial.println(offLevel);
37    if (abs(onLevel - offLevel) >= 100) return;   // yeterli fark var / enough difference
38    Serial.println(F("Isin LDR'ye ulasmiyor, hizala! / Beam misses the LDR, align it!"));
39    delay(2000);
40  }
41}
42
43// 100 = ışın tam, 0 = ışın yok; LDR'nin yönü fark etmez / 100 = full beam, 0 = no beam; LDR polarity doesn't matter
44int beamPercent() {
45  return (long)(readAvg() - offLevel) * 100 / (onLevel - offLevel);
46}
47
48void setup() {
49  Serial.begin(9600);
50  pinMode(LASER_PIN, OUTPUT);
51  pinMode(BUZZER_PIN, OUTPUT);
52  pinMode(LED_PIN, OUTPUT);
53  pinMode(RESET_PIN, INPUT_PULLUP);
54  calibrate();
55  Serial.println(F("Alarm hazir / Alarm armed"));
56}
57
58void loop() {
59  unsigned long now = millis();
60  int pct = beamPercent();
61
62  if (beamOk && pct < BREAK_PCT) {       // ışın yeni kesildi / beam just broke
63    beamOk = false;
64    brokenSince = now;
65  } else if (!beamOk && pct > RESTORE_PCT) {
66    beamOk = true;                       // ışın geri geldi / beam restored
67  }
68
69  if (!beamOk && !alarmOn && now - brokenSince >= CONFIRM_MS) {
70    alarmOn = true;
71    alarmStart = now;
72    Serial.println(F("ALARM: isin kesildi! / beam broken!"));
73  }
74
75  if (alarmOn && (now - alarmStart >= ALARM_MS || digitalRead(RESET_PIN) == LOW)) {
76    alarmOn = false;                     // süre doldu ya da butona basıldı / timeout or button pressed
77  }
78
79  digitalWrite(LED_PIN, beamOk ? LOW : HIGH);
80  digitalWrite(BUZZER_PIN, (alarmOn && (now / 200) % 2) ? HIGH : LOW);  // kesik siren / beeping siren
81}

Le programme n'utilise pas de seuil fixe. Au démarrage, calibrate() éteint le laser et mesure la valeur de la LDR sans faisceau, puis l'allume et mesure la valeur avec faisceau. beamPercent() convertit chaque mesure en pourcentage entre 0 et 100 à partir de ces deux valeurs : 100 signifie que tout le faisceau arrive, 0 qu'il est entièrement coupé. Ce calcul ne dépend pas de la position de la LDR, en haut ou en bas du pont ; que la valeur monte ou descende avec la lumière, le résultat est le même. Si le faisceau passe sous 40 % et y reste au moins 30 ms, l'alarme bipe pendant 10 secondes, et le bouton sur D4 la coupe plus tôt. Si le faisceau est toujours coupé, l'alarme repart : le système ne se tait pas tant que quelqu'un reste dans le faisceau.

Calibrage du seuil : pourquoi ne pas écrire un nombre fixe

Beaucoup d'exemples d'alarmes laser sur internet utilisent un seuil fixe comme "analogRead(A0) < 500". Cela fonctionne le soir où tu le testes sur ton bureau, mais échoue le lendemain matin quand le soleil entre dans la pièce, quand tu déplaces le laser de quelques millimètres ou quand tu changes de LDR. Le bon seuil se trouve exactement au milieu entre les valeurs avec et sans faisceau. Un calibrage automatique qui remesure ces deux valeurs à chaque démarrage adapte le système à son environnement. Dans le programme ci-dessus, le seuil n'est pas un nombre mais deux : le faisceau est considéré comme coupé sous 40 % et comme rétabli au-dessus de 60 %. Cet écart s'appelle l'hystérésis ; il évite que l'alarme s'active et se désactive des dizaines de fois par seconde quand la valeur oscille autour du seuil.

Dans un système qui fonctionne longtemps, la lumière ambiante change lentement au fil de la journée. Un moyen simple de compenser est de rappeler calibrate() lorsque le faisceau est intact et que l'alarme ne sonne pas (par exemple toutes les heures). Comme c'est l'Arduino lui-même qui éteint le laser, il ne prend pas ce bref noir pour une intrusion. Pour surveiller les mesures, le traceur série de l'IDE Arduino est très pratique : passe la main dans le faisceau et tu verras de combien la courbe chute et en combien de temps elle remonte.

Plusieurs faisceaux avec des miroirs : un filet avec un seul laser

Un seul faisceau se franchit facilement en se baissant ou en l'enjambant. Pour reproduire les filets laser des films, inutile de donner à chaque faisceau son propre laser et sa propre LDR : tu peux renvoyer un seul laser en zigzag avec des miroirs. Tu places des miroirs face à face des deux côtés d'une porte ou d'un couloir ; le faisceau rebondit d'un côté à l'autre et finit par atteindre la LDR. Si n'importe quel segment est coupé, la LDR reste dans le noir : une seule LDR et le même programme protègent tout le filet. Comme l'angle de réflexion est égal à l'angle d'incidence, il suffit d'incliner très légèrement chaque miroir pour qu'il envoie le faisceau au centre du suivant.

Chaque miroir fait perdre un peu de lumière. Un miroir de salle de bains ordinaire réfléchit environ 90 % et produit un second point faible (reflet fantôme) sur la vitre avant. Les miroirs à face avant, dont la couche réfléchissante se trouve sur le verre, réfléchissent 95 % ou plus et donnent un seul point net. Les pertes se multiplient, donc la lumière qui atteint la LDR diminue vite à mesure que tu ajoutes des miroirs :

Ce tableau montre une chose importante : même 43 % suffit largement pour le programme calibré, car le point laser est des centaines de fois plus lumineux que la lumière ambiante. La vraie difficulté n'est pas la perte de puissance, mais l'alignement. Plus le trajet est long, plus une petite erreur d'angle grandit : un écart de 1 degré décale le point d'environ 9 cm à 5 m. Le faisceau des lasers bon marché s'élargit aussi un peu en chemin ; après quelques mètres, le point peut devenir plus grand que la surface de 5 mm de la LDR.

1. Monte le laser, les miroirs et le tube de la LDR sur des supports rigides (équerres vissées, supports imprimés en 3D ou cales de bois fixées à la colle chaude) ; un miroir tenu à la main ne reste jamais aligné.
2. Baisse la lumière de la pièce et repère le point laser en tenant une feuille blanche devant le premier miroir.
3. Aligne les miroirs dans l'ordre, du premier au dernier : incline chacun très légèrement jusqu'à ce que le point tombe au centre du suivant.
4. Dirige le dernier faisceau vers l'ouverture du tube de la LDR et lance le programme de test pour trouver la position où l'écart affiché dans le moniteur série est le plus grand.
5. Une fois tout aligné, bloque l'angle des miroirs avec de la colle chaude ou une vis de blocage ; même un petit choc sur la table peut tout dérégler.
6. Teste chaque segment du filet en le coupant un par un avec la main et vérifie que l'alarme sonne à chaque fois.

Compteur de passages : combien sont passés, et en combien de temps ?

La même barrière permet de compter les personnes qui passent une porte, les cartons sur un convoyeur ou les balles qui tombent dans un bac. L'astuce consiste à compter chaque passage une seule fois. Le programme ci-dessous enregistre l'instant où le faisceau est coupé et compte le passage quand le faisceau revient ; ainsi, une personne qui reste un moment dans le faisceau ne compte qu'une fois. Les coupures de moins de 15 ms sont considérées comme de la poussière ou du bruit électrique et ignorées. Le programme affiche aussi combien de temps le faisceau est resté coupé : si tu connais la longueur de l'objet, ce temps donne directement sa vitesse (v = L / t). Par exemple, si une petite voiture de 25 cm coupe le faisceau pendant 50 ms, sa vitesse est de 0,25 / 0,05 = 5 m/s.

1// Lazer bariyeriyle geçiş sayacı ve kesilme süresi / Laser barrier pass counter and block time
2const int LASER_PIN = 7;                 // KY-008 S pini / KY-008 S pin
3const int LDR_PIN = A0;                  // LDR bölücü çıkışı / LDR divider output
4const unsigned long MIN_BREAK_MS = 15;   // daha kısa kesintiler parazittir / shorter breaks are noise
5const float OBJECT_LENGTH_M = 0.0;       // cismin boyu biliniyorsa yaz (ör. 0.25) / object length if known (e.g. 0.25)
6
7int onLevel = 0, offLevel = 0;
8bool beamOk = true;
9unsigned long brokenSince = 0;
10unsigned long passCount = 0;
11
12int readAvg() {
13  long sum = 0;
14  for (int i = 0; i < 4; i++) sum += analogRead(LDR_PIN);  // 4 ölçüm yeterli ve hızlı / 4 readings: enough and fast
15  return sum / 4;
16}
17
18void calibrate() {
19  while (true) {
20    digitalWrite(LASER_PIN, LOW);
21    delay(300);
22    offLevel = readAvg();
23    digitalWrite(LASER_PIN, HIGH);
24    delay(300);
25    onLevel = readAvg();
26    if (abs(onLevel - offLevel) >= 100) return;
27    Serial.println(F("Isin LDR'ye ulasmiyor / Beam misses the LDR"));
28    delay(2000);
29  }
30}
31
32int beamPercent() {
33  return (long)(readAvg() - offLevel) * 100 / (onLevel - offLevel);
34}
35
36void setup() {
37  Serial.begin(9600);
38  pinMode(LASER_PIN, OUTPUT);
39  calibrate();
40  Serial.println(F("Sayac hazir / Counter ready"));
41}
42
43void loop() {
44  unsigned long now = millis();
45  int pct = beamPercent();
46
47  if (beamOk && pct < 40) {
48    beamOk = false;
49    brokenSince = now;                   // kesilme anı / moment of the break
50  } else if (!beamOk && pct > 60) {
51    beamOk = true;
52    unsigned long blocked = now - brokenSince;   // ışın ne kadar kesik kaldı / how long the beam was blocked
53    if (blocked >= MIN_BREAK_MS) {
54      passCount++;
55      Serial.print(F("Gecis / Pass #"));
56      Serial.print(passCount);
57      Serial.print(F("  Sure / Time: "));
58      Serial.print(blocked);
59      Serial.print(F(" ms"));
60      if (OBJECT_LENGTH_M > 0) {
61        float speed = OBJECT_LENGTH_M / (blocked / 1000.0);  // v = L / t
62        Serial.print(F("  Hiz / Speed: "));
63        Serial.print(speed, 2);
64        Serial.print(F(" m/s"));
65      }
66      Serial.println();
67    }
68  }
69}

Pour savoir dans quel sens quelqu'un passe, utilise deux faisceaux parallèles espacés de 10 à 15 cm. Si le faisceau extérieur A est coupé d'abord, puis le faisceau intérieur B, la personne entre ; si B est coupé d'abord, puis A, elle sort. Si seul A est coupé et que le faisceau revient sans que B l'ait été, la personne s'est approchée de la porte puis a fait demi-tour, et elle n'est pas comptée. Le nombre de personnes à l'intérieur s'obtient en soustrayant les sorties des entrées, et tu peux l'afficher sur un afficheur 7 segments ou un écran LCD I2C. L'écart entre les deux faisceaux doit être assez petit pour que le corps d'une personne les coupe tous les deux au même moment.

Chronomètre de course et mesure de vitesse

Mesurer le temps entre deux portes laser donne un chronomètre précis pour la course, le vélo, les petites voitures ou les expériences de physique. Tu places la porte de départ et la porte d'arrivée à une distance connue (d) l'une de l'autre, et la vitesse vaut v = d / t. Quelqu'un qui parcourt une piste de 10 m en 2,5 secondes court à 4 m par seconde, soit 14,4 km/h. Pour allumer et éteindre les deux lasers ensemble, relie la broche − des deux modules au collecteur d'un seul transistor 2N2222 ou S8050 ; les broches S et centrales au 5V, l'émetteur du transistor à GND et sa base à D7 via 1 kΩ. La LDR de la porte de départ va sur A0, celle de la porte d'arrivée sur A1.

1// İki lazer kapılı yarış zamanlayıcı ve hız ölçer / Two-gate laser race timer and speed meter
2const int LASER_PIN = 7;                 // iki lazer tek transistörle / both lasers through one transistor
3const int START_LDR = A0;                // başlangıç kapısı / start gate
4const int FINISH_LDR = A1;               // bitiş kapısı / finish gate
5const int BUZZER_PIN = 8;                // aktif buzzer / active buzzer
6const float DISTANCE_M = 10.0;           // kapılar arası mesafe (metre) / distance between the gates (m)
7const unsigned long TIMEOUT_MS = 60000;  // 60 sn'de bitmezse iptal / cancel after 60 s
8
9int onA, offA, onB, offB;
10enum State { READY, RUNNING, DONE };
11State state = READY;
12unsigned long startUs = 0;
13unsigned long startMs = 0;
14unsigned long doneMs = 0;
15
16int readAvg(int pin) {
17  long sum = 0;
18  for (int i = 0; i < 4; i++) sum += analogRead(pin);
19  return sum / 4;
20}
21
22bool isBroken(int pin, int on, int off) {
23  long pct = (long)(readAvg(pin) - off) * 100 / (on - off);
24  return pct < 40;                       // %40'ın altı = kesik / below 40% = broken
25}
26
27void calibrate() {
28  while (true) {
29    digitalWrite(LASER_PIN, LOW);        // iki lazer de kapalı / both lasers off
30    delay(300);
31    offA = readAvg(START_LDR);
32    offB = readAvg(FINISH_LDR);
33    digitalWrite(LASER_PIN, HIGH);       // iki lazer de açık / both lasers on
34    delay(300);
35    onA = readAvg(START_LDR);
36    onB = readAvg(FINISH_LDR);
37    if (abs(onA - offA) >= 100 && abs(onB - offB) >= 100) return;
38    Serial.println(F("Kapilardan biri hizali degil / One gate is misaligned"));
39    delay(2000);
40  }
41}
42
43void beep(int ms) {
44  digitalWrite(BUZZER_PIN, HIGH);
45  delay(ms);
46  digitalWrite(BUZZER_PIN, LOW);
47}
48
49void setup() {
50  Serial.begin(9600);
51  pinMode(LASER_PIN, OUTPUT);
52  pinMode(BUZZER_PIN, OUTPUT);
53  calibrate();
54  Serial.println(F("Hazir: baslangic kapisini gec / Ready: cross the start gate"));
55}
56
57void loop() {
58  if (state == READY && isBroken(START_LDR, onA, offA)) {
59    startUs = micros();                  // zamanı hemen al / grab the time immediately
60    startMs = millis();
61    state = RUNNING;
62    beep(30);
63  } else if (state == RUNNING) {
64    if (isBroken(FINISH_LDR, onB, offB)) {
65      unsigned long elapsedUs = micros() - startUs;
66      float seconds = elapsedUs / 1000000.0;
67      float speed = DISTANCE_M / seconds;            // v = d / t
68      Serial.print(F("Sure / Time: "));
69      Serial.print(seconds, 3);
70      Serial.print(F(" s  Hiz / Speed: "));
71      Serial.print(speed, 2);
72      Serial.print(F(" m/s = "));
73      Serial.print(speed * 3.6, 1);
74      Serial.println(F(" km/h"));
75      beep(300);
76      state = DONE;
77      doneMs = millis();
78    } else if (millis() - startMs > TIMEOUT_MS) {
79      Serial.println(F("Zaman asimi / Timeout"));
80      state = READY;
81    }
82  } else if (state == DONE && millis() - doneMs > 3000 &&
83             !isBroken(START_LDR, onA, offA) && !isBroken(FINISH_LDR, onB, offB)) {
84    state = READY;                       // 3 sn sonra yeni tur / new run after 3 s
85    Serial.println(F("Hazir / Ready"));
86  }
87}

Le programme fonctionne comme une machine à états : dans l'état READY, quand le faisceau de départ est coupé, il enregistre le temps avec micros() et passe à RUNNING ; quand le faisceau d'arrivée est coupé, il affiche le temps et la vitesse, puis se prépare pour une nouvelle course au bout de 3 secondes. Si l'arrivée n'est pas franchie en 60 secondes, la course est annulée. Soyons honnêtes sur la précision : le code mesure avec une résolution meilleure que 1 ms, mais la LDR met 10 à 30 ms à réagir à l'obscurité. Heureusement, comme tu utilises le même type de LDR aux deux portes, ce retard se produit aux deux extrémités et se compense en grande partie ; pour la course à pied et le vélo, le résultat est largement suffisant.

Notification sur le téléphone avec un ESP32 (Telegram)

Pour que l'alarme serve aussi quand tu n'es pas chez toi, tu peux utiliser un ESP32 : dès que le faisceau est coupé, il t'envoie un message sur ton téléphone via Telegram. Le câblage est celui du tableau plus haut : le laser est alimenté en 5V et commuté par un transistor NPN relié au GPIO 26, et le pont de la LDR est alimenté en 3V3 et relié au GPIO 34. Ce choix n'est pas un hasard : les broches ADC2 de l'ESP32 ne fonctionnent pas quand le Wi-Fi est actif, alors branche toujours les capteurs analogiques sur des broches ADC1 (GPIO 32–39). L'ADC de l'ESP32 est sur 12 bits et renvoie des valeurs de 0 à 4095 ; c'est pourquoi l'écart minimal de calibrage dans le code est de 400. Nous avons détaillé la création du bot et l'obtention du token et du chat ID dans l'article bot Telegram avec ESP32 ; pour ce programme, installe les bibliothèques UniversalTelegramBot et ArduinoJson depuis le gestionnaire de bibliothèques.

1// ESP32 lazer bariyeri + Telegram bildirimi / ESP32 laser tripwire + Telegram notification
2#include <WiFi.h>
3#include <WiFiClientSecure.h>
4#include <UniversalTelegramBot.h>        // ArduinoJson kütüphanesi de gerekir / also needs the ArduinoJson library
5
6const char* WIFI_SSID = "WIFI_ADI";      // Wi-Fi ağının adı / your Wi-Fi name
7const char* WIFI_PASS = "WIFI_SIFRESI";  // Wi-Fi şifren / your Wi-Fi password
8#define BOT_TOKEN "1234567890:ABCdefGhIJKlmNoPQRstuVWXyz"  // BotFather'dan / from BotFather
9#define CHAT_ID "123456789"              // senin chat ID'n / your chat ID
10
11const int LASER_PIN = 26;                // NPN transistör bazına 1 kΩ ile / to the NPN base via 1 kΩ
12const int LDR_PIN = 34;                  // ADC1 pini, Wi-Fi ile çalışır / ADC1 pin, works with Wi-Fi
13const int BUZZER_PIN = 25;               // aktif buzzer / active buzzer
14const unsigned long CONFIRM_MS = 30;     // en az bu kadar kesik kalmalı / must stay broken this long
15const unsigned long SIREN_MS = 5000;     // siren süresi / siren duration
16const unsigned long COOLDOWN_MS = 30000; // iki deneme arası en az 30 sn / at least 30 s between attempts
17
18WiFiClientSecure client;
19UniversalTelegramBot bot(BOT_TOKEN, client);
20
21int onLevel = 0, offLevel = 0;
22bool beamOk = true;
23bool counted = false;                    // bu kesinti sayıldı mı / has this break been counted
24unsigned long brokenSince = 0;
25bool sirenOn = false;
26unsigned long sirenStart = 0;
27unsigned long breakCount = 0;
28bool pending = false;                    // gönderilecek bildirim var / a notification is waiting
29bool triedOnce = false;
30unsigned long lastTry = 0;
31
32int readAvg() {
33  long sum = 0;
34  for (int i = 0; i < 16; i++) sum += analogRead(LDR_PIN);  // 16 ölçüm ortalaması / average of 16 readings
35  return sum / 16;
36}
37
38void calibrate() {
39  while (true) {
40    digitalWrite(LASER_PIN, LOW);        // lazer kapalı = kesik ışın / laser off = broken beam
41    delay(300);
42    offLevel = readAvg();
43    digitalWrite(LASER_PIN, HIGH);       // lazer açık = sağlam ışın / laser on = intact beam
44    delay(300);
45    onLevel = readAvg();
46    Serial.printf("Isinli / beam: %d  Isinsiz / no beam: %d\n", onLevel, offLevel);
47    if (abs(onLevel - offLevel) >= 400) return;   // 12 bit ölçekte yeterli fark / enough gap on the 12-bit scale
48    Serial.println("Isin LDR'ye ulasmiyor / Beam misses the LDR");
49    delay(2000);
50  }
51}
52
53int beamPercent() {
54  return (long)(readAvg() - offLevel) * 100 / (onLevel - offLevel);
55}
56
57void setup() {
58  Serial.begin(115200);
59  pinMode(LASER_PIN, OUTPUT);
60  pinMode(BUZZER_PIN, OUTPUT);
61  calibrate();
62
63  WiFi.mode(WIFI_STA);
64  WiFi.begin(WIFI_SSID, WIFI_PASS);
65  client.setCACert(TELEGRAM_CERTIFICATE_ROOT);    // api.telegram.org kök sertifikası / root certificate
66  unsigned long start = millis();
67  while (WiFi.status() != WL_CONNECTED && millis() - start < 15000) {  // en fazla 15 sn bekle / wait up to 15 s
68    delay(500);
69    Serial.print(".");
70  }
71  if (WiFi.status() == WL_CONNECTED) {
72    Serial.println(WiFi.localIP());
73    bot.sendMessage(CHAT_ID, "Lazer alarmi devrede / Laser alarm armed", "");
74  }
75}
76
77void loop() {
78  unsigned long now = millis();
79  int pct = beamPercent();
80
81  if (beamOk && pct < 40) {              // ışın yeni kesildi / beam just broke
82    beamOk = false;
83    counted = false;
84    brokenSince = now;
85  } else if (!beamOk && pct > 60) {
86    beamOk = true;                       // ışın geri geldi / beam restored
87  }
88
89  if (!beamOk && !counted && now - brokenSince >= CONFIRM_MS) {
90    counted = true;                      // her kesinti bir kez sayılır / each break counts once
91    breakCount++;
92    pending = true;
93    sirenOn = true;
94    sirenStart = now;
95    Serial.printf("Kesinti / Break #%lu\n", breakCount);
96  }
97
98  if (sirenOn && now - sirenStart >= SIREN_MS) sirenOn = false;
99  digitalWrite(BUZZER_PIN, (sirenOn && (now / 200) % 2) ? HIGH : LOW);  // kesik siren / beeping siren
100
101  if (pending && (!triedOnce || now - lastTry >= COOLDOWN_MS)) {
102    triedOnce = true;
103    lastTry = now;
104    if (WiFi.status() == WL_CONNECTED) {
105      String text = "Lazer bariyeri kesildi! / Laser beam broken! Toplam / Total: " + String(breakCount);
106      if (bot.sendMessage(CHAT_ID, text, "")) pending = false;  // gitmezse 30 sn sonra yeniden / retry in 30 s if it fails
107    } else {
108      WiFi.reconnect();                  // bağlantı koptuysa yeniden dene / reconnect if the link dropped
109    }
110  }
111}

Chaque coupure est comptée une fois, la sirène sonne 5 secondes et une notification est mise en file d'attente. Les envois sont tentés au plus une fois toutes les 30 secondes ; les nouvelles coupures survenues entre-temps s'ajoutent au total et apparaissent dans le message suivant. Ainsi, ton téléphone n'est pas inondé de messages si quelqu'un fait des allers-retours dans le faisceau. Si un message ne part pas, le code réessaie 30 secondes plus tard, et si le Wi-Fi est tombé, il lance la reconnexion. sendMessage() prend une ou deux secondes, car il ouvre une connexion HTTPS sécurisée ; pendant ce temps, le motif de la sirène se fige et le faisceau n'est pas surveillé, c'est normal.

Barrière laser avec Raspberry Pi Pico et MicroPython

Sur le Raspberry Pi Pico, tu peux reproduire la même logique en quelques lignes de MicroPython. Le laser est alimenté par VBUS (le 5 V de l'USB, broche 40) et commuté par un transistor NPN relié à GP15 ; le pont de la LDR est alimenté par la broche 3V3(OUT) et relié à GP26 (ADC0), et le buzzer actif va sur GP14. Comme l'ADC du Pico renvoie des valeurs de 0 à 65535 avec read_u16(), l'écart minimal de calibrage est de 6000. Le code reprend le même calcul de pourcentage, l'hystérésis et le délai de confirmation ; il compte chaque coupure, fait sonner la sirène 5 secondes et affiche combien de temps le faisceau est resté coupé. Pour que le Pico fonctionne sans ordinateur, enregistre le fichier sur la carte sous le nom main.py avec Thonny.

1# Raspberry Pi Pico lazer bariyeri: alarm + geçiş sayacı / Laser barrier: alarm + pass counter
2from machine import Pin, ADC
3import time
4
5laser = Pin(15, Pin.OUT)        # NPN transistör bazına 1 kΩ ile / to the NPN base via 1 kΩ
6ldr = ADC(26)                   # GP26 = ADC0, bölücü 3V3'ten / divider fed from 3V3
7buzzer = Pin(14, Pin.OUT)       # aktif buzzer / active buzzer
8
9CONFIRM_MS = 30                 # en az bu kadar kesik kalmalı / must stay broken this long
10SIREN_MS = 5000                 # siren süresi / siren duration
11
12
13def read_avg(n=8):
14    total = 0
15    for _ in range(n):
16        total += ldr.read_u16()
17    return total // n
18
19
20def calibrate():
21    while True:
22        laser.value(0)          # lazer kapalı = kesik ışın / laser off = broken beam
23        time.sleep_ms(300)
24        off = read_avg(32)
25        laser.value(1)          # lazer açık = sağlam ışın / laser on = intact beam
26        time.sleep_ms(300)
27        on = read_avg(32)
28        print("Isinli / beam:", on, " Isinsiz / no beam:", off)
29        if abs(on - off) > 6000:          # 16 bit ölçekte yeterli fark / enough gap on the 16-bit scale
30            return on, off
31        print("Isin LDR'ye ulasmiyor / Beam misses the LDR")
32        time.sleep(2)
33
34
35on_level, off_level = calibrate()
36beam_ok = True
37counted = False
38broken_at = time.ticks_ms()
39siren_until = time.ticks_ms()
40count = 0
41
42while True:
43    now = time.ticks_ms()
44    pct = (read_avg() - off_level) * 100 // (on_level - off_level)   # 100 = ışın tam / full beam
45
46    if beam_ok and pct < 40:            # ışın yeni kesildi / beam just broke
47        beam_ok = False
48        counted = False
49        broken_at = now
50    elif not beam_ok and pct > 60:      # ışın geri geldi / beam restored
51        beam_ok = True
52        print("Kesik kaldigi sure / blocked for", time.ticks_diff(now, broken_at), "ms")
53
54    if not beam_ok and not counted and time.ticks_diff(now, broken_at) >= CONFIRM_MS:
55        counted = True                  # her kesinti bir kez sayılır / each break counts once
56        count += 1
57        siren_until = time.ticks_add(now, SIREN_MS)
58        print("Gecis / Pass:", count)
59
60    siren = time.ticks_diff(siren_until, now) > 0
61    buzzer.value(1 if siren and (now // 200) % 2 else 0)   # kesik siren / beeping siren

Idées de projets avec le module laser

• Alarme laser pour la maison : Combine les faisceaux de porte et de couloir avec un détecteur de mouvement PIR et regroupe toutes les entrées dans une centrale ; détails dans l'article système d'alarme Arduino.
• Harpe laser : Installe 5 à 7 faisceaux côte à côte et joue une note différente avec un buzzer passif chaque fois qu'un faisceau est coupé.
• Compteur de visiteurs : Distingue entrées et sorties avec deux faisceaux et affiche le nombre de personnes présentes sur un écran.
• Mesure de vitesse pour un concours scientifique : Mesure avec deux portes la vitesse d'objets qui glissent sur un plan incliné et compare les frottements ; pour d'autres idées, consulte l'article idées de projets pour concours scientifiques.
• Jeu du labyrinthe laser : Monte avec des miroirs un filet de faisceaux sous la hauteur des genoux ; chronomètre ceux qui essaient de le traverser sans le toucher et ajoute une pénalité à chaque contact.
• Protection de tiroir et de coffre : Détecte la coupure du faisceau à l'ouverture du couvercle et envoie une notification sur ton téléphone avec l'ESP32.

Erreurs fréquentes et solutions

Le module laser KY-008 rend possible l'un de ces rares projets qui enseignent à la fois l'optique, le pont diviseur, le calibrage et la mesure du temps avec un seul composant bon marché. Commence par observer l'écart avec le programme de test, construis ensuite l'alarme, puis enrichis ton projet avec des miroirs, un compteur et un chronomètre. Dans l'application BlueGrays, tu trouveras pas à pas, avec schémas et code, le système d'avertissement et de sécurité laser, la mesure de lumière et la veilleuse avec LDR, l'alarme de mouvement ESP32 et des projets avec notifications Telegram.