PROYECTO II B 2025 » Grupo 4B 2025

## -*- coding: utf-8 -*-

import tkinter as tk

import threading

import asyncio

import websockets

import json

import queue

import time

import os

import requests

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

# Notificaciones PUSHOVER

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

PUSHOVER_USER = "uyzqhff9yzty5ngrzprznsc2nvysft"

PUSHOVER_TOKEN = "anhyrhsp5owy7z78r8qhi5xmrsxh4y"

def enviar_notificacion(mensaje):

    url = "https://api.pushover.net/1/messages.json"

    data = {

        "token": PUSHOVER_TOKEN,

        "user": PUSHOVER_USER,

        "message": mensaje,

        "title": "InverTrack",

        "priority": 1

    }

    try:

        requests.post(url, data=data, timeout=3)

    except Exception as e:

        print("Error enviando notificación:", e)

# Configuración general

WS_URI = "ws://localhost:8764"

POLL_MS = 200

CONFIG_FILE = "config.json"

BG = "#ffffff"

ACCENT = "#4caf50"

ACCENT_DARK = "#43a047"

TEXT = "#222222"

SUBTEXT = "#555555"

CARD_BG = "#f7f7f7"

BORDER = "#dedede"

# Manejo de alertas / anti-spam

ALERTA_COOLDOWN = 60 

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

# LÍMITES PREDEFINIDOS (ARICA)

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

CULTIVOS_PREDEFINIDOS = {

    "Tomate": {

        "ph": {"min": 5.5, "max": 6.8},

        "temp": {"amb_min": 18, "amb_max": 30},

        "hum": {"amb_min": 60, "amb_max": 80},

        "npk": {

            "n_min": 50, "n_max": 150,

            "p_min": 30, "p_max": 80,

            "k_min": 150, "k_max": 300

        }

    },

    "Lechuga": {

        "ph": {"min": 5.8, "max": 6.5},

        "temp": {"amb_min": 10, "amb_max": 22},

        "hum": {"amb_min": 60, "amb_max": 90},

        "npk": {

            "n_min": 40, "n_max": 120,

            "p_min": 20, "p_max": 60,

            "k_min": 80, "k_max": 200

        }

    },

    "Cítricos": {

        "ph": {"min": 5.5, "max": 6.5},

        "temp": {"amb_min": 20, "amb_max": 35},

        "hum": {"amb_min": 50, "amb_max": 70},

        "npk": {

            "n_min": 60, "n_max": 180,

            "p_min": 30, "p_max": 90,

            "k_min": 100, "k_max": 250

        }

    },

    "Maíz": {

        "ph": {"min": 5.5, "max": 7.0},

        "temp": {"amb_min": 18, "amb_max": 32},

        "hum": {"amb_min": 50, "amb_max": 75},

        "npk": {

            "n_min": 80, "n_max": 200,

            "p_min": 40, "p_max": 100,

            "k_min": 100, "k_max": 300

        }

    }

}

class AlertaManager:

    def __init__(self, cooldown=ALERTA_COOLDOWN):

        self.cooldown = cooldown

        self.ultimo = {}  

    def debe_alertar(self, clave):

        ahora = time.time()

        last = self.ultimo.get(clave, 0)

        if ahora - last >= self.cooldown:

            self.ultimo[clave] = ahora

            return True

        return False

# Utilidades UI

def make_label(master, text, size=12, bold=False, fg=TEXT):

    font = ("Segoe UI", size, "bold") if bold else ("Segoe UI", size)

    return tk.Label(master, text=text, font=font, bg=master["bg"], fg=fg)

def style_button_primary(btn):

    btn.config(bg=ACCENT, fg="white", activebackground=ACCENT_DARK,

               relief="flat", bd=0, padx=10, pady=6,

               font=("Segoe UI", 10, "bold"), cursor="hand2")

def style_button_secondary(btn):

    btn.config(bg="#e0e0e0", fg=TEXT, relief="flat", bd=0,

               padx=8, pady=6, font=("Segoe UI", 10), cursor="hand2")

# ScrollFrame

