Pin It!

Why buy a motion detector when a laser break sensor and ESP32 do more for less?

It started with a missing screwdriver. Then a charger. Then a whole soldering iron.

In a shared makerspace—or even a chaotic home—gear tends to walk off on its own. I didn’t want to spend on an expensive motion detector system just to catch the culprit (probably a bored cousin). Instead, I turned to something far more elegant, hackable, and free-as-in-freedom: a laser break sensor using an ESP32.

As someone who builds with open-source tools by principle and necessity, I wanted a DIY solution that was transparent, affordable, and actually fun to make. No proprietary black boxes. Just laser, logic, and the joy of catching movement at the speed of light.

Want to build your own? I’ll walk you through it—step by step, with code, schematics, and practical tips. Let’s bring open-source security to life.

Read on and let’s get building.

---

Table of Contents

Pin It!

Pin It!

• What is a Laser Break Module?
• What You Need
  • Components List:
  • Wiring Diagram:
  • How It Works
• MicroPython Code Example
  • Explanation of Code
• Key Considerations
• Real Security, Open-Source Style

Pin It!

---

What is a Laser Break Module?

A laser break module is a type of sensor system designed to detect interruptions in a laser beam. It typically consists of two key components: a laser emitter and a photodetector (or receiver). The laser emitter generates a continuous beam of light, while the photodetector monitors the integrity of the beam. When an object or person crosses the laser path, it disrupts the beam, and the photodetector detects this interruption.

These modules are often used in applications such as security systems, object detection, and automated processes where real-time monitoring is crucial. For example, in security, laser break modules can form part of an alarm system, where an intruder triggers the system by crossing the laser beam. In industrial automation, these modules can be used to detect the presence or movement of objects on a conveyor belt.

Laser break modules offer several advantages, such as high precision, non-contact detection, and ease of installation, making them ideal for applications where accuracy and reliability are essential.

· · ─ ·𖥸· ─ · ·

What You Need

Pin It!

To build a laser break sensor system with the ESP32 and MicroPython, you will need the following components:

Components List:

1. Laser Diode Module (KY-008, +5V)
2. Photoresistor or Light Sensor Module (e.g., TSL2561 or LDR)
3. Resistors (for voltage dividers or protection)
4. Power Supply (5V for ESP32 and laser diode)
5. Level Shifter (Optional, if using sensors that operate on 3.3V)

Wiring Diagram:

Pin It!

• Laser Break Module:
  • Laser emitter → Connected to a power source (5V and GND).
  • Photodetector output → GPIO 4 (or any available input pin on the ESP32).
• Photoresistor (LDR):
  • One side → 3.3V or 5V on ESP32.
  • Other side → 10kΩ resistor → GND.
  • Junction between LDR and resistor → GPIO 23 (Analog input pin).

Note: You can adjust this diagram based on the specific sensor modules used.

How It Works

1. Laser Emission:
   The ESP32 controls a laser diode that continuously emits a laser beam across a predefined path. The laser should be pointed toward the photodiode or light sensor, which will detect the presence of the beam.
2. Detection Mechanism:
   When an object crosses the path of the laser, it interrupts the beam. This causes the photodiode to detect a change in the light level (e.g., from high to low). The ESP32 reads the sensor’s output to determine if the laser has been blocked.
3. Trigger Response:
   If the laser is interrupted, the ESP32 can trigger a response, such as activating an alarm or logging the event. You can also add a visual indicator like an LED to show the status.

Pin It!

MicroPython Code Example

from machine import Pin, ADC
import time

# Pin assignments
laser_pin = Pin(4, Pin.OUT)  # Laser control pin
sensor_pin = ADC(Pin(23))  # Light sensor input pin
sensor_pin.atten(ADC.ATTN_0DB)  # Set ADC range to 0-3.3V

# Function to turn on/off the laser
def set_laser(state):
    laser_pin.value(state)

# Function to read the sensor value
def read_sensor():
    return sensor_pin.read()

# Main loop
set_laser(1)  # Turn on the laser
time.sleep(1)

while True:
    sensor_value = read_sensor()  # Read the sensor value
    print("Sensor Value:", sensor_value)
    
    # Check if the sensor value is below threshold, meaning the beam is interrupted
    if sensor_value < 1000:  # Adjust this threshold based on your setup
        print("Laser Beam Interrupted!")
        set_laser(0)  # Turn off the laser
        time.sleep(1)
        set_laser(1)  # Turn the laser back on
    time.sleep(0.1)

Explanation of Code

1. Laser Control:
   The set_laser function turns the laser on or off by setting the GPIO pin (GPIO 21) to either HIGH or LOW.
2. Sensor Reading:
   The read_sensor function uses the ADC (analog-to-digital converter) on GPIO 34 to read the light sensor value. If the laser is not interrupted, the sensor will detect a high light level. If an object crosses the path, the sensor will detect a lower value.
3. Main Loop:
   The loop continuously checks the sensor value. If it detects that the beam has been interrupted (sensor value falls below a threshold), it triggers a response (in this case, turning the laser off briefly).

· · ─ ·𖥸· ─ · ·

Key Considerations

• Power Supply: Make sure that the laser diode is powered appropriately, usually requiring 5V for stable operation. The ESP32 operates at 3.3V logic, so make sure to use a level shifter or a compatible light sensor.
• Threshold Calibration: The threshold value in the code (1000) should be calibrated based on your sensor’s behavior. You can fine-tune this by adjusting the value to match the expected light levels under normal and interrupted conditions.
• Safety: Be cautious when working with lasers, especially powerful ones, as they can cause eye damage. Ensure the laser is kept within safe limits and use appropriate safety measures.

· · ─ ·𖥸· ─ · ·

Real Security, Open-Source Style

This build wasn’t just about blinking lights or tripping alarms—it was about control. With nothing more than a laser break sensor, an ESP32, and a few open tools, I now know when things move that shouldn’t. Whether it’s guarding tools, monitoring a door, or experimenting with line-of-sight detection, this setup proves that effective security doesn’t have to be expensive—or proprietary.

The best part? You own every part of it. No vendor lock-in. No closed firmware. Just real-world functionality powered by Free and Open Source Software.

Want more practical FOSS-powered builds like this?

Subscribe to the DevDigest newsletter for hands-on guides, clever hacks, and stories from the open-source trenches.