Lasermodul Arduino (KY-008): Laser-Lichtschranke und Alarm bauen

Ein Lasermodul gehört zu den auffälligsten Bauteilen, die du mit einem Arduino verwenden kannst: Es erzeugt einen dünnen roten Strahl, der sich über mehrere Meter kaum aufweitet. Das KY-008 Lasermodul aus vielen Hobby-Sets vereint eine 650-nm-Laserdiode mit etwa 5 mW auf einer kleinen Platine; es wird an einen einzigen digitalen Pin des Arduino angeschlossen und mit digitalWrite() ein- und ausgeschaltet. Allein ist es nur ein Laserpointer, doch mit einem Lichtsensor gegenüber wird daraus eine Laser-Lichtschranke als Alarmanlage wie im Film, ein Zähler für Personen an einer Tür oder eine Stoppuhr mit Millisekunden-Genauigkeit.

In diesem Artikel lernst du die technischen Daten des KY-008 kennen, erfährst, wie gefährlich ein 5-mW-Laser für deine Augen wirklich ist und welche Regeln du einhalten musst, und wie du das Modul richtig an Arduino Uno, ESP32 und Raspberry Pi Pico anschließt. Danach baust du mit einem LDR eine Laser-Lichtschranke, lässt den Arduino den Schwellwert automatisch messen statt ihn zu raten, machst mit Spiegeln aus einem Laser mehrere Strahlen, zählst Durchgänge, misst Geschwindigkeiten und schickst mit einem ESP32 eine Nachricht aufs Handy, sobald der Strahl unterbrochen wird.

Was ist das KY-008 Lasermodul und wie funktioniert es?

Das Herz des Moduls ist eine kleine Laserdiode in einem Messingröhrchen. Anders als eine gewöhnliche LED erzeugt eine Laserdiode ab einem bestimmten Schwellstrom Licht mit einer einzigen Wellenlänge und geordneter Phase (kohärent); eine winzige Linse am Ende des Röhrchens formt daraus einen nahezu parallelen Strahl. Deshalb streut das Licht einer LED schon nach wenigen Zentimetern, während der Laserpunkt selbst nach mehreren Metern nur wenige Millimeter groß ist. 650 nm entspricht einem kräftigen Rot, das das Auge gut sieht. Der Widerstand auf der kleinen Platine hinter dem Laserkopf begrenzt den Strom durch die Diode. Laserdioden reagieren viel empfindlicher auf Überstrom als LEDs; wenn du diesen Widerstand umgehst und die Diode direkt versorgst, kann sie in Sekunden kaputtgehen.

Augensicherheit: Wie gefährlich ist ein 5-mW-Laser?

Die Gefahr eines Lasers kommt nicht von seiner Gesamtleistung, sondern davon, dass diese Leistung auf einen winzigen Punkt konzentriert ist. Die Augenlinse bündelt einen parallelen Strahl auf einen mikrometerkleinen Punkt der Netzhaut; deshalb können 5 mW, die an der Wand harmlos wirken, auf der Netzhaut intensiver sein als ein direkter Blick in die Sonne. Laser werden nach diesem Risiko in Klassen eingeteilt. Bei Lasern der Klasse 2 unter 1 mW schützt meist der Lidschlussreflex (etwa 0,25 Sekunden). Die Klasse 3R, zu der das KY-008 gehört, reicht bis zum Fünffachen dieser Grenze: Ein kurzer, zufälliger Blick ist wenig riskant, aber direkt oder über einen Spiegel in den Strahl zu schauen, kann das Auge schädigen.

