Untitled

 avatar
unknown
python
a year ago
37 kB
3
Indexable
#!/usr/bin/env python3

import tkinter as tk
from tkinter import filedialog
import ttkbootstrap as ttk
from ttkbootstrap.dialogs import Messagebox
from ttkbootstrap.tableview import Tableview

import serial
import time
import datetime
import csv
import matplotlib
import matplotlib.pyplot as plt
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
import configparser
import sys
from fpdf import FPDF
from fpdf.fonts import FontFace
import subprocess
import os
import numpy as np
from scipy.optimize import minimize
import math

def remove_focus():
    window.focus_set()  # Remove focus from all widgets

def validate_input(P):
    # P is the value of the entry field
    valid_chars = set("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.-/:")
    return all(c in valid_chars for c in P)


matplotlib.use("TkAgg")

# Create a Tkinter window
window = ttk.Window(themename="solar", title="Flash teszt")

validation = window.register(validate_input)

# Create a Frame for the graph
graph_frame = ttk.Frame(window, )
graph_frame.pack(pady=5, padx=10)

# Create a Frame for the tree
tree_frame = ttk.Frame(window, )
tree_frame.pack(pady=5, padx=10)

# Create a Frame for the buttons
button_frame_1 = ttk.Frame(window,)
button_frame_1.pack(padx=10, fill=tk.X)

button_frame_2 = ttk.Frame(window,)
button_frame_2.pack(padx=10, fill=tk.X)

# Create a Figure and Axes objects
fig, ax1 = plt.subplots(figsize=(12, 6))
ax2 = ax1.twinx()

# Create a FigureCanvasTkAgg object and pack it into the graph frame
canvas = FigureCanvasTkAgg(fig, master=graph_frame)
canvas.draw()
canvas.get_tk_widget().pack()

scrollbar = ttk.Scrollbar(tree_frame, )
scrollbar.pack(side="right", fill="y")

coldata = [
            "Kategória",
            "Dobozcimke",
            "Vonalkód",
            "Uoc",
            "Isc",
            "Upm",
            "Ipm",
            "Pm",
        ]
tree = Tableview(tree_frame, coldata=coldata,searchable=True, )

tree.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)

# Configure the scrollbar to control the treeview
scrollbar.config(command=tree.view.yview)
tree.view.config(yscrollcommand=scrollbar.set)

Rs = 3 #Soros ellenallas kezdoertek
A = 1 #diode ideality factor
Rsh = 3000 #Sontellenallas kezdoertek
data_rows = []
graph_data = {}
options = ['Uoc', 'Isc', 'Upm','Ipm','Pm',]


def read_settings():
    config = configparser.ConfigParser()
    config.read('settings.ini')

    calibration_settings = {}
    calibration_settings['U'] = float(config.get('Calibration', 'U'))
    calibration_settings['I'] = float(config.get('Calibration', 'I'))

    measurement_settings = {}
    measurement_settings['step'] = float(config.get('Settings', 'step'))
    measurement_settings['box_size'] = int(config.get('Settings', 'box_size'))
    measurement_settings['save_loc'] = str(config.get('Settings', 'save_loc'))
    measurement_settings['light_power'] = str(config.get('Settings', 'light_power'))
    measurement_settings['norvegian_save_mode']= config.get('Settings', 'norvegian_save_mode')
    measurement_settings['category_1_name'] = str(config.get('Settings', 'category_1_name'))
    measurement_settings['category_1_1'] = float(config.get('Settings', 'category_1_1'))
    measurement_settings['category_1_2'] = float(config.get('Settings', 'category_1_2'))
    measurement_settings['category_2_name'] = str(config.get('Settings', 'category_2_name'))
    measurement_settings['category_2_1'] = float(config.get('Settings', 'category_2_1'))
    measurement_settings['category_2_2'] = float(config.get('Settings', 'category_2_2'))

    return calibration_settings, measurement_settings

def PV_Model_cf(p,V,I):
    #global V, I
    Rs = p[0]
    A = p[1]
    Rsh = p[2]
    # V = p[3] #tomb feszultseg pontokkal
    # I = p[4] #tomb aram pontokkal
    data_rows
    Isc = I[0] #rovidzarasi aram
    Voc = V[-1] #nyilthurku fesz
    Ns = 78 #sorbakapcsolt cellak szama
    cf_min = 1e20 #hiba?
    q = 1.602e-19 #Elektron toltes [C]
    k = 1.38064852e-23 #Boltzmann constant [J/K]
    Tc = 25 #meresihomerseklet
    TK = 273 + Tc #meresihomerseklet Kelvinben

    vt = (A * k * TK * Ns) / q
    I0 = (Isc - (Voc / Rsh)) / (math.exp(Voc / vt) - 1)
    IL = I0 * (math.exp((Isc * Rs) / vt) - 1) + Isc + (Isc * Rs) / Rsh
    V_I_Rs=np.add(V,[i * Rs for i in I])
    I_Model = IL - I0 * (np.exp(V_I_Rs/vt) - 1) - V_I_Rs / Rsh  #tomb szamitott aram
    cf = (sum(abs((I[0:-1] - I_Model[0:-1]) / I[0:-1])) * 100 / len(V[0:-1]))

    if cf < cf_min:
        cf_min = cf
    return cf

