KY-008-lasermodule met Arduino: laserbarrière-alarm en timer
KY-008-lasermodule en Arduino: bedrading, oogveiligheid bij 5 mW 650 nm, een LDR-laserbarrière, automatische drempelkalibratie, spiegels, een racetimer en ESP32-meldingen.
Een lasermodule is een van de meest opvallende onderdelen die je met een Arduino kunt gebruiken: hij maakt een dunne rode straal die meters ver reikt zonder uit te waaieren. De KY-008-lasermodule uit hobbysets heeft een laserdiode van 650 nm en ongeveer 5 mW op een klein printje; hij sluit je aan op één digitale pin van de Arduino en schakelt aan en uit met digitalWrite(). Op zichzelf is het alleen een laserpointer, maar met een lichtsensor aan de overkant wordt het een laserbarrière-alarm zoals in films, een teller voor mensen die door een deur lopen of een racetimer die op de milliseconde nauwkeurig is.
In deze gids leer je de specificaties van de KY-008, hoe gevaarlijk een laser van 5 mW echt is voor je ogen en welke regels je volgt, en hoe je de module goed aansluit op een Arduino Uno, ESP32 en Raspberry Pi Pico. Daarna bouw je een laserbarrière met een LDR, laat je de Arduino de drempel automatisch meten in plaats van hem te raden, maak je van één laser meerdere stralen met spiegels, tel je passages en meet je snelheid, en stuur je met een ESP32 een melding naar je telefoon als de straal wordt onderbroken.

