Componenten · 19 min leestijd

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.

KY-008-lasermodule (650 nm, 5 mW)
KY-008-lasermodule: een messing laserkop van 6 mm, een stroombegrenzende weerstand op het printje erachter en drie pins (S, middelste pin en −).

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.

EigenschapWaarde
ModelKY-008 (bij sommige verkopers HW-493)
Golflengte650 nm (zichtbaar rood)
UitgangsvermogenOngeveer 5 mW
Laserklasse3R (IEC 60825-1), IIIa in de VS
Werkspanning5 V (zwakker bij 3,3 V)
StroomOnder 40 mA; verschilt per board
LaserkopMessing buisje van 6 mm
PinsS (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.

KlasseVermogen (zichtbaar licht)Risk
1Zeer laag, of de straal zit opgesloten in het apparaatVeilig bij normaal gebruik
2Tot 1 mWDe knipperreflex beschermt; staar er niet bewust in
3R1–5 mW (KY-008)Direct kijken kan het oog beschadigen
3B5–500 mWDirecte en door spiegels weerkaatste stralen zijn gevaarlijk
4Boven 500 mWGevaar 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.
Een laser op mensen, dieren, bestuurders of vliegtuigen richten kan oogletsel en ernstige ongelukken veroorzaken en is in veel landen strafbaar. Houd de straal in elk KY-008-project vast, onder ooghoogte en onder controle.

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.

AansluitingArduino UnoESP32Raspberry Pi Pico
KY-008 SD75V (VIN)VBUS (pin 40)
Middelste pin van de KY-008Niet aangesloten (5V als de laser niet oplicht)5V (VIN)VBUS (pin 40)
KY-008 −GNDNPN-collectorNPN-collector
NPN-emitter–GNDGND (pin 38)
NPN-basis (via 1 kΩ)–GPIO 26GP15 (pin 20)
LDR-pootje 15V3V33V3(OUT) (pin 36)
LDR-pootje 2 + bovenkant van de weerstandA0GPIO 34GP26 (pin 31)
Onderkant van de weerstand (3,3–10 kΩ)GNDGNDGND
Actieve buzzer +D8GPIO 25GP14 (pin 19)
ESP32- en Pico-pins werken op 3,3 V en leveren weinig stroom; een GPIO-pin van de Pico levert standaard maar 4 mA en maximaal 12 mA. Voed de laser op deze boards niet rechtstreeks vanaf een pin; gebruik een transistor. En voed de LDR-deler altijd vanaf de 3V3-pin: een deler op 5V stuurt meer dan 3,3 V naar de analoge pin als de laser de LDR raakt, wat de pin kan beschadigen. Actieve buzzers kunnen ook 20–30 mA trekken: een ESP32-pin kan er direct een aansturen, maar stuur op de Pico de buzzer ook via een NPN-transistor aan of kies een 3V-buzzer met laag stroomverbruik.

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.

C++ (Arduino IDE)
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.

LDR (fotoweerstand)
LDR (fotoweerstand)
NPN-transistor (S8050)
NPN-transistor (S8050)
Actieve buzzer
Actieve buzzer

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.

SituatieLDR-weerstand (voorbeeld)analogRead met 10 kΩanalogRead met 3,3 kΩ
Laser op de LDR (in een buis)300 Ω993938
Straal onderbroken (in een buis)30 kΩ256101
Straal onderbroken (zonder buis, felle kamer)3 kΩ787536
Verschil tussen straal en geen straal (in een buis)–737837
De beste waarde voor de vaste weerstand van de deler is het meetkundig gemiddelde van de LDR-weerstand met en zonder straal: R = √(R_straal × R_onderbroken). Voor de 300 Ω en 30 kΩ uit de tabel is √(300 × 30.000) = 3.000 Ω; de dichtstbijzijnde standaardwaarde is 3,3 kΩ. Meet beide weerstanden van je eigen LDR met een multimeter, probeer het resultaat in de spanningsdelerberekening en zoek de dichtstbijzijnde waarde met de tool voor standaardwaarden van weerstanden.

Stap voor stap: een laserbarrière-alarm met Arduino

  1. 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).
  2. 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.
  3. Plaats de LDR onderin een zwarte buis en richt de opening van de buis op de laser.
  4. 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.
  5. 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.
  6. 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.
C++ (Arduino IDE)
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.