# Write the settings to the INI file
def write_settings(calibration_settings, measurement_settings):
    config = configparser.ConfigParser()
    config.optionxform = str  # Preserve capitalization
    config['Calibration'] = {
        'U': str(calibration_settings['U']),
        'I': str(calibration_settings['I']),
    }
    config['Settings'] = {
        'step': str(measurement_settings['step']),
        'box_size': str(measurement_settings['box_size']),
        'save_loc': str(measurement_settings['save_loc']),
        'light_power': str(measurement_settings['light_power']),
        'norvegian_save_mode': str(measurement_settings['norvegian_save_mode']),
        'category_1_name': str(measurement_settings['category_1_name']),
        'category_2_name': str(measurement_settings['category_2_name']),
        'category_1_1':  str(measurement_settings['category_1_1']),
        'category_1_2': str(measurement_settings['category_1_2']),
        'category_2_1': str(measurement_settings['category_2_1']),
        'category_2_2': str(measurement_settings['category_2_2']),
    }

    with open('settings.ini', 'w') as configfile:
        config.write(configfile)

def open_settings_window():
    # Create a new top-level window for the calibration settings
    calib_window = tk.Toplevel(window)
    calib_window.title("Beállítások")

    setting_frame_1 = ttk.Frame(calib_window)
    setting_frame_1.pack(side=tk.LEFT, padx=10, pady=10)
    setting_frame_2 = ttk.Frame(calib_window)
    setting_frame_2.pack(side=tk.LEFT, padx=10, pady=10)
    setting_frame_3 = ttk.Frame(calib_window)
    setting_frame_3.pack(side=tk.LEFT, padx=10, pady=10)


    def calculate_multipliers():
        u_w = float(entry_u_wanted.get())
        u_m = float(entry_u_measured.get())
        i_w = float(entry_i_wanted.get())
        i_m = float(entry_i_measured.get())

        u_multi = u_w/u_m
        i_multi = i_w/i_m

        entry_u.delete(0,tk.END)
        entry_i.delete(0,tk.END)

        entry_u.insert(tk.END, str(u_multi))
        entry_i.insert(tk.END, str(i_multi))

    # Function to save the calibration settings
    def save_calibration_settings():
        calibration = {
            'U': float(entry_u.get()),
            'I': float(entry_i.get())
        }
        settings = {
            'step': str(entry_step.get()),
            'box_size': str(entry_box_size.get()),
            'save_loc': str(entry_save_location.get()),
            'light_power': str(entry_light_power.get()),
            'norvegian_save_mode': str(norvegian_mode_button_var.get()),
            'category_1_name': str(entry_cat_1_name.get()),
            'category_1_1': str(entry_cat_1_upper.get()),
            'category_1_2': str(entry_cat_1_lower.get()),
            'category_2_name': str(entry_cat_2_name.get()),
            'category_2_1': str(entry_cat_2_upper.get()),
            'category_2_2': str(entry_cat_2_lower.get()),
        }
        write_settings(calibration, settings)
        calib_window.destroy()
        remove_focus()

    label_u_measured = ttk.Label(setting_frame_1, text="Uoc Mért:")
    label_u_measured.pack(padx=5, pady=5)
    entry_u_measured = ttk.Entry(setting_frame_1, validate="key", validatecommand=(validation, "%P"))
    entry_u_measured.pack(padx=5, pady=5)

    label_u_wanted = ttk.Label(setting_frame_1, text="Uoc Elméleti:")
    label_u_wanted.pack( padx=5)
    entry_u_wanted = ttk.Entry(setting_frame_1, validate="key", validatecommand=(validation, "%P"))
    entry_u_wanted.pack(padx=5, pady=5)

    label_u = ttk.Label(setting_frame_1, text="U Szorzó:")
    label_u.pack(padx=5, pady=5)
    entry_u = ttk.Entry(setting_frame_1, validate="key", validatecommand=(validation, "%P"))
    entry_u.pack(padx=5, pady=5)

    label_i_measured = ttk.Label(setting_frame_1, text="Isc Mért:")
    label_i_measured.pack(padx=5, pady=5)
    entry_i_measured = ttk.Entry(setting_frame_1, validate="key", validatecommand=(validation, "%P"))
    entry_i_measured.pack(padx=5, pady=5)

    label_i_wanted = ttk.Label(setting_frame_1, text="Isc Elméleti:")
    label_i_wanted.pack(padx=5, pady=5)
    entry_i_wanted = ttk.Entry(setting_frame_1, validate="key", validatecommand=(validation, "%P"))
    entry_i_wanted.pack(padx=5, pady=5)

    # # Create entry fields for U, I, and step calibration value
    label_i = ttk.Label(setting_frame_1, text="I Szorzó:")
    label_i.pack(padx=5, pady=5)
    entry_i = ttk.Entry(setting_frame_1, validate="key", validatecommand=(validation, "%P"))
    entry_i.pack(padx=5, pady=5)

    btn_calculate = ttk.Button(setting_frame_1, width = 20, text="Kalibráció", command=calculate_multipliers)
    btn_calculate.pack(padx=5, pady=5)

    label_step = ttk.Label(setting_frame_2, text="Lépésköz:")
    label_step.pack(padx=5, pady=5)
    entry_step = ttk.Entry(setting_frame_2, validate="key", validatecommand=(validation, "%P"))
    entry_step.pack(padx=5, pady=5)

    lable_box_size = ttk.Label(setting_frame_2, text="Doboz méret [db]:")
    lable_box_size.pack(padx=5, pady=5)
    entry_box_size = ttk.Entry(setting_frame_2, validate="key", validatecommand=(validation, "%P"))
    entry_box_size.pack(padx=5, pady=5)

    label_save_location = ttk.Label(setting_frame_2, text="Mentés helye(Pl.: /home/flash/Desktop/):")
    label_save_location.pack( padx=5, pady=5)
    entry_save_location = ttk.Entry(setting_frame_2, validate="key", validatecommand=(validation, "%P"))
    entry_save_location.pack(padx=5, pady=5)

    label_light_power = ttk.Label(setting_frame_2, text="Besugárzási teljesitmény(200W/m2=020):")
    label_light_power.pack( padx=5, pady=5)
    entry_light_power = ttk.Entry(setting_frame_2, validate="key", validatecommand=(validation, "%P"))
    entry_light_power.pack(padx=5, pady=5)

    norvegian_mode_button_var = tk.BooleanVar()
    norvegian_mode_button = ttk.Checkbutton(setting_frame_2, text="Norvég mentési mód", variable=norvegian_mode_button_var)
    norvegian_mode_button.pack(padx=5, pady=5)

    label_cat_1_name = ttk.Label(setting_frame_3, text="Mérték 1:")
    label_cat_1_name.pack(padx=5, pady=5)
    entry_cat_1_name = ttk.Combobox(setting_frame_3, values=options)
    entry_cat_1_name.pack(padx=5, pady=5)

    label_cat_1_upper = ttk.Label(setting_frame_3, text="Felső határ 1:")
    label_cat_1_upper.pack(padx=5, pady=5)
    entry_cat_1_upper = ttk.Entry(setting_frame_3, validate="key", validatecommand=(validation, "%P"))
    entry_cat_1_upper.pack(padx=5, pady=5)

    label_cat_1_lower = ttk.Label(setting_frame_3, text="Alsó határ 1:")
    label_cat_1_lower.pack(padx=5, pady=5)
    entry_cat_1_lower = ttk.Entry(setting_frame_3, validate="key", validatecommand=(validation, "%P"))
    entry_cat_1_lower.pack(padx=5, pady=5)

    label_cat_2_name = ttk.Label(setting_frame_3, text="Mérték 2:")
    label_cat_2_name.pack(padx=5, pady=5)
    entry_cat_2_name = ttk.Combobox(setting_frame_3, values=options, validate="key", validatecommand=(validation, "%P"))
    entry_cat_2_name.pack(padx=5, pady=5)

    label_cat_2_upper = ttk.Label(setting_frame_3, text="Felső határ 2:")
    label_cat_2_upper.pack(padx=5, pady=5)
    entry_cat_2_upper = ttk.Entry(setting_frame_3, validate="key", validatecommand=(validation, "%P"))
    entry_cat_2_upper.pack(padx=5, pady=5)

    label_cat_2_lower = ttk.Label(setting_frame_3, text="Alsó határ 2:")
    label_cat_2_lower.pack(padx=5, pady=5)
    entry_cat_2_lower = ttk.Entry(setting_frame_3, validate="key", validatecommand=(validation, "%P"))
    entry_cat_2_lower.pack(padx=5, pady=5)


    # Load current calibration settings
    settings = read_settings()
    entry_u.insert(tk.END, str(settings[0]['U']))
    entry_i.insert(tk.END, str(settings[0]['I']))

    entry_step.insert(tk.END, str(settings[1]['step']))
    entry_box_size.insert(tk.END, str(settings[1]['box_size']))
    entry_save_location.insert(tk.END, str(settings[1]['save_loc']))
    entry_light_power.insert(tk.END, str(settings[1]['light_power']))
    norvegian_mode_button_var.set(settings[1]['norvegian_save_mode'])
    
    entry_cat_1_name.insert(tk.END, str(settings[1]['category_1_name']))
    entry_cat_1_upper.insert(tk.END, str(settings[1]['category_1_1']))
    entry_cat_1_lower.insert(tk.END, str(settings[1]['category_1_2']))
    entry_cat_2_name.insert(tk.END, str(settings[1]['category_2_name']))
    entry_cat_2_upper.insert(tk.END, str(settings[1]['category_2_1']))
    entry_cat_2_lower.insert(tk.END, str(settings[1]['category_2_2']))

    # Create a button to save the calibration settings
    btn_save = ttk.Button(setting_frame_2, width = 20, text="Beállítások Mentése", command=save_calibration_settings)
    btn_save.pack(pady=10)

