534 lines
23 KiB
Python
Executable File
534 lines
23 KiB
Python
Executable File
#!/usr/bin/env python3
|
||
"""
|
||
DPS-150 Power Supply Management Utility
|
||
Полнофункциональная утилита для управления блоком питания DPS-150
|
||
"""
|
||
|
||
import tkinter as tk
|
||
from tkinter import ttk, messagebox, scrolledtext
|
||
import serial.tools.list_ports
|
||
from matplotlib.figure import Figure
|
||
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
|
||
import matplotlib.animation as animation
|
||
from collections import deque
|
||
import threading
|
||
import time
|
||
from dps150 import DPS150
|
||
from dps150.packets.cmd import (
|
||
VOLTAGE_SET, CURRENT_SET, OUTPUT_ENABLE, OVP, OCP, OPP, OTP, LVP
|
||
)
|
||
|
||
|
||
class DPS150GUI:
|
||
def __init__(self, root):
|
||
self.root = root
|
||
self.root.title("DPS-150 Управление блоком питания")
|
||
self.root.geometry("1400x900")
|
||
|
||
self.device = None
|
||
self.connected = False
|
||
self.data = {}
|
||
|
||
# Данные для графиков (храним последние 200 точек)
|
||
self.max_points = 200
|
||
self.time_data = deque(maxlen=self.max_points)
|
||
self.voltage_data = deque(maxlen=self.max_points)
|
||
self.current_data = deque(maxlen=self.max_points)
|
||
self.power_data = deque(maxlen=self.max_points)
|
||
self.start_time = time.time()
|
||
|
||
self.setup_ui()
|
||
self.update_serial_ports()
|
||
|
||
def setup_ui(self):
|
||
"""Создание интерфейса"""
|
||
# Главный контейнер
|
||
main_frame = ttk.Frame(self.root, padding="10")
|
||
main_frame.grid(row=0, column=0, sticky=(tk.W, tk.E, tk.N, tk.S))
|
||
self.root.columnconfigure(0, weight=1)
|
||
self.root.rowconfigure(0, weight=1)
|
||
|
||
# Левая панель - управление
|
||
left_panel = ttk.Frame(main_frame)
|
||
left_panel.grid(row=0, column=0, sticky=(tk.W, tk.E, tk.N, tk.S), padx=(0, 10))
|
||
|
||
# Правая панель - графики
|
||
right_panel = ttk.Frame(main_frame)
|
||
right_panel.grid(row=0, column=1, sticky=(tk.W, tk.E, tk.N, tk.S))
|
||
|
||
main_frame.columnconfigure(1, weight=1)
|
||
main_frame.rowconfigure(0, weight=1)
|
||
|
||
self.setup_connection_panel(left_panel)
|
||
self.setup_info_panel(left_panel)
|
||
self.setup_control_panel(left_panel)
|
||
self.setup_protection_panel(left_panel)
|
||
self.setup_log_panel(left_panel)
|
||
self.setup_graphs_panel(right_panel)
|
||
|
||
def setup_connection_panel(self, parent):
|
||
"""Панель подключения"""
|
||
frame = ttk.LabelFrame(parent, text="Подключение", padding="10")
|
||
frame.grid(row=0, column=0, sticky=(tk.W, tk.E), pady=5)
|
||
|
||
ttk.Label(frame, text="COM порт:").grid(row=0, column=0, sticky=tk.W, pady=5)
|
||
self.port_var = tk.StringVar(value="/dev/ttyACM0")
|
||
port_combo = ttk.Combobox(frame, textvariable=self.port_var, width=20, state="readonly")
|
||
port_combo.grid(row=0, column=1, padx=5, pady=5)
|
||
self.port_combo = port_combo
|
||
|
||
ttk.Button(frame, text="Обновить", command=self.update_serial_ports).grid(
|
||
row=0, column=2, padx=5, pady=5
|
||
)
|
||
|
||
self.connect_btn = ttk.Button(
|
||
frame, text="Подключиться", command=self.toggle_connection
|
||
)
|
||
self.connect_btn.grid(row=1, column=0, columnspan=3, pady=10, sticky=(tk.W, tk.E))
|
||
|
||
self.status_label = ttk.Label(frame, text="Отключено", foreground="red")
|
||
self.status_label.grid(row=2, column=0, columnspan=3, pady=5)
|
||
|
||
def setup_info_panel(self, parent):
|
||
"""Панель информации об устройстве"""
|
||
frame = ttk.LabelFrame(parent, text="Информация об устройстве", padding="10")
|
||
frame.grid(row=1, column=0, sticky=(tk.W, tk.E), pady=5)
|
||
|
||
self.info_labels = {}
|
||
info_fields = [
|
||
("modelName", "Модель:"),
|
||
("hardwareVersion", "Версия железа:"),
|
||
("firmwareVersion", "Версия прошивки:"),
|
||
]
|
||
|
||
for i, (key, label) in enumerate(info_fields):
|
||
ttk.Label(frame, text=label).grid(row=i, column=0, sticky=tk.W, pady=2)
|
||
value_label = ttk.Label(frame, text="---", foreground="gray")
|
||
value_label.grid(row=i, column=1, sticky=tk.W, padx=10)
|
||
self.info_labels[key] = value_label
|
||
|
||
def setup_control_panel(self, parent):
|
||
"""Панель управления"""
|
||
frame = ttk.LabelFrame(parent, text="Управление выходом", padding="10")
|
||
frame.grid(row=2, column=0, sticky=(tk.W, tk.E), pady=5)
|
||
|
||
# Текущие значения
|
||
values_frame = ttk.Frame(frame)
|
||
values_frame.grid(row=0, column=0, columnspan=2, sticky=(tk.W, tk.E), pady=5)
|
||
|
||
self.value_labels = {}
|
||
value_fields = [
|
||
("inputVoltage", "Входное напряжение:", "V"),
|
||
("outputVoltage", "Выходное напряжение:", "V"),
|
||
("outputCurrent", "Выходной ток:", "A"),
|
||
("outputPower", "Выходная мощность:", "W"),
|
||
("temperature", "Температура:", "°C"),
|
||
("outputCapacity", "Ёмкость:", "Ah"),
|
||
("outputEnergy", "Энергия:", "Wh"),
|
||
]
|
||
|
||
for i, (key, label, unit) in enumerate(value_fields):
|
||
ttk.Label(values_frame, text=label).grid(row=i, column=0, sticky=tk.W, pady=2)
|
||
value_label = ttk.Label(
|
||
values_frame, text="---", font=("Arial", 10, "bold"), foreground="blue"
|
||
)
|
||
value_label.grid(row=i, column=1, sticky=tk.W, padx=10)
|
||
self.value_labels[key] = (value_label, unit)
|
||
|
||
# Установка значений
|
||
set_frame = ttk.Frame(frame)
|
||
set_frame.grid(row=1, column=0, columnspan=2, sticky=(tk.W, tk.E), pady=10)
|
||
|
||
ttk.Label(set_frame, text="Установить напряжение (V):").grid(
|
||
row=0, column=0, sticky=tk.W, pady=5
|
||
)
|
||
self.voltage_var = tk.StringVar(value="0.0")
|
||
voltage_entry = ttk.Entry(set_frame, textvariable=self.voltage_var, width=10)
|
||
voltage_entry.grid(row=0, column=1, padx=5, pady=5)
|
||
|
||
ttk.Button(
|
||
set_frame, text="Установить", command=self.set_voltage
|
||
).grid(row=0, column=2, padx=5, pady=5)
|
||
|
||
ttk.Label(set_frame, text="Установить ток (A):").grid(
|
||
row=1, column=0, sticky=tk.W, pady=5
|
||
)
|
||
self.current_var = tk.StringVar(value="0.0")
|
||
current_entry = ttk.Entry(set_frame, textvariable=self.current_var, width=10)
|
||
current_entry.grid(row=1, column=1, padx=5, pady=5)
|
||
|
||
ttk.Button(
|
||
set_frame, text="Установить", command=self.set_current
|
||
).grid(row=1, column=2, padx=5, pady=5)
|
||
|
||
# Кнопка включения/выключения
|
||
self.output_btn = ttk.Button(
|
||
frame, text="Включить выход", command=self.toggle_output, state="disabled"
|
||
)
|
||
self.output_btn.grid(row=2, column=0, columnspan=2, pady=10, sticky=(tk.W, tk.E))
|
||
|
||
# Режим работы
|
||
mode_frame = ttk.Frame(frame)
|
||
mode_frame.grid(row=3, column=0, columnspan=2, pady=5)
|
||
|
||
ttk.Label(mode_frame, text="Режим:").grid(row=0, column=0, sticky=tk.W)
|
||
self.mode_label = ttk.Label(
|
||
mode_frame, text="---", font=("Arial", 10, "bold"), foreground="green"
|
||
)
|
||
self.mode_label.grid(row=0, column=1, padx=10)
|
||
|
||
# Состояние защиты
|
||
ttk.Label(mode_frame, text="Защита:").grid(row=1, column=0, sticky=tk.W, pady=5)
|
||
self.protection_label = ttk.Label(
|
||
mode_frame, text="---", font=("Arial", 10, "bold"), foreground="orange"
|
||
)
|
||
self.protection_label.grid(row=1, column=1, padx=10, pady=5)
|
||
|
||
def setup_protection_panel(self, parent):
|
||
"""Панель настроек защиты"""
|
||
frame = ttk.LabelFrame(parent, text="Настройки защиты", padding="10")
|
||
frame.grid(row=3, column=0, sticky=(tk.W, tk.E), pady=5)
|
||
|
||
self.protection_vars = {}
|
||
protection_fields = [
|
||
(OVP, "overVoltageProtection", "OVP (V):"),
|
||
(OCP, "overCurrentProtection", "OCP (A):"),
|
||
(OPP, "overPowerProtection", "OPP (W):"),
|
||
(OTP, "overTemperatureProtection", "OTP (°C):"),
|
||
(LVP, "lowVoltageProtection", "LVP (V):"),
|
||
]
|
||
|
||
for i, (cmd, key, label) in enumerate(protection_fields):
|
||
ttk.Label(frame, text=label).grid(row=i, column=0, sticky=tk.W, pady=2)
|
||
var = tk.StringVar(value="0.0")
|
||
entry = ttk.Entry(frame, textvariable=var, width=10)
|
||
entry.grid(row=i, column=1, padx=5, pady=2)
|
||
|
||
def make_setter(cmd_val, var_ref=var):
|
||
return lambda: self.set_protection(cmd_val, var_ref.get())
|
||
|
||
ttk.Button(frame, text="Уст.", command=make_setter(cmd)).grid(
|
||
row=i, column=2, padx=5, pady=2
|
||
)
|
||
self.protection_vars[key] = var
|
||
|
||
def setup_log_panel(self, parent):
|
||
"""Панель логов"""
|
||
frame = ttk.LabelFrame(parent, text="Лог", padding="10")
|
||
frame.grid(row=4, column=0, sticky=(tk.W, tk.E, tk.N, tk.S), pady=5)
|
||
parent.rowconfigure(4, weight=1)
|
||
|
||
self.log_text = scrolledtext.ScrolledText(
|
||
frame, height=8, width=40, wrap=tk.WORD
|
||
)
|
||
self.log_text.grid(row=0, column=0, sticky=(tk.W, tk.E, tk.N, tk.S))
|
||
frame.columnconfigure(0, weight=1)
|
||
frame.rowconfigure(0, weight=1)
|
||
|
||
def setup_graphs_panel(self, parent):
|
||
"""Панель графиков"""
|
||
frame = ttk.Frame(parent)
|
||
frame.grid(row=0, column=0, sticky=(tk.W, tk.E, tk.N, tk.S))
|
||
parent.columnconfigure(0, weight=1)
|
||
parent.rowconfigure(0, weight=1)
|
||
|
||
# Создаём фигуру с тремя подграфиками
|
||
self.fig = Figure(figsize=(10, 8), dpi=100)
|
||
|
||
# График напряжения
|
||
self.ax_voltage = self.fig.add_subplot(311)
|
||
self.ax_voltage.set_title("Выходное напряжение", fontsize=10)
|
||
self.ax_voltage.set_ylabel("Напряжение (V)", fontsize=9)
|
||
self.ax_voltage.grid(True)
|
||
self.line_voltage, = self.ax_voltage.plot([], [], 'b-', lw=1.5, label="Напряжение")
|
||
self.ax_voltage.legend(fontsize=8)
|
||
|
||
# График тока
|
||
self.ax_current = self.fig.add_subplot(312)
|
||
self.ax_current.set_title("Выходной ток", fontsize=10)
|
||
self.ax_current.set_ylabel("Ток (A)", fontsize=9)
|
||
self.ax_current.grid(True)
|
||
self.line_current, = self.ax_current.plot([], [], 'r-', lw=1.5, label="Ток")
|
||
self.ax_current.legend(fontsize=8)
|
||
|
||
# График мощности
|
||
self.ax_power = self.fig.add_subplot(313)
|
||
self.ax_power.set_title("Выходная мощность", fontsize=10)
|
||
self.ax_power.set_xlabel("Время (сек)", fontsize=9)
|
||
self.ax_power.set_ylabel("Мощность (W)", fontsize=9)
|
||
self.ax_power.grid(True)
|
||
self.line_power, = self.ax_power.plot([], [], 'g-', lw=1.5, label="Мощность")
|
||
self.ax_power.legend(fontsize=8)
|
||
|
||
self.fig.tight_layout()
|
||
|
||
# Встраиваем в tkinter
|
||
self.canvas = FigureCanvasTkAgg(self.fig, master=frame)
|
||
self.canvas.draw()
|
||
self.canvas.get_tk_widget().pack(fill=tk.BOTH, expand=True)
|
||
|
||
# Запускаем анимацию
|
||
self.ani = animation.FuncAnimation(
|
||
self.fig, self.update_graphs, interval=200, blit=False, cache_frame_data=False
|
||
)
|
||
|
||
def log(self, message):
|
||
"""Добавить сообщение в лог"""
|
||
timestamp = time.strftime("%H:%M:%S")
|
||
self.log_text.insert(tk.END, f"[{timestamp}] {message}\n")
|
||
self.log_text.see(tk.END)
|
||
|
||
def update_serial_ports(self):
|
||
"""Обновить список доступных COM портов"""
|
||
ports = [port.device for port in serial.tools.list_ports.comports()]
|
||
if not ports:
|
||
ports = ["/dev/ttyACM0", "/dev/ttyUSB0", "COM1", "COM3"]
|
||
self.port_combo['values'] = ports
|
||
if ports and not self.port_var.get() in ports:
|
||
self.port_var.set(ports[0])
|
||
|
||
def toggle_connection(self):
|
||
"""Подключение/отключение от устройства"""
|
||
if not self.connected:
|
||
self.connect()
|
||
else:
|
||
self.disconnect()
|
||
|
||
def connect(self):
|
||
"""Подключиться к устройству"""
|
||
port = self.port_var.get()
|
||
if not port:
|
||
messagebox.showerror("Ошибка", "Выберите COM порт")
|
||
return
|
||
|
||
try:
|
||
self.log(f"Подключение к {port}...")
|
||
self.device = DPS150(port, callback=self.on_data_received)
|
||
self.device.start()
|
||
time.sleep(0.5)
|
||
self.device.get_all()
|
||
|
||
self.connected = True
|
||
self.connect_btn.config(text="Отключиться")
|
||
self.status_label.config(text="Подключено", foreground="green")
|
||
self.output_btn.config(state="normal")
|
||
self.log("Успешно подключено")
|
||
# Запускаем периодическое обновление данных
|
||
self.schedule_data_update()
|
||
|
||
except Exception as e:
|
||
messagebox.showerror("Ошибка подключения", str(e))
|
||
self.log(f"Ошибка подключения: {e}")
|
||
if self.device:
|
||
try:
|
||
self.device.stop()
|
||
except:
|
||
pass
|
||
self.device = None
|
||
|
||
def disconnect(self):
|
||
"""Отключиться от устройства"""
|
||
try:
|
||
if self.device:
|
||
if self.device._running:
|
||
self.device.disable()
|
||
self.device.stop()
|
||
self.connected = False
|
||
self.connect_btn.config(text="Подключиться")
|
||
self.status_label.config(text="Отключено", foreground="red")
|
||
self.output_btn.config(state="disabled")
|
||
self.log("Отключено")
|
||
self.device = None
|
||
# Останавливаем периодическое обновление
|
||
if hasattr(self, 'update_job'):
|
||
self.root.after_cancel(self.update_job)
|
||
except Exception as e:
|
||
self.log(f"Ошибка при отключении: {e}")
|
||
|
||
def on_data_received(self, data):
|
||
"""Обработка полученных данных от устройства"""
|
||
self.data.update(data)
|
||
self.root.after(0, self.update_ui)
|
||
|
||
def update_ui(self):
|
||
"""Обновление интерфейса на основе полученных данных"""
|
||
# Информация об устройстве
|
||
for key, label in self.info_labels.items():
|
||
value = self.data.get(key, "---")
|
||
label.config(text=str(value) if value != "---" else "---")
|
||
|
||
# Текущие значения
|
||
for key, (label, unit) in self.value_labels.items():
|
||
value = self.data.get(key)
|
||
if value is not None:
|
||
label.config(text=f"{value:.3f} {unit}")
|
||
else:
|
||
label.config(text="---")
|
||
|
||
# Режим работы
|
||
mode = self.data.get("mode", "---")
|
||
if mode != "---":
|
||
self.mode_label.config(text=mode)
|
||
|
||
# Состояние защиты
|
||
protection = self.data.get("protectionState", "---")
|
||
if protection and protection != "---":
|
||
self.protection_label.config(text=protection, foreground="red")
|
||
else:
|
||
self.protection_label.config(text="Норма", foreground="green")
|
||
|
||
# Обновление данных для графиков
|
||
current_time = time.time() - self.start_time
|
||
voltage = self.data.get("outputVoltage")
|
||
current = self.data.get("outputCurrent")
|
||
power = self.data.get("outputPower")
|
||
|
||
if voltage is not None:
|
||
self.time_data.append(current_time)
|
||
self.voltage_data.append(voltage)
|
||
self.current_data.append(current if current is not None else 0)
|
||
self.power_data.append(power if power is not None else 0)
|
||
|
||
# Обновление значений защиты в полях ввода
|
||
for key, var in self.protection_vars.items():
|
||
value = self.data.get(key)
|
||
if value is not None and not var.get():
|
||
var.set(f"{value:.2f}")
|
||
|
||
# Обновление кнопки выхода
|
||
self._update_output_button()
|
||
|
||
def update_graphs(self, frame):
|
||
"""Обновление графиков"""
|
||
if len(self.time_data) > 0:
|
||
time_list = list(self.time_data)
|
||
|
||
# Обновление графика напряжения
|
||
if len(self.voltage_data) > 0:
|
||
self.line_voltage.set_data(time_list, list(self.voltage_data))
|
||
self.ax_voltage.relim()
|
||
self.ax_voltage.autoscale_view()
|
||
|
||
# Обновление графика тока
|
||
if len(self.current_data) > 0:
|
||
self.line_current.set_data(time_list, list(self.current_data))
|
||
self.ax_current.relim()
|
||
self.ax_current.autoscale_view()
|
||
|
||
# Обновление графика мощности
|
||
if len(self.power_data) > 0:
|
||
self.line_power.set_data(time_list, list(self.power_data))
|
||
self.ax_power.relim()
|
||
self.ax_power.autoscale_view()
|
||
|
||
return [self.line_voltage, self.line_current, self.line_power]
|
||
|
||
def set_voltage(self):
|
||
"""Установить напряжение"""
|
||
if not self.connected or not self.device:
|
||
messagebox.showwarning("Предупреждение", "Сначала подключитесь к устройству")
|
||
return
|
||
|
||
try:
|
||
value = float(self.voltage_var.get())
|
||
self.device.set_float_value(VOLTAGE_SET, value)
|
||
self.log(f"Установлено напряжение: {value} V")
|
||
except ValueError:
|
||
messagebox.showerror("Ошибка", "Неверное значение напряжения")
|
||
except Exception as e:
|
||
messagebox.showerror("Ошибка", f"Не удалось установить напряжение: {e}")
|
||
self.log(f"Ошибка установки напряжения: {e}")
|
||
|
||
def set_current(self):
|
||
"""Установить ток"""
|
||
if not self.connected or not self.device:
|
||
messagebox.showwarning("Предупреждение", "Сначала подключитесь к устройству")
|
||
return
|
||
|
||
try:
|
||
value = float(self.current_var.get())
|
||
self.device.set_float_value(CURRENT_SET, value)
|
||
self.log(f"Установлен ток: {value} A")
|
||
except ValueError:
|
||
messagebox.showerror("Ошибка", "Неверное значение тока")
|
||
except Exception as e:
|
||
messagebox.showerror("Ошибка", f"Не удалось установить ток: {e}")
|
||
self.log(f"Ошибка установки тока: {e}")
|
||
|
||
def _update_output_button(self):
|
||
"""Обновить текст кнопки выхода на основе текущего состояния"""
|
||
if not self.connected:
|
||
return
|
||
|
||
output_closed = self.data.get("outputClosed", False)
|
||
if output_closed:
|
||
self.output_btn.config(text="Включить выход")
|
||
else:
|
||
self.output_btn.config(text="Выключить выход")
|
||
|
||
def toggle_output(self):
|
||
"""Включить/выключить выход"""
|
||
if not self.connected or not self.device:
|
||
return
|
||
|
||
try:
|
||
output_closed = self.data.get("outputClosed", False)
|
||
if output_closed:
|
||
self.device.enable()
|
||
self.log("Выход включен")
|
||
else:
|
||
self.device.disable()
|
||
self.log("Выход выключен")
|
||
# Обновление произойдёт при следующем получении данных
|
||
except Exception as e:
|
||
messagebox.showerror("Ошибка", f"Не удалось изменить состояние выхода: {e}")
|
||
self.log(f"Ошибка изменения состояния выхода: {e}")
|
||
|
||
def set_protection(self, cmd, value_str):
|
||
"""Установить значение защиты"""
|
||
if not self.connected or not self.device:
|
||
messagebox.showwarning("Предупреждение", "Сначала подключитесь к устройству")
|
||
return
|
||
|
||
try:
|
||
value = float(value_str)
|
||
self.device.set_float_value(cmd, value)
|
||
protection_names = {
|
||
OVP: "OVP", OCP: "OCP", OPP: "OPP", OTP: "OTP", LVP: "LVP"
|
||
}
|
||
name = protection_names.get(cmd, "Защита")
|
||
self.log(f"Установлена {name}: {value}")
|
||
except ValueError:
|
||
messagebox.showerror("Ошибка", "Неверное значение")
|
||
except Exception as e:
|
||
messagebox.showerror("Ошибка", f"Не удалось установить защиту: {e}")
|
||
self.log(f"Ошибка установки защиты: {e}")
|
||
|
||
def schedule_data_update(self):
|
||
"""Планировать периодическое обновление данных"""
|
||
if self.connected and self.device:
|
||
try:
|
||
self.device.get_all()
|
||
except:
|
||
pass
|
||
if self.connected:
|
||
self.update_job = self.root.after(1000, self.schedule_data_update) # Обновление каждую секунду
|
||
|
||
def on_closing(self):
|
||
"""Обработка закрытия окна"""
|
||
if self.connected:
|
||
self.disconnect()
|
||
self.root.destroy()
|
||
|
||
|
||
def main():
|
||
root = tk.Tk()
|
||
app = DPS150GUI(root)
|
||
root.protocol("WM_DELETE_WINDOW", app.on_closing)
|
||
root.mainloop()
|
||
|
||
|
||
if __name__ == "__main__":
|
||
main()
|
||
|