InstellingWaarde in de codeWat doet het?Wanneer pas je het aan?
BREAK_PCT40Niveau waarop de straal als onderbroken teltVerhoog naar 60–70 om ook halfdoorzichtige voorwerpen (glas, dun doek) te detecteren
RESTORE_PCT60Niveau waarop de straal weer als heel teltHoud het altijd 15–20 punten boven BREAK_PCT
CONFIRM_MS30Negeert korte storingen (insecten, stof, trillingen)Verhoog naar 100–200 ms bij valse alarmen; verlaag als snelle passages worden gemist
Aantal gemiddelde metingen8Egaliseert elektrische ruis en flikkering van lampenElke meting duurt op een Uno ongeveer 0,1 ms; 8 metingen blijven onder 1 ms
Kalibratieverschil100Stopt de setup als de straal de LDR niet bereiktJe 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 spiegelsGewone spiegel (90%)Voorzijdespiegel (95%)
190%95%
281%90%
466%81%
653%74%
843%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.

  1. 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.
  2. Dim de kamer en zoek de laserstip door wit papier voor de eerste spiegel te houden.
  3. 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.
  4. 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.
  5. 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.
  6. Test elk deel van het net door het een voor een met je hand te onderbreken en controleer dat het alarm elke keer afgaat.
Als je alle bedrading aan één kant wilt hebben, kaats de straal dan terug met een spiegel op de tegenoverliggende muur: de laser en de LDR zitten naast elkaar en aan de andere kant blijft alleen een spiegel die geen stroom nodig heeft. In schone lucht kun je een laserstraal van opzij niet zien, alleen de stip waar hij landt; wil je het pad van de straal zien, voeg dan een beetje waterdamp of mist aan de lucht toe.

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.

C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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.

Voor snelle voorwerpen die de straal korter dan 50 ms onderbreken (een gegooide bal, een snelle speelgoedauto) is een LDR niet genoeg: de straal is terug voordat de meetwaarde kan dalen. Gebruik dan in plaats van een LDR een fototransistor of fotodiode, die binnen microseconden reageert, sluit de uitgang aan op een digitale pin en leg de tijd vast met een interrupt. Waarom je timing beter met millis() en micros() kunt doen dan met delay(), lees je in de gids over millis en delay.

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.

C++ (Arduino IDE)
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.

MicroPython
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

Projectideeë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

SymptoomWaarschijnlijke oorzaakOplossing
De laser licht helemaal niet opS en − verwisseld, of een board waarvan de middelste pin stroom nodig heeftControleer de pinlabels, sluit de middelste pin aan op 5V en probeer opnieuw
De laser is erg zwakDe module wordt gevoed met 3,3 V of de pin kan niet genoeg stroom leverenVoed 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 sterkZoek de stip met papier en zet de LDR in een zwarte buis
Het alarm blijft afgaanDe uitlijning is verschoven, de laser of een spiegel wiebeltZet de houders stevig vast en volg de meetwaarde in de Serial Plotter
Het alarm gaat nooit afOok met onderbroken straal houdt zonlicht of een lamp de LDR verlichtVoeg een buis toe en draai de sensor weg van het raam
Snelle passages worden niet geteldDe reactietijd van de LDR (10–30 ms) is te langzaamVerlaag CONFIRM_MS en MIN_BREAK_MS of gebruik een fototransistor
De Arduino reset of een pin wordt heetMeerdere lasers worden vanaf één pin aangestuurdVoed de lasers met 5V en schakel ze met een transistor
Op de ESP32 gaat de meting fout als de wifi startDe LDR zit op een ADC2-pinVerplaats de LDR naar een ADC1-pin tussen GPIO 32 en 39
Er komt geen Telegram-bericht aanVerkeerd token of chat-ID, of je hebt de bot nooit een bericht gestuurdStuur /start naar de bot en controleer het token en de chat-ID nogmaals
Test het systeem na het installeren onder echte omstandigheden: maak de kamer donker, doe het licht aan, open de gordijnen en noteer telkens het verschil tussen de meetwaarden met en zonder straal in de Serial Monitor. Als het verschil ook in het slechtste geval boven 100 blijft, is je barrière betrouwbaar. Zie dit project als een leer- en hobbyalarm; professionele beveiligingssystemen gebruiken onzichtbare infraroodstralen en gemoduleerde ontvangers.

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.

Alle projecten bekijken
Lichtsterkte meten met een LDR
AR-11Beginner

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.

4.6(83)
143
Nachtlampje met LDR
AR-12Beginner

Nachtlampje met LDR

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

4.7(105)
224
Lichtsterkte meten met de ESP32 en een LDR-module
ES-11Beginner

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.

4.6(36)
55
Laserwaarschuwingssysteem
AR-22Gemiddeld
Premium

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…

4.8(64)
83
Lasersysteem voor beveiliging
AR-23Gevorderd
Premium

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.

4.8(61)
78
ESP32-nachtlampje met LDR
ES-10Beginner
Premium

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.

4.6(17)
30
ESP32-bewegingsalarm (PIR + buzzer + LED + Telegram)
ES-41Gevorderd
Premium

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.

9