from machine import ADC, Pin
import time

# --- Hardware-Definition ---
ldr = ADC(Pin(35))         # ADC1_CH0, Lichtsensor
ldr.atten(ADC.ATTN_11DB)  # vollen Messbereich bis ~3.3V

# Schrittmotor-Pins (ULN2003)
step_pins = [Pin(p, Pin.OUT) for p in (14, 12, 13, 15)]
# Halb- oder Vollschritt-Sequenz (hier Vollschritt)
step_seq = [
    [1,0,1,0], #sequenz 0
    [0,1,1,0], #sequenz 1
    [0,1,0,1], #sequenz 2
    [1,0,0,1]  #sequenz 3
]

# --- Parameter ---
SAMPLE_COUNT = 10    # Anzahl Messungen pro Zyklus
THRESHOLD_HIGH = 2000  # Schwelle (0-4095) zum Öffnen
THRESHOLD_LOW = 1000   # Schwelle zum Schließen
STEP_DELAY = 0.005     # Zeit zwischen Schrittmotor-Stufen

# --- Hilfsfunktionen ---
def read_light(n):
    #Liest n Mal den LDR-Wert und gibt Liste zurück.
    vals = []
    for _ in range(n):
        vals.append(ldr.read())
        time.sleep(0.01)
    return vals


def arithmetic_mean(vals): #Mittelwert
    return sum(vals) / len(vals)


def median(vals): # Median
    s = sorted(vals)
    mid = len(s)//2
    if len(s) % 2:
        return s[mid]
    else:
        return (s[mid-1] + s[mid]) / 2


glide_window = []

def moving_average(val, size=5):
    #Gleitender Durchschnitt: fügt neuen Wert hinzu, entfernt alten, berechnet Mittelwert
    glide_window.append(val)
    if len(glide_window) > size:
        glide_window.pop(0)
    return sum(glide_window) / len(glide_window)


def step_motor(steps, direction=1):
    #Bewegt den Schrittmotor um 'steps' Schritte. direction: 1=vorwärts, -1=rückwärts
    #Bei direction=1 (vorwärts) starten wir bei idx = 0.
    #Bei direction=-1 (rückwärts) starten wir bei idx = 3 (letzte Sequenz-Position).
    seq_len = len(step_seq)
    idx = 0 if direction>0 else seq_len-1
    for _ in range(steps):
        # 1) Aktuelle Stufe an alle Pins ausgeben
        for pin, val in zip(step_pins, step_seq[idx]):
            pin.value(val)
        # 2) Index für nächste Stufe erhöhen oder verringern
        #Bei vorwärts (direction=1) erhöhen wir den Index
        #bei rückwärts (direction=-1) verringern wir ihn.
        #Durch Modulo (% 4) sorgen wir für ein zyklisches Durchlaufen der Sequenz.
        idx = (idx + direction) % seq_len
        # 3) Kurze Pause, bis zum nächsten Schritt
        #Ein kleiner Pausewert (STEP_DELAY = 0.005 s) bestimmt die Dreh­geschwindigkeit: 
        #je kleiner, desto schneller.
        time.sleep(STEP_DELAY)


def stop_motor():
    for pin in step_pins:
        pin.value(0)

# --- Hauptprogramm ---
    while True:
        # 1. Messungen sammeln
        samples = read_light(SAMPLE_COUNT)

        # 2. Mittelwerte berechnen
        mean_val = arithmetic_mean(samples)
        med_val = median(samples)
        mov_val = moving_average(mean_val)

        # 3. Entscheidung anhand des bewegten Durchschnitts
        print("Mean:", mean_val, "Median:", med_val, "MovingAvg:", mov_val)
        if mov_val > THRESHOLD_HIGH:
            print("Hohe Helligkeit: Blende öffnen")
            step_motor(50, direction=1)
        elif mov_val < THRESHOLD_LOW:
            print("Niedrige Helligkeit: Blende schließen")
            step_motor(50, direction=-1)
        else:
            print("Helligkeit im Soll-Bereich: Motor aus")
            stop_motor()

        time.sleep(1)