import machine
from machine import Pin, I2C, ADC, PWM, Pin
import time
import ssd1306
import dht
import framebuf
import imagen
import ultrasonico

# Asignación de terminales al canal I2C
# --> Canal, Terminal Reloj, Terminal Datos)
i2c = I2C(0, scl=Pin(22), sda=Pin(21))

oled_width = 128      # Ancho de la pantalla
oled_height = 64      # Alto de la pantalla

#Creacion de objetos
oled = ssd1306.SSD1306_I2C(oled_width, oled_height, i2c)  # Creación de un objeto del tipo 'pantalla OLED'
dht22 = dht.DHT22(Pin(19))                                 # Creación de un objeto

#Pines PIR
pir_pin = Pin(18, Pin.IN)


# Configuración de los pines de los botones
#Definidos como Pull_down apar que esten en bajo hasta que reciban un estado alto
Boton_1 = machine.Pin(14, machine.Pin.IN, Pin.PULL_UP)
Boton_2 = machine.Pin(12, machine.Pin.IN, Pin.PULL_UP)
Boton_3 = machine.Pin(13, machine.Pin.IN, Pin.PULL_UP)

#Pines de salida de los leds
led_azul = machine.Pin(15,Pin.OUT)
led_rojo = machine.Pin(2,Pin.OUT)
led_verde = machine.Pin(4,Pin.OUT)

#Potenciometro
s = PWM(Pin(5))  # Pin 2 en el ESP32
s.freq(50)
adc = ADC(Pin(34))

#Primer menu 
menu_principal = ["LedsOn","Sensores","ServoMotor","GraficaVx","GraficaHy"]
menu_principal_seleccion = 0

#Primer submenu
sub_menu_1 = ["LedAzul","LedRojo","LedVerde","Salir"]
sub_menu1_seleccion = 0

#Segundo submenu
sub_menu_2 = ["Humedad","Ultrasonico","Pir","Salir"]
sub_menu2_seleccion = 0

#tercer submenu
sub_menu_3 = ["Mostrart Ang", "control servo","Salir"]
sub_menu3_seleccion = 0


# Cuarto submenu
sub_menu_4 = ["imagen","salir",]
sub_menu4_seleccion = 0

# quinto submenu
sub_menu_5 = ["imagen","salir"]
sub_menu5_seleccion = 0

# Función que llama la imagen
def mostrar_imagen(matriz_imagen,):
    oled.fill(0)
    for y, fila in enumerate(matriz_imagen):
        for x, pixel in enumerate(fila):
            oled.pixel(x, y,)
    oled.show()
    time.sleep(5)

#Función del ultrasonico
def mostrar_distancia():
    distancia = ultrasonico.medir_distancia()# Medir la distancia con el sensor ultrasónico
    oled.fill(0)
    oled.text("Distancia:", 0, 20)
    oled.text("{:.1f} cm".format(distancia), 0, 30)  # Mostrar la distancia en cm
    oled.show()
    time.sleep(5)

#Función Pir
def detectar_movimiento():
    if pir_pin.value() == 1:
        oled.fill(0)
        oled.text("Movimiento", 0, 20)
        oled.text("detectado", 0, 40 )
        oled.show()
    elif pir_pin.value() == 0:
        oled.fill(0)
        oled.text("Movimiento no", 0, 20)
        oled.text("detectado", 0, 40 )
        oled.show()
    time.sleep(5)

#Función de encender leds en secuencia
def encender_led_secuencia(index):
    led_azul.off()
    led_rojo.off()
    led_verde.off()

    if index == 0:
        led_azul.on()
    elif index == 1:
        led_rojo.on()
    elif index == 2:
        led_verde.on()
   
# Actualizar la pantalla cada vez que se cambia de opción
#------------------------------------------------------------------
def menu_principal_muestra():
    oled.fill(0)
    oled.text("Main Menu:", 30, 0)
    for i, opcion in enumerate(menu_principal):
        if i == menu_principal_seleccion:
            oled.text(">>" + opcion, 0, 13 + i * 10)
        else:
            oled.text(opcion, 0, 13 + i * 10)
    oled.show()