• Schau nie in den Strahl: Bring das Austrittsende des Lasers nicht in die Nähe deiner Augen und schwenke das eingeschaltete Modul nicht in der Hand herum.
• Halte den Strahl unter Augenhöhe: Montiere Alarm- und Zählerstrahlen 20–50 cm über dem Boden. Diese Höhe entspricht der Augenhöhe eines krabbelnden Babys, eines kleinen Kindes oder einer Katze oder eines Hundes; lass den Laser nicht an, solange sie in der Nähe sind.
• Achte auf Reflexionen: Spiegel, Glas, Uhrengläser und glänzendes Metall lenken den Strahl in unerwartete Richtungen. Prüfe den Strahlweg vom Anfang bis zum Ende und lass ihn auf einer matten, dunklen Fläche enden.
• Kinder nicht allein arbeiten lassen: Ein Laser ist kein Spielzeug; arbeite bei Schul- und Wettbewerbsprojekten unter Aufsicht eines Erwachsenen.
• Vertraue dem Etikett nicht blind: Bei billigen Modulen kann die tatsächliche Leistung von der Angabe abweichen; behandle jedes Modul mindestens wie Klasse 3R.
• Justiere mit einem Blatt Papier: Halte weißes Papier vor den Strahl und verfolge den Punkt auf dem Papier; schau nie in den Strahl, um zu sehen, wohin er geht.

KY-008 anschließen: Arduino Uno, ESP32 und Raspberry Pi Pico

Das KY-008 hat drei Pins: S ist der Signalpin und schaltet den Laser bei HIGH ein, − ist GND, und der unbeschriftete mittlere Pin führt bei den meisten Platinen zu +5V oder ist gar nicht belegt. Der Laser liegt zwischen S und −; der Arduino-Pin an S liefert also den Strom des Lasers direkt. Am Arduino Uno ist das für kurze Tests kein Problem, aber der Strom des Moduls schwankt von Platine zu Platine und kann sich 40 mA nähern. Das ist der absolute Grenzwert des ATmega328P pro Pin; empfohlen sind 20 mA. Wenn der Laser stundenlang leuchten soll, du mehrere Laser verwendest oder mit ESP32 bzw. Pico arbeitest, versorge den Laser aus 5V und schalte ihn über einen NPN-Transistor (BC547, S8050 oder 2N2222). Die Pinbelegung des Transistors findest du im Transistor-Ratgeber.

Bevor es mit den Sketches losgeht, teste Laser und LDR mit dem kleinen Programm unten. Es schaltet den Laser jede halbe Sekunde ein und aus und gibt in beiden Zuständen den Messwert im seriellen Monitor aus. Je größer der Abstand zwischen den beiden Werten, desto zuverlässiger arbeitet deine Lichtschranke: Am Uno ist ein Unterschied über 300 sehr gut; liegt er unter 100, trifft der Strahl den LDR nicht genau oder das Umgebungslicht ist zu stark.

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}

Wie funktioniert eine Laser-Lichtschranke mit LDR?

Das Prinzip einer Laser-Lichtschranke ist einfach: Der Laserstrahl trifft ständig auf einen LDR (Fotowiderstand) auf der Gegenseite. Liegt der Laserpunkt auf dem LDR, sinkt sein Widerstand auf einige hundert Ohm; wird der Strahl unterbrochen, steigt er auf mehrere zehn Kiloohm. Schaltest du den LDR mit einem festen Widerstand als Spannungsteiler, wird diese Widerstandsänderung zu einer Spannungsänderung am Analogeingang: Bei 5V → LDR → A0 → Widerstand → GND liest A0 bei vorhandenem Strahl hohe und bei unterbrochenem Strahl niedrige Werte. Sobald jemand durch den Strahl läuft, fällt der Wert und der Arduino löst den Alarm aus.

Warum der Laser so stark auf den LDR wirkt, zeigt eine kurze Rechnung: Konzentriert sich der 5-mW-Strahl auf einen Punkt von etwa 3 mm Durchmesser, ergibt das rund 700 W pro Quadratmeter. Das liegt in derselben Größenordnung wie die Mittagssonne und ist hunderte Male heller als ein gut beleuchteter Raum. Trotzdem ist der größte Feind der Lichtschranke das Umgebungslicht: Vor einem sonnigen Fenster bleibt der LDR auch bei unterbrochenem Strahl hell, und der Alarm merkt nichts. Die Abhilfe kostet fast nichts: Setz den LDR an das Ende eines 3–5 cm langen schwarzen Röhrchens (leere Kugelschreiberhülse, schwarzer Strohhalm oder Schrumpfschlauch). Das Röhrchen lässt nur den Laser von vorne herein und blockiert seitliches Umgebungslicht.