def start_measurement(event=None):
# Check if a box name is entered
    box_name = entry_box_name.get().strip()
    if not box_name:
        Messagebox.show_error("Kérem adjon meg doboz cimke azonosítót.", "Error")
        return
    entry_box_name.config(state="readonly")
    barcode = entry_barcode.get()

    if not barcode:
        Messagebox.show_error("Kérem adjon meg vonalkódot.", "Error")
        return
        
    if barcode in graph_data:
        Messagebox.show_error("Ezzel a vonalkóddal már létezik mért panel.", "Error")
        return
        
    settings = read_settings()

    if len(data_rows)>=settings[1]['box_size']:
        Messagebox.show_error("Kész a doboz!", "Error")
        return
    ax1.clear()
    ax2.clear()
        

    try:
        ser_itech = serial.Serial(baudrate=115200, port='/dev/ttyUSB0', timeout=2)
        ser_led = serial.Serial('/dev/ttyUSB1', timeout=1)
    except:
        Messagebox.show_error("Soros vonali hiba", "Error")

    #try:
        # ser_led.write(('#000ONPX80100' + '\r\n').encode())  # LED felkapcsolása
    ser_led.write(('#000ONPX80' + str(settings[1]['light_power']) + '\r\n').encode())  # LED felkapcsolása

    time.sleep(0.2)
    ser_led.write(b'\r\n')

    ser_itech.write(b'SYSTem:REMote\r\n')
    ser_itech.write(b'SYSTem:CLEar\r\n')
    ser_itech.write(b'INPut OFF\r\n')
    ser_itech.write(b'FUNCtion:MODE FIXed\r\n')
    ser_itech.write(b':FUNCtion IMPedance\r\n')
    ser_itech.write(b':MEASure:VOLT?\r\n')
    time.sleep(0.1)
    ser_itech.write(b':FUNCtion VOLTage\r\n')

    umax = ser_itech.readline().decode().strip()
    u_oc = float(umax)
    u_oc=u_oc*settings[0]['U']
    ser_itech.write(b':VOLT 0.1\r\n')
    ser_itech.write(b'INPut ON\r\n')
    time.sleep(0.1)

    dt = 0
    u_min = 0.1
    min_u = 0.0
    step_u = settings[1]['step']
    
    db_u = u_oc / step_u
    db_u = int(db_u)
    measured = []

    for i in range(1, db_u + 1):
        v = min_u + ((i - 1) * step_u)
        if v < u_min:
            v = u_min
        out_str = ':VOLT {:5.4f}'.format(v)
        ser_itech.write(out_str.encode() + b'\r\n')
        time.sleep(dt)
        ser_itech.write(b':MEASure:VOLT?;:MEASure:CURR?\r\n')
        in_str = ser_itech.readline().decode().strip().split(";")
        in_str[0] = float(in_str[0]) * settings[0]['U']
        in_str[1] = float(in_str[1]) * settings[0]['I']

        measured.append(in_str)

    ser_led.write(('#000OFXX0' + '\r\n').encode())
    ser_itech.close()
    ser_led.close()

    x = [float(item[0]) for item in measured]
    y = [float(item[1]) for item in measured]
    p = [float(float(item[0]) * float(item[1])) for item in measured]


    # Plot the first dataset
    ax1.plot(x, y, 'b-', label='I-V')
    ax1.set_xlabel('Feszültség U [V]')
    ax1.set_ylabel('Áram I [A]', color='b')

    # Plot the second dataset
    ax2.plot(x, p, 'r-', label='P-V')
    ax2.yaxis.set_label_coords(1.1, 0.5)
    ax2.set_ylabel('Teljesítmény P [W]', color='r', loc='center')

    # Show legends for both datasets
    ax1.legend(loc='upper left')
    ax2.legend(loc='upper right')

    plt.title('Eredmény')

    canvas.draw()

    i_sc = y[0]
    max_p_index = p.index(max(p))
    value_list = [u_oc, i_sc, x[max_p_index], y[max_p_index], max(p)] 

    category_param_1 = settings[1]['category_1_name']
    category_param_2 = settings[1]['category_2_name']
    compare_value_1 = value_list[options.index(category_param_1)]
    compare_value_2 = value_list[options.index(category_param_2)] 
    category_1_upper = settings[1]['category_1_1']
    category_1_lower = settings[1]['category_1_2']
    category_2_upper = settings[1]['category_2_1']
    category_2_lower = settings[1]['category_2_2']

    if compare_value_1<category_1_lower or compare_value_2<category_2_lower:
        category="1"
    elif (compare_value_1>=category_1_lower and compare_value_1<category_1_upper) or (compare_value_2>=category_2_lower and compare_value_2<category_2_upper):
        category="2"
    else:
        category="3"

    
    
    tree_values = str(category), str(box_name),str(barcode),*(round(value, 3) if isinstance(value, float) else value for value in value_list)
    data_rows.append(tree_values)
    tree.build_table_data(coldata=coldata, rowdata=data_rows)
    tree.load_table_data()
    tree.view.selection_remove(tree.view.selection())
    tree.view.selection_add(tree.view.get_children()[-1])
    
    tree.view.yview_moveto(1.0)
    #scrollbar.set(scrollbar.get()[1], 1.0)

    graph_data[barcode] = {
        'x': x,
        'y': y,
        'p': p,
    }

    v_ind=[Rs,A, Rsh]
    result = minimize(PV_Model_cf, v_ind, args=(x, y), method='nelder-mead')
    error = result.fun
    print(error)
    print(result.x[0],result.x[1],result.x[2])

    save_data()
    if settings[1]['norvegian_save_mode'] == "True":
        save_data_norvegian()

    panel_count.config(text="Panelek száma: {}".format(str(len(data_rows))))

    entry_barcode.delete(0, tk.END)
    entry_barcode.focus_set()
    # except:
    #     Messagebox.show_error("Mérési hiba", "Error")

