$ python3 main.py


# ------------------------------------------------------------
# Laser “seen/not seen” detector with simple software filtering
# Target: MicroPython (e.g., Raspberry Pi Pico)
#
# What it does:
# - Watches a digital input from a laser receiver module.
# - Uses a tiny "debounce-like" filter so brief glitches are ignored.
# - Turns the onboard LED on when the laser is detected.
# - Drives a buzzer when the laser is NOT detected.
#
# Key ideas you'll see below:
# - Digital input with (optional) internal pull-up.
# - Polling in a loop at a fixed interval (every few milliseconds).
# - Measuring time between changes to ensure a stable state.
# ------------------------------------------------------------

from machine import Pin
import utime

# -----------------------------
# Pin numbers (GPIO identifiers)
# -----------------------------
# Change these to match your wiring. Numbers are GP pin numbers, not physical pin numbers.

RX_DO_PIN   = 2   # Receiver's DO output connected to GPIO 2 (GP2)
LED_PIN     = 25  # Onboard LED on the Pico is GPIO 25 (GP25)
BUZZER_PIN  = 19  # Active buzzer control pin wired to GPIO 19 (GP19)
                 # Make sure your wiring and comment match!

# Some receiver boards want a specific pin held HIGH (e.g., to power or enable something).
# Here GP3 is set as an output and driven HIGH at ~3.3 V. This is so the laser module has power
gp3 = Pin(3, Pin.OUT)
gp3.value(1)  # Keep GP3 at a steady logic HIGH

# -----------------------------
# Tuning / configuration knobs
# -----------------------------

STABLE_MS = 40  # How long (in milliseconds) a new reading must remain unchanged
                # before we accept it as the "real" state. Helps ignore brief noise.
POLL_MS   = 2   # How often (in milliseconds) we sample the input in the main loop.

# Lots of receiver modules have an "open collector" type output and expect a pull-up.
# If set to True, we enable the Pico's internal pull-up resistor on the input pin.
# That means: idle = HIGH, and the module pulls it to LOW when the laser is seen.
USE_INPUT_PULLUP = True

# -----------------------------
# Input setup and helper function
# -----------------------------

if USE_INPUT_PULLUP:
    # Configure RX pin as input with an internal pull-up to 3.3 V.
    rx = Pin(RX_DO_PIN, Pin.IN, Pin.PULL_UP)

    # With pull-up: LOW means "detected" (the module actively pulls the line down).
    def laser_seen():
        # rx.value() returns 0 for LOW, 1 for HIGH
        return rx.value() == 0
else:
    # No pull-up: depends on your module. Often HIGH will mean "detected".
    rx = Pin(RX_DO_PIN, Pin.IN)

    def laser_seen():
        return rx.value() == 1

# -----------------------------
# Output devices: LED + buzzer
# -----------------------------
# value=0 sets their initial state to OFF.

led    = Pin(LED_PIN, Pin.OUT, value=0)      # Onboard LED off initially
buzzer = Pin(BUZZER_PIN, Pin.OUT, value=0)   # Buzzer off initially

# -----------------------------
# State variables for filtering
# -----------------------------

stable_state = False       # The last "accepted" (filtered) state: True=laser, False=no laser
last_sample  = False       # The most recent raw sample read from the pin
last_change  = utime.ticks_ms()  # When the raw sample last flipped (timestamp in ms)

# ---------------------------------------
# Main loop: poll, filter, and take action
# ---------------------------------------
while True:
    # 1) Read the raw input (True if laser is seen, per laser_seen() definition above)
    sample = laser_seen()

    # 2) If the raw reading changed since last time, remember *when* it changed.
    #    We don't immediately trust the new value; we wait to see if it "sticks".
    if sample != last_sample:
        last_sample = sample
        last_change = utime.ticks_ms()  # mark the time of this change

    # 3) Has the raw reading stayed the same for long enough (STABLE_MS)?
    #    If yes, and it's different from our current accepted state, we accept it now.
    if utime.ticks_diff(utime.ticks_ms(), last_change) >= STABLE_MS and sample != stable_state:
        stable_state = sample  # accept the new stable state

        # 4) Take action based on the accepted (filtered) state
        if stable_state:
            # Laser detected
            print("Laser detected")
            led.value(1)   # LED ON
            buzzer.value(0)  # Buzzer OFF
        else:
            # Laser not detected
            print("No laser")
            led.value(0)   # LED OFF
            buzzer.value(1)  # Buzzer ON

    # 5) Wait a tiny bit before sampling again.
    #    Smaller POLL_MS = faster response but more CPU usage.
    utime.sleep_ms(POLL_MS)