PROYECTO II B 2025 » Grupo 6B 2025

import grovepi

import time

import math

from datetime import datetime

import tkinter as tk

from tkinter import ttk, messagebox

import threading

import os

import pandas as pd

import matplotlib.pyplot as plt

from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg

# --- TUS VALORES R0 CALCULADOS ---

R0_MQ7 = 5451.23

R0_MQ4 = 21159.60

R0_MQ135 = 14967.54

# -----------------------------------

# --- CONFIGURACIÓN DE PINES Y CONSTANTES ---

MQ7_PIN = 0     

MQ4_PIN = 1     

MQ135_PIN = 2   

BUZZER_PIN = 7  

NOMBRE_ARCHIVO = 'database.txt' 

RL_VALUE = 10000.0

MAX_ANALOG = 1023.0

TIEMPO_LECTURA_MS = 1000 

# LÍMITES DE ESCALA PARA MEDIDORES PPM

MAX_CO_DISPLAY = 100        

MAX_PPM_DISPLAY = 2000      

# Variables de control de estado

MEDICION_ACTIVA = False 

ALARMA_ACTIVA = False

# --- VARIABLES GLOBALES DE UMBRAL ---

UMBRAL_CO_DEFECTO = 50.0 

UMBRAL_CH4_DEFECTO = 1000.0 

UMBRAL_AIRE_DEFECTO = 1000.0 

UMBRAL_CO = UMBRAL_CO_DEFECTO

UMBRAL_CH4 = UMBRAL_CH4_DEFECTO

UMBRAL_AIRE = UMBRAL_AIRE_DEFECTO

# --- DECLARACIÓN DE VARIABLES GLOBALES DE WIDGETS ---

# Declaradas para evitar NameError en las funciones

canvas_mq7 = None

canvas_mq4 = None

canvas_mq135 = None

estado_general_label = None

btn_iniciar_mediciones = None

btn_iniciar_inicio = None

notebook = None

# ----------------------------------------------------

# FUNCIONES MATEMÁTICAS Y DE SENSORES

# ----------------------------------------------------

def get_RS_resistance(analog_value):

    if analog_value == 0: return float('inf')

    return RL_VALUE * ((MAX_ANALOG / analog_value) - 1.0)

def MQ7_to_PPM(rs, R0):

    if R0 == 0: return 0.0

    ratio = rs / R0

    if ratio >= 0.783:

        return 10**((math.log10(ratio) - 0.783) / -1.531)

    return 0.0

def MQ4_to_PPM(rs, R0):

    if R0 == 0: return 0.0

    ratio = rs / R0

    if ratio <= 2.5:

        return 10**((math.log10(ratio) - 2.5) / -1.5)

    return 0.0

def MQ135_to_PPM(rs, R0):

    if R0 == 0: return 0.0

    ratio = rs / R0

    if ratio < 0.0000001:

        return 0.0

    if ratio <= 2.5:

        return 10**((math.log10(ratio) - 2.5) / -2.5)

    return 0.0

def calcular_aqi_co(ppm_co):

    """Calcula un AQI simplificado (Mantenido solo por consistencia de la función)."""

    ppm = ppm_co

    CO_GOOD_PPM = 4.4

    CO_FAIR_PPM = 9.4

    CO_POOR_PPM = 12.4

    if ppm <= CO_GOOD_PPM:

        aqi = int(round(ppm * (50 / CO_GOOD_PPM)))

    elif ppm <= CO_FAIR_PPM:

        aqi = 51 + int(round(((ppm - CO_GOOD_PPM) / (CO_FAIR_PPM - CO_GOOD_PPM)) * (100 - 51)))

    elif ppm <= CO_POOR_PPM:

        aqi = 101 + int(round(((ppm - CO_FAIR_PPM) / (CO_POOR_PPM - CO_FAIR_PPM)) * (150 - 101)))

    else:

        aqi = 151 + int(ppm * 10) 

    return aqi, "N/A", "gray" 

# ----------------------------------------------------

# FUNCIONES DE CONTROL DE LA GUI

# ----------------------------------------------------

