Plataforma Colaborativa de Datos Ambientales con IoT y Machi

import threading
import math
from fastapi import FastAPI, HTTPException, Query
from fastapi.middleware.cors import CORSMiddleware
from pydantic import BaseModel
import uvicorn
import paho.mqtt.client as mqtt
import firebase_admin
from firebase_admin import credentials, firestore
import pickle

# ---------------------------
# Cargar el modelo de predicción
# ---------------------------
try:
    with open("environment_quality_model.pkl", "rb") as f:
        clf = pickle.load(f)
except Exception as e:
    raise RuntimeError("No se pudo cargar el modelo: " + str(e))

# ---------------------------
# Inicialización de FastAPI y configuración CORS
# ---------------------------
app = FastAPI()

app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],  # En producción, restringir a los orígenes necesarios, ej.: ["http://localhost:8001"]
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

# ---------------------------
# Inicialización de Firebase Admin
# ---------------------------
try:
    firebase_admin.get_app()
except ValueError:
    cred = credentials.Certificate("firebase_credentials.json")
    firebase_admin.initialize_app(cred)

db = firestore.client()

# ---------------------------
# Configuración de MQTT
# ---------------------------
MQTT_BROKER = "test.mosquitto.org"
MQTT_PORT = 1883
MQTT_TOPICS = {
    "temp": "esp32/dht22/temperatura",
    "hum": "esp32/dht22/humedad",
    "gas": "esp32/mq5/gas",
    "luxRaw": "esp32/temt6000/lux_raw",
    "luxEst": "esp32/temt6000/lux_est",
    "uvRaw": "esp32/uv/raw",
    "uvPower": "esp32/uv/uWcm2",
    "soundRaw": "esp32/sound/raw",
    "soundDB": "esp32/sound/db_est"
}

# Diccionario global para almacenar los datos de los sensores
sensor_data = {
    "temp": "---",
    "hum": "---",
    "gas": "---",
    "gasPPM": "---",
    "luxRaw": "---",
    "luxEst": "---",
    "uvRaw": "---",
    "uvPower": "---",
    "soundRaw": "---",
    "soundDB": "---"
}

# ---------------------------
# Función para actualizar Firebase (crea un nuevo documento con timestamp)
# ---------------------------
def update_firebase(data: dict):
    data_with_timestamp = data.copy()
    data_with_timestamp["timestamp"] = firestore.SERVER_TIMESTAMP
    db.collection("sensors").add(data_with_timestamp)

# ---------------------------
# Callbacks de MQTT
# ---------------------------
def on_connect(client, userdata, flags, rc):
    print("Conectado a MQTT con código de resultado:", rc)
    for topic in MQTT_TOPICS.values():
        client.subscribe(topic)
        print("Suscrito al topic:", topic)

def on_message(client, userdata, msg):
    topic = msg.topic
    value = msg.payload.decode()
    print(f"Mensaje recibido en {topic}: {value}")

    global sensor_data
    if topic == MQTT_TOPICS["temp"]:
        sensor_data["temp"] = value
    elif topic == MQTT_TOPICS["hum"]:
        sensor_data["hum"] = value
    elif topic == MQTT_TOPICS["gas"]:
        sensor_data["gas"] = value
        try:
            raw = int(value)
            if raw > 0 and raw < 4095:
                ratio = (4095 - raw) / raw
                gas_ppm = round(116250 * math.pow(ratio, 2.65))
                sensor_data["gasPPM"] = gas_ppm
            else:
                sensor_data["gasPPM"] = "---"
        except Exception as e:
            sensor_data["gasPPM"] = "---"
    elif topic == MQTT_TOPICS["luxRaw"]:
        sensor_data["luxRaw"] = value
    elif topic == MQTT_TOPICS["luxEst"]:
        sensor_data["luxEst"] = value
    elif topic == MQTT_TOPICS["uvRaw"]:
        sensor_data["uvRaw"] = value
    elif topic == MQTT_TOPICS["uvPower"]:
        sensor_data["uvPower"] = value
    elif topic == MQTT_TOPICS["soundRaw"]:
        sensor_data["soundRaw"] = value
    elif topic == MQTT_TOPICS["soundDB"]:
        sensor_data["soundDB"] = value

    update_firebase(sensor_data)

# Configuración del cliente MQTT
mqtt_client = mqtt.Client()
mqtt_client.on_connect = on_connect
mqtt_client.on_message = on_message

def mqtt_loop():
    mqtt_client.connect(MQTT_BROKER, MQTT_PORT, 60)
    mqtt_client.loop_forever()

# ---------------------------
# Definición de modelos y endpoints de FastAPI
# ---------------------------
# Modelo para datos de sensores (para el endpoint /sensors)
class SensorData(BaseModel):
    temp: str
    hum: str
    gas: str
    gasPPM: str
    luxRaw: str
    luxEst: str
    uvRaw: str
    uvPower: str
    soundRaw: str
    soundDB: str

@app.get("/sensors", response_model=SensorData)
def get_sensor_data():
    """
    Devuelve los datos más recientes de los sensores.
    Se intenta recuperar el documento 'latest' de Firestore;
    si no existe, se retorna el diccionario en memoria.
    """
    doc_ref = db.collection("sensors").document("latest")
    doc = doc_ref.get()
    if doc.exists:
        return doc.to_dict()
    return sensor_data

@app.get("/sensors/history")
def get_sensor_history(limit: int = Query(50, gt=0)):
    """
    Devuelve los registros históricos de la colección "sensors".
    Puedes limitar la cantidad de documentos devueltos con el parámetro 'limit'.
    """
    try:
        docs = db.collection("sensors") \
                 .order_by("timestamp", direction=firestore.Query.DESCENDING) \
                 .limit(limit).stream()
        history = []
        for doc in docs:
            data = doc.to_dict()
            data["id"] = doc.id
            history.append(data)
        return history
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Error al obtener la historia: {e}")