def delete_measurment():
    # Get the selected item from the treeview
    selected_items_iids = tree.view.selection()  # Get selected item IDs

    # Check if anything is selected
    if selected_items_iids:
        # Get the TableRow object for the first selected item (assuming single selection)
        selected_item_row = tree.get_row(iid=selected_items_iids[0])

        # Access the actual data using the values attribute
        selected_item_data = selected_item_row.values
        # Get the barcode of the selected item
        barcode = str(selected_item_data[2])
        # Remove the data from the graph_data dictionary
        graph_data.pop(barcode)

        for row in data_rows:
            if row[2] == barcode:
                data_rows.remove(row)
                break 
        
        # Remove the item from the treeview
        index = tree.tablerows_visible.index(selected_item_row)
        tree.delete_row(index)
        ax1.cla()
        ax2.cla()
        canvas.draw()
        panel_count.config(text="Panelek száma: {}".format(str(len(data_rows))))
        save_data()
    else:
        print("No item selected")

def delete_all():
    # Check if there are any rows in the table
    if tree.tablerows_visible:
        # Loop through the visible rows and delete each row
        # for row in tree.tablerows_visible:
        #     index = tree.tablerows_visible.index(row)
        #     tree.delete_row(index)

        # Clear the data structures and update the UI
        data_rows.clear()
        graph_data.clear()
        ax1.cla()
        ax2.cla()
        canvas.draw()
        tree.build_table_data(coldata=coldata, rowdata=data_rows)
        tree.load_table_data()
        entry_box_name.config(state="normal")
        entry_box_name.delete(0, tk.END)

        panel_count.config(text="Panelek száma: {}".format(str(len(data_rows))))
        
    else:
        print("No rows to delete")