def guardar_datos(ppm_7, ppm_4, ppm_135, estado_alarma):

    """Escribe los datos en el archivo database.txt."""

    try:

        timestamp_completo = datetime.now().strftime('%d-%m-%Y | %H:%M:%S')

        datos_a_escribir = f"""

FECHA: {timestamp_completo}

ALARMA: {estado_alarma}

---

MQ-7 (CO)   : {ppm_7:.2f} PPM

MQ-4 (CH4)  : {ppm_4:.2f} PPM

MQ-135 (Aire): {ppm_135:.2f} PPM

---------------------------------"""

        with open(NOMBRE_ARCHIVO, 'a', encoding="utf-8") as archivo:

            archivo.write(datos_a_escribir)

            archivo.write("\n")

    except Exception as e:

        print(f"Error de escritura en archivo: {e}")

def aplicar_umbrales():

    """Lee y valida los valores de los Entry y los actualiza globalmente."""

    global UMBRAL_CO, UMBRAL_CH4, UMBRAL_AIRE

    try:

        UMBRAL_CO = float(entry_co_var.get())

        UMBRAL_CH4 = float(entry_ch4_var.get())

        UMBRAL_AIRE = float(entry_aire_var.get())

        if UMBRAL_CO <= 0 or UMBRAL_CH4 <= 0 or UMBRAL_AIRE <= 0:

            raise ValueError("Los umbrales deben ser mayores que cero.")

        tk.messagebox.showinfo("Configuración", "Umbrales guardados con éxito.")

    except ValueError as e:

        tk.messagebox.showerror("Error de Configuración", f"Valor inválido: {e}. Use números.")

def reset_umbrales():

    """Restaura los umbrales a los valores de seguridad por defecto."""

    entry_co_var.set(UMBRAL_CO_DEFECTO)

    entry_ch4_var.set(UMBRAL_CH4_DEFECTO)

    entry_aire_var.set(UMBRAL_AIRE_DEFECTO)

    aplicar_umbrales() 

def limpiar_historial():

    """Borra el archivo database.txt para iniciar un nuevo historial."""

    if os.path.exists(NOMBRE_ARCHIVO):

        os.remove(NOMBRE_ARCHIVO)

        tk.messagebox.showinfo("Historial", f"Historial '{NOMBRE_ARCHIVO}' limpiado con éxito.")

    else:

        tk.messagebox.showinfo("Historial", "El archivo de historial ya estaba vacío.")

# --- FUNCIONES DE DIBUJO Y NAVEGACIÓN ---

def dibujar_medidor_ppm(canvas, ppm_valor, umbral, max_escala, titulo):

    """Dibuja el medidor radial para un valor PPM dado. (Lógica de umbral corregida)"""

    if canvas is None: return 

    ancho = 200

    alto = 120

    centro_x = ancho / 2

    centro_y = alto 

    radio = 80

    canvas.delete("all")

    canvas.config(bg="#F0F0F0") 

    escala_angular = 180 / max_escala

    # 1. Dibujar el arco de fondo

    canvas.create_arc(centro_x - radio, centro_y - radio, 

                      centro_x + radio, centro_y + radio,

                      start=0, extent=180, style=tk.ARC, outline="#DDDDDD", width=15)

    # 2. Ángulo del Valor Medido (Arco verde/rojo)

    angulo_valor_ppm = min(ppm_valor, max_escala) * escala_angular

    angulo_inicio_valor = 180 - angulo_valor_ppm # 180 = 0 PPM

    color = "red" if ppm_valor >= umbral else "green"

    # Dibujar el arco de valor medido

    canvas.create_arc(centro_x - radio, centro_y - radio, 

                      centro_x + radio, centro_y + radio,

                      start=angulo_inicio_valor, extent=angulo_valor_ppm,

                      style=tk.ARC, outline=color, width=15)

    # 3. Ángulo del Umbral (Línea roja punteada)

    angulo_umbral_total = umbral * escala_angular

    # CORRECCIÓN DEFINITIVA: 

    # Queremos que 0 PPM esté en 180 grados. 

    # Queremos que Max PPM esté en 0 grados.

    # El ángulo que necesitamos para cos/sin es 180 - (Valor * Escala)

    angulo_umbral_pos = 180 - angulo_umbral_total

    # Convertir a radianes

    rad_umbral = math.radians(angulo_umbral_pos)

    # Coordenadas de la punta de la línea de umbral

    punta_x_u = centro_x - (radio - 25) * math.cos(rad_umbral)

    punta_y_u = centro_y - (radio - 25) * math.sin(rad_umbral)

    # Dibujar la línea de umbral

    canvas.create_line(centro_x, centro_y, punta_x_u, punta_y_u, 

                       fill="red", width=2, dash=(3, 3)) 

    # 4. Dibujar el valor central y etiquetas (Más grande y visible)

    canvas.create_text(centro_x, centro_y - 45, text=titulo, 

                       font=("Helvetica", 12, "bold"), fill="#333333")

    canvas.create_text(centro_x, centro_y - 20, text=f"{ppm_valor:.1f}", 

                       font=("Helvetica", 24, "bold"), fill=color) 

    canvas.create_text(centro_x, centro_y + 5, text="PPM", 

                       font=("Helvetica", 12), fill="#333333") 

    canvas.create_text(centro_x - radio - 10, centro_y - 5, text="0", fill="#333333")

    canvas.create_text(centro_x + radio + 5, centro_y - 5, text=str(max_escala), fill="#333333")