#------------------------------------------------------------------
#Mover cursor en la pantalla principal
def desp_menu(desplazamiento_menu):
    global menu_principal_seleccion
    if desplazamiento_menu == "up":
        menu_principal_seleccion = (menu_principal_seleccion - 1) % len(menu_principal)
        time.sleep(0.2)
    elif desplazamiento_menu == "down":
        menu_principal_seleccion = (menu_principal_seleccion + 1) % len(menu_principal)
        time.sleep(0.2)
#------------------------------------------------------------------
#Sub menu numero 1
def sub_menu_muestra_1():
    global sub_menu1_seleccion
    sub_menu1_seleccion = 0
    led_azul_encendido = False
    led_rojo_encendido = False
    led_verde_encendido = False
    time.sleep(0.3)
    while True:
        oled.fill(0)
        oled.text("Submenu:", 30, 0)
        for i, option in enumerate(sub_menu_1):
            if i == sub_menu1_seleccion:
                oled.text(">>" + option, 0, 20 + i * 10)
            else:
                oled.text(option, 0, 20 + i * 10)
        oled.show()

        if not Boton_1.value():
          desp_sub_menu_1("up")          

        if not Boton_2.value():
          desp_sub_menu_1("down")

        if not Boton_3.value() and sub_menu1_seleccion == 0:
            if led_azul_encendido:
                led_azul.off()
                oled.text("Off", 80, 20)
                oled.show()
                led_azul_encendido = False
                time.sleep(3)
            else:
                led_azul.on()
                led_azul_encendido = True
                oled.text("ON", 80, 20)
                oled.show()
                time.sleep(3)

        if not Boton_3.value() and sub_menu1_seleccion == 1:
            if led_rojo_encendido:
                led_rojo.off()
                oled.text("Off", 80, 30)
                oled.show()
                led_rojo_encendido = False
                time.sleep(3)
            else:
                led_rojo.on()
                oled.text("ON", 80, 30)
                oled.show()
                led_rojo_encendido = True
                time.sleep(3)

        if not Boton_3.value() and sub_menu1_seleccion == 2:
            if led_verde_encendido:
                led_verde.off()
                oled.text("Off", 85, 40)
                oled.show()
                led_verde_encendido = False
                time.sleep(3)
            else:
                led_verde.on()
                oled.text("ON", 85, 40)
                oled.show()
                led_verde_encendido = True
                time.sleep(3)
        if not Boton_3.value() and sub_menu1_seleccion == 3:
            apagar_leds()
            time.sleep(0.2)
            break

      
#-------------------------------------------------------------------

#Mover cursor en la pantalla del submenu 1
def desp_sub_menu_1(desplazamiento_menu):
    global sub_menu1_seleccion
    if desplazamiento_menu == "up":
        sub_menu1_seleccion = (sub_menu1_seleccion - 1) % len(sub_menu_1)
        time.sleep(0.2)
    elif desplazamiento_menu == "down":
        sub_menu1_seleccion = (sub_menu1_seleccion + 1) % len(sub_menu_1)
        time.sleep(0.2)
#-------------------------------------------------------------------
#Función para apagar todos los LEDs
def apagar_leds():
  led_azul.off()
  led_rojo.off()
  led_verde.off() 
#Sub menu numero 2
def sub_menu_muestra_2():
    global sub_menu2_seleccion
    sub_menu2_seleccion = 0
    time.sleep(0.3)
    while True:
        oled.fill(0)
        oled.text("Submenu:", 30, 0)
        for i, option in enumerate(sub_menu_2):
            if i == sub_menu2_seleccion:
                oled.text(">>" + option, 0, 20 + i * 10)
            else:
                oled.text(option, 0, 20 + i * 10)
        oled.show()

        if not Boton_1.value():
          desp_sub_menu_2("up")          

        if not Boton_2.value():
          desp_sub_menu_2("down")

        if not Boton_3.value() and sub_menu2_seleccion == 0:
            sensor_humedad() 
        
        if not Boton_3.value() and sub_menu2_seleccion == 1:
            mostrar_distancia()

        if not Boton_3.value() and sub_menu2_seleccion == 2:
            detectar_movimiento()

        if not Boton_3.value() and sub_menu2_seleccion == 3:
            time.sleep(0.2)
            break