def on_treeview_select(event):
    selected_item = tree.view.selection()
    if selected_item:
        # Get the TableRow object for the selected item
        selected_item_row = tree.get_row(iid=selected_item[0])

        # Access the actual data using the values attribute
        selected_item_data = selected_item_row.values
        barcode = str(selected_item_data[2])

        # Check if the barcode exists in graph_data
        if barcode in graph_data:
            data = graph_data[barcode]

            # Clear the current graph
            ax1.cla()
            ax2.cla()

            # Retrieve the x, y, and p data from the dictionary
            x = data['x']
            y = data['y']
            p = data['p']

            # Plot the data on the graph
            ax1.plot(x, y, 'b-', label='I-V')
            ax1.set_xlabel('Feszültség U [V]')
            ax1.set_ylabel('Áram I [A]', color='b')

            ax2.plot(x, p, 'r-', label='P-V')
            ax2.yaxis.set_label_coords(1.13, 0.5)
            ax2.set_ylabel('Teljesítmény P [W]', color='r', loc='center')

            ax1.legend(loc='upper left')
            ax2.legend(loc='upper right')

            plt.title('Eredmény')

            # Redraw the canvas
            canvas.draw()
        else:
            # Clear the graph if the barcode is not found
            ax1.cla()
            ax2.cla()
            canvas.draw()
    else:
        print("No item selected")