def abrir_historial():

    notebook.select(historial_frame)

    generar_grafico() 

def abrir_configuracion():

    notebook.select(opciones_frame)

def abrir_mediciones():

    notebook.select(mediciones_frame)

def salir_limpiar():

    grovepi.digitalWrite(BUZZER_PIN, 0)

    root.destroy()

# --- Funciones de Medición y Control ---

def iniciar_medicion():

    """Inicia el ciclo de lectura de sensores."""

    global MEDICION_ACTIVA

    if not MEDICION_ACTIVA:

        aplicar_umbrales() 

        MEDICION_ACTIVA = True

        # Actualizar ambos botones de inicio/detención

        btn_iniciar_mediciones.config(text="Detener Medición", command=detener_medicion, style='Red.TButton')

        btn_iniciar_inicio.config(text="Detener Medición", command=detener_medicion, style='Red.TButton')

        estado_general_label.config(text="Monitor Activo", background="blue")

        root.after(0, actualizar_sensores) # Inicia el bucle de Tkinter

def detener_medicion():

    """Detiene el ciclo de lectura de sensores."""

    global MEDICION_ACTIVA

    MEDICION_ACTIVA = False

    # Actualizar ambos botones de inicio/detención

    btn_iniciar_mediciones.config(text="Empezar Medición", command=iniciar_medicion, style='Green.TButton')

    btn_iniciar_inicio.config(text="Empezar Medición", command=iniciar_medicion, style='Green.TButton')

    estado_general_label.config(text="Monitor Detenido", background="gray")

# ----------------------------------------------------

# GENERACIÓN DE GRÁFICOS (Se mantiene igual)

# ----------------------------------------------------

def generar_grafico():

    """Lee el archivo de texto y genera TRES gráficos con Matplotlib, con escala optimizada."""

    def leer_datos_y_estructurar_todos():

        datos = []

        try:

            with open(NOMBRE_ARCHIVO, 'r', encoding='utf-8') as f:

                contenido = f.read()

            patrones = contenido.split("---------------------------------")

            for patron in patrones:

                if 'MQ-7 (CO)' in patron:

                    try:

                        fecha_str = patron.split("FECHA: ")[1].split('\n')[0].strip()

                        ppm_7 = float(patron.split('MQ-7 (CO)   : ')[1].split(' PPM')[0].strip())

                        ppm_4 = float(patron.split('MQ-4 (CH4)  : ')[1].split(' PPM')[0].strip())

                        ppm_135 = float(patron.split('MQ-135 (Aire): ')[1].split(' PPM')[0].strip())

                        fecha = datetime.strptime(fecha_str, '%d-%m-%Y | %H:%M:%S')

                        datos.append({

                            'Fecha': fecha, 'PPM_CO': ppm_7, 'PPM_CH4': ppm_4, 'PPM_AIRE': ppm_135

                        })

                    except Exception:

                        continue 

        except FileNotFoundError:

            return pd.DataFrame({'Fecha': [], 'PPM_CO': [], 'PPM_CH4': [], 'PPM_AIRE': []})

        return pd.DataFrame(datos)

    df = leer_datos_y_estructurar_todos()

    if df.empty:

        tk.messagebox.showwarning("Gráfico", "No hay datos suficientes para graficar.")

        return

    # 2. Configurar Matplotlib para Tkinter (Figura con 3 subplots)

    fig, axes = plt.subplots(nrows=3, ncols=1, figsize=(8, 8)) 

    plt.subplots_adjust(hspace=0.4) 

    # 3. Datos y Umbrales

    sensores_info = [

        {'col': 'PPM_CO', 'titulo': 'MQ-7 (Monóxido de Carbono)', 'umbral': UMBRAL_CO},

        {'col': 'PPM_CH4', 'titulo': 'MQ-4 (Metano)', 'umbral': UMBRAL_CH4},

        {'col': 'PPM_AIRE', 'titulo': 'MQ-135 (Calidad del Aire)', 'umbral': UMBRAL_AIRE}

    ]

    # 4. Generar cada gráfico

    for i, info in enumerate(sensores_info):

        ax = axes[i]

        ax.plot(df['Fecha'], df[info['col']], marker='', linestyle='-', label=info['titulo'])

        ax.axhline(info['umbral'], color='red', linestyle='--', label=f'Alarma ({info["umbral"]:.0f} PPM)')

        ax.set_title(info['titulo'], fontsize=10)

        ax.set_ylabel('PPM', fontsize=8)

        # --- LÓGICA DE ESCALA OPTIMIZADA (AJUSTA EL EJE Y) ---

        max_val_data = df[info['col']].max()

        if max_val_data < info['umbral']:

            y_lim_max = max_val_data * 1.2 

            if y_lim_max < 5: y_lim_max = 5 

        else:

            y_lim_max = max_val_data * 1.2

        ax.set_ylim(0, y_lim_max)

        # -----------------------------------------------------

        ax.legend(fontsize=7, loc='upper left')

        # CORRECCIÓN CLAVE: Mostrar la marca de tiempo en todos los ejes

        ax.tick_params(axis='x', labelbottom=True) 

        for tick in ax.get_xticklabels():

            tick.set_rotation(30)

            tick.set_ha('right')

    # 5. Integrar el gráfico en la GUI

    for widget in historial_frame.winfo_children():

        widget.destroy()

    canvas = FigureCanvasTkAgg(fig, master=historial_frame)

    canvas_widget = canvas.get_tk_widget()

    canvas_widget.pack(fill=tk.BOTH, expand=True)

    canvas.draw()

    tk.Label(historial_frame, text="Gráficos generados de los tres sensores con escala optimizada.").pack(pady=5)