@app.get("/sensors/{doc_id}")
def get_sensor_by_id(doc_id: str):
    """
    Devuelve los datos de un registro específico identificado por su ID.
    """
    doc_ref = db.collection("sensors").document(doc_id)
    doc = doc_ref.get()
    if doc.exists:
        return doc.to_dict()
    else:
        raise HTTPException(status_code=404, detail="Documento no encontrado")

# Modelo de entrada para el endpoint de predicción (/predict)
class SensorInput(BaseModel):
    temp: float
    hum: float
    gasPPM: float
    luxEst: float
    uvPower: float
    soundDB: float

@app.post("/predict")
def predict_quality(input_data: SensorInput):
    """
    Realiza la predicción de calidad ambiental utilizando el modelo entrenado y
    publica el resultado en MQTT (topic: "esp32/model/prediction").
    """
    X_input = [[
        input_data.temp,
        input_data.hum,
        input_data.gasPPM,
        input_data.luxEst,
        input_data.uvPower,
        input_data.soundDB
    ]]
    try:
        prediction = clf.predict(X_input)[0]
        # Publicar el resultado de la predicción en MQTT:
        mqtt_client.publish("esp32/model/prediction", str(prediction))
    except Exception as e:
        raise HTTPException(status_code=500, detail="Error al predecir: " + str(e))
    # Retornamos un mensaje indicando que la predicción se publicó vía MQTT
    return {"detail": "Prediction published via MQTT"}

# ---------------------------
# Iniciar el loop de MQTT al arrancar la aplicación
# ---------------------------
@app.on_event("startup")
def startup_event():
    thread = threading.Thread(target=mqtt_loop)
    thread.daemon = True
    thread.start()

# ---------------------------
# Ejecutar la aplicación con uvicorn
# ---------------------------
if __name__ == "__main__":
    uvicorn.run("plataformaDatosAmbientales:app", host="0.0.0.0", port=8000)

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report
import pickle

# 1. Cargar el CSV
df = pd.read_csv("firestore_data.csv")
print(df.head())
print("Número de registros:", len(df))

# 2. Convertir columnas a numérico y reemplazar NaN por 0
numeric_cols = [
    "temp", "hum", "gas", "gasPPM", 
    "luxRaw", "luxEst", "uvRaw", "uvPower", 
    "soundRaw", "soundDB"
]
for col in numeric_cols:
    df[col] = pd.to_numeric(df[col], errors='coerce')
df[numeric_cols] = df[numeric_cols].fillna(0)

# 3. Definir las variables que usaremos en la métrica multivariable:
# La fórmula es:
# Calidad_ambiental = w1·Temp + w2·Humedad + w3·GasPPM +
#                      w4·LuxEst + w5·UV_power + w6·SoundDB
features = ["temp", "hum", "gasPPM", "luxEst", "uvPower", "soundDB"]

# 4. Calcular la métrica de calidad ambiental (quality_score)
# Simulamos unos pesos determinados históricamente (estos valores son un ejemplo)
weights = [0.2, 0.15, 0.3, 0.1, 0.15, 0.1]  # w1, w2, ..., w6
df['quality_score'] = (weights[0] * df['temp'] +
                       weights[1] * df['hum'] +
                       weights[2] * df['gasPPM'] +
                       weights[3] * df['luxEst'] +
                       weights[4] * df['uvPower'] +
                       weights[5] * df['soundDB'])

# 5. Definir umbrales de clasificación basados en cuantiles del quality_score
threshold1 = df['quality_score'].quantile(0.33)
threshold2 = df['quality_score'].quantile(0.66)

def classify_quality(score):
    if score < threshold1:
        return "Buena"
    elif score < threshold2:
        return "Regular"
    else:
        return "Mala"

df['quality_cat'] = df['quality_score'].apply(classify_quality)

print("Distribución de calidad ambiental:")
print(df['quality_cat'].value_counts())

# 6. Seleccionar características y variable objetivo para el modelo
X = df[features]
y = df["quality_cat"]

# 7. Dividir el dataset en entrenamiento y prueba
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# 8. Entrenar un modelo de clasificación (RandomForestClassifier)
clf = RandomForestClassifier(n_estimators=100, random_state=42)
clf.fit(X_train, y_train)

# 9. Evaluar el modelo
y_pred = clf.predict(X_test)
print("Reporte de clasificación:")
print(classification_report(y_test, y_pred))

# 10. Guardar el modelo para uso futuro
with open("environment_quality_model.pkl", "wb") as f:
    pickle.dump(clf, f)

print("Modelo entrenado y guardado correctamente.")

import pickle
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel

# Cargar el modelo entrenado
try:
    with open("environment_quality_model.pkl", "rb") as f:
        clf = pickle.load(f)
except Exception as e:
    raise RuntimeError("No se pudo cargar el modelo: " + str(e))

# Definir el modelo de entrada con Pydantic
class SensorInput(BaseModel):
    temp: float
    hum: float
    gasPPM: float
    luxEst: float
    uvPower: float
    soundDB: float

app = FastAPI()

@app.post("/predict")
def predict_quality(input_data: SensorInput):
    # Orden de características según se entrenó el modelo
    X_input = [[
        input_data.temp,
        input_data.hum,
        input_data.gasPPM,
        input_data.luxEst,
        input_data.uvPower,
        input_data.soundDB
    ]]
    try:
        prediction = clf.predict(X_input)[0]
    except Exception as e:
        raise HTTPException(status_code=500, detail="Error al predecir: " + str(e))
    return {"prediction": prediction}