def save_data():
    delim = ";"
    file_path = read_settings()[1]['save_loc']+data_rows[0][1]+".csv"
    if len(data_rows) == 1: 
        if os.path.exists(file_path):
            # Ask the user if they want to overwrite the existing file
            response = Messagebox.show_question(f"Egy fájl már létezik '{data_rows[0][1]}.csv' néven. Kívánja felülírni?","Létező file")
            if not response:
                return

    if file_path:
        with open(file_path, 'w', newline='') as csvfile:
            writer = csv.writer(csvfile)
            writer.writerow([datetime.datetime.now(),])

            writer.writerow(["Kategoria", "Doboz név", "Vonalkód", "Uoc [V]", "Isc [A]", "Upm [V]", "Ipm [A]", "Pm [W]", "U", "I", "P"])
            
            # Write measurement data and graph data rows
            for i in range(len(data_rows)):
                measurement_row = list(data_rows[i])
                barcode = measurement_row[2]

                x = graph_data[barcode]['x']
                y = graph_data[barcode]['y']
                p = graph_data[barcode]['p']

                x_list = delim.join(map(str, x))
                y_list = delim.join(map(str, y))
                p_list = delim.join(map(str, p))

                measurement_row.append(x_list)
                measurement_row.append(y_list)
                measurement_row.append(p_list)

                writer.writerow(measurement_row)

def save_data_norvegian():
    file_path = read_settings()[1]['save_loc']+data_rows[0][1]+"skarpnes"+".csv"
    if len(data_rows) == 1: 
        if os.path.exists(file_path):
            # Ask the user if they want to overwrite the existing file
            response = Messagebox.show_question(f"Egy fájl már létezik '{data_rows[0][1]}skarpnes.csv' néven. Kívánja felülírni?","Létező file")
            if not response:
                return

    if file_path:
        with open(file_path, 'w', newline='') as csvfile:
            writer = csv.writer(csvfile)
            writer.writerow([datetime.datetime.now(),])

            writer.writerow(["Category", "Box Number", "Barcode", "Voc [V]", "Isc [A]", "Vpm [V]", "Ipm [A]", "Pm [W]"])
            
            # Write measurement data and graph data rows
            for i in range(len(data_rows)):
                measurement_row = list(data_rows[i])

                writer.writerow(measurement_row)

def save_data_as():
    delim = ";"
    file_path =filedialog.asksaveasfilename(defaultextension=".csv", filetypes=[("CSV File", "*.csv")])
    if len(data_rows) == 1: 
        if os.path.exists(file_path):
            # Ask the user if they want to overwrite the existing file
            response = Messagebox.show_question(f"Egy fájl már létezik '{data_rows[0][1]}.csv' néven. Kívánja felülírni?","Létező file")
            if not response:
                return
    if file_path:
        with open(file_path, 'w', newline='') as csvfile:
            writer = csv.writer(csvfile)
            writer.writerow([datetime.datetime.now(),])
            writer.writerow(["Doboz név", "Vonalkód", "Uoc [V]", "Isc [A]", "Upm [V]", "Ipm [A]", "Pm [W]", "U", "I", "P"])
            # Write measurement data and graph data rows
            for i in range(len(data_rows)):
                measurement_row = list(data_rows[i])
                barcode = measurement_row[2]

                x = graph_data[barcode]['x']
                y = graph_data[barcode]['y']
                p = graph_data[barcode]['p']

                x_list = delim.join(map(str, x))
                y_list = delim.join(map(str, y))
                p_list = delim.join(map(str, p))

                measurement_row.append(x_list)
                measurement_row.append(y_list)
                measurement_row.append(p_list)

                writer.writerow(measurement_row)
    remove_focus()

def load_data():
    file_path = filedialog.askopenfilename(filetypes=[("CSV File", "*.csv")])
    if file_path:
        delete_all()
        with open(file_path, 'r') as csvfile:
            reader = csv.reader(csvfile)
            date = next(reader) 
            header = next(reader)

            for row in reader:
                category = row[0]
                box_name = row[1]
                barcode = row[2]
                u_oc = float(row[3])
                i_sc = float(row[4])
                u_pm = float(row[5])
                i_pm = float(row[6])
                p_pm = float(row[7])

                x_list = row[8].split(";")
                y_list = row[9].split(";")
                p_list = row[10].split(";")
                
                x = [float(value) for value in x_list]
                y = [float(value) for value in y_list]
                p = [float(value) for value in p_list]

                graph_data[barcode] = {
                    'x': x,
                    'y': y,
                    'p': p,
                }

                tree_values = category, box_name, barcode, u_oc, i_sc, u_pm, i_pm, p_pm
                tree.insert_row("end", values=tree_values)
                data_rows.append(tree_values)

                # Plot the data on the graph
            ax1.plot(x, y, 'b-', label='I-V')
            ax2.plot(x, p, 'r-', label='P-V')

            # Set the labels and legends
            ax1.set_xlabel('Feszültség U [V]')
            ax1.set_ylabel('Áram I [A]', color='b')
            ax2.set_ylabel('Teljesítmény P [W]', color='r', loc='center')
            ax1.legend(loc='upper left')
            ax2.legend(loc='upper right')
            plt.title('Eredmény')

            tree.load_table_data()

            # Redraw the canvas
            canvas.draw()
            entry_box_name.configure(state="normal")
            entry_box_name.delete(0,tk.END)
            entry_box_name.configure(state="readonly")
            entry_box_name.insert(tk.END, str(box_name))
            panel_count.config(text="Panelek száma: {}".format(str(len(data_rows))))

