Untitled
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