class ScrollFrame(tk.Frame):

    def __init__(self, parent, *args, **kwargs):

        bg = kwargs.pop("bg", BG)

        super().__init__(parent, bg=bg, *args, **kwargs)

        self.canvas = tk.Canvas(self, bg=bg, highlightthickness=0)

        self.vsb = tk.Scrollbar(self, orient="vertical", command=self.canvas.yview)

        self.canvas.configure(yscrollcommand=self.vsb.set)

        self.inner = tk.Frame(self.canvas, bg=bg)

        self.window = self.canvas.create_window((0, 0), window=self.inner, anchor="nw")

        self.canvas.pack(side="left", fill="both", expand=True)

        self.vsb.pack(side="right", fill="y")

        self.inner.bind("<Configure>", self._on_frame_configure)

        self.canvas.bind("<Configure>", self._on_canvas_configure)

        self.canvas.bind_all("<MouseWheel>", self._on_mousewheel)

    def _on_frame_configure(self, event=None):

        self.canvas.configure(scrollregion=self.canvas.bbox("all"))

    def _on_canvas_configure(self, event):

        self.canvas.itemconfig(self.window, width=event.width)

    def _on_mousewheel(self, event):

        try:

            self.canvas.yview_scroll(int(-1*(event.delta/120)), "units")

        except:

            pass

# HorizontalCard

class HorizontalCard(tk.Frame):

    def __init__(self, parent, title):

        super().__init__(parent, bg=CARD_BG, highlightthickness=1,

                         highlightbackground=BORDER, padx=12, pady=10)

        self.lbl_title = make_label(self, title, size=11, bold=True)

        self.lbl_title.pack(anchor="w")

        self.lbl_value = make_label(self, "--", size=14, bold=True, fg=SUBTEXT)

        self.lbl_value.pack(anchor="w", pady=(6,0))

    def set_value(self, text):

        self.lbl_value.config(text=text)

class DualHorizontalCard(tk.Frame):

    def __init__(self, parent, left_title, right_title):

        super().__init__(

            parent,

            bg=CARD_BG,

            highlightthickness=1,

            highlightbackground=BORDER,

            padx=12,

            pady=10

        )

        cont = tk.Frame(self, bg=CARD_BG)

        cont.pack(fill="x")

        # --- IZQUIERDA (Ambiente) ---

        left = tk.Frame(cont, bg=CARD_BG)

        left.pack(side="left", expand=True, fill="x")

        self.lbl_left_title = make_label(left, left_title, size=10, bold=True)

        self.lbl_left_title.pack(anchor="center")

        self.lbl_left_value = make_label(left, "--", size=16, bold=True)

        self.lbl_left_value.pack(anchor="center", pady=(6, 0))

        # --- SEPARADOR ---

        sep = tk.Frame(cont, width=1, bg=BORDER)

        sep.pack(side="left", fill="y", padx=8)

        # --- DERECHA (Suelo) ---

        right = tk.Frame(cont, bg=CARD_BG)

        right.pack(side="left", expand=True, fill="x")

        self.lbl_right_title = make_label(right, right_title, size=10, bold=True)

        self.lbl_right_title.pack(anchor="center")

        self.lbl_right_value = make_label(right, "--", size=16, bold=True)

        self.lbl_right_value.pack(anchor="center", pady=(6, 0))

    def set_left(self, text):

        self.lbl_left_value.config(text=text)

    def set_right(self, text):

        self.lbl_right_value.config(text=text)

    def set_value(self, text):

        # Compatibilidad con código antiguo

        self.set_left(text)

# AccordionSection