#-------------------------------------------------------------------

#Mover cursor en la pantalla del submenu 2
def desp_sub_menu_2(desplazamiento_menu_2):
    global sub_menu2_seleccion
    if desplazamiento_menu_2 == "up":
        sub_menu2_seleccion = (sub_menu2_seleccion - 1) % len(sub_menu_2)
        time.sleep(0.2)
    elif desplazamiento_menu_2 == "down":
        sub_menu2_seleccion = (sub_menu2_seleccion + 1) % len(sub_menu_2)
        time.sleep(0.2)
#-------------------------------------------------------------------
#servomotor
def sub_menu_muestra_3():
    global sub_menu3_seleccion
    sub_menu3_seleccion = 0
    time.sleep(0.3)
    
    while True:
        oled.fill(0)
        oled.text("ServoMotor", 13, 0)
        for i, option in enumerate(sub_menu_3):
            if i == sub_menu3_seleccion:
                oled.text(">>" + option, 0, 20 + i * 10)
            else:
                oled.text(option, 0, 20 + i * 10)
        oled.show()

        if not Boton_1.value():
            desp_sub_menu_3("up")          

        if not Boton_2.value():
            desp_sub_menu_3("down")

        if not Boton_3.value() and sub_menu3_seleccion == 0:
            servo_motor1()  # Mostrar ángulo predeterminado y encender LEDs
            time.sleep(0.2)

        if not Boton_3.value() and sub_menu3_seleccion == 1:
            control_servo()  # Controlar el servo con el potenciómetro
            time.sleep(0.2)
        
        if not Boton_3.value() and sub_menu3_seleccion == 2:
            time.sleep(0.2)  # Salir del submenú y regresar al menú principal
            break
#Mover cursor en la pantalla del submenu 3
def desp_sub_menu_3(desplazamiento_menu_3):
    global sub_menu3_seleccion
    if desplazamiento_menu_3 == "up":
        sub_menu3_seleccion = (sub_menu3_seleccion - 1) % len(sub_menu_3)
        time.sleep(0.2)
    elif desplazamiento_menu_3 == "down":
        sub_menu3_seleccion = (sub_menu3_seleccion + 1) % len(sub_menu_3)
        time.sleep(0.2)

#Senosr de humedad
def sensor_humedad():
    dht22.measure()
    oled.fill(0)
    oled.text("Temp:"+str(dht22.temperature()),0,17)
    oled.text("Hum:"+str(dht22.humidity()),0,32)
    oled.show()
    time.sleep(5)
#Sub menu numero 4
def sub_menu_muestra_4():
    global sub_menu4_seleccion
    sub_menu4_seleccion = 0
    time.sleep(0.3)
    
    while True:
        oled.fill(0)
        oled.text("imagen Vx", 13, 0)
        for i, option in enumerate(sub_menu_4):
            if i == sub_menu4_seleccion:
                oled.text(">>" + option, 0, 20 + i * 10)
            else:
                oled.text(option, 0, 20 + i * 10)
        oled.show()

        if not Boton_1.value():
          desp_sub_menu_4("up")          

        if not Boton_2.value():
          desp_sub_menu_4("down")

        if not Boton_3.value() and sub_menu4_seleccion == 0:
           graficaVx()  # Llama a la función graficaVx en lugar de mostrar la imagen estática
           break
           
        
        if not Boton_3.value() and sub_menu4_seleccion == 1:
            time.sleep(0.2)
            break
       
#-------------------------------------------------------------------

