"""
 Página oficial:          https://micropython.org/
 Referencia del lenguaje: https://docs.micropython.org/en/latest/ 
 Referencia al lenguaje propio del ESP32: https://docs.micropython.org/en/latest/esp32/quickref.html
 Tutorials https://www.youtube.com/@Piogram
      Ejemplo del uso del FOR: https://www.youtube.com/watch?v=qt9lWtvvi1A 
"""
"""
Para la programación, debo ponerlo como AP (AccessPoint). De esta manera un dispositivo se puede conectar
directo al ESP32 y ahí leveanto una WEB pidiendo los datos a configurar en duro.
Video Ejemplo: https://www.youtube.com/watch?v=laHXQoIRiUw&list=PLJ9xqaywaFW6cTQIchNmjKRiPMdveiJjV&index=4$0 
"""
"""
 A useful function for connecting to your local WiFi network is:
 def do_connect():
     import network
     wlan = network.WLAN(network.STA_IF)
     wlan.active(True)
     if not wlan.isconnected():
         print('connecting to network...')
         wlan.connect('ssid', 'key')
         while not wlan.isconnected():
             pass
     print('network config:', wlan.ipconfig('addr4'))
"""
"""
import time

time.sleep(1)           # sleep for 1 second
time.sleep_ms(500)      # sleep for 500 milliseconds
time.sleep_us(10)       # sleep for 10 microseconds
start = time.ticks_ms() # get value of millisecond counter
delta = time.ticks_diff(time.ticks_ms(), start) # compute time difference
"""
"""
Ver "class RTC - real time clock" que permite programar alarmas y manejar un IRQ cuando se dispara la alarma. 
Puedo usarlo para el senseo de temperatura cada x tiempo y enviar un mensaje por MQTT o verificar si no pasa de determinado
valor para enceder automaticamente el extractor.
"""
#import machine
from machine import Pin
from machine import Timer
import time
import dht

## Inicia declaración de Variables ##
# Defino los Timers que usare para ejecuciones programadas
timApagadoAutomatico = Timer(0)
timLedParpadea = Timer(1)
timSensor = Timer(3)

# Listas donde se almacenan los valores de los pines a conectar los botones, los reles y los leds indicadores
Boton_Pins = [Pin(26, Pin.IN, Pin.PULL_DOWN),   # Botón Luz
              Pin(25, Pin.IN, Pin.PULL_DOWN),   # Botón Vel1
              Pin(33, Pin.IN, Pin.PULL_DOWN),   # Botón Vel2
              Pin(32, Pin.IN, Pin.PULL_DOWN)    # Botón Vel3
]
Rele_Pins = [Pin(15, Pin.OUT, value=0),         # Rele Luz
             Pin(4, Pin.OUT, value=0),          # Rele Vel1
             Pin(18, Pin.OUT, value=0),         # Rele Vel2
             Pin(19, Pin.OUT, value=0)          # Rele Vel3
]
Leds_Pins = [Pin(27, Pin.OUT, value=0),         # Botón Luz
             Pin(14, Pin.OUT, value=0),         # Botón Vel1
             Pin(12, Pin.OUT, value=0),         # Botón Vel2
             Pin(13, Pin.OUT, value=0)          # Botón Vel3
]
# Lista donde se almacena el estado lógico permanente de cada botón.
Boton_State = [0,                               # Estado inicial Botón Luz
               0,                               # Estado inicial Botón Vel1
               0,                               # Estado inicial Botón Vel2
               0                                # Estado inicial Botón Vel3
]
Leds_State = [0,                                # Estado inicial Led Luz
              0,                                # Estado inicial Led Vel1
              0,                                # Estado inicial Led Vel2
              0                                 # Estado inicial Led Vel3
]

# Variables Generales
DuracionPresion = 0;  # Guarda la cantidad de milisegundos que se presiona un botón
idxLuz = 0;           # Posición en las listas del valor LUZ
TiempoApagado = 5000; # Tiempo de apagado por Temporizador (5000ms = 5s)

# Asignación del pin y creación de variable del sensor de temperatura y humedad
sensorDHT = dht.DHT22(Pin(23))
## Finaliza declaración de Variables ##


## Inicia declaración de Funciones ##
# Verifica cada botón si fue presionado.
# 1) Si algún botón fue presionado, espera a que se libere la presión y retorna el indice al botón en cuestión.
# 2) Si ningún botón se presiona, devuelve el valor "None".
def LeeBotones():
  global DuracionPresion

  IniciaPresion = 0
  DuracionPresion = 0

  for idxBoton in range(len(Boton_Pins)):
    if Boton_Pins[idxBoton].value() == 1:
      IniciaPresion = time.ticks_ms()
      time.sleep_ms(25)

      while Boton_Pins[idxBoton].value() == 1:
        time.sleep_ms(25)

      DuracionPresion = time.ticks_diff(time.ticks_ms(), IniciaPresion)
      return idxBoton
  return None
# Fin Fx "LeeBotones"
"""
def LeeBotones():
  for Boton in Boton_Pins:
    if Boton.value() == 1:
      time.sleep_ms(50)  
      while Boton.value() == 1:
        time.sleep_ms(50)
      return Boton_Pins.index(Boton)
  return None
"""


