print("Hello, ESP32!")

from machine import Pin  #Importa a classe Pin(pinos de entrada) da biblioteca machine, que permite controlar os pinos GPIO do ESP32.
import time   #Importa o módulo time, que fornece funções para manipulação e controle do tempo. Estas funções são amplamente utilizadas para várias tarefas relacionadas ao tempo, como criar atrasos na execução do código, medir intervalos de tempo, obter a data e hora atuais, entre outras.
import network  # Pode se conectar-se a uma rede Wi-Fi, verificar o status da conexão ou configurar outros parâmetros de rede.
#Após importar o módulo network, você pode usar suas classes e funções para realizar operações relacionadas à rede
#Permitindo que você use a classe WLAN do módulo para configurar e controlar a interface Wi-Fi do dispositivo.
import ntptime   #Biblioteca para sincronização de tempo com servidores NTP.
import utime    #Biblioteca para operações de tempo.
import machine   #Fornece acesso a recursos específicos da placa, como GPIO, RTC, etc.

# Conectar-se à rede Wi-Fi
print("Conectando-se ao Wi-Fi", end="") 
sta_if = network.WLAN(network.STA_IF)   # Cria um objeto WLAN no modo station (STA_IF) que permite conectar-se a uma rede Wi-Fi
sta_if.active(True)   # Ativa a interface Wi-Fi para começar a procurar e se conectar a redes
sta_if.connect('Wokwi-GUEST', '')   # Conecta à rede Wi-Fi com o SSID 'Wokwi-GUEST' e sem senha
while not sta_if.isconnected():   # Inicia um loop que continua até que a conexão Wi-Fi esteja estabelecida
    print(".", end="")   # Imprime um ponto na mesma linha para indicar que está tentando conectar
    time.sleep(0.1)     # Aguarda 0.1 segundo antes de tentar novamente, para não sobrecarregar a CPU
print(" Conectado!")

# Sincronizar o relógio com o servidor NTP
print("Sincronizando o relógio com o servidor NTP")
time.sleep(1.5)
print("Sincronizado")

# Função para configurar o RTC (Real Time Clock) com o tempo obtido
# Sincronizar o RTC com o tempo obtido via NTP
def set_rtc():  #Sincroniza o tempo com um servidor NTP.
    #Sincronizamos o Relógio de Tempo Real (RTC) do dispositivo com o tempo obtido de um servidor NTP, garantindo que o relógio esteja sempre preciso.
    ntptime.settime()  # Sincronizar com o servidor de tempo NTP

    # Ajustar o RTC com o tempo obtido
    rtc = machine.RTC()   #Cria uma instância do objeto RTC. Isso permite que você interaja com o Relógio de Tempo Real do dispositivo.
    tm = utime.localtime()   #Esta função retorna uma tupla contendo o tempo local atual, no formato (ano, mês, dia, dia_da_semana, hora, minuto, segundo, microsegundo).
    rtc.datetime((tm[0], tm[1], tm[2], tm[6] + 1, tm[3], tm[4], tm[5], 0))   #Define a data e hora no RTC do dispositivo. Isso é feito passando uma tupla contendo os componentes de data e hora para o método datetime() do objeto RTC. Os componentes passados são:
#tm[0]:Ano  tm[1]:Mês  tm[2]:Dia 
#tm[6] + 1: dia da semana (adicionando 1, pois o dia da semana começa em 0 para segunda-feira)
#tm[3]:Hora  tm[4]:Minuto  tm[5]:Segundo  0: microsegundo (definido como 0)

#Esta função sincroniza o RTC do dispositivo com o tempo obtido de um servidor NTP e ajusta o RTC para refletir o tempo local atual.

# Função para obter o horário atual
def get_current_time():  #Esta função é responsável por obter o horário atual do RTC do dispositivo.
    rtc = machine.RTC()  #Isso permite que você interaja com o Relógio de Tempo Real do dispositivo.
    tm = rtc.datetime()  #Este método retorna uma tupla contendo os componentes de data e hora no formato "a cima"
    print("Horário atual:", tm)   #Imprime o horário atual. O horário atual é representado pela tupla tm, que foi obtida do RTC.
    return tm[3], tm[4]  #Como o índice 3 de tm representa a hora e o índice 4 representa os minuto. Retorna a hora e os minutos atuais. 

# Configurar o RTC com o horário obtido via NTP
set_rtc() #Configurando o Relógio de Tempo Real (RTC) com o horário obtido via NTP 