Schritt für Schritt: Laser-Alarmanlage mit Arduino

1. Verbinde den S-Pin des KY-008 mit D7 und den −-Pin mit GND; lass den mittleren Pin frei (verbinde ihn mit 5V, falls der Laser nicht leuchtet).
2. Verbinde ein Bein des LDR mit 5V und das andere mit A0; setz einen Widerstand von 3,3 kΩ oder 10 kΩ zwischen A0 und GND.
3. Setz den LDR an das Ende eines schwarzen Röhrchens und richte die Öffnung auf den Laser.
4. Verbinde das +-Bein des aktiven Summers mit D8 und das −-Bein mit GND. Den Taster zum Stummschalten setzt du zwischen D4 und GND; da der interne Pull-up genutzt wird, brauchst du keinen zusätzlichen Widerstand.
5. Befestige Laser und LDR auf einer stabilen Unterlage; such den Laserpunkt zuerst mit einem weißen Blatt Papier und lenke ihn dann in das Röhrchen.
6. Lade den Sketch hoch und öffne den seriellen Monitor mit 9600 Baud. Beim Start darf niemand im Strahl stehen; der Arduino kalibriert sich, indem er den Laser einmal aus- und wieder einschaltet.

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}

Der Sketch verwendet keinen festen Schwellwert. Beim Start schaltet calibrate() den Laser aus und misst den Wert des LDR ohne Strahl, schaltet ihn dann ein und misst den Wert mit Strahl. beamPercent() rechnet jede Messung anhand dieser beiden Werte in einen Prozentwert zwischen 0 und 100 um: 100 bedeutet voller Strahl, 0 bedeutet komplett unterbrochen. Diese Rechnung ist unabhängig davon, ob der LDR oben oder unten im Teiler sitzt; ob der Wert mit Licht steigt oder fällt, das Ergebnis ist dasselbe. Fällt der Strahl unter 40 % und bleibt mindestens 30 ms dort, piept der Alarm 10 Sekunden lang, und der Taster an D4 schaltet ihn vorher stumm. Ist der Strahl noch unterbrochen, startet der Alarm erneut; das System verstummt also nicht, solange jemand im Strahl steht.

Schwellwert kalibrieren: Warum du keine feste Zahl eintragen solltest

Viele Beispiele für Laser-Alarmanlagen im Netz verwenden einen festen Schwellwert wie "analogRead(A0) < 500". Das funktioniert an dem Abend, an dem du es am Schreibtisch testest, versagt aber am nächsten Morgen, wenn die Sonne ins Zimmer scheint, wenn du den Laser um ein paar Millimeter verschiebst oder den LDR austauschst. Der richtige Schwellwert liegt genau in der Mitte zwischen dem Wert mit und ohne Strahl. Eine automatische Kalibrierung, die beide Werte bei jedem Start neu misst, passt das System an seine Umgebung an. Im Sketch oben ist der Schwellwert keine einzelne Zahl, sondern zwei: Unter 40 % gilt der Strahl als unterbrochen, über 60 % wieder als intakt. Diese Lücke heißt Hysterese; sie verhindert, dass der Alarm dutzende Male pro Sekunde an- und ausgeht, wenn der Wert genau um die Schwelle schwankt.

In einem System, das lange läuft, ändert sich das Umgebungslicht im Tagesverlauf langsam. Ein einfacher Ausgleich ist, calibrate() erneut aufzurufen, während der Strahl intakt ist und kein Alarm läuft (zum Beispiel jede volle Stunde). Da der Arduino den Laser selbst ausschaltet, hält er diese kurze Dunkelheit nicht für einen Einbrecher. Zum Beobachten der Messwerte ist der serielle Plotter der Arduino IDE sehr praktisch: Fahr mit der Hand durch den Strahl und du siehst, wie tief die Kurve fällt und wie schnell sie sich erholt.