Wat is de KY-008-lasermodule en hoe werkt hij?
Het hart van de module is een kleine laserdiode in een messing buisje. Anders dan een gewone led zendt een laserdiode licht uit met één golflengte en op een geordende (coherente) manier zodra de stroom een bepaalde drempel overschrijdt; een piepklein lensje aan het eind van de buis maakt van dit licht een bijna evenwijdige straal. Daarom waaiert het licht van een led binnen enkele centimeters uit, terwijl de laserstip zelfs op meters afstand maar een paar millimeter breed blijft. 650 nm is een diep rood dat het oog goed ziet. De weerstand op het printje achter de laserkop beperkt de stroom door de diode. Laserdiodes zijn veel gevoeliger voor te hoge stroom dan leds; als je deze weerstand overslaat en de diode direct voedt, kun je hem binnen seconden kapotmaken.
| Eigenschap | Waarde |
|---|---|
| Model | KY-008 (bij sommige verkopers HW-493) |
| Golflengte | 650 nm (zichtbaar rood) |
| Uitgangsvermogen | Ongeveer 5 mW |
| Laserklasse | 3R (IEC 60825-1), IIIa in de VS |
| Werkspanning | 5 V (zwakker bij 3,3 V) |
| Stroom | Onder 40 mA; verschilt per board |
| Laserkop | Messing buisje van 6 mm |
| Pins | S (signaal), middelste pin (+5V of bij de meeste boards niet aangesloten), − (GND) |
| Werktemperatuur | −10 tot 40 °C |
Oogveiligheid: hoe gevaarlijk is een laser van 5 mW?
Het gevaar van een laser komt niet door het totale vermogen, maar doordat dat vermogen in een heel klein punt is samengebracht. De lens van je oog focust een evenwijdige straal op een punt ter grootte van een micron op het netvlies, dus 5 mW die op een muur onschuldig lijkt, kan op het netvlies een felle stip worden die intenser is dan recht in de zon kijken. Lasers zijn op basis van dit risico in klassen verdeeld. Bij klasse 2-lasers onder 1 mW is de knipperreflex van het oog (ongeveer 0,25 seconde) meestal genoeg bescherming. Klasse 3R, waartoe de KY-008 hoort, gaat tot vijf keer die grens: een kort, per ongeluk oogcontact is een laag risico, maar direct in de straal kijken, of via een spiegel, kan het oog beschadigen.
| Klasse | Vermogen (zichtbaar licht) | Risk |
|---|---|---|
| 1 | Zeer laag, of de straal zit opgesloten in het apparaat | Veilig bij normaal gebruik |
| 2 | Tot 1 mW | De knipperreflex beschermt; staar er niet bewust in |
| 3R | 1–5 mW (KY-008) | Direct kijken kan het oog beschadigen |
| 3B | 5–500 mW | Directe en door spiegels weerkaatste stralen zijn gevaarlijk |
| 4 | Boven 500 mW | Gevaar voor ogen, huid en brand |
- Kijk nooit in de straal: Houd de uitgang van de laser niet bij je oog en zwaai niet met de module in je hand terwijl hij aan staat.
- Houd de straal onder ooghoogte: Monteer alarm- en tellerstralen 20–50 cm boven de vloer. Die hoogte komt overeen met de ooghoogte van een kruipende baby, een klein kind of een kat of hond, dus laat de laser niet aan staan als zij in de buurt zijn.
- Pas op voor reflecties: Spiegels, glas, horlogeglazen en glimmend metaal sturen de straal in onverwachte richtingen. Controleer het pad van de straal van begin tot eind en laat hem eindigen op een matte, donkere ondergrond.
- Kinderen gebruiken hem niet alleen: Een laser is geen speelgoed; werk bij schoolprojecten en wetenschapsbeurzen onder toezicht van een volwassene.
- Vertrouw het label niet blindly: Het echte vermogen van goedkope modules kan afwijken van het label; behandel elke module als minimaal klasse 3R.
- Richt af met een vel papier: Houd wit papier voor de straal en volg de stip op het papier; kijk nooit in de straal om te zien waar hij heen gaat.
KY-008-bedrading: Arduino Uno, ESP32 en Raspberry Pi Pico
De KY-008 heeft drie pins: S is de signaalpin en zet de laser aan bij HIGH, − is GND en de niet-gemarkeerde middelste pin gaat bij de meeste boards naar +5V of is helemaal niet aangesloten. De laser zit tussen S en −, dus de Arduino-pin die je op S aansluit levert de stroom van de laser rechtstreeks. Op een Arduino Uno is dat prima voor korte tests, maar de stroom van de module verschilt per board en kan tegen 40 mA aan komen. Dat is het absolute maximum per pin van de ATmega328P; de aanbevolen waarde is 20 mA. Als je de laser urenlang aan laat, meer dan één laser gebruikt of met een ESP32 of Pico werkt, voed de laser dan met 5V en schakel hem met een NPN-transistor (BC547, S8050 of 2N2222). De pinout van de transistor vind je in de transistorgids.
| Aansluiting | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| KY-008 S | D7 | 5V (VIN) | VBUS (pin 40) |
| Middelste pin van de KY-008 | Niet aangesloten (5V als de laser niet oplicht) | 5V (VIN) | VBUS (pin 40) |
| KY-008 − | GND | NPN-collector | NPN-collector |
| NPN-emitter | – | GND | GND (pin 38) |
| NPN-basis (via 1 kΩ) | – | GPIO 26 | GP15 (pin 20) |
| LDR-pootje 1 | 5V | 3V3 | 3V3(OUT) (pin 36) |
| LDR-pootje 2 + bovenkant van de weerstand | A0 | GPIO 34 | GP26 (pin 31) |
| Onderkant van de weerstand (3,3–10 kΩ) | GND | GND | GND |
| Actieve buzzer + | D8 | GPIO 25 | GP14 (pin 19) |
Probeer, voordat je verdergaat met de sketches, de laser en de LDR samen uit met het kleine testprogramma hieronder. Het zet de laser elke halve seconde aan en uit en toont de meetwaarde in beide toestanden in de Serial Monitor. Hoe groter het verschil tussen de twee waarden, hoe betrouwbaarder je barrière: op een Uno is een verschil boven 300 heel goed; onder 100 betekent dat de straal de LDR niet recht raakt of dat het omgevingslicht te sterk is.
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}Hoe werkt een LDR-laserbarrière?
Het idee achter een laserbarrière is simpel: de laserstraal valt steeds op een LDR (lichtafhankelijke weerstand) aan de andere kant. Met de laserstip erop daalt de weerstand van de LDR tot een paar honderd ohm; als de straal wordt onderbroken, stijgt die tot tientallen kilo-ohm. Schakel de LDR met een vaste weerstand als spanningsdeler en deze weerstandsverandering wordt een spanningsverandering op de analoge pin: met 5V → LDR → A0 → weerstand → GND is A0 hoog zolang de straal er is en laag als hij wordt onderbroken. Zodra iemand door de straal loopt, daalt de waarde en laat de Arduino het alarm afgaan.