#Mover cursor en la pantalla del submenu 4
def desp_sub_menu_4(desplazamiento_menu):
    global sub_menu4_seleccion
    if desplazamiento_menu == "up":
        sub_menu4_seleccion = (sub_menu4_seleccion - 1) % len(sub_menu_4)
        time.sleep(0.2)
    elif desplazamiento_menu == "down":
        sub_menu4_seleccion = (sub_menu4_seleccion + 1) % len(sub_menu_4)
        time.sleep(0.2)

#Sub menu numero 5
def sub_menu_muestra_5():
    global sub_menu5_seleccion
    sub_menu5_seleccion = 0
    time.sleep(0.3)
    while True:
        oled.fill(0)
        oled.text("imagen HY", 13, 0)
        for i, option in enumerate(sub_menu_5):
            if i == sub_menu5_seleccion:
                oled.text(">>" + option, 0, 20 + i * 10)
            else:
                oled.text(option, 0, 20 + i * 10)
        oled.show()

        if not Boton_1.value():
          desp_sub_menu_5("up")          

        if not Boton_2.value():
          desp_sub_menu_5("down")

        if not Boton_3.value() and sub_menu5_seleccion == 0:
            graficaHy()  # Llama a la función graficaHy en lugar de mostrar la imagen estática
            break
        
        if not Boton_3.value() and sub_menu5_seleccion == 1:
            time.sleep(0.2)
            break

#-------------------------------------------------------------------

#Mover cursor en la pantalla del submenu 5
def desp_sub_menu_5(desplazamiento_menu):
    global sub_menu5_seleccion
    if desplazamiento_menu == "up":
        sub_menu5_seleccion = (sub_menu5_seleccion - 1) % len(sub_menu_5)
        time.sleep(0.2)
    elif desplazamiento_menu == "down":
        sub_menu5_seleccion = (sub_menu5_seleccion + 1) % len(sub_menu_5)
        time.sleep(0.2)
#Sensor ultrasonico
# Motor
def servo_motor1():  # Pin 34 en el ESP32 (ADC1_CH6)
 # Definir los ángulos predefinidos
    angulos = [5, 21, 43, 128, 167]
    # Definir los mensajes correspondientes a los ángulos predefinidos
    mensajes = ["", "21 grados LED azul", "", "LED rojo encendido, LED azul apagado y 128 grados", ""]
    
    tiempo_inicio = time.ticks_ms()  

    index = 0  # Índice para recorrer los ángulos predefinidos

    while True:
        # Obtener el ángulo actual
        angulo_actual = angulos[index]

        # Mostrar el ángulo actual en la pantalla OLED
        oled.fill(0)
        oled.text("Angulo: {}".format(angulo_actual), 0, 0)
        oled.show()

        # Controlar el motor servo
        ton = (angulo_actual + 45) * 100000 // 9
        s.duty_ns(int(ton))

        # Comprobar si el ángulo actual coincide con algún ángulo predefinido
        if angulo_actual == 21:
            led_azul.on()
        elif angulo_actual == 128:
            led_azul.off()
            led_rojo.on()
        else:
            led_azul.off()
            led_rojo.off()

        # Mostrar el mensaje correspondiente en la pantalla OLED
        oled.text(mensajes[index], 0, 20)
        oled.show()

        # Incrementar el índice para pasar al siguiente ángulo
        index = (index + 1) % len(angulos)

        # Si han pasado 5 segundos, salir del bucle
        if time.ticks_diff(time.ticks_ms(), tiempo_inicio) >= 5000:
            break

        # Esperar un corto tiempo antes de pasar al siguiente ángulo
        time.sleep(0.5)
#_________________
def control_servo():
 tiempo_inicio = time.ticks_ms()  
 while True:
    pot = int(adc.read_u16() * 180 / 65535)
    print(pot)
    oled.fill(0)
    oled.text("Angulo: {}".format(pot), 0, 0)
    oled.show()
    ton = (pot + 45) * 100000 // 9  # Corregido el cálculo de ton
    s.duty_ns(int(ton))
    time.sleep_ms(200) 
    if time.ticks_diff(time.ticks_ms(), tiempo_inicio) >= 5000:
            break