# ----------------------------------------------------

# BUCLE PRINCIPAL DE LECTURA (ACTUALIZA LA GUI)

# ----------------------------------------------------

def actualizar_sensores():

    """Bucle principal de lectura y actualización de la GUI."""

    global ALARMA_ACTIVA, MEDICION_ACTIVA, UMBRAL_CO, UMBRAL_CH4, UMBRAL_AIRE

    if not MEDICION_ACTIVA:

        return

    try:

        # LECTURA Y CÁLCULO DE SENSORES

        ppm_7 = MQ7_to_PPM(get_RS_resistance(grovepi.analogRead(MQ7_PIN)), R0_MQ7)

        ppm_4 = MQ4_to_PPM(get_RS_resistance(grovepi.analogRead(MQ4_PIN)), R0_MQ4)

        ppm_135 = MQ135_to_PPM(get_RS_resistance(grovepi.analogRead(MQ135_PIN)), R0_MQ135)

        # -------------------------------------------------------

        # LÓGICA DE ALARMA MULTI-SENSOR

        # -------------------------------------------------------

        alerta_co = ppm_7 >= UMBRAL_CO

        alerta_ch4 = ppm_4 >= UMBRAL_CH4

        alerta_aire = ppm_135 >= UMBRAL_AIRE

        if alerta_co or alerta_ch4 or alerta_aire:

            ALARMA_ACTIVA = True

            grovepi.digitalWrite(BUZZER_PIN, 1)

            estado_alarma_texto = "!!! ALERTA GENERAL !!!"

            color_alarma = "red"

            detalle = []

            if alerta_co: detalle.append("CO")

            if alerta_ch4: detalle.append("CH4")

            if alerta_aire: detalle.append("AIR")

            estado_alarma_texto += " (" + ", ".join(detalle) + ")"

        else:

            ALARMA_ACTIVA = False

            grovepi.digitalWrite(BUZZER_PIN, 0)

            estado_alarma_texto = "Monitor Activo"

            color_alarma = "green"

        # 2. GUARDAR DATOS 

        guardar_datos(ppm_7, ppm_4, ppm_135, estado_alarma_texto)

        # 3. ACTUALIZACIÓN DE LA GUI

        # Actualización de Medidores PPM 

        dibujar_medidor_ppm(canvas_mq7, ppm_7, UMBRAL_CO, MAX_CO_DISPLAY, "Monóxido Carbono (CO)")

        dibujar_medidor_ppm(canvas_mq4, ppm_4, UMBRAL_CH4, MAX_PPM_DISPLAY, "Metano (CH4)")

        dibujar_medidor_ppm(canvas_mq135, ppm_135, UMBRAL_AIRE, MAX_PPM_DISPLAY, "Calidad del Aire")

        estado_general_label.config(text=estado_alarma_texto, background=color_alarma)

        hora_var.set(datetime.now().strftime('%H:%M:%S'))

    except IOError:

        estado_general_label.config(text="Error de Conexión I/O", background="orange")

    except Exception as e:

        estado_general_label.config(text="Error", background="red")

        print(f"Error durante la lectura: {e}")

        detener_medicion()

    if MEDICION_ACTIVA:

        root.after(TIEMPO_LECTURA_MS, actualizar_sensores)

