Calibracion

Author: TypeErrorRic

lib/Caudal/Caudal.h

@@ -4,6 +4,7 @@
 #include "C:\Users\user\Desktop\Taller_de_Ing\Azucarado\include\Config.h"
 #include <Memoria_no_volatil.h>
 #include <HX711.h>
+//#include <LiquidCrystal.h>
 
 #define elementos 3
 #define pi 3.14

server/README.md

@@ -0,0 +1 @@
+# Monitor de control Del tanque:

server/src/Datos.json

@@ -7,7 +7,7 @@
         "xonxoff": false,
         "dsrdtr": false,
         "rtscts": false,
-        "timeout": 5,
+        "timeout": 2,
         "write_timeout": null,
         "inter_byte_timeout": null
     },
@@ -51,5 +51,17 @@
         0.0,
         0.0
     ],
-    "Tiempo llenado": 0
+    "Tiempo llenado": 5000,
+    "Regresion_x": [
+        -2.0,
+        1.0,
+        4.0,
+        3.0,
+        0.0
+    ],
+    "Regresion": {
+        "a0": 1.1428571428571428,
+        "x1": 0.3896103896103897,
+        "x2": 0.06493506493506493
+    }
 }

server/src/__pycache__/botones.cpython-39.pyc

@@ -14,6 +14,7 @@ def __init__(self, pantalla: Ventana, Dispostivo: Arduino, caja: tkinter.Listbox
         self.dispositivo: Arduino = Dispostivo
         self.caja = caja
         self.ventanas: Ventana = pantalla
+        self.values_x : list = []
 
     #Funcionalidades para realizar la regresion:
     def __boton_regresion(self, posx: float, posy: float, size: str) -> tkinter.Button:
@@ -79,14 +80,26 @@ def __regresion(self, size: str) -> None:
         Realizar = tkinter.Button(
             nueva, text="Realizar", command=lambda: self.__regresion_datos(
                 etiqueta1, etiqueta2, etiqueta3, etiqueta4, etiqueta5, pantalla=nueva, estado1=opcion, estado2=opcion2
-            ), bg='lightgreen'
+            ), bg='lightgreen', state="disabled"
         )
         Realizar.place(relx=0.36, rely=0.85)
         # eliminar datos ingresados:
         reset = tkinter.Button(
             nueva, text="Reset", command=lambda: self.__reset(nueva), bg='indian red'
         )
         reset.place(relx=0.53, rely=0.85)
+        # desactivar opciones por un cierto tiempo:
+        self.dispositivo.limpiar()
+        self.dispositivo.escribir_datos("[true/8]")
+        self.pantalla.after(self.dispositivo.Guardar.tiempo, self.__activar_Valores, Realizar)
+
+    def __activar_Valores(self, boton: tkinter.Button) -> None:
+        self.values_x = self.dispositivo.leer_valores_celdad_carga()
+        boton.config(state="active")
+        if len(self.values_x) == 5:
+            self.caja.insert(tkinter.END, "Se recivieron los datos.")
+        else:
+            self.caja.insert(tkinter.END, "No se recivieron los datos.")
 
     def __estado(self, estado: tkinter.IntVar, boton: tkinter.Checkbutton, estado2: tkinter.IntVar):
         if (estado.get() == 1 and estado2.get() == 1):
