Modulo Laser Arduino KY-008: Barriera Laser, Allarme e Contatore

Il modulo laser è uno dei componenti più spettacolari da usare con Arduino: produce un fascio rosso e sottile che percorre parecchi metri quasi senza allargarsi. Il modulo laser KY-008 presente in molti kit riunisce su una piccola scheda un diodo laser da 650 nm e circa 5 mW; si collega a un solo pin digitale di Arduino e si accende e spegne con digitalWrite(). Da solo è un semplice puntatore, ma con un sensore di luce di fronte diventa un allarme a barriera laser da film, un contatore di persone che attraversano una porta o un cronometro preciso al millisecondo.

In questo articolo scoprirai le caratteristiche tecniche del KY-008, quanto è davvero pericoloso un laser da 5 mW per i tuoi occhi e quali regole seguire, e come collegare correttamente il modulo ad Arduino Uno, ESP32 e Raspberry Pi Pico. Poi costruirai una barriera laser con una LDR, farai misurare la soglia ad Arduino in automatico invece di indovinarla, trasformerai un solo laser in più fasci con gli specchi, conterai i passaggi, misurerai velocità e, con un ESP32, invierai una notifica al telefono quando il fascio viene interrotto.

Che cos'è il modulo laser KY-008 e come funziona?

Il cuore del modulo è un piccolo diodo laser montato in un tubetto di ottone. A differenza di un normale LED, un diodo laser, quando la corrente supera una certa soglia, emette luce di una sola lunghezza d'onda e in modo ordinato (coerente); una minuscola lente in cima al tubetto trasforma questa luce in un fascio quasi parallelo. Per questo la luce di un LED si disperde in pochi centimetri, mentre il punto laser resta largo pochi millimetri anche a diversi metri. 650 nm corrisponde a un rosso intenso che l'occhio vede facilmente. La resistenza sulla piccola scheda dietro la testina limita la corrente nel diodo. I diodi laser sono molto più sensibili alle sovracorrenti dei LED; se aggiri questa resistenza e alimenti il diodo direttamente, può guastarsi in pochi secondi.

Sicurezza degli occhi: quanto è pericoloso un laser da 5 mW?

Il pericolo di un laser non dipende dalla sua potenza totale, ma dal fatto che questa potenza è concentrata in un punto minuscolo. Il cristallino mette a fuoco un fascio parallelo in un punto di pochi micron sulla retina; per questo 5 mW che sembrano innocui su un muro possono diventare sulla retina un punto più intenso che guardare direttamente il sole. I laser sono divisi in classi in base a questo rischio. Nei laser di classe 2, sotto 1 mW, il riflesso di ammiccamento (circa 0,25 secondi) di solito basta a proteggere l'occhio. La classe 3R, a cui appartiene il KY-008, arriva fino a cinque volte questo limite: un'occhiata breve e accidentale comporta poco rischio, ma guardare il fascio direttamente o tramite uno specchio può danneggiare l'occhio.

• Non guardare mai nel fascio: Non avvicinare all'occhio l'estremità da cui esce il laser e non muovere il modulo acceso con la mano.
• Tieni il fascio sotto l'altezza degli occhi: Monta i fasci di allarmi e contatori a 20–50 cm da terra. Questa altezza corrisponde agli occhi di un bambino che gattona, di un bambino piccolo o di un gatto o un cane: non lasciare il laser acceso quando sono nei paraggi.
• Attenzione ai riflessi: Specchi, vetri, quadranti di orologi e metalli lucidi deviano il fascio in direzioni impreviste. Controlla tutto il percorso del fascio e fallo terminare su una superficie opaca e scura.
• Niente bambini da soli: Un laser non è un giocattolo; nei progetti scolastici e alle fiere della scienza lavora sotto la supervisione di un adulto.
• Non fidarti ciecamente dell'etichetta: Nei moduli economici la potenza reale può essere diversa da quella dichiarata; tratta ogni modulo almeno come un laser di classe 3R.
• Allinea con un foglio di carta: Tieni un foglio bianco davanti al fascio e segui il punto sulla carta; non guardare mai dentro il fascio per vedere dove va.