# ----------------------------------------------------

# CONFIGURACIÓN DE LA INTERFAZ GRÁFICA (TKINTER)

# ----------------------------------------------------

try:

    grovepi.pinMode(BUZZER_PIN, "OUTPUT")

except:

    pass 

root = tk.Tk()

root.title("KEL AviGasDetector")

# Establecer tamaño DINÁMICO (Escalable)

root.geometry("400x600") 

root.resizable(True, True) 

# --- Estilos Mejorados (Themed Tkinter) ---

style = ttk.Style()

style.theme_use('clam') 

style.configure('TNotebook.Tab', font=('Helvetica', 10, 'bold'))

style.configure('Red.TButton', foreground='white', background='#CC0000', font=('Helvetica', 10, 'bold'))

style.map('Red.TButton', background=[('active', '#FF3333')])

style.configure('Green.TButton', foreground='white', background='#006600', font=('Helvetica', 10, 'bold'))

style.map('Green.TButton', background=[('active', '#009900')])

style.configure('Dashboard.TButton', font=('Helvetica', 12), padding=10)

notebook = ttk.Notebook(root)

notebook.pack(pady=5, padx=5, expand=True, fill='both')

# --- Variables de control (Instanciadas globalmente) ---

mq7_var = tk.StringVar(root)

mq4_var = tk.StringVar(root)

mq135_var = tk.StringVar(root)

hora_var = tk.StringVar(root, value="")

entry_co_var = tk.StringVar(root, value=UMBRAL_CO_DEFECTO)

entry_ch4_var = tk.StringVar(root, value=UMBRAL_CH4_DEFECTO)

entry_aire_var = tk.StringVar(root, value=UMBRAL_AIRE_DEFECTO)

# -----------------------------------------------------

# --- PESTAÑA 1: INICIO/ACCESO ---

# -----------------------------------------------------

inicio_frame = ttk.Frame(notebook, padding="10")

notebook.add(inicio_frame, text='Inicio')

ttk.Label(inicio_frame, text="KEL AviGasDetector", font=("Helvetica", 20, "bold"), foreground="#007bff").pack(pady=30)

ttk.Label(inicio_frame, text="Monitor de Calidad del Aire", font=("Helvetica", 14)).pack(pady=5)

ttk.Label(inicio_frame, text="Seleccione una opción:", font=("Helvetica", 12)).pack(pady=20)

# Botones de Acción de Inicio

btn_iniciar_inicio = ttk.Button(inicio_frame, text="Empezar Medición", command=iniciar_medicion, style='Green.TButton')

btn_iniciar_inicio.pack(pady=10, ipadx=20, ipady=10)

ttk.Button(inicio_frame, text="VER HISTORIAL", command=abrir_historial, style='Dashboard.TButton').pack(pady=10, ipadx=20, ipady=5)

ttk.Button(inicio_frame, text="CONFIGURACIÓN", command=abrir_configuracion, style='Dashboard.TButton').pack(pady=10, ipadx=20, ipady=5)

# -----------------------------------------------------

# --- PESTAÑA 2: MEDICIONES (DASHBOARD 3 MEDIDORES) ---

# -----------------------------------------------------

mediciones_frame = ttk.Frame(notebook, padding="10")

notebook.add(mediciones_frame, text='Mediciones')

ttk.Label(mediciones_frame, text="Monitor PPM en Tiempo Real", font=("Helvetica", 16, "bold")).pack(pady=10)

# Contenedor para los 3 Canvas

medidores_grid = ttk.Frame(mediciones_frame)

medidores_grid.pack(pady=10, padx=10)

# Medidor MQ-7

canvas_mq7 = tk.Canvas(medidores_grid, width=200, height=120, bg="#F0F0F0")

canvas_mq7.grid(row=0, column=0, padx=5, pady=5)