@@ -123,23 +136,34 @@ def __regresion_datos(self, *args: tkinter.StringVar, pantalla: tkinter.Toplevel
                     self.caja.insert(tkinter.END, "Intente de nuevo")
                     break
                 else:
-                    if (indx == 4):
-                        list1: list = [-2, 1, 4, 3, 0]
+                    if indx == 4 and len(self.values_x) == 5:
+                        #list1: list = [-2, 1, 4, 3, 0]
                         aux: str = self.__definir(estado1, estado2)
-                        regresion_final: list = realizar(aux, list1, lista)
+                        regresion_final: list = realizar(aux, self.values_x, lista)
                         self.caja.insert(
                                 tkinter.END, "Valores de la Regresion {}:".format(aux))
                         for element in regresion_final:
                             self.caja.insert(
                                 tkinter.END, "{:.2f}".format(element))
                             self.dispositivo.Regresion(element)
-                        self.pantalla.after(1400, self.confirmar)
-                        self.caja.insert(
-                                tkinter.END, "Regresion configurada")
+                        self.pantalla.after(2000, self.valorar_regresion)
                         pantalla.destroy()
+                    elif len(self.values_x) < 5:
+                        for widget in pantalla.winfo_children():
+                            if isinstance(widget, tkinter.Button):
+                                if widget.config('text')[-1] == "Realizar":
+                                    self.__activar_Valores(widget)
+                                    break
+                        self.caja.insert(tkinter.END, "Valores del eje x no han sido recividos aún completos")
                     else:
                         pass
 
+    def valorar_regresion(self):
+        if self.dispositivo.confirmar_regresion():
+            self.caja.insert(tkinter.END, "Regresion configurada")
+        else:
+            self.caja.insert(tkinter.END, "Regresion No configurada")
+    
     def regresion(self, posx: float, posy: float, size: str) -> None:
         self.__boton_regresion(posx, posy, size)
 
@@ -178,6 +202,7 @@ def conection_arduino(self) -> None:
             aux.config(state="disabled")
             var.set(self.dispositivo.Port())
             self.caja.insert(tkinter.END, self.dispositivo.conexion)
+            self.dispositivo.limpiar()
 
     #Boton para obtener las opciones:
     def menu_opciones_conexion(self, var: tkinter.StringVar, port: list) -> tkinter.OptionMenu:
@@ -209,6 +234,7 @@ def __conectar(self, var: tkinter.StringVar, etiqueta: tkinter.Label, var2: tkin
                 elif isinstance(widget, tkinter.Entry):
                     widget.config(state="disabled")
             self.caja.insert(tkinter.END, self.dispositivo.conexion)
+            self.dispositivo.limpiar()
         else:
             self.caja.insert(tkinter.END, self.dispositivo.Errores)
 

server/src/__pycache__/conectado_datos.cpython-39.pyc

@@ -288,5 +288,42 @@ def terminado(self) -> None:
         self.pantalla.destroy()
 
     def confi_regresion(self) -> None:
-        boton = tkinter.Button(self.pantalla, text= "Configuracion", command=lambda:print("Hola"), )
-        boton.place(relx=0.83, rely=0.84)
+        boton = tkinter.Button(self.pantalla, text= "Configuracion", command=self.realizar_configuracion)
+        boton.place(relx=0.83, rely=0.84)
+    
+    def realizar_configuracion(self) -> None:
+        nueva : tkinter.Toplevel = tkinter.Toplevel(background="#2a8d90")
+        nueva.geometry("380x120")
+        nueva.resizable(False, False)
+        nueva.title("Set the time")
+        self.ventanas.etiqueta_titulo(nueva, "Tiempo de Llenado Tanque")
+        variable = tkinter.StringVar(value="En segundos")
+        etiqueta = tkinter.Entry(nueva, width=35, textvariable=variable)
+        etiqueta.place(relx=0.1, rely=0.4)
+        boton = tkinter.Button(nueva, text="Guardar", command=lambda:self.configuracion_tiempo(variable,etiqueta,nueva))
+        boton.place(relx=0.7, rely=0.4)
+        boton1 = tkinter.Button(nueva, text="Imprimir", command=self.mostrar_confi)
+        boton1.place(relx = 0.4, rely = 0.7)
+    
+    def configuracion_tiempo(self, var: tkinter.StringVar, eti: tkinter.Entry, pantalla: tkinter.Toplevel) -> None:
+        guarda: float
+        try:
+            guarda = float(var.get())
+        except:
+            eti.delete(0, 'end')
+            var.set("")
+            self.caja.insert(tkinter.END, "Dato no valido. Ingrese otro valor.")
+        else:
+            aux_21 : int = int(guarda*1000)
+            self.dispositivo.set_the_time(aux_21)
+            self.caja.insert(tkinter.END, "Dato configurado correctamente.")
+            pantalla.destroy()
+        
+    def mostrar_confi(self) -> None:
+        self.caja.insert(tkinter.END, "Configuración del dispostivio:")
+        for key, value in self.dispositivo.Guardar.configuracion.items():
+            self.caja.insert(tkinter.END, f"{key}: {value}")
+        self.caja.insert(tkinter.END, f"tiempo de llenado: {self.dispositivo.Guardar.tiempo}")
+
+
+

server/src/__pycache__/logica.cpython-39.pyc

@@ -1,6 +1,5 @@
 from module.Transfer import Transfer
 from module.Base_datos import Almacenamiento
-import time
 
 class Arduino(Transfer):
 
@@ -28,6 +27,7 @@ def __Enviar_valores_regresion(self, lista : list) -> None:
         aux = aux + "0]"
         print(aux)
         super().escribir_datos(aux)
+        self.guardar_valores_regresion(lista)
 
     def Regresion(self, value : float):
         if (contador := self.__contador2 + 1) <= (3):
@@ -41,6 +41,33 @@ def Regresion(self, value : float):
                 self.__Enviar_valores_regresion(list(self.__Regresion.values()))
                 self.Guardar.Guardar_datos()
 
+    def confirmar_regresion(self) -> bool:
+        if self.Arduino.is_open:
+            if self.señal.isSet():
+                count: int = 0 
+                try:
+                    if(len(self.data) == 3):
+                        for indx, element in enumerate(self.data , start=0):
+                            if(element == self.data[indx]):
+                                count += 1
+                        if count == 3:
+                            self.limpiar()
+                            return True
+                        else:
+                            self.limpiar()
+                            return False
+                    else:
+                        return False
+                except ValueError:
+                    self.limpiar()
+                    return False
+            else:
+                print("Hilo fallo")
+                self.Arduino.close()
+                return False
+        else:
+            return False
+
     def conection(self, value: str) -> bool:
         if self.Arduino.is_open:
             if self.señal.isSet():
@@ -103,6 +130,42 @@ def recolectar_datos(self, validacion: bool) -> dict:
                 print("Sin datos")
         return self.Guardar.datos_arduino
 
+    def set_the_time(self, value: int) -> None:
+        self.Guardar.tiempo = value
+        self.Guardar.Guardar_datos()
+
+    def leer_valores_celdad_carga(self) -> list:
+        aux_list_regre: list = []
+        if(len(self.data) == 5):
+            for element in self.data:
+                try:
+                    variable : float = float(element)
+                    aux_list_regre.append(variable)
+                except ValueError:
+                    self.Errores = "Error en el recivimiento del mensaje."
+                    pass
+            else:
+                self.__guardar_Value_x(aux_list_regre)
+                self.limpiar()
+                return aux_list_regre.copy()
+        return aux_list_regre
+    
+    def __guardar_Value_x(self, lista: list ):
+        self.Guardar.Resion_values_x = lista
+        self.Guardar.Guardar_datos()
+
+    def guardar_valores_regresion(self, lista : list) -> None:
+        if len(lista) == 3:
+            self.Guardar.Regresion_metodo = {
+                "a0" : lista[0],
+                "x1" : lista[1],
+                "x2" : lista[2]
+            }
+            self.Guardar.Guardar_datos()
+        else:
+            pass
+                
+
 if __name__ == '__main__':
     logic = Arduino(9600)
     logic.comprobar_data()

server/src/botones.py

@@ -23,14 +23,18 @@ def __init__(self, configuracion : dict = {}) -> None:
         self.__datos_arduino : dict = {}
         self.__datos_estadisticos: list = []
         self.__guardar :dict = {}
-        self.__tiempo_regr : float = 0
+        self.__tiempo_regr : int = 0
+        self.__values_x : list = []
+        self.__regresion: dict = {}
 
     def Guardar_datos(self) -> None:
         self.__guardar = {
                             "configuracion": self.__configuracion, 
                             "Datos_Arduino": self.__datos_arduino, 
                             "Estadistica": self.__datos_estadisticos,
-                            "Tiempo llenado": self.__tiempo_regr
+                            "Tiempo llenado": self.__tiempo_regr,
+                            "Regresion_x": self.__values_x,
+                            "Regresion": self.__regresion
                         }
         with open(self.ruta_archivo, 'w') as archivo:
             json.dump(self.__guardar, archivo, indent=4)
@@ -41,7 +45,9 @@ def Cargar_datos(self) -> dict:
             self.__configuracion = self.__guardar.setdefault("configuracion")
             self.__datos_arduino = self.__guardar.setdefault("Datos_Arduino")
             self.__datos_estadisticos = self.__guardar.setdefault("Estadistica")
-            self.__tiempo = self.__guardar.setdefault("Tiempo llenado")
+            self.__tiempo_regr = self.__guardar.setdefault("Tiempo llenado")
+            self.__values_x = self.__guardar.setdefault("Regresion")
+            self.__regresion = self.__guardar.setdefault("Regresion")
             return self.__guardar
 
     @property
@@ -69,12 +75,28 @@ def datos_estadisticos(self, diccionario: list) -> None:
         self.__datos_estadisticos = diccionario
 
     @property
-    def tiempo_regr(self) -> float:
+    def tiempo_regr(self) -> int:
         return self.__tiempo_regr
 
     @tiempo_regr.setter
-    def tiempo(self, valor_time: float) -> None:
+    def tiempo(self, valor_time: int) -> None:
         self.__tiempo_regr = valor_time
+    
+    @property
+    def Regresion_values_x(self) -> list:
+        return self.__values_x
+
+    @Regresion_values_x.setter
+    def Resion_values_x(self, valor_list: list) -> None:
+        self.__values_x = valor_list
+    
+    @property
+    def Regresion_metodo(self) -> dict:
+        return self.__regresion
+
+    @Regresion_metodo.setter
+    def Regresion_metodo(self, valor_dict: dict) -> None:
+        self.__regresion = valor_dict
 
     def __str__(self): 
         aux : str = ""

server/src/conectado_datos.py

@@ -1 +1 @@
-380x480
+#2a8d90

server/src/logica.py

@@ -153,6 +153,19 @@ namespace Correr
                 Manejo_datos::guarda_config_peso(Variables_datos.altura);
                 Serial.println(Variables_datos.altura);
             }
+            //Valores x de la regresion:
+            else if(list[0] == "8")
+            {
+                if (list[1] == "true")
+                {
+                    float array_regr[5] = {-2, 1, 4, 3, 0};
+                    Serial.println(array_regr[0]);
+                    Serial.println(array_regr[1]);
+                    Serial.println(array_regr[2]);
+                    Serial.println(array_regr[3]);
+                    Serial.println(array_regr[4]);
+                }
+            }
             delete[] list;
         }
     }

server/src/module/Base_datos.py

@@ -20,7 +20,6 @@
 //Elementos de ejecuión:
 #include "..\include\Correr.h"
 
-
 /**
  * @brief Función que se encarga de configurar los parametros inciales de las funciones.
  */