Een snelle berekening laat zien waarom de laser zo'n sterk effect op de LDR heeft: als de straal van 5 mW in een stip van ongeveer 3 mm breed is geconcentreerd, geeft dat een intensiteit van ruwweg 700 W per vierkante meter. Dat ligt in dezelfde orde als zonlicht op de middag en is honderden keren helderder dan een goed verlichte kamer. Toch is de grootste vijand van de barrière het omgevingslicht: voor een zonnig raam blijft de LDR helder, ook als de straal is onderbroken, en merkt het alarm niets. De oplossing is erg goedkoop: plaats de LDR onderin een zwarte buis van 3–5 cm lang (een lege balpenhuls, een zwart rietje of krimpkous). De buis laat alleen de laser van recht voren door en houdt omgevingslicht van opzij tegen.
| Situatie | LDR-weerstand (voorbeeld) | analogRead met 10 kΩ | analogRead met 3,3 kΩ |
|---|---|---|---|
| Laser op de LDR (in een buis) | 300 Ω | 993 | 938 |
| Straal onderbroken (in een buis) | 30 kΩ | 256 | 101 |
| Straal onderbroken (zonder buis, felle kamer) | 3 kΩ | 787 | 536 |
| Verschil tussen straal en geen straal (in een buis) | – | 737 | 837 |
Stap voor stap: een laserbarrière-alarm met Arduino
- Sluit de S-pin van de KY-008 aan op D7 en de −-pin op GND; laat de middelste pin onaangesloten (sluit hem aan op 5V als de laser niet oplicht).
- Sluit één pootje van de LDR aan op 5V en het andere op A0; zet een weerstand van 3,3 kΩ of 10 kΩ tussen A0 en GND.
- Plaats de LDR onderin een zwarte buis en richt de opening van de buis op de laser.
- Sluit het +-pootje van de actieve buzzer aan op D8 en het −-pootje op GND. Zet de stilteknop tussen D4 en GND; je hebt geen extra weerstand nodig omdat de interne pull-up wordt gebruikt.
- Bevestig de laser en de LDR op een stevige ondergrond; zoek eerst de laserstip met een vel wit papier en leid hem dan de buis in.
- Upload de sketch en open de Serial Monitor op 9600 baud. Er mag bij het opstarten niemand voor de straal staan; de Arduino kalibreert zichzelf door de laser één keer uit en aan te zetten.
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}De sketch gebruikt geen vaste drempel. Bij het opstarten zet calibrate() de laser uit en meet de waarde van de LDR zonder straal, zet hem dan aan en meet de waarde met straal. beamPercent() zet elke meting op basis van die twee waarden om in een percentage tussen 0 en 100: 100 betekent dat de volle straal binnenkomt, 0 dat hij helemaal geblokkeerd is. Deze berekening maakt niet uit of de LDR boven of onder in de deler zit; het resultaat is hetzelfde, of de meetwaarde nu met licht stijgt of daalt. Als de straal onder 40% zakt en minstens 30 ms onder die waarde blijft, piept het alarm 10 seconden, en de knop op D4 zet het eerder stil. Als de straal nog steeds onderbroken is, begint het alarm opnieuw, dus het systeem blijft niet stil zolang iemand in de straal staat.
Drempelkalibratie: waarom je geen vast getal in de code zet
Veel voorbeelden van laseralarmen online gebruiken een vaste drempel zoals "analogRead(A0) < 500". Dat werkt op de avond dat je het aan je bureau test, maar het faalt de volgende ochtend als de zon de kamer inschijnt, als je de laser een paar millimeter verschuift of als je de LDR vervangt. De juiste drempel ligt precies halverwege de meetwaarden met en zonder straal. Automatische kalibratie, die beide waarden bij elke start opnieuw meet, past het systeem aan op de omgeving. In de sketch hierboven is de drempel niet één getal maar twee: de straal telt als onderbroken als hij onder 40% zakt en als heel als hij boven 60% stijgt. Dit verschil heet hysterese; het voorkomt dat het alarm tientallen keren per seconde aan en uit gaat als de meetwaarde precies rond de drempel zweeft.
| Instelling | Waarde in de code | Wat doet het? | Wanneer pas je het aan? |
|---|---|---|---|
| BREAK_PCT | 40 | Niveau waarop de straal als onderbroken telt | Verhoog naar 60–70 om ook halfdoorzichtige voorwerpen (glas, dun doek) te detecteren |
| RESTORE_PCT | 60 | Niveau waarop de straal weer als heel telt | Houd het altijd 15–20 punten boven BREAK_PCT |
| CONFIRM_MS | 30 | Negeert korte storingen (insecten, stof, trillingen) | Verhoog naar 100–200 ms bij valse alarmen; verlaag als snelle passages worden gemist |
| Aantal gemiddelde metingen | 8 | Egaliseert elektrische ruis en flikkering van lampen | Elke meting duurt op een Uno ongeveer 0,1 ms; 8 metingen blijven onder 1 ms |
| Kalibratieverschil | 100 | Stopt de setup als de straal de LDR niet bereikt | Je kunt het verlagen naar 50 bij zeer grote afstanden of in zeer felle kamers |
In een systeem dat lang draait, verandert het omgevingslicht langzaam gedurende de dag. Een eenvoudige manier om dat te compenseren is om calibrate() opnieuw aan te roepen terwijl de straal heel is en het alarm niet afgaat (bijvoorbeeld elk uur). Omdat de Arduino de laser zelf uitzet, ziet hij dit korte donker niet aan voor een indringer. De Serial Plotter in de Arduino IDE is erg handig om de meetwaarden te volgen: zwaai met je hand door de straal en je ziet hoe ver de grafiek zakt en hoe lang het herstel duurt.
Meerdere stralen met spiegels: een net weven met één laser
Over één straal kom je gemakkelijk heen door eronder te bukken of eroverheen te stappen. Om de lasernetten uit films te bouwen kun je, in plaats van elke straal een eigen laser en LDR te geven, één laser in zigzag laten weerkaatsen met spiegels. Je plaatst spiegels tegenover elkaar aan weerszijden van een deur of gang; de straal kaatst heen en weer en bereikt uiteindelijk de LDR. Als een deel wordt onderbroken, wordt het donker op de LDR, dus één LDR en dezelfde sketch beschermen het hele net. Omdat de hoek van terugkaatsing gelijk is aan de hoek van inval, hoef je elke spiegel maar heel licht te kantelen zodat hij de straal naar het midden van de volgende stuurt.
Elke spiegel verliest een deel van het licht. Een gewone badkamerspiegel weerkaatst ongeveer 90% en geeft een zwakke tweede stip (een spookreflectie) door het glas ervoor. Voorzijdespiegels, waarvan de reflecterende laag bovenop het glas zit, weerkaatsen 95% of meer en geven één schone stip. De verliezen vermenigvuldigen zich, dus het licht dat de LDR bereikt neemt snel af naarmate je spiegels toevoegt:
| Aantal spiegels | Gewone spiegel (90%) | Voorzijdespiegel (95%) |
|---|---|---|
| 1 | 90% | 95% |
| 2 | 81% | 90% |
| 4 | 66% | 81% |
| 6 | 53% | 74% |
| 8 | 43% | 66% |
Deze tabel laat iets belangrijks zien: zelfs 43% is meer dan genoeg voor de gekalibreerde sketch, omdat de laserstip honderden keren helderder is dan omgevingslicht. De echte uitdaging is niet het vermogensverlies maar de uitlijning. Hoe langer het pad van de straal, hoe meer een kleine hoekfout groeit: een fout van 1 graad verschuift de stip op 5 m met ongeveer 9 cm. De straal van een goedkope laser wordt onderweg ook wat breder; na een paar meter kan de stip groter worden dan het oppervlak van 5 mm van de LDR.
- Monteer de laser, de spiegels en de LDR-buis op stevige houders (vastgeschroefde L-beugels, 3D-geprinte houders of houten blokjes vastgezet met hete lijm); een spiegel in je hand blijft nooit uitgelijnd.
- Dim de kamer en zoek de laserstip door wit papier voor de eerste spiegel te houden.
- Lijn de spiegels in volgorde uit, van begin tot eind: kantel elke spiegel heel licht tot de stip in het midden van de volgende spiegel valt.
- Richt de laatste straal in de opening van de LDR-buis en draai de testsketch om de positie te vinden waarbij het verschil in de Serial Monitor het grootst is.
- Zet de hoek van de spiegels vast met hete lijm of een borgschroef zodra alles is uitgelijnd; zelfs een lichte stoot tegen de tafel kan de uitlijning verpesten.
- Test elk deel van het net door het een voor een met je hand te onderbreken en controleer dat het alarm elke keer afgaat.
Passagetelling: hoeveel gingen er door, en hoelang?
Dezelfde barrière kan mensen tellen die door een deur lopen, dozen op een lopende band of ballen die in een bak vallen. De truc is om elke passage één keer te tellen. De sketch hieronder legt het moment vast waarop de straal wordt onderbroken en telt de passage wanneer de straal terugkomt, dus iemand die even in de straal blijft staan telt nog steeds als één passage. Onderbrekingen korter dan 15 ms worden als stof of elektrische ruis gezien en genegeerd. De sketch toont ook hoelang de straal geblokkeerd was: als je de lengte van het voorwerp kent, geeft die tijd direct de snelheid (v = L / t). Als een speelgoedauto van 25 cm de straal bijvoorbeeld 50 ms blokkeert, is zijn snelheid 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}Wil je weten in welke richting iemand passeert, gebruik dan twee parallelle stralen op 10–15 cm van elkaar. Als de buitenste straal A eerst wordt onderbroken en daarna de binnenste straal B, komt de persoon binnen; als B eerst wordt onderbroken en dan A, gaat hij naar buiten. Als alleen A wordt onderbroken en de straal terugkomt zonder dat B ooit onderbroken wordt, liep de persoon naar de deur en bedacht zich, dus dat telt niet mee. Het aantal mensen binnen krijg je door het aantal uitgangen van het aantal ingangen af te trekken, en je kunt het tonen op een 7-segmentdisplay of een I2C-lcd-display. De afstand tussen de twee stralen moet klein genoeg zijn dat het lichaam van een persoon beide op hetzelfde moment blokkeert.
Racetimer en snelheidsmeting
Als je de tijd tussen twee laserpoorten meet, krijg je een nauwkeurige stopwatch voor hardlopen, fietsen, speelgoedauto's of natuurkundige experimenten. Je zet de start- en finishpoort op een bekende afstand (d) van elkaar, en de snelheid is v = d / t. Iemand die een baan van 10 m in 2,5 seconden loopt, rent met 4 m per seconde, oftewel 14,4 km/u. Om beide lasers samen aan en uit te zetten, sluit je de −-pin van elk aan op de collector van één 2N2222- of S8050-transistor; verbind de S- en middelste pins met 5V, de emitter van de transistor met GND en de basis via 1 kΩ met D7. De LDR van de startpoort gaat naar A0 en die van de finishpoort naar 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}De sketch werkt als een toestandsmachine: in de toestand READY legt hij met micros() de tijd vast wanneer de startstraal wordt onderbroken en gaat hij over naar RUNNING; als de finishstraal wordt onderbroken, toont hij de verstreken tijd en snelheid en maakt hij zich na 3 seconden klaar voor de volgende run. Als de finishpoort niet binnen 60 seconden wordt gepasseerd, wordt de run geannuleerd. Eerlijk over de nauwkeurigheid: de code zelf meet met een resolutie beter dan 1 ms, maar de LDR heeft 10–30 ms nodig om op donker te reageren. Gelukkig treedt die vertraging, omdat je bij beide poorten hetzelfde type LDR gebruikt, aan beide kanten op en valt ze grotendeels weg; voor hardlopen en fietsen is het resultaat meer dan goed genoeg.
Telefoonmeldingen met een ESP32 (Telegram)
Om het alarm nuttig te maken als je niet thuis bent, kun je een ESP32 gebruiken: zodra de straal wordt onderbroken, stuurt hij via Telegram een bericht naar je telefoon. De bedrading is zoals in de tabel hierboven: de laser wordt gevoed vanaf 5V en geschakeld door een NPN-transistor op GPIO 26, en de LDR-deler wordt gevoed vanaf 3V3 en aangesloten op GPIO 34. Die keuze is niet willekeurig: de ADC2-pins van de ESP32 werken niet zolang wifi aan staat, dus sluit analoge sensoren altijd aan op ADC1-pins (GPIO 32–39). De ADC van de ESP32 is 12 bit en geeft waarden van 0 tot 4095, daarom is het minimale kalibratieverschil in de code 400. Hoe je de bot maakt en het token en de chat-ID krijgt, hebben we uitgebreid behandeld in de gids over de ESP32 Telegram-bot; installeer voor de sketch de bibliotheken UniversalTelegramBot en ArduinoJson via de Library Manager.
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}Elke onderbreking wordt één keer geteld, de sirene klinkt 5 seconden en er komt een melding in de wachtrij. Meldingen worden hoogstens eens per 30 seconden geprobeerd; nieuwe onderbrekingen die ondertussen plaatsvinden, worden bij het totaal opgeteld en verschijnen in het volgende bericht. Zo wordt je telefoon niet overspoeld met berichten terwijl iemand heen en weer door de straal loopt. Als een bericht niet verstuurd kan worden, probeert de code het 30 seconden later opnieuw, en als de wifi is weggevallen begint hij opnieuw te verbinden. sendMessage() duurt een seconde of twee omdat er een beveiligde HTTPS-verbinding wordt geopend; in die tijd bevriest het sirenepatroon en wordt de straal niet bewaakt, wat normaal is.
Laserbarrière met Raspberry Pi Pico en MicroPython
Op de Raspberry Pi Pico bouw je dezelfde logica in een paar regels MicroPython. De laser wordt gevoed vanaf VBUS (USB 5 V, pin 40) en geschakeld door een NPN-transistor op GP15; de LDR-deler wordt gevoed vanaf de 3V3(OUT)-pin en aangesloten op GP26 (ADC0), en de actieve buzzer gaat naar GP14. Omdat de ADC van de Pico met read_u16() waarden van 0 tot 65535 geeft, is het minimale kalibratieverschil 6000. De code gebruikt dezelfde percentageberekening, hysterese en bevestigingstijd; hij telt elke onderbreking, laat de sirene 5 seconden klinken en toont hoelang de straal geblokkeerd was. Om de Pico zonder computer te laten draaien, sla je het bestand met Thonny als main.py op het board op.
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 sirenProjectideeën met de lasermodule
- Laser-huisalarm: Combineer deur- en gangstralen met een PIR-bewegingssensor en breng alle ingangen samen in één centrale; details in de gids over het Arduino-alarmsysteem.
- Laserharp: Zet 5–7 stralen naast elkaar en speel een andere noot op een passieve buzzer telkens als een straal wordt onderbroken.
- Bezoekersteller: Scheid ingangen en uitgangen met twee stralen en toon het aantal mensen binnen op een display.
- Snelheidsmeter voor de wetenschapsbeurs: Meet met twee poorten de snelheid van voorwerpen die van een helling glijden en vergelijk wrijving; meer ideeën vind je in de gids met projectideeën voor wetenschapsbeurzen.
- Lasermazespel: Bouw met spiegels een net van stralen onder kniehoogte; neem de tijd van spelers die proberen over te steken zonder het aan te raken en geef een strafpunt voor elke aanraking.
- Beveiliging van lades en kluizen: Detecteer dat de straal wordt onderbroken als het deksel opengaat en stuur met een ESP32 een melding naar je telefoon.
Veelgemaakte fouten en hoe je ze oplost
| Symptoom | Waarschijnlijke oorzaak | Oplossing |
|---|---|---|
| De laser licht helemaal niet op | S en − verwisseld, of een board waarvan de middelste pin stroom nodig heeft | Controleer de pinlabels, sluit de middelste pin aan op 5V en probeer opnieuw |
| De laser is erg zwak | De module wordt gevoed met 3,3 V of de pin kan niet genoeg stroom leveren | Voed de laser met 5V en schakel hem met een transistor |
| Melding "Isin LDR'ye ulasmiyor" (straal mist de LDR) | De stip valt niet op de LDR of het omgevingslicht is te sterk | Zoek de stip met papier en zet de LDR in een zwarte buis |
| Het alarm blijft afgaan | De uitlijning is verschoven, de laser of een spiegel wiebelt | Zet de houders stevig vast en volg de meetwaarde in de Serial Plotter |
| Het alarm gaat nooit af | Ook met onderbroken straal houdt zonlicht of een lamp de LDR verlicht | Voeg een buis toe en draai de sensor weg van het raam |
| Snelle passages worden niet geteld | De reactietijd van de LDR (10–30 ms) is te langzaam | Verlaag CONFIRM_MS en MIN_BREAK_MS of gebruik een fototransistor |
| De Arduino reset of een pin wordt heet | Meerdere lasers worden vanaf één pin aangestuurd | Voed de lasers met 5V en schakel ze met een transistor |
| Op de ESP32 gaat de meting fout als de wifi start | De LDR zit op een ADC2-pin | Verplaats de LDR naar een ADC1-pin tussen GPIO 32 en 39 |
| Er komt geen Telegram-bericht aan | Verkeerd token of chat-ID, of je hebt de bot nooit een bericht gestuurd | Stuur /start naar de bot en controleer het token en de chat-ID nogmaals |
De KY-008-lasermodule maakt een van de zeldzame projecten mogelijk die optica, spanningsdelers, kalibratie en tijdmeting in één keer leren met één goedkoop onderdeel. Begin met het verschil te bekijken met de testsketch, bouw dan het alarm en breid je project uit met spiegels, een teller en een timer. In de BlueGrays-app vind je stap voor stap de projecten voor laserwaarschuwing en beveiligingssysteem, LDR-lichtmeting en nachtlampje, het ESP32-bewegingsalarm en de Telegram-melding, met schakelschema's en code.
Veelgestelde vragen
Welke spanning heeft de KY-008-lasermodule nodig?
De KY-008 is ontworpen voor 5 V en dankzij de stroombegrenzende weerstand op de module kun je hem direct op een digitale pin van een Arduino Uno aansluiten. Hij licht ook op bij 3,3 V, maar zwakker. Voed de module nooit met meer dan 5 V en voed de laserdiode nooit zonder zijn weerstand.
Kan een laser van 5 mW je ogen beschadigen?
Een rode laser van 5 mW is klasse 3R: een korte, onbedoelde blootstelling veroorzaakt meestal geen blijvende schade, maar in de straal staren of een spiegelreflectie in je oog krijgen kan het netvlies beschadigen. Houd de straal onder ooghoogte, richt hem nooit op mensen of dieren en controleer bij opstellingen met spiegels het hele pad van de straal.
Hoe ver werkt een laserbarrière?
Uitlijning en omgevingslicht beperken de afstand meer dan het vermogen van de laser. Met stevige houders en een LDR in een zwarte buis werkt het binnen prima over 10–20 m; op grotere afstand wordt de stip groter en valt er minder licht op de LDR. Buiten verminderen zonlicht, mist en door wind veroorzaakt schudden het bereik merkbaar.
Wat kan ik gebruiken in plaats van een LDR in een laserbarrière?
Een LDR is goedkoop en makkelijk, maar zijn reactietijd is 10–30 ms. Voor timers en tellers die sneller moeten meten, gebruik je een fototransistor of fotodiode, die binnen microseconden reageert. Er bestaan ook kant-en-klare laserontvangermodules; die geven een digitale uitgang als ze licht ontvangen en sluit je direct aan op een digitale pin.
Werkt de lasermodule met ESP32 en Raspberry Pi Pico?
Ja, maar voed de laser liever vanaf 5V en schakel hem met een NPN-transistor dan rechtstreeks vanaf een pin; Pico-pins leveren standaard maar 4 mA. Voed de LDR-deler op deze boards vanaf 3V3 en gebruik op de ESP32 een ADC1-pin (GPIO 32–39), die samen met wifi werkt.
Is een infraroodbarrière beter dan een laseralarm?
Professionele beveiligingssystemen gebruiken onzichtbare infraroodstralen en gemoduleerde ontvangers; de straal is niet te zien en door de modulatie heeft zonlicht er nauwelijks invloed op. Een rode laser daarentegen is zichtbaar en dus erg makkelijk uit te lijnen, wat hem ideaal maakt voor leerprojecten, tellers en timers.
Projecten om hierna te bouwen
Alle projecten bekijken
Lichtsterkte meten met een LDR
Wil je zien hoe licht je kamer is, als getal? De LDR, een klein onderdeel dat op licht reageert, meet het licht om je heen en de Arduino schrijft de waarde elke halve seconde naar je computerscherm.