class PDF(FPDF):
    def header(self):
        self.set_font('helvetica', 'B', 8)
        # Move to the right
        # Title
        self.cell(0,0, str(datetime.datetime.now()))
        # Line break
        self.ln(10)

def pdf_generator():
    pdf = PDF()
    greyscale=200
    pdf.set_font("helvetica", size=8)
    pdf.add_page()
    pdf.set_draw_color(greyscale)
    pdf.set_line_width(0.3)
    headings_style = FontFace(emphasis="BOLD", color=255, fill_color=150)
    
    with pdf.table(
        # borders_layout="NO_HORIZONTAL_LINES",
        cell_fill_color=greyscale,
        col_widths=(40, 70, 110, 50, 50, 50, 50, 50),
        headings_style=headings_style,
        line_height=4,
        text_align=("CENTER", "RIGHT", "RIGHT", "CENTER", "CENTER", "CENTER", "CENTER", "CENTER", "CENTER"),
        width=180,
    ) as table:
        row = table.row()
        for data in ["Cat.", "Box ID","Barcode", "Voc[V]", "Isc[A]", "Vpm[V]", "Ipm[A]", "Pm[W]"]:
                row.cell(str(data))
        for data_row in data_rows:
            row = table.row()
            for data in data_row:
                row.cell(str(data))
    pdf.output(read_settings()[1]['save_loc'] + entry_box_name.get()+'.pdf')
    subprocess.call(["xdg-open",  read_settings()[1]['save_loc'] + entry_box_name.get()+'.pdf'])

def change_barcode():
    selected_item = tree.view.selection()
    if not selected_item:
        Messagebox.show_warning("Válassza ki a felülirandó vonalkódot","Nincs kiválasztott panel")
        return
    
    item_values = list(tree.view.item(selected_item, 'values'))
    current_barcode = item_values[2]

    top = tk.Toplevel()
    top.title("Vonalkód változtatás")

    label = tk.Label(top, text=f"Új vonalkód {current_barcode} helyett:")
    label.pack(pady=10)

    new_barcode_var = tk.StringVar(value=current_barcode)
    entry = tk.Entry(top, textvariable=new_barcode_var, width= 20, validate="key", validatecommand=(validation, "%P"))
    entry.pack(pady=5)

    def save_new_barcode():
        new_barcode = new_barcode_var.get()
        if new_barcode:
            if new_barcode in graph_data:
                Messagebox.show_error("Ezzel a vonalkóddal már létezik mért panel.", "Error")
                return
            
            item_values[2] = new_barcode
            tree.view.item(selected_item, values=item_values)

            for row in data_rows:
                if row[2] == current_barcode:
                    index= data_rows.index(row)
                    lst_row= list(row)
                    lst_row[2]= new_barcode
                    data_rows[index] = tuple(lst_row)
            if current_barcode in graph_data:
                graph_data[new_barcode] = graph_data.pop(current_barcode)
            # Messagebox.show_warning( f"Vonalkód megváltoztatva {new_barcode}-ra.","Siker")
            top.destroy()
            save_data()
        else:
            Messagebox.show_warning( "Kérem adjon meg egy megfelelő vonalkódot","Hiba")

    save_button = tk.Button(top, text="Mentés", command=save_new_barcode)
    save_button.pack(pady=10)

def change_box_name():
        
    current_box_name = entry_box_name.get()

    top = tk.Toplevel()
    top.title("Doboznév változtatás")

    label = tk.Label(top, text=f"Új doboznév {current_box_name} helyett:")
    label.pack(pady=10)

    new_box_name_var = tk.StringVar(value=current_box_name)
    entry = tk.Entry(top, textvariable=new_box_name_var, width= 20, validate="key", validatecommand=(validation, "%P"))
    entry.pack(pady=5)

    def save_new_barcode():
        new_boxname = new_box_name_var.get()
        if new_boxname:
            if new_boxname == current_box_name:
                Messagebox.show_error("Nem változott a doboznév.", "Error")
                return
            

            for row in data_rows:
                index= data_rows.index(row)
                lst_row= list(row)
                lst_row[1]= new_boxname
                data_rows[index] = tuple(lst_row)

            tree.build_table_data(coldata=coldata, rowdata=data_rows)
            tree.load_table_data()
            tree.view.selection_remove(tree.view.selection())
            tree.view.selection_add(tree.view.get_children()[-1])
            # Messagebox.show_warning( f"Vonalkód megváltoztatva {new_barcode}-ra.","Siker")
            entry_box_name.configure(state="normal")
            entry_box_name.delete(0, tk.END)
            entry_box_name.insert(0,new_boxname)
            entry_box_name.configure(state="readonly")

            top.destroy()
            save_data()
        else:
            Messagebox.show_warning( "Kérem adjon meg egy megfelelő vonalkódot","Hiba")

    save_button = tk.Button(top, text="Mentés", command=save_new_barcode)
    save_button.pack(pady=10)