class AccordionSection(tk.Frame):

    def __init__(self, parent, app, key, title, config_schema):

        super().__init__(parent, bg=BG)

        self.app = app

        self.key = key

        self.title = title

        self.config_schema = config_schema

        self.config_values = {}

        self.is_open = False

        self.header = tk.Frame(self, bg=BG)

        self.header.pack(fill="x", pady=(6,0))

        self.arrow = make_label(self.header, "►", size=14)

        self.arrow.pack(side="left", padx=(4,8))

        self.lbl_title = make_label(self.header, title, size=13, bold=True)

        self.lbl_title.pack(side="left", pady=8)

        self.header.bind("<Button-1>", self.toggle)

        self.arrow.bind("<Button-1>", self.toggle)

        self.lbl_title.bind("<Button-1>", self.toggle)

        self.body = tk.Frame(self, bg=BG)

        if key in ("temp", "hum"):

            self.card = DualHorizontalCard(

                self.body,

                "Ambiente",

                "Suelo"

            )

        else:

            self.card = HorizontalCard(self.body, title)

        self.card.pack(fill="x", pady=(10,6))

        self.card.pack(fill="x", pady=(10,6))

        self.actions_frame = tk.Frame(self.body, bg=BG)

        self.actions_frame.pack(fill="x", pady=(0,6))

        if key == "ph":

            self.btn_action = tk.Button(self.actions_frame, text="Activar Dosificador")

            style_button_primary(self.btn_action)

            self.btn_action.pack(side="left", padx=4)

        elif key == "temp":

            self.btn_action = tk.Button(self.actions_frame, text="Desplegar Mallas")

            style_button_primary(self.btn_action)

            self.btn_action.pack(side="left", padx=4)

        else:

            self.btn_action = None

        self.btn_config = tk.Button(self.actions_frame, text="Configurar")

        style_button_secondary(self.btn_config)

        self.btn_config.pack(side="left", padx=4)

        self.btn_config.config(command=self.toggle_config_panel)

        self.config_panel = tk.Frame(self.body, bg=BG,

                                     highlightthickness=1,

                                     highlightbackground=BORDER)

        self._build_config_fields()

        stored = self.app.config_store.get(self.key, {})

        for f in self.config_schema:

            name = f["name"]

            default = f.get("default", "")

            val = stored.get(name, default)

            self.config_values[name] = val

            if name in self.field_vars:

                self.field_vars[name][0].set(str(val))

    def _build_config_fields(self):

       hdr = make_label(self.config_panel, "Configuración", size=12, bold=True)

       hdr.pack(anchor="w", padx=10, pady=(8,6))

       self.field_vars = {}

       self.error_labels = {}

       for field in self.config_schema:

           frm = tk.Frame(self.config_panel, bg=BG)

           frm.pack(fill="x", padx=10, pady=2)

           lbl = make_label(frm, field.get("label", field["name"]), size=10)

           lbl.pack(anchor="w")

           var = tk.StringVar(value=str(field.get("default", "")))

           ent = tk.Entry(frm, textvariable=var)

           ent.pack(fill="x")

           err = tk.Label(frm, text="", fg="red", bg=BG, font=("Segoe UI", 9))

           err.pack(anchor="w")

           self.field_vars[field["name"]] = (var, field)

           self.error_labels[field["name"]] = err

       btns = tk.Frame(self.config_panel, bg=BG)

       btns.pack(fill="x", padx=10, pady=(6,10))

       btn_save = tk.Button(btns, text="Guardar", width=10)

       style_button_primary(btn_save)

       btn_save.pack(side="right", padx=6)

       btn_save.config(command=self._on_save_config)

       btn_cancel = tk.Button(btns, text="Cerrar", width=10, bg="#e0e0e0", relief="flat")

       btn_cancel.pack(side="right")

       btn_cancel.config(command=self.toggle_config_panel)

    def toggle(self, event=None):

        if self.is_open:

            self.body.pack_forget()

            self.arrow.config(text="►")

            self.is_open = False

        else:

            self.body.pack(fill="x")

            self.arrow.config(text="▼")

            self.is_open = True

    def toggle_config_panel(self):

        if self.config_panel.winfo_ismapped():

            self.config_panel.pack_forget()

        else:

            self.config_panel.pack(fill="x", padx=4, pady=(6,8))

    def set_value(self, text):

        self.card.set_value(text)

    def _on_save_config(self):

        cfg = {}

        for lbl in self.error_labels.values():

            lbl.config(text="")

        for name, (var, meta) in self.field_vars.items():

            cfg[name] = var.get().strip()

        errores = self.validar_config(cfg)

        if errores:

            for campo, msg in errores.items():

                if campo in self.error_labels:

                    self.error_labels[campo].config(text=msg)

            return

        for name, (var, meta) in self.field_vars.items():

            raw = var.get().strip()

            t = meta.get("type", "str")

            try:

                if t == "int":

                    cfg[name] = int(raw)

                elif t == "float":

                    cfg[name] = float(raw)

                else:

                    cfg[name] = raw

            except:

                cfg[name] = None

        self.app.config_store.setdefault(self.key, {}).update(cfg)

        self.app.save_config_file()

        payload = {

            "type": "config",

            "sensor": self.key,

            "config": cfg,

            "ts": time.time()

        }

        try:

            self.app.outgoing_q.put_nowait(payload)

        except:

            pass

        self.toggle_config_panel()

    def actualizar_campos(self, nuevos_valores):

        for nombre, valor in nuevos_valores.items():

            if nombre in self.field_vars:

                self.field_vars[nombre][0].set(str(valor))

    def validar_config(self, cfg):

        errores = {}

        def num(x):

            try:

                return float(x)

            except:

                return None

        if self.key == "ph":

            lo = num(cfg.get("min"))

            hi = num(cfg.get("max"))

            if lo is None or hi is None:

                errores["min"] = "Debe ser numérico"

                errores["max"] = "Debe ser numérico"

            elif lo >= hi:

                errores["min"] = "Debe ser menor que el máximo"

                errores["max"] = "Debe ser mayor que el mínimo"

        if self.key == "temp":

            lo = num(cfg.get("amb_min"))

            hi = num(cfg.get("amb_max"))

            if lo is None or hi is None:

                errores["amb_min"] = "Debe ser numérico"

                errores["amb_max"] = "Debe ser numérico"

            elif lo >= hi:

                errores["amb_min"] = "Debe ser menor que el máximo"

                errores["amb_max"] = "Debe ser mayor que el mínimo"

        if self.key == "hum":

            lo = num(cfg.get("amb_min"))

            hi = num(cfg.get("amb_max"))

            if lo is None or hi is None:

                errores["amb_min"] = "Debe ser numérico"

                errores["amb_max"] = "Debe ser numérico"

            elif lo < 0 or hi > 100:

                errores["amb_min"] = "Rango válido 0–100"

                errores["amb_max"] = "Rango válido 0–100"

            elif lo >= hi:

                errores["amb_min"] = "Debe ser menor que el máximo"

                errores["amb_max"] = "Debe ser mayor que el mínimo"

        if self.key == "npk":

            for nutr in ("n", "p", "k"):

                lo = num(cfg.get(f"{nutr}_min"))

                hi = num(cfg.get(f"{nutr}_max"))

                if lo is None or hi is None:

                    errores[f"{nutr}_min"] = "Debe ser numérico"

                    errores[f"{nutr}_max"] = "Debe ser numérico"

                elif lo < 0 or hi < 0:

                    errores[f"{nutr}_min"] = "No puede ser negativo"

                    errores[f"{nutr}_max"] = "No puede ser negativo"

                elif lo >= hi:

                    errores[f"{nutr}_min"] = "Debe ser menor que el máximo"

                    errores[f"{nutr}_max"] = "Debe ser mayor que el mínimo"

        return errores