# Configuração dos pinos
led_pin = 4 # Pino ao qual o LED está conectado
button_pin = 2 # Pino ao qual o botão está conectado
rele_pin = 5  # Pino ao qual o relé está conectado

# Configuração dos pinos como saída (LED) e entrada com resistor de pull-up (botão)
led = Pin(led_pin, Pin.OUT) # Configura o pino do LED como saída  (resultando em uma alteração do led)
button = Pin(button_pin, Pin.IN, Pin.PULL_UP) # Configura o pino do botão como entrada com resistor de pull-up
rele = Pin(rele_pin, Pin.OUT) # Configura o pino do relé como saída  (resultando em uma alteração do rele)

# Variável para armazenar o estado atual do LED
led_estado = 0
rele_estado = 0

# Variável para armazenar o estado do botão na última verificação
ultimo_estado_botao = 1 # É uma variável que armazena o estado atual do LED/RELÉ. (0 para desligado, 1 para ligado) 

# Variável para armazenar o tempo de início do LED ligado
tempo_dispositivos_ligado_inicio = 0

# Loop principal
while True:
    estado_botao = button.value() # Este é um loop infinito que permite que o programa execute continuamente.
    
    if estado_botao == 0 and ultimo_estado_botao == 1: # Inverte o estado atual do LED
        if led_estado == 0:
            led.value(1) # Liga o LED
            rele.value(1)  # Liga o RELÉ
            led_estado = 1 # Atualiza o estado do LED
            rele_estado = 1 # Atualiza o estado do RELÉ
            tempo_dispositivos_ligado_inicio = time.time() # Registra o tempo de início do LED ligado
            current_time = utime.localtime()
            print("LED/RELÉ LIGADOS - DATAta {:02d}/{:02d}/{:02d}".format(current_time[2], current_time[1], current_time[0])) #(DATA) DIA / MES / ANO
            print("LED/RELÉ LIGADOS - BOTÃO {:02d}:{:02d}".format(current_time[3] - 3, current_time[4]))  #(HORAS) HH:MM 
        else:
            led.value(0) # Desliga o LED
            rele.value(0) # Desliga o RELÉ
            led_estado = 0 # Atualiza o estado do LED
            rele_estado = 0 # Atualiza o estado do RELÉ
            tempo_dispositivos_ligado_total = time.time() - tempo_dispositivos_ligado_inicio # Calcula o tempo total que o LED permaneceu ligado
            #Divisão inteira (//): Calcula o número de horas inteiras a partir dos segundos totais, descartando qualquer parte fracionária.
            horas = int(tempo_dispositivos_ligado_total) // 3600 # Calcula horas.  Converte o tempo total de segundos para horas inteiras, dividindo o tempo total por 3600 (o número de segundos em uma hora).
            minutos = int(tempo_dispositivos_ligado_total) // 60 % 60 # Calcula minutos.   Converte o tempo total de segundos para minutos, dividindo por 60 (o número de segundos em um minuto) e depois obtendo o restante após remover as horas.
            segundos = int(tempo_dispositivos_ligado_total) % 60 # Calcula segundos.    Obtém o restante de segundos após remover as horas e minutos.
#A função int() é usada para converter o valor de tempo_dispositivos_ligado_total de ponto flutuante para um número inteiro. Isso é necessário porque, normalmente, o tempo em segundos pode incluir frações de segundo, mas para calcular horas inteiras, precisamos de um valor inteiro.            
            print("LED/RELÉ DESLIGADOS - DATA {:02d}/{:02d}/{:02d}".format(current_time[2], current_time[1], current_time[0])) #(DATA) DIA / MES / ANO
            print("LED/RELÉ DESLIGADOS - BOTÃO  {:02d}:{:02d}".format(current_time[3] - 3, current_time[4]))  #(HORAS) HH:MM 
            print("LED/RELÉ OPERARAM POR: {:02d}:{:02d}:{:02d}".format(horas, minutos, segundos)) # Exibe o tempo total de operação.
            
    ultimo_estado_botao = estado_botao # Estamos armazenando o estado atual do botão para que possamos compará-lo na próxima iteração do loop
    # E determinar se houve uma mudança de estado do botão desde a última iteração. Isso é útil para detectar quando o botão foi pressionado.
    
    time.sleep(0.1)  # Aguarda um curto período para evitar detecção de pressionamento múltiplo