frontend-dev/frontend/app.py

import tkinter as tk
from tkinter import ttk
from tkinter.messagebox import showinfo
import threading
from time import sleep
from statistics import mean

from .serial_reader import SerialReader
from .config import DEFAULT_CALIB, DISPLAY_TYPES
from .views import *

class WeightApp(tk.Tk):
    def __init__(self, weight_reader: SerialReader):
        super().__init__()
        self.weight_reader = weight_reader
        self.view = None
        
        self.toolbar = tk.Frame(self, padx=10)
        self.toolbar.pack(side=tk.LEFT)
        
        #### Connection Settings ####
        self.connection_settings = tk.Frame(self.toolbar, pady=10)
        self.scan_ports_button = ttk.Button(self.connection_settings, text="Scan Devices", command=self.update_devices)
        self.scan_ports_button.pack()
        self.port_label = ttk.Label(self.connection_settings, text="Port:")
        self.port_label.pack(side=tk.LEFT)
        self.port = ttk.Combobox(self.connection_settings, values=[])
        self.update_devices()
        self.port.pack(side=tk.LEFT)
        self.connection_settings.pack()
        self.connect_button = ttk.Button(self.toolbar, text="Connect", command=self.connect)
        self.connect_button.pack()

        #### Weight Reader Settings ####
        self.reader_settings = tk.Frame(self.toolbar, pady=30)
        self.reader_settings.pack()
        
        self.calib_factor = tk.Frame(self.reader_settings)
        self.calib_factor.pack()
        self.calib_label = ttk.Label(self.calib_factor, text="Calibration Factor:")
        self.calib_label.pack()
        self.calib_weight = ttk.Combobox(self.calib_factor, values=[100], width=5)
        self.calib_weight.set(100)
        self.calib_weight.pack(side=tk.LEFT)
        self.calib_measurements = ttk.Entry(self.calib_factor)
        self.calib_measurements.insert(0, DEFAULT_CALIB)
        self.calib_measurements.pack(side=tk.LEFT)
        self.update_calib_button = ttk.Button(self.reader_settings, text="Update Calibration", command=self.update_calib)
        self.update_calib_button.pack()
        
        self.view_type = tk.Frame(self.toolbar, pady=20)
        self.view_type.pack()
        self.view_type_label = ttk.Label(self.view_type, text="Visual:")
        self.view_type_label.pack(side=tk.LEFT)
        self.view_type_select = ttk.Combobox(self.view_type, values=[t.value for t in DISPLAY_TYPES])
        self.view_type_select.set(DISPLAY_TYPES.NUMBER.value)
        self.view_type_select.pack(side=tk.LEFT)
        self.view_type_update = ttk.Button(self.view_type, text="Refresh", command=self.update_view)
        self.view_type_update.pack()

        #### Display ####
        self.update_view()

        self.update_weight_display()

        self.hide_device_components()
        
        self.focus_force()

    
    def show_device_components(self):
        self.connect_button.pack_forget()
        self.connection_settings.pack_forget()
        self.reader_settings.pack_forget()
        self.view_type.pack_forget()
        self.view.pack_forget()

        self.connect_button.pack()
        self.reader_settings.pack()
        self.view_type.pack()
        self.view.pack()
    
    def hide_device_components(self):
        self.connect_button.pack_forget()
        self.connection_settings.pack_forget()
        self.reader_settings.pack_forget()
        self.view_type.pack_forget()
        self.view.pack_forget()
        self.connection_settings.pack()
        self.connect_button.pack()
        
    
    def connect(self):
        if self.weight_reader.serial is None:
            port = self.port.get()
            self.weight_reader.connect(port)
            self.connect_button.config(text="Disconnect")
            self.show_device_components()
        else:
            self.weight_reader.disconnect()
            self.connect_button.config(text="Connect")
            self.hide_device_components()
    
    def update_devices(self):
        self.weight_reader.scan_devices()
        self.port.config(values=self.weight_reader.ports)
        if len(self.weight_reader.ports) > 0:
            self.port.set(self.weight_reader.ports[0])
    
    def update_calib(self):
        self.weight_reader.calib_factor = self.calib_weight.get() / float(self.calib_measurements.get())
    
    def update_view(self):
        selected_view = self.view_type_select.get()
        
        if self.view is not None:
            self.view.pack_forget()

        
        if selected_view == DISPLAY_TYPES.NUMBER.value:
            self.view = NumberView(self,
                                tare_command=self.weight_reader.tare,
                                calibrate_command=self.calibrate,
                                padx=50)
            self.view.pack(side=tk.RIGHT)
        elif selected_view == DISPLAY_TYPES.CIRCLE.value:
            self.view = CircleView(self,
                                   tare_command=self.weight_reader.tare,
                                   calibrate_command=self.calibrate,
                                   padx=50)
            self.view.pack(side=tk.RIGHT)
        else:
            raise Exception(f"View {selected_view} not found.")

    def update_weight_display(self):
        weight = self.weight_reader.value
        self.view.update_weight(weight)
        self.after(100, self.update_weight_display)
    
    def calibrate(self):
        showinfo("Calibration", "Remove all weights.")
        self.weight_reader.reset()
        sleep(2)
        showinfo("Calibration", "Place Weight")
        self.weight_reader.calibrating = True
        sleep(30)
        self.weight_reader.calibrating = False
        print(self.weight_reader.calib_window)
        self.calib_measurements.delete(0, 'end')
        self.calib_measurements.insert(0, mean(self.weight_reader.calib_window))



def main():
    weight_reader = SerialReader()
    threading.Thread(target=weight_reader.read_weights, daemon=True).start()

    app = WeightApp(weight_reader)
    app.protocol("WM_DELETE_WINDOW", lambda: on_closing(app, weight_reader))
    app.mainloop()

def on_closing(app, weight_reader):
    weight_reader.stop()
    app.destroy()

if __name__ == "__main__":
    main()