Nachtlampje met LDR
Een klein nachtlampje dat vanzelf aangaat als het donker wordt en uitgaat als het ochtend is.

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

Laserwaarschuwingssysteem
Je bouwt een onzichtbaar lichtscherm, net als in films. Een laser schijnt op een lichtsensor aan de overkant; zodra iemand erdoorheen loopt en de straal onderbreekt, gaat de led branden en klinkt de…

Lasersysteem voor beveiliging
Net als de laserroofscènes in films: een laserstraal valt op een lichtsensor en zodra iemand de straal onderbreekt, gaat de rode led branden en begint de buzzer te piepen.

ESP32-nachtlampje met LDR
Nachtlampje waarvan de LED in het donker automatisch aangaat en bij licht uit. Je gebruikt de D0-pin (digitale uitgang) van de LDR-sensormodule: de donkerdrempel stel je in met de kleine potmeter op de module en de module zelf geeft het HIGH/LOW-signaal. De ESP32 leest dit signaal alleen met digitalRead(); de code is heel eenvoudig.

ESP32-bewegingsalarm (PIR + buzzer + LED + Telegram)
Een slim beveiligingsalarm: als de PIR-sensor beweging detecteert, gaat de buzzer af, licht de LED op en krijgt de eigenaar direct een Telegram-melding. Een afkoeltijd van 30 seconden beperkt hoe vaak het alarm zich herhaalt; valse detecties van de PIR-sensor filtert dit niet weg. Gebruik het thuis, in een garage, een berging of een studeerkamer.
Meer artikelen
BlueGrays-app
Bouw deze schakeling stap voor stap op je telefoon
Schakelschema, code en onderdelenlijst op één scherm. Meer dan 500 Arduino-, ESP32- en Pico-projecten om te bouwen.
Scan met je telefoon
Richt je camera op de code en de appstore van je telefoon opent.
of open de store