Collegamento del KY-008: Arduino Uno, ESP32 e Raspberry Pi Pico

Il KY-008 ha tre pin: S è il pin di segnale e accende il laser quando è HIGH, − è GND e il pin centrale, senza scritte, va a +5V nella maggior parte delle schede oppure non è collegato. Il laser si trova tra S e −, quindi il pin di Arduino collegato a S fornisce direttamente la sua corrente. Su un Arduino Uno non è un problema per prove brevi, ma la corrente del modulo varia da scheda a scheda e può avvicinarsi a 40 mA. È il limite assoluto per pin dell'ATmega328P; il valore consigliato è 20 mA. Se il laser deve restare acceso per ore, se usi più laser o se lavori con ESP32 o Pico, alimenta il laser dai 5V e commutalo con un transistor NPN (BC547, S8050 o 2N2222). Trovi la piedinatura del transistor nella guida ai transistor.

Prima di passare agli sketch, prova insieme laser e LDR con il piccolo programma qui sotto. Accende e spegne il laser ogni mezzo secondo e scrive nel Monitor seriale il valore letto nei due stati. Più grande è la differenza tra i due valori, più affidabile sarà la tua barriera: su un Uno una differenza superiore a 300 è ottima; sotto 100 il fascio non colpisce bene la LDR oppure la luce ambiente è troppo 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}

Come funziona una barriera laser con LDR?

L'idea di una barriera laser è semplice: il fascio laser colpisce di continuo una LDR (fotoresistenza) posta di fronte. Con il punto laser sopra, la resistenza della LDR scende a qualche centinaio di ohm; quando il fascio viene interrotto, sale a decine di kiloohm. Se colleghi la LDR con una resistenza fissa come partitore di tensione, questa variazione di resistenza diventa una variazione di tensione sull'ingresso analogico: con 5V → LDR → A0 → resistenza → GND, A0 legge un valore alto finché c'è il fascio e basso quando viene interrotto. Appena qualcuno attraversa il fascio, il valore crolla e Arduino fa scattare l'allarme.

Un rapido calcolo spiega perché il laser ha un effetto così forte sulla LDR: se il fascio da 5 mW si concentra in un punto di circa 3 mm di diametro, l'intensità è di circa 700 W per metro quadrato. È dello stesso ordine del sole di mezzogiorno e centinaia di volte più di una stanza ben illuminata. Eppure il nemico peggiore della barriera è la luce ambiente: davanti a una finestra al sole la LDR resta illuminata anche con il fascio interrotto e l'allarme non si accorge di nulla. La soluzione costa pochissimo: metti la LDR in fondo a un tubetto nero lungo 3–5 cm (il fusto vuoto di una penna, una cannuccia nera o una guaina termorestringente). Il tubetto lascia entrare solo il laser che arriva di fronte e blocca la luce laterale.

Passo dopo passo: allarme a barriera laser con Arduino

1. Collega il pin S del KY-008 a D7 e il pin − a GND; lascia libero il pin centrale (collegalo ai 5V se il laser non si accende).
2. Collega un piedino della LDR ai 5V e l'altro ad A0; metti una resistenza da 3,3 kΩ o 10 kΩ tra A0 e GND.
3. Metti la LDR in fondo a un tubetto nero e rivolgi l'apertura del tubetto verso il laser.
4. Collega il piedino + del buzzer attivo a D8 e il − a GND. Inserisci il pulsante per silenziare tra D4 e GND; non serve una resistenza aggiuntiva perché si usa il pull-up interno.
5. Fissa laser e LDR su una base solida; trova prima il punto laser con un foglio bianco, poi portalo dentro il tubetto.
6. Carica lo sketch e apri il Monitor seriale a 9600 baud. All'avvio nessuno deve trovarsi davanti al fascio; Arduino si calibra spegnendo e riaccendendo il laser una volta.

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}