# ImagenVer
def graficaVx():
    # Definir la posición inicial en el eje x (columna)
    x_position = 0
    tiempo_inicio = time.ticks_ms()
    led_index = 0

    # Iterar mientras se muestra la imagen en movimiento vertical
    while True:
        # Mostrar la imagen en la posición actual en el eje x (columna)
        mostrar_imagen_vertical(imagen.imagen_matriz, x_position)

        # Incrementar la posición en el eje x (columna) para el próximo frame
        x_position += 1

        # Si la imagen se sale completamente de la pantalla, reiniciar la posición en x (columna)
        if x_position > oled_width:
            x_position = 0
        
        # Encender el LED correspondiente según el índice
        encender_led_secuencia(led_index)

        # Incrementar el índice para controlar la secuencia de LEDs
        led_index = (led_index + 1) % 3  # Suponiendo que hay 3 LEDs

        if time.ticks_diff(time.ticks_ms(), tiempo_inicio) >= 10000:
            break

        # Ajustar la velocidad de desplazamiento horizontal
        time.sleep_ms(50)  # Ajusta el tiempo según la velocidad deseada
    sub_menu_muestra_4()

#Mover imagen en Vx
def mostrar_imagen_vertical(matriz_imagen, x_position):
    oled.fill(0)
    for y, fila in enumerate(matriz_imagen):
        for x, pixel in enumerate(fila):
            oled.pixel(x + x_position, y, pixel)  # Sumamos x_position para desplazar verticalmente
    oled.show()

#ImagenHor
def graficaHy():
    # Definir la posición inicial en el eje y (fila)
    y_position = 0
    tiempo_inicio = time.ticks_ms()
    led_index = 0

    # Iterar mientras se muestra la imagen en movimiento horizontal
    while True:
        # Mostrar la imagen en la posición actual en el eje y (fila)
        mostrar_imagen_horizontal(imagen.imagen_matriz, y_position)

        # Incrementar la posición en el eje y (fila) para el próximo frame
        y_position += 1

        # Si la imagen se sale completamente de la pantalla, reiniciar la posición en y (fila)
        if y_position > oled_height:
            y_position = 0
        
        # Encender el LED correspondiente según el índice
        encender_led_secuencia(led_index)

        # Incrementar el índice para controlar la secuencia de LEDs
        led_index = (led_index + 1) % 3  # Suponiendo que hay 3 LEDs
        
        if time.ticks_diff(time.ticks_ms(), tiempo_inicio) >= 10000:
            break
            
        # Ajustar la velocidad de desplazamiento vertical
        time.sleep_ms(50)  # Ajusta el tiempo según la velocidad deseada
    sub_menu_muestra_5()

# mover imagen Hy
def mostrar_imagen_horizontal(matriz_imagen, y_position):
    oled.fill(0)
    for x, fila in enumerate(matriz_imagen):
        for y, pixel in enumerate(fila):
            oled.pixel(x, y + y_position, pixel)  # Sumamos y_position para desplazar horizontalmente
    oled.show()

#Bucle principal de todo el menu 
while True:
    menu_principal_muestra()
    if not Boton_1.value():
      desp_menu("up")
      
    if not Boton_2.value():
      desp_menu("down")
      
    if not Boton_3.value() and menu_principal_seleccion == 0:
      sub_menu_muestra_1()

    if not Boton_3.value() and menu_principal_seleccion == 1:
        sub_menu_muestra_2()
    
    if not Boton_3.value() and menu_principal_seleccion == 2:
      sub_menu_muestra_3()

    if not Boton_3.value() and menu_principal_seleccion == 3:
     sub_menu_muestra_4()

    if not Boton_3.value() and menu_principal_seleccion == 4:
     sub_menu_muestra_5()