Mehrere Strahlen mit Spiegeln: ein Netz aus einem einzigen Laser

Unter einem einzelnen Strahl kann man sich leicht hindurchducken oder darübersteigen. Für die Lasernetze aus Filmen musst du nicht jedem Strahl einen eigenen Laser und LDR geben: Du kannst einen Laser mit Spiegeln im Zickzack umlenken. Dazu stellst du an beiden Seiten einer Tür oder eines Flurs Spiegel gegenüber auf; der Strahl springt von Seite zu Seite und erreicht schließlich den LDR. Wird irgendein Abschnitt unterbrochen, bleibt der LDR dunkel, sodass ein einziger LDR mit demselben Sketch das ganze Netz überwacht. Weil Einfallswinkel gleich Ausfallswinkel ist, musst du jeden Spiegel nur ganz leicht neigen, damit er den Strahl in die Mitte des nächsten Spiegels schickt.

An jedem Spiegel geht etwas Licht verloren. Ein normaler Badezimmerspiegel reflektiert etwa 90 % und erzeugt durch das Glas davor einen schwachen zweiten Punkt (Geisterreflex). Oberflächenspiegel, bei denen die Spiegelschicht vorne auf dem Glas liegt, reflektieren 95 % und mehr und liefern einen einzigen sauberen Punkt. Die Verluste multiplizieren sich, daher nimmt das Licht am LDR mit jedem weiteren Spiegel schnell ab:

Diese Tabelle zeigt etwas Wichtiges: Selbst 43 % reichen für den kalibrierten Sketch locker aus, weil der Laserpunkt hunderte Male heller ist als das Umgebungslicht. Die eigentliche Herausforderung ist nicht der Leistungsverlust, sondern die Justierung. Je länger der Strahlweg, desto stärker wächst ein kleiner Winkelfehler: Eine Abweichung von 1 Grad verschiebt den Punkt in 5 m Entfernung um etwa 9 cm. Der Strahl billiger Laser weitet sich unterwegs außerdem etwas auf; nach einigen Metern kann der Punkt größer werden als die 5-mm-Fläche des LDR.

1. Montiere Laser, Spiegel und LDR-Röhrchen auf stabilen Haltern (verschraubte L-Winkel, 3D-gedruckte Halter oder mit Heißkleber fixierte Holzklötze); ein Spiegel in der Hand bleibt nie justiert.
2. Dunkle den Raum etwas ab und such den Laserpunkt, indem du ein weißes Blatt vor den ersten Spiegel hältst.
3. Justiere die Spiegel der Reihe nach vom Anfang zum Ende: Neige jeden Spiegel ganz leicht, bis der Punkt in der Mitte des nächsten landet.
4. Richte den letzten Strahl in die Öffnung des LDR-Röhrchens und such mit dem Test-Sketch die Position, an der der Unterschied im seriellen Monitor am größten ist.
5. Ist alles justiert, fixiere den Winkel der Spiegel mit Heißkleber oder einer Kontermutter; schon ein kleiner Stoß gegen den Tisch kann die Justierung zerstören.
6. Teste jeden Abschnitt des Netzes, indem du ihn einzeln mit der Hand unterbrichst, und prüfe, ob der Alarm jedes Mal auslöst.

Durchgangszähler: Wie viele sind durchgegangen und wie lange hat es gedauert?

Dieselbe Lichtschranke zählt auch Personen an einer Tür, Kartons auf einem Förderband oder Bälle, die in einen Behälter fallen. Der Trick ist, jeden Durchgang genau einmal zu zählen. Der folgende Sketch merkt sich den Moment, in dem der Strahl unterbrochen wird, und zählt den Durchgang, wenn der Strahl zurückkommt; so zählt auch jemand, der eine Weile im Strahl steht, nur einmal. Unterbrechungen unter 15 ms gelten als Staub oder elektrische Störung und werden ignoriert. Der Sketch gibt außerdem aus, wie lange der Strahl unterbrochen war: Kennst du die Länge des Objekts, liefert diese Zeit direkt seine Geschwindigkeit (v = L / t). Unterbricht zum Beispiel ein 25 cm langes Spielzeugauto den Strahl 50 ms lang, fährt es 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}

