import machine
import _thread
from time import sleep
import dht
import network
import ujson
from umqtt.simple import MQTTClient

MQTT_CLIENT_ID = "esp1"
MQTT_BROKER    = "broker.mqttdashboard.com"
MQTT_USER      = ""
MQTT_PASSWORD  = ""
MQTT_TOPIC    = "medidor_umidade"

print("Connecting to WiFi", end="")
sta_if = network.WLAN(network.STA_IF)
sta_if.active(True)
sta_if.connect('Wokwi-GUEST', '')
while not sta_if.isconnected():
    print(".", end="")
    sleep(0.1)
print(" Connected!")

print("Connecting to MQTT server... ", end="")
client = MQTTClient(MQTT_CLIENT_ID, MQTT_BROKER, user=MQTT_USER, password=MQTT_PASSWORD)
client.connect()

print("Connected!")

# Define a chave na porta 12 (ou qualquer outra porta disponível)
chave = machine.Pin(12, machine.Pin.IN, machine.Pin.PULL_UP)

def set_angulo_servo(pwm, angle):
    min_duty = 40  # 0 graus
    max_duty = 115  # 180 graus
    duty = min_duty + (angle * (max_duty - min_duty) // 180)
    pwm.duty(duty)

def medir_temp(ang_min, ang_max, porta_sensor, sensor_id, porta_servo):
    ultima_temperatura = None
    sensor = dht.DHT22(machine.Pin(porta_sensor))
    servo_pin = machine.Pin(porta_servo)
    pwm = machine.PWM(servo_pin)
    pwm.freq(50)
    
    while True:
        try:
            sensor.measure()
            temperatura = sensor.temperature()
            umidade = sensor.humidity()

            if chave.value() == 0:  # Se a chave estiver ativada (0V no pino)
                set_angulo_servo(pwm, 0)  # Retorna o servo à posição inicial
            elif temperatura != ultima_temperatura:
                if temperatura < 60:
                    set_angulo_servo(pwm, ang_min)
                    print(f'Temperatura sensor {sensor_id} OK!: {temperatura} ºC.')
                else: 
                    set_angulo_servo(pwm, ang_max)
                    print(f'Temperatura sensor {sensor_id} acima dos 60 ºC ({temperatura} ºC), abrindo a comporta 1')
        
            ultima_temperatura = temperatura
            sleep(2)  # Aumenta o intervalo para respeitar o tempo mínimo entre leituras
        except OSError as e:
            print(f'Erro ao ler o sensor {sensor_id}: {e}. Tentando novamente em 2 segundos.')
            sleep(2)  # Espera antes de tentar novamente

def medir_umidade(client, sensor_pins):
    sensores = [dht.DHT22(machine.Pin(pin)) for pin in sensor_pins]
    ultima_umidade = [None] * len(sensor_pins)
    
    while True:
        if chave.value() == 0:  # Se a chave estiver ativada, não envia alarme
            print("Chave ativada, alarme de umidade e temperatura desativados.")
            sleep(2)
        else:
            umidades_estabilizadas = True  # Assume que ambos estão estabilizados
            for i, sensor in enumerate(sensores):
                try:
                    sensor.measure()
                    umidade = sensor.humidity()
                    
                    if ultima_umidade[i] is None or umidade != ultima_umidade[i]:
                        if umidade < 20:
                            mensagem = f"Alerta: umidade no sensor {i+1} abaixo de 20%! ({umidade}%)"
                            client.publish(MQTT_TOPIC, mensagem)
                            print("Mensagem enviada:", mensagem)
                            umidades_estabilizadas = False  # Se qualquer um estiver abaixo de 20%, não está estabilizado
                        ultima_umidade[i] = umidade

                    sleep(2)  # Respeitar intervalo de 2 segundos entre leituras
                except OSError as e:
                    print(f'Erro ao ler o sensor {i+1}: {e}. Tentando novamente em 2 segundos.')
                    sleep(2)  # Espera antes de tentar novamente
            
            # Envia mensagem de estabilização se ambos os sensores estiverem estáveis
            if umidades_estabilizadas:
                mensagem = f"umidade estabilizada"
                client.publish(MQTT_TOPIC, mensagem)

        sleep(5)


def thread1():
    medir_temp(0, 50, 15, 1, 2)

def thread2():
    medir_temp(0, 180, 4, 2, 17)

def thread3():
    medir_umidade(client, [15, 4])

_thread.start_new_thread(thread1, ())
_thread.start_new_thread(thread2, ()) 
_thread.start_new_thread(thread3, ())