# MAIN APP

class MainApp(tk.Tk):

    def __init__(self, incoming_q, outgoing_q):

        super().__init__()

        self.title("InverTrack")

        self.configure(bg=BG)

        self.geometry("520x700")

        self.resizable(True, True)

        self.incoming_q = incoming_q

        self.outgoing_q = outgoing_q

        self.config_store = {}

        self._load_config_file()

        self.alertas = AlertaManager()

        hdr = tk.Frame(self, bg=BG)

        hdr.pack(fill="x", pady=(12,4))

        make_label(hdr, "InverTrack", size=20, bold=True).pack()

        make_label(hdr, "Panel de monitoreo", size=11, fg=SUBTEXT).pack()

        sf = ScrollFrame(self, bg=BG)

        sf.pack(fill="both", expand=True, padx=12, pady=12)

        container = sf.inner

        # MENÚ LÍMITES PREDEFINIDOS

        ph_schema = [

            {"name":"min", "label":"Mínimo (pH)", "type":"float", "default":"5.5"},

            {"name":"max", "label":"Máximo (pH)", "type":"float", "default":"7.0"},

        ]

        npk_schema = [

            {"name":"n_min","label":"N min","type":"float","default":"0"},

            {"name":"n_max","label":"N max","type":"float","default":"100"},

            {"name":"p_min","label":"P min","type":"float","default":"0"},

            {"name":"p_max","label":"P max","type":"float","default":"100"},

            {"name":"k_min","label":"K min","type":"float","default":"0"},

            {"name":"k_max","label":"K max","type":"float","default":"100"},

        ]

        temp_schema = [

            {"name":"amb_min","label":"Ambiente min (°C)","type":"float","default":"12"},

            {"name":"amb_max","label":"Ambiente max (°C)","type":"float","default":"35"},

        ]

        hum_schema = [

            {"name":"amb_min","label":"Ambiente min (%)","type":"float","default":"30"},

            {"name":"amb_max","label":"Ambiente max (%)","type":"float","default":"80"},

        ]

        self.sections = {}

        self.sections["ph"] = AccordionSection(container, self, "ph", "pH del agua", ph_schema)

        self.sections["ph"].pack(fill="x", pady=8)

        self.sections["npk"] = AccordionSection(container, self, "npk", "NPK (N-P-K)", npk_schema)

        self.sections["npk"].pack(fill="x", pady=8)

        self.sections["temp"] = AccordionSection(container, self, "temp", "Temperaturas", temp_schema)

        self.sections["temp"].pack(fill="x", pady=8)

        self.sections["hum"] = AccordionSection(container, self, "hum", "Humedad", hum_schema)

        self.sections["hum"].pack(fill="x", pady=8)

        self.presets_section = AccordionSection(

            container,

            self,

            "presets",

            "Límites Predefinidos",

            []

        )

        self.presets_section.pack(fill="x", pady=8)

        for cultivo in CULTIVOS_PREDEFINIDOS:

            fila = tk.Frame(self.presets_section.body, bg=BG)

            fila.pack(fill="x", padx=12, pady=6)

            make_label(fila, cultivo, size=11).pack(side="left")

            btn = tk.Button(

                fila,

                text="Asignar",

                command=lambda c=cultivo: self.aplicar_cultivo(c)

            )

            style_button_primary(btn)

            btn.pack(side="right")

        # Mantener cerrado por defecto

        self.presets_section.body.pack_forget()

        if hasattr(self.presets_section, "btn_config"):

           self.presets_section.btn_config.pack_forget()

        if self.presets_section.key == "presets":

            # Quitar tarjeta de valor (--)

            if hasattr(self.presets_section, "card"):

                self.presets_section.card.pack_forget()

            # Quitar frame de acciones (configurar / automatizaciones)

            if hasattr(self.presets_section, "actions_frame"):

                self.presets_section.actions_frame.pack_forget()

        self.presets_section.body.pack_forget()

        btn_exit = tk.Button(self, text="Salir", bg="#e0e0e0", relief="flat", command=self.on_close)

        btn_exit.pack(side="bottom", fill="x", padx=8, pady=8)

        self.after(POLL_MS, self._poll_incoming)

    def _load_config_file(self):

        try:

            if os.path.exists(CONFIG_FILE):

                with open(CONFIG_FILE, "r", encoding="utf-8") as f:

                    self.config_store = json.load(f)

            else:

                self.config_store = {}

        except:

            self.config_store = {}

    def save_config_file(self):

        try:

            with open(CONFIG_FILE + ".tmp", "w", encoding="utf-8") as f:

                json.dump(self.config_store, f, indent=2, ensure_ascii=False)

            os.replace(CONFIG_FILE + ".tmp", CONFIG_FILE)

        except Exception as e:

            print("Error guardando config:", e)

    def aplicar_cultivo(self, nombre):

        if nombre not in CULTIVOS_PREDEFINIDOS:

            return

        datos = CULTIVOS_PREDEFINIDOS[nombre]

        # Aplicar los nuevos valores a config_store

        for sensor, cfg in datos.items():

            self.config_store.setdefault(sensor, {}).update(cfg)

            if sensor in self.sections:

                # Actualizamos los valores en la UI usando actualizar_campos

                self.sections[sensor].actualizar_campos(cfg)

            payload = {

                "type": "config",

                "sensor": sensor,

                "config": cfg,

                "ts": time.time()

            }

            try:

                self.outgoing_q.put_nowait(payload)

            except:

                pass

        # Guardar configuración en el archivo local

        self.save_config_file()

        # Notificar que se aplicó el cultivo

        enviar_notificacion(f"Límites predefinidos aplicados: {nombre}")

    def _poll_incoming(self):

        try:

            while True:

                item = self.incoming_q.get_nowait()

                if "temp" in item and item.get("temp") is not None:

                    t_raw = item.get("temp")

                    try:

                        t = float(t_raw)

                    except:

                        t = None

                    if t is not None:

                        self.sections["temp"].set_value(f"Ambiente: {t} °C")

                        cfg = self.config_store.get("temp", {})

                        amb_min = cfg.get("amb_min")

                        amb_max = cfg.get("amb_max")

                        try:

                            amb_min = float(amb_min) if amb_min is not None else None

                        except:

                            amb_min = None

                        try:

                            amb_max = float(amb_max) if amb_max is not None else None

                        except:

                            amb_max = None

                        fuera = False

                        if amb_min is not None and t < amb_min:

                            fuera = True

                        if amb_max is not None and t > amb_max:

                            fuera = True

                        if fuera and self.alertas.debe_alertar("temp_amb"):

                            enviar_notificacion(f"Temperatura ambiente fuera de rango: {t} °C")

                if "hum" in item and item.get("hum") is not None:

                    h_raw = item.get("hum")

                    try:

                        h = float(h_raw)

                    except:

                        h = None

                    if h is not None:

                        self.sections["hum"].set_value(f"Ambiente: {h}%")

                        cfg = self.config_store.get("hum", {})

                        amb_min = cfg.get("amb_min")

                        amb_max = cfg.get("amb_max")

                        try:

                            amb_min = float(amb_min) if amb_min is not None else None

                        except:

                            amb_min = None

                        try:

                            amb_max = float(amb_max) if amb_max is not None else None

                        except:

                            amb_max = None

                        fuera = False

                        if amb_min is not None and h < amb_min:

                            fuera = True

                        if amb_max is not None and h > amb_max:

                            fuera = True

                        if fuera and self.alertas.debe_alertar("hum_amb"):

                            enviar_notificacion(f"Humedad ambiente fuera de rango: {h}%")

                if "valor_adc" in item and item.get("valor_adc") is not None:

                    try:

                        ph = float(item.get("valor_adc"))

                    except:

                        ph = None

                    if ph is not None:

                        self.sections["ph"].set_value(f"{ph} pH")

                        cfg = self.config_store.get("ph", {})

                        try:

                            lo = float(cfg.get("min")) if cfg.get("min") is not None else None

                        except:

                            lo = None

                        try:

                            hi = float(cfg.get("max")) if cfg.get("max") is not None else None

                        except:

                            hi = None

                        fuera = False

                        if lo is not None and ph < lo:

                            fuera = True

                        if hi is not None and ph > hi:

                            fuera = True

                        if fuera and self.alertas.debe_alertar("ph"):

                            enviar_notificacion(f"pH fuera de rango: {ph}")

                if any(k in item for k in ("n", "p", "k")):

                    n_raw = item.get("n")

                    p_raw = item.get("p")

                    k_raw = item.get("k")

                    n_disp = n_raw if n_raw is not None else "--"

                    p_disp = p_raw if p_raw is not None else "--"

                    k_disp = k_raw if k_raw is not None else "--"

                    self.sections["npk"].set_value(f"N: {n_disp}   P: {p_disp}   K: {k_disp}")

                    cfg = self.config_store.get("npk", {})

                    try:

                        n_val = float(n_raw)

                        n_min = float(cfg.get("n_min")) if cfg.get("n_min") is not None else None

                        n_max = float(cfg.get("n_max")) if cfg.get("n_max") is not None else None

                    except:

                        n_val = None

                        n_min = None

                        n_max = None

                    if n_val is not None:

                        fuera = False

                        if n_min is not None and n_val < n_min:

                            fuera = True

                        if n_max is not None and n_val > n_max:

                            fuera = True

                        if fuera and self.alertas.debe_alertar("npk_n"):

                            enviar_notificacion(f"N fuera de rango: {n_val}")

                    try:

                        p_val = float(p_raw)

                        p_min = float(cfg.get("p_min")) if cfg.get("p_min") is not None else None

                        p_max = float(cfg.get("p_max")) if cfg.get("p_max") is not None else None

                    except:

                        p_val = None

                        p_min = None

                        p_max = None

                    if p_val is not None:

                        fuera = False

                        if p_min is not None and p_val < p_min:

                            fuera = True

                        if p_max is not None and p_val > p_max:

                            fuera = True

                        if fuera and self.alertas.debe_alertar("npk_p"):

                            enviar_notificacion(f"P fuera de rango: {p_val}")

                    try:

                        k_val = float(k_raw)

                        k_min = float(cfg.get("k_min")) if cfg.get("k_min") is not None else None

                        k_max = float(cfg.get("k_max")) if cfg.get("k_max") is not None else None

                    except:

                        k_val = None

                        k_min = None

                        k_max = None

                    if k_val is not None:

                        fuera = False

                        if k_min is not None and k_val < k_min:

                            fuera = True

                        if k_max is not None and k_val > k_max:

                            fuera = True

                        if fuera and self.alertas.debe_alertar("npk_k"):

                            enviar_notificacion(f"K fuera de rango: {k_val}")

        except queue.Empty:

            pass

        self.after(POLL_MS, self._poll_incoming)

    def on_close(self):

        self.destroy()