Wenn du wissen willst, in welche Richtung jemand geht, nimm zwei parallele Strahlen im Abstand von 10–15 cm. Wird zuerst der äußere Strahl A und dann der innere Strahl B unterbrochen, kommt die Person herein; zuerst B und dann A bedeutet, dass sie hinausgeht. Wird nur A unterbrochen und kommt der Strahl zurück, ohne dass B je unterbrochen wurde, ist die Person zur Tür gekommen und hat kehrtgemacht; das wird nicht gezählt. Die Zahl der Personen im Raum ergibt sich aus Eintritten minus Austritten, und du kannst sie auf einer 7-Segment-Anzeige oder einem I2C-LCD-Display anzeigen. Der Abstand der beiden Strahlen muss so klein sein, dass ein Körper kurz beide gleichzeitig unterbricht.

Stoppuhr für Rennen und Geschwindigkeitsmessung

Die Zeit zwischen zwei Laser-Lichtschranken zu messen, ergibt eine präzise Stoppuhr für Laufen, Radfahren, Spielzeugautos oder Physikversuche. Du stellst Start- und Ziellichtschranke in einem bekannten Abstand (d) auf; die Geschwindigkeit ist v = d / t. Wer eine 10-m-Strecke in 2,5 Sekunden läuft, ist mit 4 m pro Sekunde unterwegs, also mit 14,4 km/h. Damit beide Laser gemeinsam ein- und ausgeschaltet werden, verbinde den −-Pin beider Module mit dem Kollektor eines einzigen 2N2222- oder S8050-Transistors; S und mittleren Pin an 5V, den Emitter des Transistors an GND und die Basis über 1 kΩ an D7. Der LDR der Startlichtschranke kommt an A0, der der Ziellichtschranke an 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}

Der Sketch arbeitet wie ein Zustandsautomat: Im Zustand READY speichert er beim Unterbrechen des Startstrahls die Zeit mit micros() und wechselt zu RUNNING; wird der Zielstrahl unterbrochen, gibt er Zeit und Geschwindigkeit aus und ist nach 3 Sekunden bereit für den nächsten Lauf. Wird die Ziellichtschranke nicht innerhalb von 60 Sekunden erreicht, wird der Lauf abgebrochen. Ehrlich zur Genauigkeit: Der Code selbst misst mit einer Auflösung von besser als 1 ms, aber der LDR braucht 10–30 ms, um auf Dunkelheit zu reagieren. Zum Glück tritt diese Verzögerung an beiden Lichtschranken auf, weil du dort denselben LDR-Typ verwendest, und hebt sich weitgehend auf; für Laufen und Radfahren ist das Ergebnis mehr als genau genug.

Benachrichtigung aufs Handy mit dem ESP32 (Telegram)

Damit der Alarm auch nützt, wenn du nicht zu Hause bist, kannst du einen ESP32 verwenden: Sobald der Strahl unterbrochen wird, schickt er dir über Telegram eine Nachricht aufs Handy. Die Verdrahtung entspricht der Tabelle oben: Der Laser wird aus 5V versorgt und über einen NPN-Transistor an GPIO 26 geschaltet, der LDR-Teiler hängt an 3V3 und an GPIO 34. Diese Wahl ist kein Zufall: Die ADC2-Pins des ESP32 funktionieren nicht, solange WLAN aktiv ist; schließ analoge Sensoren daher immer an ADC1-Pins (GPIO 32–39) an. Der ADC des ESP32 hat 12 Bit und liefert Werte von 0 bis 4095; deshalb beträgt der minimale Kalibrier-Abstand im Code 400. Wie du den Bot erstellst und Token sowie Chat-ID bekommst, erklären wir ausführlich im Artikel ESP32 Telegram-Bot; für den Sketch installierst du die Bibliotheken UniversalTelegramBot und ArduinoJson über den Bibliotheksverwalter.

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}

