diagram.json

import time
import _thread
import uasyncio as asyncio
from wifi_manager import WiFiManager
from mqtt_handler import MQTTHandler

# Función principal de ejecución
async def main():  
    # Configuración WiFi
    wifi = WiFiManager()
    if not wifi.connect():
        print("No se pudo conectar al WiFi. Reiniciando...")
        return
          
    # Instanciar los manejadores
    mqtt_handler = MQTTHandler()

    # Tarea para manejar MQTT y publicar datos cada 5 segundos
    async def run_mqtt():
        print("Iniciando el bucle de MQTT...")
        while True:
            try:
                mqtt_handler.publish_sensor_data()
                await asyncio.sleep(5)  # Espera 5 segundos antes de publicar de nuevo
            except Exception as e:
                print(f"Error en el manejo de MQTT: {e}")

    # Ejecutar las tareas en paralelo (puedes agregar otras tareas aquí en el futuro)
    await asyncio.gather(run_mqtt())

# Ejecutar el ciclo de eventos principal
if __name__ == "__main__":
    try:
        asyncio.run(main())  # Iniciar el bucle de eventos asíncrono
    except Exception as e:
        print(f"Error en el ciclo principal: {e}")


main.py

import ujson
import time
import ntptime
from umqtt.simple import MQTTClient
from machine import RTC


class MQTTHandler:
    def __init__(self):
        """
        Inicializa el cliente MQTT y los sensores.
        """
        try:
            # Configuración del broker MQTT
            self.broker = "mqtt-dashboard.com"
            self.client_id = "saferide-esp32-645321563"
            self.port = 1883
            self.topic = "andina/diplomado/python/saferide/sensors"

            # Configuración del cliente MQTT
            self.client = MQTTClient(self.client_id, self.broker, port=self.port)
            self.client.connect()
            print(f"Conectado al broker MQTT: {self.broker}:{self.port}")

            # Inicialización de simulación de sensores
            self.battery_level = 1.0  # Nivel inicial de batería (%)
            self.distance = 5.5  # Distancia inicial (mm)
            self.execution_interval = 5  # Intervalo de ejecución (segundos)
            self.total_runtime = 3600  # Tiempo total de ejecución (segundos)
            self.battery_decrement = self.battery_level / (self.total_runtime / self.execution_interval)
            self.distance_decrement = (self.distance - 5.0) / (self.total_runtime / self.execution_interval)
        except Exception as e:
            print(f"Error durante la inicialización de MQTTHandler: {e}")
            raise

    def sync_ntp(self):
        """
        Sincroniza el reloj del ESP32 con un servidor NTP.
        """
        try:
            # Configura el servidor NTP de Google
            ntptime.host = "time.google.com"
            # Obtén el tiempo UTC desde el servidor NTP
            ntp_time = ntptime.time()
            # Convierte el tiempo a una tupla de tiempo local
            tm = time.localtime(ntp_time)
            # Configura el RTC del ESP32 con la hora obtenida
            rtc = RTC()
            rtc.datetime((tm[0], tm[1], tm[2], 0, tm[3], tm[4], tm[5], 0))
            print("Sincronización con NTP exitosa:", rtc.datetime())
            return True
        except Exception as e:
            print("Error sincronizando con NTP:", str(e))
            return False

    def leer_sensores(self):
        """
        Simula la lectura de los sensores con decremento progresivo.

        Retorna:
            dict: Un diccionario con los datos de batería y distancia.
        """
        try:
            # Reducir progresivamente la batería y la distancia
            if self.battery_level > 0:
                self.battery_level -= self.battery_decrement
                self.battery_level = max(self.battery_level, 0)  # Evitar valores negativos

            if self.distance > 5.0:
                self.distance -= self.distance_decrement
                self.distance = max(self.distance, 5.0)  # Evitar valores por debajo de 5.0 mm

            # Validar hora
            if self.sync_ntp():
                tm = time.localtime()
                current_time_utc = "{:04d}-{:02d}-{:02d}T{:02d}:{:02d}:{:02d}Z".format(
                    tm[0], tm[1], tm[2], tm[3], tm[4], tm[5]
                )
            else:
                current_time_utc = None

            return {
                'date': current_time_utc,
                'battery': round(self.battery_level, 3),  # Mostrar con 3 decimales
                'distance': round(self.distance, 3)
            }
        except Exception as e:
            print(f"Error al leer datos de los sensores: {e}")
            return {'date': None, 'battery': None, 'distance': None}

    def publish_sensor_data(self):
        """
        Lee los sensores, envía los datos al broker MQTT.
        """
        try:
            # Leer datos de los sensores
            sensor_data = self.leer_sensores()

            # Publicar datos en MQTT
            payload = ujson.dumps(sensor_data)  # Convertir a JSON
            self.client.publish(self.topic, payload)  # Publicar en el topic configurado

            print(f"Publicando en el topic {self.topic}")
            print("Datos enviados por MQTT:", sensor_data)
        except Exception as e:
            print(f"Error al publicar datos por MQTT: {e}")


mqtt_handler.py

import network
import time

class WiFiManager:
    def __init__(self):
        self.ssid = "Wokwi-GUEST"
        self.password = ""

    def connect(self, timeout=10):
        """
        Intenta conectar a la red WiFi especificada.

        :param timeout: Tiempo máximo (en segundos) para intentar conectarse.
        :return: True si la conexión es exitosa, False si falla.
        """
        # Crea una instancia de la interfaz WiFi en modo estación
        wlan = network.WLAN(network.STA_IF)
        wlan.active(True)  # Activa la interfaz WiFi
        wlan.connect(self.ssid, self.password)  # Intenta conectarse usando las credenciales
        print(f"Conectando a WiFi: {self.ssid}...")

        # Esperar hasta que el dispositivo se conecte o se agote el tiempo
        start_time = time.time()
        while not wlan.isconnected():
            if time.time() - start_time > timeout:
                print("Error: No se pudo conectar al WiFi dentro del tiempo límite.")
                return False
            time.sleep(1)

        # Una vez conectado, imprime la configuración de la red
        print("Conexión exitosa. Configuración de red:", wlan.ifconfig())
        return True