dibujar_medidor_ppm(canvas_mq7, 0, UMBRAL_CO, MAX_CO_DISPLAY, "Monóxido Carbono (CO)")

# Medidor MQ-4

canvas_mq4 = tk.Canvas(medidores_grid, width=200, height=120, bg="#F0F0F0")

canvas_mq4.grid(row=0, column=1, padx=5, pady=5)

dibujar_medidor_ppm(canvas_mq4, 0, UMBRAL_CH4, MAX_PPM_DISPLAY, "Metano (CH4)")

# Medidor MQ-135 (Debajo de MQ-7)

canvas_mq135 = tk.Canvas(medidores_grid, width=200, height=120, bg="#F0F0F0")

canvas_mq135.grid(row=1, column=0, padx=5, pady=5)

dibujar_medidor_ppm(canvas_mq135, 0, UMBRAL_AIRE, MAX_PPM_DISPLAY, "Calidad del Aire")

# Etiqueta de Estado de Alarma Principal

estado_general_label = tk.Label(mediciones_frame, text="Presiona COMENZAR", font=("Helvetica", 14, "bold"), background="gray", foreground="white", width=30)

estado_general_label.pack(pady=15)

# Botón de Control

btn_iniciar_mediciones = ttk.Button(mediciones_frame, text="Empezar Medición", command=iniciar_medicion, style='Green.TButton')

btn_iniciar_mediciones.pack(pady=10)

# -----------------------------------------------------

# --- PESTAÑA 3: HISTORIAL Y GRÁFICOS ---

# -----------------------------------------------------

historial_frame = ttk.Frame(notebook, padding="10")

notebook.add(historial_frame, text='Historial y Gráficos')

ttk.Label(historial_frame, text="Visualización de Datos Históricos", font=("Helvetica", 14, "bold")).pack(pady=5)

ttk.Button(historial_frame, text="Generar TRES Gráficos por Sensor", command=generar_grafico).pack(pady=10)

ttk.Button(historial_frame, text="Limpiar Historial de Archivo", command=limpiar_historial, style='Red.TButton').pack(pady=5)

# -----------------------------------------------------

# --- PESTAÑA 4: OPCIONES (CONFIGURACIÓN) ---

# -----------------------------------------------------

opciones_frame = ttk.Frame(notebook, padding="10")

notebook.add(opciones_frame, text='Opciones de Alarma')

ttk.Label(opciones_frame, text="Configuración de Umbrales de Seguridad (PPM)", font=("Helvetica", 14, "bold")).pack(pady=10)

# Función auxiliar para crear filas de configuración

def crear_fila_umbral(parent, label_text, entry_var, unidad, defecto):

    frame = ttk.Frame(parent)

    frame.pack(fill='x', padx=5, pady=5)

    ttk.Label(frame, text=label_text, width=20, anchor='w').pack(side='left')

    ttk.Entry(frame, textvariable=entry_var, width=10).pack(side='left', padx=5)

    ttk.Label(frame, text=f"{unidad} (Defecto: {defecto:.0f} PPM)").pack(side='left')

# Filas de configuración

crear_fila_umbral(opciones_frame, "MQ-7 (CO):", entry_co_var, "PPM", UMBRAL_CO_DEFECTO)

crear_fila_umbral(opciones_frame, "MQ-4 (CH4):", entry_ch4_var, "PPM", UMBRAL_CH4_DEFECTO)

crear_fila_umbral(opciones_frame, "MQ-135 (Aire/CO2):", entry_aire_var, "PPM", UMBRAL_AIRE_DEFECTO)

# Botones de Acción

action_frame = ttk.Frame(opciones_frame)

action_frame.pack(pady=20)

ttk.Button(action_frame, text="GUARDAR Umbrales", command=aplicar_umbrales, style='Green.TButton').pack(side='left', padx=10)

ttk.Button(action_frame, text="Restaurar Defecto", command=reset_umbrales, style='Red.TButton').pack(side='left', padx=10)

# Botón de Salida Global

ttk.Button(root, text="SALIR (Cerrar Programa y Limpiar)", command=salir_limpiar, style='Red.TButton').pack(pady=10)

# Iniciar los valores por defecto en los Entry fields al inicio

entry_co_var.set(UMBRAL_CO_DEFECTO)

entry_ch4_var.set(UMBRAL_CH4_DEFECTO)

entry_aire_var.set(UMBRAL_AIRE_DEFECTO)

root.mainloop()