Lo sketch non usa una soglia fissa. All'avvio calibrate() spegne il laser e misura il valore della LDR senza fascio, poi lo accende e misura il valore con il fascio. beamPercent() converte ogni lettura in una percentuale tra 0 e 100 in base a questi due valori: 100 significa che arriva tutto il fascio, 0 che è completamente interrotto. Questo calcolo non dipende dalla posizione della LDR, sopra o sotto nel partitore; che il valore salga o scenda con la luce, il risultato è lo stesso. Se il fascio scende sotto il 40 % e ci resta per almeno 30 ms, l'allarme suona a intermittenza per 10 secondi, e il pulsante su D4 lo silenzia prima. Se il fascio è ancora interrotto, l'allarme riparte: il sistema non tace finché qualcuno resta nel fascio.

Calibrazione della soglia: perché non scrivere un numero fisso

Molti esempi di allarme laser online usano una soglia fissa come "analogRead(A0) < 500". Funziona la sera in cui lo provi sulla scrivania, ma si guasta la mattina dopo quando il sole entra nella stanza, quando sposti il laser di qualche millimetro o quando cambi la LDR. La soglia giusta sta esattamente a metà tra i valori con e senza fascio. Una calibrazione automatica che rimisura entrambi i valori a ogni avvio adatta il sistema all'ambiente. Nello sketch qui sopra la soglia non è un numero ma due: il fascio è considerato interrotto quando scende sotto il 40 % e integro quando sale sopra il 60 %. Questo margine si chiama isteresi ed evita che l'allarme si attivi e disattivi decine di volte al secondo quando il valore oscilla proprio sulla soglia.

In un sistema che funziona a lungo, la luce ambiente cambia lentamente durante la giornata. Un modo semplice per compensare è richiamare calibrate() quando il fascio è integro e l'allarme non suona (per esempio ogni ora). Dato che è Arduino stesso a spegnere il laser, non scambia quel breve buio per un intruso. Per osservare le letture è molto utile il Plotter seriale dell'IDE di Arduino: passa la mano nel fascio e vedrai di quanto scende il grafico e in quanto tempo risale.

Più fasci con gli specchi: una rete con un solo laser

Un singolo fascio si supera facilmente abbassandosi o scavalcandolo. Per costruire le reti laser dei film non serve dare a ogni fascio il suo laser e la sua LDR: puoi far rimbalzare un solo laser a zigzag con degli specchi. Metti degli specchi affacciati sui due lati di una porta o di un corridoio; il fascio rimbalza da un lato all'altro e alla fine arriva alla LDR. Se si interrompe un qualsiasi tratto, la LDR resta al buio, quindi una sola LDR e lo stesso sketch proteggono l'intera rete. Poiché l'angolo di riflessione è uguale a quello di incidenza, basta inclinare pochissimo ogni specchio perché mandi il fascio al centro del successivo.

Ogni specchio fa perdere un po' di luce. Un normale specchio da bagno riflette circa il 90 % e crea un secondo punto debole (riflesso fantasma) sul vetro davanti. Gli specchi a prima superficie, con lo strato riflettente sopra il vetro, riflettono il 95 % o più e danno un unico punto pulito. Le perdite si moltiplicano, quindi la luce che arriva alla LDR cala rapidamente aggiungendo specchi:

Questa tabella mostra una cosa importante: anche il 43 % è più che sufficiente per lo sketch calibrato, perché il punto laser è centinaia di volte più luminoso della luce ambiente. La vera sfida non è la perdita di potenza, ma l'allineamento. Più è lungo il percorso, più cresce un piccolo errore di angolo: una deviazione di 1 grado sposta il punto di circa 9 cm a 5 m. Inoltre il fascio dei laser economici si allarga un po' lungo il percorso; dopo qualche metro il punto può diventare più grande della superficie di 5 mm della LDR.