Jede Unterbrechung wird einmal gezählt, die Sirene ertönt 5 Sekunden lang und eine Benachrichtigung wird vorgemerkt. Nachrichten werden höchstens alle 30 Sekunden versucht; neue Unterbrechungen in der Zwischenzeit werden zur Gesamtzahl addiert und erscheinen in der nächsten Nachricht. So wird dein Handy nicht mit Nachrichten überflutet, wenn jemand im Strahl hin- und hergeht. Kann eine Nachricht nicht gesendet werden, versucht es der Code nach 30 Sekunden erneut, und ist das WLAN weg, startet er die Wiederverbindung. sendMessage() dauert ein bis zwei Sekunden, weil es eine sichere HTTPS-Verbindung aufbaut; in dieser Zeit stockt das Sirenenmuster und der Strahl wird nicht überwacht, das ist normal.

Laser-Lichtschranke mit Raspberry Pi Pico und MicroPython

Auf dem Raspberry Pi Pico baust du dieselbe Logik mit wenigen Zeilen MicroPython. Der Laser wird aus VBUS (5 V vom USB, Pin 40) versorgt und über einen NPN-Transistor an GP15 geschaltet; der LDR-Teiler hängt am Pin 3V3(OUT) und an GP26 (ADC0), der aktive Summer an GP14. Da der ADC des Pico mit read_u16() Werte von 0 bis 65535 liefert, beträgt der minimale Kalibrier-Abstand 6000. Der Code nutzt dieselbe Prozentrechnung, Hysterese und Bestätigungszeit; er zählt jede Unterbrechung, lässt die Sirene 5 Sekunden ertönen und gibt aus, wie lange der Strahl unterbrochen war. Damit der Pico ohne Computer läuft, speichere die Datei mit Thonny als main.py auf dem Board.

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

Projektideen mit dem Lasermodul

• Laser-Alarmanlage fürs Haus: Kombiniere Tür- und Flurstrahlen mit einem PIR-Bewegungsmelder und führe alle Eingänge in einer Zentrale zusammen; Details im Artikel Arduino-Alarmanlage.
• Laserharfe: Baue 5–7 Strahlen nebeneinander auf und spiele mit einem passiven Summer einen anderen Ton, sobald ein Strahl unterbrochen wird.
• Besucherzähler: Trenne Ein- und Ausgänge mit zwei Strahlen und zeige die Zahl der Personen im Raum auf einem Display an.
• Geschwindigkeitsmesser für den Schulwettbewerb: Miss mit zwei Lichtschranken die Geschwindigkeit von Körpern auf einer schiefen Ebene und vergleiche die Reibung; mehr Ideen findest du im Artikel Projektideen für Wettbewerbe.
• Laserlabyrinth-Spiel: Bau mit Spiegeln ein Strahlennetz unterhalb der Kniehöhe; miss die Zeit der Spieler, die es ohne Berührung durchqueren wollen, und gib für jede Berührung Strafzeit.
• Schutz für Schublade und Tresor: Erkenne die Unterbrechung des Strahls beim Öffnen des Deckels und schick mit dem ESP32 eine Nachricht aufs Handy.

Häufige Fehler und ihre Lösungen

Das KY-008 Lasermodul ermöglicht eines der seltenen Projekte, die mit einem einzigen günstigen Bauteil Optik, Spannungsteiler, Kalibrierung und Zeitmessung gleichzeitig vermitteln. Sieh dir zuerst mit dem Test-Sketch den Unterschied an, bau dann den Alarm und erweitere dein Projekt mit Spiegeln, Zähler und Stoppuhr. In der BlueGrays-App findest du das Laser-Warnsystem und die Laser-Alarmanlage, Lichtmessung und Nachtlicht mit LDR, den ESP32-Bewegungsalarm und Projekte mit Telegram-Benachrichtigung Schritt für Schritt mit Schaltplan und Code.