from machine import Pin
import time

# Configuracion de pines
# Semaforo Norte
rpn = Pin(2, Pin.OUT); apn = Pin(3, Pin.OUT); vpn = Pin(4, Pin.OUT)
# Semaforo Sur y Flecha
rps = Pin(5, Pin.OUT); aps = Pin(6, Pin.OUT); vps = Pin(7, Pin.OUT); fp = Pin(8, Pin.OUT)
# Semaforo Lateral
rl = Pin(9, Pin.OUT); al = Pin(10, Pin.OUT); vl = Pin(11, Pin.OUT)

# Teclados
filas_pines = [12, 13, 14, 15]
cols_k1_pines = [16, 17, 18, 19]
col_k2_pin = [20]

filas = [Pin(p, Pin.OUT) for p in filas_pines]
cols_k1 = [Pin(p, Pin.IN, Pin.PULL_UP) for p in cols_k1_pines]
cols_k2 = [Pin(p, Pin.IN, Pin.PULL_UP) for p in col_k2_pin]

# Matrices de sensores: [SP1-SP5], [SS1-SS5], [SF1-SF5], [SL1-SL5]
sensores = [[0]*5, [0]*5, [0]*5, [0]*5]

def calcular_membresia(carros):
    mu = [0.0, 0.0, 0.0, 0.0]
    if carros <= 2: mu[0] = 1.0
    elif 2 < carros < 3: mu[0] = 3 - carros; mu[1] = carros - 2
    elif 3 <= carros <= 4: mu[1] = 1.0
    elif 4 < carros < 5: mu[1] = 5 - carros; mu[2] = carros - 4
    elif 5 <= carros <= 8: mu[2] = 1.0
    elif 8 < carros < 9: mu[2] = 9 - carros; mu[3] = carros - 8
    else: mu[3] = 1.0
    return mu

def obtener_tiempo_difuso(carros):
    mu = calcular_membresia(carros)
    tiempos_base = [5, 23, 41, 60] 
    numerador = sum(m * t for m, t in zip(mu, tiempos_base))
    denominador = sum(mu)
    if denominador == 0: return 5
    return int(numerador / denominador)

# Control de semaforo
def inicializar_luces():
    rpn.on(); rps.on(); rl.on()
    apn.off(); aps.off(); al.off()
    vpn.off(); vps.off(); vl.off(); fp.off()

def transicion_verde_a_rojo(pin_verde, pin_amarillo, pin_rojo_siguiente):
    pin_verde.off()
    time.sleep(1)
    pin_verde.on()
    time.sleep(1)
    pin_verde.off()
    if pin_amarillo:
        pin_amarillo.on()
        time.sleep(2)
        pin_amarillo.off()
    if pin_rojo_siguiente:
        pin_rojo_siguiente.on()

def transicion_flecha(pin_flecha):
    for i in range(2):
        pin_flecha.off()
        time.sleep(0.5)
        pin_flecha.on()
        time.sleep(0.5)
    pin_flecha.off()

def escanear_teclados():
    for i, fila in enumerate(filas):
        fila.off() 
        for j, col in enumerate(cols_k1):
            if col.value() == 0: 
                if sensores[i][j] < 2: sensores[i][j] += 1
                time.sleep(0.2) 
        if cols_k2[0].value() == 0:
            if sensores[i][4] < 2: sensores[i][4] += 1
            time.sleep(0.2)
        fila.on()

def ciclo_semaforo():
    # Suma los vehiculos por carril
    carros_norte = sum(sensores[0])
    carros_sur = sum(sensores[1])
    carros_flecha = sum(sensores[2])
    carros_lateral = sum(sensores[3])
    
    # Calculo de tiempos difusos
    tiempo_principal = obtener_tiempo_difuso(max(carros_norte, carros_sur))
    tiempo_lateral = obtener_tiempo_difuso(carros_lateral)
    
    # Tiempo de flecha
    if carros_flecha == 0: tiempo_flecha = 0
    elif 1 <= carros_flecha <= 2: tiempo_flecha = 4
    elif 3 <= carros_flecha <= 4: tiempo_flecha = 7
    else: tiempo_flecha = 10

    # Aviso de numero de carros y tiempo de cada semaforo
    print("      Trafico y tiempo por semaforo")
    print(f" Conteo de Vehiculos:")
    print(f"  - Carril Principal Norte : {carros_norte} carros")
    print(f"  - Carril Principal Sur   : {carros_sur} carros")
    print(f"  - Flecha Principal Sur   : {carros_flecha} carros")
    print(f"  - Carril Lateral         : {carros_lateral} carros")
    print("-" * 40)
    print(f" Tiempos:")
    print(f"  - Verde Principal (N/S)  : {tiempo_principal} segundos")
    print(f"  - Verde Flecha           : {tiempo_flecha} segundos" if tiempo_flecha > 0 else "  - Verde Flecha           : 0s")
    print(f"  - Verde Lateral          : {tiempo_lateral} segundos")
    print("-" * 40 + "\n")

    # Secuencia de luces
    # Carril Principal
    rl.on() 
    rpn.off(); rps.off()
    
    if tiempo_flecha > 0:
        vps.on(); fp.on()
        rpn.on()
        time.sleep(tiempo_flecha)
        
        transicion_flecha(fp)
        
        rpn.off() 
        vps.on(); vpn.on()
        time.sleep(tiempo_principal)
        
        transicion_verde_a_rojo(vpn, apn, rpn)
        vps.off() 
        aps.on(); time.sleep(2); aps.off(); rps.on()
        
    else:
        vpn.on(); vps.on()
        time.sleep(tiempo_principal)
        
        vpn.off(); vps.off()
        time.sleep(1); vpn.on(); vps.on()
        time.sleep(1); vpn.off(); vps.off()
        apn.on(); aps.on(); time.sleep(2)
        apn.off(); aps.off()
        rpn.on(); rps.on()

    # Carril Lateral
    rl.off()
    vl.on()
    time.sleep(tiempo_lateral)
    transicion_verde_a_rojo(vl, al, rl)
    
    # Reinicio de sensores
    for i in range(4):
        for j in range(5):
            sensores[i][j] = 0

# Bucle principal
inicializar_luces()

while True:
    tiempo_inicio = time.ticks_ms()
    print("Leyendo sensores...")
    while time.ticks_diff(time.ticks_ms(), tiempo_inicio) < 5000: 
        escanear_teclados()
        
    print("Procesando datos...")
    ciclo_semaforo()