# Verifica si algún botón ha sido presionado y de haber sido presionado realiza las siguientes comprobaciones y acciones:
# 1) Si el estado anterior del boton presionado es apagado, realiza las siguientes acciones:
#    A) Si presionó el boton para enceder la LUZ, cambia el estado de la luz a encendido.
#    B) Si presionó el botón para enceder una Velocidad, cambia el estado de todas las Velocidades a apagado y luego cambia el estado de la Velocidad seleccionada a encendida.
# 2) Si el estado anterior del botón presionado es encendido, realiza las siguientes accione:
#    A) Verifica cuanto tiempo ha estado presionado el botón:
#       a) Si estuvo por menos tiempo del necesario para programar el apagado automático, entonces cambia el estado del boton a apagado.
#       b) Si estuvo por mas tiempo del necesario para programar el apagado automático, programa el apagado automático.
def Botonera ():
  global DuracionPresion

  BotonPresionado = LeeBotones()

  if BotonPresionado != None:
    # Boton presionado
    #mensaje = "Boton presionado {} - Estado Actual: {}".format(str(BotonPresionado), str(Boton_State))

    # Si el estado anterior del botón es apagado, entonces cambia el estado a encendido, de lo contario lo cambia a apagado.
    if Boton_State[BotonPresionado] == 0:
      # Cambia el estado del boton a apagado
      if BotonPresionado != idxLuz:
        # Si presiono boton de Velocidad, debe marcar el estado de todos los botones de Velocidad como apagado.
        Boton_State[1] = Leds_State[1] = 0
        Boton_State[2] = Leds_State[2] = 0
        Boton_State[3] = Leds_State[3] = 0

    
      # Marca el estado del botón presionado como encendido.
      Boton_State[BotonPresionado] = Leds_State[BotonPresionado] = 1
    else:
      # Si la presión del botón duró menos de 1.5s (1500ms), cambia el estado del botón a apagado. De lo contrario inicia proceso de apagado automático.
      if DuracionPresion < 1500:
        # La duración de la presion del botón es menor al tiempo de automatización del apagado, por lo tanto cambia el estado del botón a apagado.
        Boton_State[BotonPresionado] = Leds_State[BotonPresionado] = 0
      else:
        # La duración de la presion del botón es igual o superior al tiempo de automatización del apagado, por lo tanto:
        # 1) programa el apagado automático.
        # 2) programa el parpadeo de los leds.
        timApagadoAutomatico.init(mode=Timer.ONE_SHOT, period=TiempoApagado, callback=ApagadoAutomatico)
        timLedParpadea.init(mode=Timer.PERIODIC, period=175, callback=LedParpadea)
        timSensor.deinit()
        #print("Activa Temporizador")

    #mensaje = mensaje + " - Nuevo Estado:  {} - Duracion Presion: {}".format(str(Boton_State), str(DuracionPresion))
    #print(mensaje)
# Fin Fx "Botonera"


# Recorre la lista de Estado y asigna el valor del estado al Rele y al Led Indicador.
# Esto implica que enciendo o apaga según corresponda al valor del Estado.
def Activador():
  for i in range(len(Boton_State)):
    Rele_Pins[i].value(Boton_State[i])
    Leds_Pins[i].value(Leds_State[i])
# Fin Fx "Activador"


# Si si ejecuta el temporizador de Apagado Automático, llama a esta función que actualiza el estado de todos los botones a apagado y luego ejecuta el apagado de los mismos.
def ApagadoAutomatico(Timer):
  #print(f"Apaga Temporizado [{Timer}]")  
  for i in range(len(Boton_State)):
    Boton_State[i] = Leds_State[i] = 0

  timLedParpadea.deinit()
  timSensor.init(mode=Timer.PERIODIC, period=1000, callback=SensarTemperatura)

  Activador()
# Fin Fx "ApagadoAutomatico"


# Si se ejecuta el temporizador de parpadeo de los Les, llama a esta funcion cada 175ms que enciende o apaga los leds del Boton activado.
def LedParpadea(Timer):
  for i in range(len(Boton_State)):
    if Boton_State[i] == 1:
      Leds_Pins[i].value(not Leds_State[i])
      Leds_State[i] = not Leds_State[i]
# Fin Fx "LedParpadea"


# Se ejecuta automaticamente cada 1s. Sensa temperatura y humedad y envía un mensaje MQTT (pendiente desarrollar)
def SensarTemperatura(Timer):
  sensorDHT.measure() 
  temperature = sensorDHT.temperature()
  humedad = sensorDHT.humidity()
  print ("temp: {}, humedad: {}".format(temperature, humedad))
# Fin Fx "SensarTemperatura"

def fxPrueba(Pin):
#  Pin.irq().disable()
  time.sleep_ms(25)

  print(f"Ejecuta interrupcion: {Pin}")


print("Inicia Configuracion")
#Boton_Pins[0].irq(handler=fxPrueba, trigger=Pin.IRQ_FALLING)#, priority=1, wake=None, hard=False)

# Inicializa el Timer del sensor de Temperatura y Humedad.
timSensor.init(mode=Timer.PERIODIC, period=1000, callback=SensarTemperatura)

print("Inicia Bucle")
while True:
  Botonera()
  Activador()