import machine
import utime

# ==========================================
# Project: Noise Detector with Automatic Recording System
# Features: Sound + Ultrasonic + LDR + LCD + Red LED + Buzzer + Button
# ==========================================

# --- I2C LCD DRIVER (Included for convenience) ---
class I2cLcd:
    def __init__(self, i2c, i2c_addr):
        self.i2c = i2c
        self.i2c_addr = i2c_addr
        utime.sleep_ms(50) # Increased delay for stability
        self._send_nibble(0x03)
        utime.sleep_ms(5)
        self._send_nibble(0x03)
        utime.sleep_ms(1)
        self._send_nibble(0x03)
        utime.sleep_ms(1)
        self._send_nibble(0x02)
        self.write_cmd(0x28)
        self.write_cmd(0x0C)
        self.write_cmd(0x06)
        self.clear()

    def _send_nibble(self, nibble):
        self.i2c.writeto(self.i2c_addr, bytearray([(nibble << 4) | 0x0C])) 
        self.i2c.writeto(self.i2c_addr, bytearray([(nibble << 4) | 0x08])) 

    def write_cmd(self, cmd):
        self.i2c.writeto(self.i2c_addr, bytearray([(cmd & 0xF0) | 0x0C]))
        self.i2c.writeto(self.i2c_addr, bytearray([(cmd & 0xF0) | 0x08]))
        self.i2c.writeto(self.i2c_addr, bytearray([((cmd << 4) & 0xF0) | 0x0C]))
        self.i2c.writeto(self.i2c_addr, bytearray([((cmd << 4) & 0xF0) | 0x08]))

    def write_char(self, char_val):
        val = ord(char_val)
        self.i2c.writeto(self.i2c_addr, bytearray([(val & 0xF0) | 0x0D])) 
        self.i2c.writeto(self.i2c_addr, bytearray([(val & 0xF0) | 0x09])) 
        self.i2c.writeto(self.i2c_addr, bytearray([((val << 4) & 0xF0) | 0x0D]))
        self.i2c.writeto(self.i2c_addr, bytearray([((val << 4) & 0xF0) | 0x09]))

    def putstr(self, string):
        for char in string:
            self.write_char(char)

    def clear(self):
        self.write_cmd(0x01)
        utime.sleep_ms(2)

    def move_to(self, cursor_x, cursor_y):
        addr = cursor_x & 0x3F
        if cursor_y == 1:
            addr += 0x40
        self.write_cmd(0x80 | addr)

# --- PINS SETUP ---

# 1. LCD Setup (Decreased frequency to 100000 for better stability)
i2c = machine.I2C(0, sda=machine.Pin(0), scl=machine.Pin(1), freq=100000)
lcd = I2cLcd(i2c, 0x27)

# 2. Sound Sensor
sound_adc = machine.ADC(26)
sound_digital = machine.Pin(15, machine.Pin.IN)

# 3. Red LED
led_red = machine.Pin(14, machine.Pin.OUT)

# 4. Buzzer
buzzer = machine.Pin(16, machine.Pin.OUT)

# 5. Push Button
button = machine.Pin(12, machine.Pin.IN, machine.Pin.PULL_UP)

# 6. Ultrasonic Sensor (HC-SR04)
trig = machine.Pin(6, machine.Pin.OUT)
echo = machine.Pin(7, machine.Pin.IN)

# 7. Light Sensor (LDR)
ldr = machine.ADC(27)

# --- SYSTEM PARAMETERS ---
NOISE_THRESHOLD = 50000  
RECORDING_DURATION = 50  # Loop iterations for recording

# --- HELPER FUNCTIONS ---
def read_distance():
    trig.value(0)
    utime.sleep_us(2)
    trig.value(1)
    utime.sleep_us(10)
    trig.value(0)
    timeout = utime.ticks_us()
    while echo.value() == 0:
        if utime.ticks_diff(utime.ticks_us(), timeout) > 30000:
            return -1
    pulse_start = utime.ticks_us()
    while echo.value() == 1:
        if utime.ticks_diff(utime.ticks_us(), pulse_start) > 30000:
            return -1
    pulse_end = utime.ticks_us()
    return (utime.ticks_diff(pulse_end, pulse_start) * 0.0343) / 2

# --- STARTUP SEQUENCE ---
print("---------------------------------")
print(" Noise Detector & Auto Recording ")
print(" System Initializing...          ")
print("---------------------------------")

lcd.clear()
lcd.putstr("Noise Detector")
lcd.move_to(0, 1)
lcd.putstr("Starting up...")
led_red.value(0) # LED Off during boot
utime.sleep(2)

# --- MAIN LOOP ---
while True:
    # Monitoring State (No Noise)
    lcd.clear()
    lcd.putstr("Status: QUIET")
    lcd.move_to(0, 1)
    lcd.putstr("Monitoring...")
    led_red.value(0) # LED Off during standby
    
    print("\n[*] Room is QUIET. System is monitoring for noise...")

    # Wait until button is unpressed to allow future manual stop
    button_ready = False

    while True:
        noise_level = sound_adc.read_u16()
        is_loud = sound_digital.value() == 1

        if noise_level > NOISE_THRESHOLD or is_loud:
            break # Exit listening loop to trigger recording
        
        utime.sleep_ms(100)

    # --- NOISE DETECTED EVENT ---
    print("\n===================================")
    print("[!] WARNING: HIGH NOISE DETECTED!")
    print("===================================")
    
    # Read context sensors
    distance = read_distance()
    light_level = ldr.read_u16()
    
    print("-> Target Distance: {:.1f} cm".format(distance))
    print("-> Room Light Level: {}".format(light_level))
    print("-> Action: Recording audio to memory...")
    
    # Update LCD
    lcd.clear()
    lcd.putstr("NOISE DETECTED!")
    lcd.move_to(0, 1)
    lcd.putstr("Rec... Dist:{:.0f}cm".format(distance))
    
    # Turn LED solid RED during the entire recording phase
    led_red.value(1) 

    # Recording & Alarm Loop
    aborted = False
    
    for i in range(RECORDING_DURATION):
        # Enable manual stop only if button is not short-circuited/stuck
        if button.value() == 1:
            button_ready = True
            
        if button_ready and button.value() == 0:
            aborted = True
            break
            
        # Toggle ONLY Buzzer (LED stays solid Red)
        buzzer.value(1)
        utime.sleep_ms(100)
        buzzer.value(0)
        utime.sleep_ms(100)

    # --- END OF EVENT ---
    lcd.clear()
    print("-----------------------------------")
    
    if aborted:
        print("[X] Alert Canceled: Stopped by User.")
        lcd.putstr("ALERT CANCELED")
        lcd.move_to(0, 1)
        lcd.putstr("Stopped by User")
        led_red.value(0) # LED Off
        utime.sleep(2)
    else:
        print("[V] Event Completed: Audio Saved.")
        lcd.putstr("EVENT COMPLETED")
        lcd.move_to(0, 1)
        lcd.putstr("Audio Saved!")
        led_red.value(0) # LED Off
        utime.sleep(2)