1. Monta laser, specchi e tubetto della LDR su supporti robusti (squadrette avvitate, supporti stampati in 3D o blocchetti di legno fissati con colla a caldo); uno specchio tenuto in mano non resta mai allineato.
2. Abbassa la luce della stanza e trova il punto laser tenendo un foglio bianco davanti al primo specchio.
3. Allinea gli specchi in ordine, dal primo all'ultimo: inclina ciascuno pochissimo finché il punto cade al centro del successivo.
4. Dirigi l'ultimo fascio nell'apertura del tubetto della LDR ed esegui lo sketch di prova per trovare la posizione con la differenza maggiore nel Monitor seriale.
5. Quando tutto è allineato, blocca l'angolo degli specchi con colla a caldo o una vite di bloccaggio; anche un piccolo urto sul tavolo può rovinare l'allineamento.
6. Prova ogni tratto della rete interrompendolo uno alla volta con la mano e verifica che l'allarme suoni ogni volta.

Contatore di passaggi: quanti sono passati e in quanto tempo?

La stessa barriera serve a contare le persone che attraversano una porta, le scatole su un nastro trasportatore o le palline che cadono in un contenitore. Il trucco è contare ogni passaggio una sola volta. Lo sketch qui sotto registra l'istante in cui il fascio viene interrotto e conta il passaggio quando il fascio ritorna; così chi resta per un po' davanti al fascio conta come un solo passaggio. Le interruzioni più brevi di 15 ms sono considerate polvere o disturbi elettrici e vengono ignorate. Lo sketch scrive anche per quanto tempo il fascio è rimasto interrotto: se conosci la lunghezza dell'oggetto, questo tempo ti dà direttamente la velocità (v = L / t). Per esempio, se una macchinina lunga 25 cm interrompe il fascio per 50 ms, la sua velocità è 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}

Se vuoi sapere in che direzione passa qualcuno, usa due fasci paralleli distanti 10–15 cm. Se si interrompe prima il fascio esterno A e poi quello interno B, la persona sta entrando; se prima B e poi A, sta uscendo. Se si interrompe solo A e il fascio torna senza che B venga mai interrotto, la persona si è avvicinata alla porta e ha cambiato idea, e non viene contata. Il numero di persone all'interno si ottiene sottraendo le uscite dagli ingressi e puoi mostrarlo su un display a 7 segmenti o su un display LCD I2C. La distanza tra i due fasci deve essere abbastanza piccola perché il corpo di una persona li interrompa entrambi nello stesso istante.

Cronometro per gare e misura della velocità

Misurare il tempo tra due porte laser ti dà un cronometro preciso per corsa, bicicletta, macchinine o esperimenti di fisica. Metti le porte di partenza e di arrivo a una distanza nota (d), e la velocità è v = d / t. Chi percorre una pista di 10 m in 2,5 secondi corre a 4 m al secondo, cioè a 14,4 km/h. Per accendere e spegnere insieme i due laser, collega il pin − di entrambi al collettore di un unico transistor 2N2222 o S8050; i pin S e centrali ai 5V, l'emettitore del transistor a GND e la base a D7 tramite 1 kΩ. La LDR della porta di partenza va su A0, quella della porta di arrivo su 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}

Lo sketch funziona come una macchina a stati: nello stato READY, quando si interrompe il fascio di partenza, registra il tempo con micros() e passa a RUNNING; quando si interrompe il fascio di arrivo, scrive tempo e velocità e dopo 3 secondi è pronto per una nuova prova. Se l'arrivo non viene superato entro 60 secondi, la prova viene annullata. Siamo onesti sulla precisione: il codice misura con una risoluzione migliore di 1 ms, ma la LDR impiega 10–30 ms a reagire al buio. Per fortuna, dato che usi lo stesso tipo di LDR su entrambe le porte, questo ritardo si verifica a tutte e due le estremità e in gran parte si compensa; per corsa e bicicletta il risultato è più che sufficiente.

Notifiche sul telefono con ESP32 (Telegram)