# SensorClient

class SensorClient:

    def __init__(self, incoming_q, outgoing_q, uri=WS_URI):

        self.incoming_q = incoming_q

        self.outgoing_q = outgoing_q

        self.uri = uri

        self.thread = None

        self._stop = threading.Event()

    def start(self):

        if self.thread and self.thread.is_alive():

            return

        self.thread = threading.Thread(target=self._run, daemon=True)

        self.thread.start()

    def stop(self):

        self._stop.set()

    def _run(self):

        asyncio.run(self._main())

    async def _main(self):

        backoff = 1

        while not self._stop.is_set():

            try:

                async with websockets.connect(self.uri) as ws:

                    print("SensorClient: conectado a", self.uri)

                    # NOTIFICACIÓN: CONECTADO

                    enviar_notificacion("Raspberry conectada al servidor de sensores.")

                    sender_task = asyncio.create_task(self._sender(ws))

                    try:

                        async for msg in ws:

                            try:

                                data = json.loads(msg)

                            except:

                                continue

                            normalized = {

                                "temp": data.get("temp_ambiente", data.get("temp")),

                                "hum": data.get("hum_ambiente", data.get("hum")),

                                "valor_adc": data.get("valor_adc", data.get("valor ADC")),

                                "n": data.get("n"),

                                "p": data.get("p"),

                                "k": data.get("k"),

                            }

                            try:

                                self.incoming_q.put_nowait(normalized)

                            except queue.Full:

                                pass

                    finally:

                        sender_task.cancel()

            except Exception as e:

                print("SensorClient: error conexión ->", e)

                # NOTIFICACIÓN: DESCONECTADO

                enviar_notificacion("Raspberry desconectada del servidor de sensores.")

                await asyncio.sleep(backoff)

                backoff = min(backoff * 2, 30)

    async def _sender(self, ws):

        loop = asyncio.get_event_loop()

        while True:

            try:

                payload = await loop.run_in_executor(None, self.outgoing_q.get)

                try:

                    await ws.send(json.dumps(payload))

                except Exception as exc:

                    print("SensorClient: error enviando payload:", exc)

            except Exception:

                await asyncio.sleep(0.1)

# Boot

def main():

    incoming_q = queue.Queue(maxsize=500)

    outgoing_q = queue.Queue(maxsize=200)

    client = SensorClient(incoming_q, outgoing_q, uri=WS_URI)

    client.start()

    app = MainApp(incoming_q, outgoing_q)

    try:

        app.mainloop()

    finally:

        client.stop()

if __name__ == "__main__":

    main()