print(r"""
  █████▒██▀███   ▒█████   ███▄ ▄███▓ ██░ ██  █    ██  ███▄    █ 
▓██   ▒▓██ ▒ ██▒▒██▒  ██▒▓██▒▀█▀ ██▒▓██░ ██▒ ██  ▓██▒ ██ ▀█   █ 
▒████ ░▓██ ░▄█ ▒▒██░  ██▒▓██    ▓██░▒██▀▀██░▓██  ▒██░▓██  ▀█ ██▒
░▓█▒  ░▒██▀▀█▄  ▒██   ██░▒██    ▒██ ░▓█ ░██ ▓▓█  ░██░▓██▒  ▐▌██▒
░▒█░   ░██▓ ▒██▒░ ████▓▒░▒██▒   ░██▒░▓█▒░██▓▒▒█████▓ ▒██░   ▓██░
 ▒ ░   ░ ▒▓ ░▒▓░░ ▒░▒░▒░ ░ ▒░   ░  ░ ▒ ░░▒░▒░▒▓▒ ▒ ▒ ░ ▒░   ▒ ▒ 
 ░       ░▒ ░ ▒░  ░ ▒ ▒░ ░  ░      ░ ▒ ░▒░ ░░░▒░ ░ ░ ░ ░░   ░ ▒░
 ░ ░     ░░   ░ ░ ░ ░ ▒  ░      ░    ░  ░░ ░ ░░░ ░ ░    ░   ░ ░ 
          ░         ░ ░         ░    ░  ░  ░   ░              ░ 
                                                                
""")

# Create an input field for the barcode
btn_calibration = ttk.Button(button_frame_1, text="Beállítások", width= 20, command=open_settings_window)
btn_calibration.pack(side=tk.LEFT, padx=10)

btn_save = ttk.Button(button_frame_1, text="Mentés Másképp", width= 20, command=save_data_as)
btn_save.pack(side=tk.LEFT, padx=10)

btn_load = ttk.Button(button_frame_1, text="Megnyitás", width= 20, command=load_data)
btn_load.pack(side=tk.LEFT, padx=10)

btn_pdf = ttk.Button(button_frame_1, text="PDF export", width= 20, command=pdf_generator)
btn_pdf.pack(side=tk.LEFT, padx=10)

panel_count = ttk.Label(button_frame_1,  text="Panelek száma: 0")
panel_count.pack(side=tk.RIGHT, padx=10)

btn_start = ttk.Button(button_frame_2, text="Mérés", width= 20, command=start_measurement)
btn_start.pack(side=tk.RIGHT, padx=10, pady=5)

entry_barcode = ttk.Entry(button_frame_2, width= 20, validate="key", validatecommand=(validation, "%P"))
entry_barcode.pack(side=tk.RIGHT, padx=10)

label_barcode = ttk.Label(button_frame_2, text="Vonalkód:")
label_barcode.pack(side=tk.RIGHT, padx=10)

entry_box_name = ttk.Entry(button_frame_2, width=20, validate="key", validatecommand=(validation, "%P"))
entry_box_name.pack(side=tk.RIGHT, padx=10)

label_box_name = ttk.Label(button_frame_2, text="Dobozcimke:")
label_box_name.pack(side=tk.RIGHT, padx=10)

btn_delete_all = ttk.Button(button_frame_2, text="Új Munkalap", width=20, command=delete_all)
btn_delete_all.pack(side=tk.LEFT, padx=10)

btn_delete = ttk.Button(button_frame_2, text="Törlés", width=20, command=delete_measurment)
btn_delete.pack(side=tk.LEFT, padx=10)

btn_barcode_change = ttk.Button(button_frame_2, text="Vonalkód változtatás", width= 20, command=change_barcode)
btn_barcode_change.pack(side=tk.LEFT, padx=10)

btn_box_name_change = ttk.Button(button_frame_2, text="Dobozcimke változtatás", width= 20, command=change_box_name)
btn_box_name_change.pack(side=tk.LEFT, padx=10)

# tree.view.bind("<Double-Button-1>", on_treeview_select)
tree.view.bind("<<TreeviewSelect>>", on_treeview_select)

window.bind("<Return>", start_measurement)
window.protocol("WM_DELETE_WINDOW", lambda:on_closing_window())

def on_closing_window():
    window.destroy
    sys.exit()

window.mainloop()
Editor is loading...
Leave a Comment