Perché l'allarme sia utile anche quando non sei in casa, puoi usare un ESP32: appena il fascio viene interrotto, ti invia un messaggio sul telefono tramite Telegram. I collegamenti sono quelli della tabella sopra: il laser è alimentato dai 5V e commutato da un transistor NPN collegato al GPIO 26, e il partitore della LDR è alimentato dai 3V3 e collegato al GPIO 34. Non è un caso: i pin ADC2 dell'ESP32 non funzionano con il Wi-Fi attivo, quindi collega sempre i sensori analogici ai pin ADC1 (GPIO 32–39). L'ADC dell'ESP32 è a 12 bit e restituisce valori da 0 a 4095; per questo la differenza minima di calibrazione nel codice è 400. Come creare il bot e ottenere token e chat ID lo spieghiamo in dettaglio nell'articolo bot Telegram con ESP32; per questo sketch installa le librerie UniversalTelegramBot e ArduinoJson dal Gestore librerie.

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}

Ogni interruzione viene contata una volta, la sirena suona per 5 secondi e una notifica viene messa in coda. I tentativi di invio avvengono al massimo una volta ogni 30 secondi; le nuove interruzioni nel frattempo si sommano al totale e compaiono nel messaggio successivo. Così il telefono non viene sommerso di messaggi se qualcuno va avanti e indietro nel fascio. Se un messaggio non parte, il codice riprova dopo 30 secondi e, se il Wi-Fi è caduto, avvia la riconnessione. sendMessage() richiede uno o due secondi perché apre una connessione HTTPS sicura; in quel tempo lo schema della sirena si blocca e il fascio non viene controllato, è normale.

Barriera laser con Raspberry Pi Pico e MicroPython

Sulla Raspberry Pi Pico puoi realizzare la stessa logica con poche righe di MicroPython. Il laser è alimentato da VBUS (i 5 V dell'USB, pin 40) e commutato da un transistor NPN collegato a GP15; il partitore della LDR è alimentato dal pin 3V3(OUT) e collegato a GP26 (ADC0), e il buzzer attivo va su GP14. Poiché l'ADC della Pico restituisce valori da 0 a 65535 con read_u16(), la differenza minima di calibrazione è 6000. Il codice usa lo stesso calcolo percentuale, l'isteresi e il tempo di conferma; conta ogni interruzione, fa suonare la sirena per 5 secondi e scrive per quanto tempo il fascio è rimasto interrotto. Perché la Pico funzioni senza computer, salva il file sulla scheda come main.py con 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

Idee di progetto con il modulo laser

• Allarme laser per la casa: Combina i fasci di porte e corridoi con un sensore di movimento PIR e riunisci tutti gli ingressi in un'unica centrale; dettagli nell'articolo sistema di allarme con Arduino.
• Arpa laser: Monta 5–7 fasci affiancati e suona una nota diversa con un buzzer passivo ogni volta che un fascio viene interrotto.
• Contatore di visitatori: Distingui ingressi e uscite con due fasci e mostra su un display quante persone ci sono dentro.
• Misuratore di velocità per la fiera della scienza: Misura con due porte la velocità di oggetti che scivolano su un piano inclinato e confronta l'attrito; per altre idee guarda l'articolo sulle idee di progetto per concorsi scientifici.
• Gioco del labirinto laser: Costruisci con gli specchi una rete di fasci sotto l'altezza del ginocchio; cronometra chi prova ad attraversarla senza toccarla e aggiungi una penalità a ogni contatto.
• Protezione di cassetti e casseforti: Rileva l'interruzione del fascio all'apertura del coperchio e invia una notifica al telefono con l'ESP32.

Errori comuni e soluzioni

Il modulo laser KY-008 rende possibile uno di quei rari progetti che, con un solo componente economico, insegnano insieme ottica, partitori di tensione, calibrazione e misura dei tempi. Comincia osservando la differenza con lo sketch di prova, poi costruisci l'allarme e amplia il progetto con specchi, contatore e cronometro. Nell'app BlueGrays trovi passo dopo passo, con schemi e codice, il sistema di avviso e di sicurezza laser, la misura della luce e la luce notturna con LDR, l'allarme di movimento con ESP32 e progetti con notifiche Telegram.