Merge origin/ump-v4 into main
Combine Flash CAN updates, signal processing and HOPE pin fixes with current Modbus/GAS, STM32 ports and CCS release exports. Resolve protocol, documentation and Qt conflicts; deduplicate Android JNI sources and include gauge/IGBT sources in host builds.
This commit is contained in:
@@ -2,27 +2,40 @@
|
||||
from datetime import datetime
|
||||
from pathlib import Path
|
||||
|
||||
from PySide6.QtCore import QTimer
|
||||
from PySide6.QtCore import QTimer, Signal # Таймер обновляет буфер, а общий сигнал сообщает владельцу об изменении любых настроек расшифровки.
|
||||
from PySide6.QtWidgets import (QWidget, QHBoxLayout, QVBoxLayout, QPushButton,
|
||||
QCheckBox, QComboBox, QLabel, QLineEdit, QTableWidget, QTableWidgetItem,
|
||||
QMessageBox, QApplication, QAbstractItemView, QFileDialog)
|
||||
from ..can_transport import build_frame
|
||||
from ..can_monitor import CanSession, PROTOCOLS, parse_filter, format_data, decode_protocol
|
||||
from ..can_monitor import CanSession, PROTOCOLS, UMP_MAPS, parse_filter, parse_gas_filter, matches_filters, format_data, decode_protocol # Общие декодер, карты и независимые фильтры обеспечивают одинаковое поведение всех CAN-мониторов.
|
||||
|
||||
|
||||
class MonitorControls(QWidget):
|
||||
decoding_changed = Signal() # Владельцы обновляют онлайн и трассировку при смене формата, карты адресов или номера УМП.
|
||||
|
||||
def __init__(self, owner, directory, default="auto"):
|
||||
super().__init__(owner)
|
||||
self.owner = owner
|
||||
self.directory = directory
|
||||
self.session = CanSession()
|
||||
self._dirty = False
|
||||
layout = QHBoxLayout(self)
|
||||
self._pending_frames = {} # Упорядоченные ключи объединяют повторы между тактами таймера и сохраняют порядок первого поступления новых кадров.
|
||||
self._history_rows = {} # Ключ уникального кадра указывает на строку и последний показанный счётчик, исключая поиск по всей таблице.
|
||||
self._history_total = 0 # Сумма показанных повторов обновляется по разнице счётчиков, без перебора накопленной истории.
|
||||
self._history_needs_reset = False # Частичная ошибка записи требует однократной сверки таблицы с фактически сохранённой сессией.
|
||||
controls_layout = QVBoxLayout(self) # Отдельная строка параметров УМП сохраняет компактную ширину основной панели монитора.
|
||||
controls_layout.setContentsMargins(0, 0, 0, 0) # Панель встраивается в существующую вкладку без дополнительных внешних отступов.
|
||||
layout = QHBoxLayout() # Основные кнопки остаются в прежнем горизонтальном порядке над параметрами УМП.
|
||||
controls_layout.addLayout(layout) # Общие элементы занимают первую строку вертикального контейнера.
|
||||
layout.setContentsMargins(0, 0, 0, 0)
|
||||
self.protocol = QComboBox()
|
||||
for key, label in PROTOCOLS:
|
||||
self.protocol.addItem(label, key)
|
||||
self.protocol.setCurrentIndex(self.protocol.findData(default))
|
||||
self.protocol.setMinimumContentsLength(28)
|
||||
self.protocol.setSizeAdjustPolicy(QComboBox.SizeAdjustPolicy.AdjustToContents)
|
||||
self.protocol.setToolTip("Выберите формат CAN. Для УМП / ProtoCAN GAS карта адресов и устройство выбираются отдельно.") # Подсказка объясняет разделение протокола и прикладного профиля.
|
||||
legacy_ump = default in ("ump1_gas167", "ump2_gas167", "ump_gas") # Старые значения исходного профиля поддерживаются без возврата дублирующихся пунктов в список.
|
||||
self.protocol.setCurrentIndex(self.protocol.findData("ump_protocan" if legacy_ump else default)) # Прежние профили УМП открывают единый формат с отдельно восстановленными параметрами.
|
||||
layout.addWidget(QLabel("Протокол"))
|
||||
layout.addWidget(self.protocol)
|
||||
self.raw = QCheckBox("Без парса")
|
||||
@@ -51,15 +64,52 @@ class MonitorControls(QWidget):
|
||||
self.status = QLabel("Буфер: 0")
|
||||
layout.addWidget(self.status)
|
||||
layout.addStretch(1)
|
||||
self.ump_options = QWidget() # Контейнер дополнительных параметров показывается только для формата УМП / ProtoCAN GAS.
|
||||
ump_layout = QHBoxLayout(self.ump_options) # Карта и номер УМП расположены рядом на второй строке панели.
|
||||
ump_layout.setContentsMargins(0, 0, 0, 0) # Вложенная строка выравнивается с основными элементами монитора.
|
||||
ump_layout.addWidget(QLabel("Карта адресов")) # Подпись отличает нумерацию регистров от формата CAN-кадра.
|
||||
self.ump_map = QComboBox() # Выбор карты определяет словарь параметров при неизменном формате ProtoCAN.
|
||||
for key, label in UMP_MAPS: # Оба монитора используют единый каталог действующей и планируемой карт.
|
||||
self.ump_map.addItem(label, key) # Пользователь видит статус карты, а декодер получает устойчивый ключ профиля.
|
||||
self.ump_map.setToolTip("167/v1: слова 0…127 и 0x5000…0x507F. Новые десятичные ID 5000…5127 и 6000…6127 назначены, но ещё не перенесены в прошивку; устройство определяется по ID.") # Подсказка указывает диапазоны обеих карт и состояние планируемой адресации.
|
||||
self.ump_map.setCurrentIndex(self.ump_map.findData("assigned" if default == "ump_gas" else "gas167")) # Прежний профиль новых ID восстанавливает сквозную карту, остальные начинают с текущей.
|
||||
ump_layout.addWidget(self.ump_map) # Карта выбирается независимо от списка форматов CAN.
|
||||
self.ump_node_label = QLabel("Устройство") # Номер УМП относится к устройству, а не к отдельному протоколу.
|
||||
ump_layout.addWidget(self.ump_node_label) # Подпись находится перед селектором номера УМП.
|
||||
self.ump_node = QComboBox() # Текущая локальная карта требует ручного назначения УМП 1 или УМП 2.
|
||||
self.ump_node.addItem("УМП 1", 1) # Число 1 обозначает первый УМП и передаётся декодеру как номер устройства.
|
||||
self.ump_node.addItem("УМП 2", 2) # Число 2 обозначает второй УМП; карта регистров остаётся общей для обоих приборов.
|
||||
self.ump_node.setCurrentIndex(self.ump_node.findData(2 if default == "ump2_gas167" else 1)) # Старый профиль второго УМП сохраняет выбранный прибор, остальные используют первый.
|
||||
self.ump_node.setToolTip("Номер УМП для карты 167/v1 задаётся вручную. В новой карте устройство определяется по GAS ID.") # Подсказка объясняет, почему ручной выбор скрывается для сквозных ID.
|
||||
ump_layout.addWidget(self.ump_node) # Устройство занимает собственное поле после карты адресов.
|
||||
ump_layout.addStretch(1) # Свободное место справа удерживает дополнительные поля у левого края панели.
|
||||
controls_layout.addWidget(self.ump_options) # Параметры УМП добавляются под основной строкой без расширения списка протоколов.
|
||||
self._update_ump_options() # Исходный формат определяет видимость дополнительной строки до первого показа вкладки.
|
||||
self.timer = QTimer(self)
|
||||
self.timer.setInterval(250)
|
||||
self.timer.timeout.connect(self.refresh)
|
||||
self.timer.start()
|
||||
QApplication.instance().aboutToQuit.connect(self.session.close)
|
||||
self.destroyed.connect(lambda: self.session.close())
|
||||
self.protocol.currentIndexChanged.connect(lambda *_: self.refilter())
|
||||
self.protocol.currentIndexChanged.connect(self._change_protocol) # Смена формата обновляет параметры УМП и все представления принятых кадров.
|
||||
self.ump_map.currentIndexChanged.connect(self._change_protocol) # Смена карты перерасшифровывает буфер и обновляет необходимость ручного номера устройства.
|
||||
self.ump_node.currentIndexChanged.connect(self._change_protocol) # Смена устройства применяется к уже принятым кадрам текущей локальной карты.
|
||||
self.raw.toggled.connect(lambda *_: self.refilter())
|
||||
|
||||
def _update_ump_options(self): # Видимость дополнительных полей зависит от формата и способности карты определить устройство по адресу.
|
||||
self.ump_options.setVisible(self.protocol.currentData() == "ump_protocan") # Остальные форматы обходятся без настроек карты УМП.
|
||||
manual_node = self.ump_map.currentData() == "gas167" # Только действующая локальная карта требует вручную выбранного номера УМП.
|
||||
self.ump_node_label.setVisible(manual_node) # Подпись устройства скрывается вместе с ненужным ручным селектором новой карты.
|
||||
self.ump_node.setVisible(manual_node) # Сквозные ID сами задают УМП, поэтому ручной номер не должен противоречить адресу кадра.
|
||||
|
||||
def _change_protocol(self, *_args): # Сигналы трёх селекторов используют общий путь обновления, не зависящий от индекса изменённого поля.
|
||||
self._update_ump_options() # Сначала интерфейс показывает только применимые к выбранному формату параметры.
|
||||
self.refilter() # Таблица уникальных кадров сразу получает расшифровку с новой картой и устройством.
|
||||
self.decoding_changed.emit() # Владелец обновляет онлайн, трассировку и сведения о ранее принятых кадрах.
|
||||
|
||||
def decode(self, frame): # Все таблицы монитора разбирают кадры с одним набором выбранных параметров.
|
||||
return decode_protocol(frame, self.protocol.currentData(), ump_map=self.ump_map.currentData(), ump_node=self.ump_node.currentData()) # Формат, карта и номер УМП передаются независимо, исключая расхождение онлайн и буфера.
|
||||
|
||||
def format_data(self, data):
|
||||
return format_data(data, self.data_format.isChecked())
|
||||
|
||||
@@ -73,13 +123,28 @@ class MonitorControls(QWidget):
|
||||
layout = QVBoxLayout(panel)
|
||||
layout.setContentsMargins(0, 0, 0, 0)
|
||||
row = QHBoxLayout()
|
||||
row.addWidget(QLabel("Фильтр ID (hex)"))
|
||||
self.filter_enabled = QCheckBox("Фильтр CAN ID (hex)") # Первый флажок управляет существующим отбором по идентификатору кадра.
|
||||
self.filter_enabled.setChecked(True) # Сохраняем прежнее поведение: ввод CAN ID сразу фильтрует нижнюю таблицу.
|
||||
row.addWidget(self.filter_enabled) # Флажок занимает место прежней подписи фильтра.
|
||||
self.filter = QLineEdit()
|
||||
self.filter.setPlaceholderText("701 или 0x701, 201")
|
||||
self.filter.setToolTip("Фильтр только нижней таблицы; сверху отображаются все ID")
|
||||
self.filter.setToolTip("CAN ID в HEX. Оба включённых фильтра работают по И; фильтруется только нижняя таблица, сверху остаются все кадры.") # Поясняем совместный отбор и сохраняем независимость основных таблиц.
|
||||
self.filter.setClearButtonEnabled(True)
|
||||
self.filter.textChanged.connect(self.refilter)
|
||||
row.addWidget(self.filter)
|
||||
self.gas_filter_enabled = QCheckBox("Фильтр GAS (dec / 0xHEX)") # Второй флажок позволяет включить адреса GAS отдельно или совместно с CAN ID.
|
||||
row.addWidget(self.gas_filter_enabled) # Размещаем новый критерий в той же строке рядом с существующим фильтром.
|
||||
self.gas_filter = QLineEdit() # Поле содержит список адресов слов GAS, независимо от списка идентификаторов кадров.
|
||||
self.gas_filter.setPlaceholderText("5000, 5127 или 0x5000") # Примеры различают десятичные назначенные ID и шестнадцатеричное локальное окно.
|
||||
self.gas_filter.setToolTip("GAS ID: DEC либо HEX с 0x, через запятую. Учитываются все слова кадра. При включённых обоих фильтрах должны совпасть и CAN ID, и GAS ID.") # Объясняем формат и поиск адреса внутри многословной посылки.
|
||||
self.gas_filter.setClearButtonEnabled(True) # Очистка временно убирает GAS-условие без изменения флажка CAN ID.
|
||||
self.gas_filter.setEnabled(False) # Новый фильтр включается пользователем явно и не меняет прежний начальный экран.
|
||||
self.gas_filter.textChanged.connect(self.refilter) # Изменение списка сразу пересчитывает строки и счётчики сохранённого буфера.
|
||||
self.filter_enabled.toggled.connect(self.filter.setEnabled) # Выключенный CAN-критерий сохраняет введённый текст для повторного включения.
|
||||
self.filter_enabled.toggled.connect(self.refilter) # Снятие флажка сразу убирает ограничение CAN ID.
|
||||
self.gas_filter_enabled.toggled.connect(self.gas_filter.setEnabled) # Состояние поля показывает, применяется ли GAS-условие.
|
||||
self.gas_filter_enabled.toggled.connect(self.refilter) # Каждый флажок независимо пересчитывает пересечение двух критериев.
|
||||
row.addWidget(self.gas_filter) # Поле GAS расположено перед общим счётчиком совпавших кадров.
|
||||
self.count = QLabel("Кадров: 0")
|
||||
row.addWidget(self.count)
|
||||
layout.addLayout(row)
|
||||
@@ -100,8 +165,10 @@ class MonitorControls(QWidget):
|
||||
|
||||
def ingest(self, identifier, data, extended, rtr=False, source="CAN", timestamp=None):
|
||||
try:
|
||||
self.session.append(identifier, data, extended, rtr, source, timestamp)
|
||||
key = self.session.append(identifier, data, extended, rtr, source, timestamp) # Сессия возвращает точную идентичность кадра с учётом канала, STD/EXT, RTR и данных.
|
||||
self._pending_frames[key] = None # Один ключ объединяет любое число повторов до следующего обновления экрана.
|
||||
except OSError as exc:
|
||||
self._history_needs_reset = True # Ошибка могла возникнуть после изменения буфера, поэтому следующий такт заново сверит все строки.
|
||||
self.status.setText("Ошибка записи: " + str(exc))
|
||||
self.session.stop()
|
||||
self.record.setText("● Запись")
|
||||
@@ -153,46 +220,68 @@ class MonitorControls(QWidget):
|
||||
if not self.owner._paused and self._dirty:
|
||||
self._dirty = False
|
||||
self.status.setText("Буфер: %d" % sum(self.session.counts.values()))
|
||||
self.refilter()
|
||||
self._update_history(self._history_needs_reset) # Обычный такт обрабатывает лишь новые данные; полная сверка нужна только после ошибки записи.
|
||||
|
||||
def refilter(self):
|
||||
if not hasattr(self, "filter"):
|
||||
return
|
||||
try:
|
||||
ids = parse_filter(self.filter.text())
|
||||
except ValueError as exc:
|
||||
self.count.setText(str(exc))
|
||||
ids = set()
|
||||
else:
|
||||
count = sum(value for key, value in self.session.counts.items()
|
||||
if ids is None or key in ids)
|
||||
unique_count = sum(1 for values, _ in self.session.unique_frames.values()
|
||||
if ids is None or int(values[3], 16) in ids)
|
||||
self.count.setText("Кадров: %d; уникальных: %d" % (count, unique_count))
|
||||
self.history.horizontalHeaderItem(7).setText(
|
||||
"Данные (DEC)" if self.data_format.isChecked() else "Данные (HEX)")
|
||||
self.history.setColumnHidden(8, self.raw.isChecked())
|
||||
self.history.setVisible(ids is not None)
|
||||
if ids is None:
|
||||
self.history.setRowCount(0)
|
||||
return
|
||||
frames = [(values, count) for values, count in self.session.unique_frames.values()
|
||||
if int(values[3], 16) in ids]
|
||||
self.history.setRowCount(len(frames))
|
||||
for row, (values, count) in enumerate(frames):
|
||||
data = bytes.fromhex(values[6])
|
||||
summary = ""
|
||||
if not self.raw.isChecked():
|
||||
frame = build_frame(int(values[3], 16), data,
|
||||
ide=values[2] == "EXT", rtr=bool(values[4]),
|
||||
to_can=values[1] == "TX")
|
||||
summary = decode_protocol(frame, self.protocol.currentData()).summary
|
||||
display = values[:6] + (count, self.format_data(data), summary)
|
||||
for column, value in enumerate(display):
|
||||
item = self.history.item(row, column)
|
||||
if item is None:
|
||||
self.history.setItem(row, column, QTableWidgetItem(str(value)))
|
||||
elif item.text() != str(value):
|
||||
item.setText(str(value))
|
||||
if column == 8:
|
||||
self.history.item(row, column).setToolTip(summary)
|
||||
def refilter(self): # Изменение фильтра, протокола или формата требует однократного пересчёта существующих строк.
|
||||
self._update_history(True) # Полная перестройка применяется только по явному изменению настроек либо сбросу буфера.
|
||||
|
||||
def _update_history(self, rebuild): # Таймер и настройки используют один путь отбора, но разный объём входных записей.
|
||||
if not hasattr(self, "filter"): # При сборке панели сигналы могут прийти до создания нижней таблицы.
|
||||
return # Отложим отображение до завершения построения элементов интерфейса.
|
||||
error = None # Ошибка активного фильтра заменяет счётчики понятным сообщением и очищает выборку.
|
||||
try: # Разбор коротких условий выполняется одинаково для полного и добавочного обновления.
|
||||
ids = parse_filter(self.filter.text()) if self.filter_enabled.isChecked() else None # Текст выключенного CAN-фильтра не влияет на выборку и не вызывает ошибок ввода.
|
||||
gas_ids = parse_gas_filter(self.gas_filter.text()) if self.gas_filter_enabled.isChecked() else None # Независимо разбираем только включённое условие адресов GAS.
|
||||
except ValueError as exc: # Неверный ввод не должен оставлять на экране строки от прежнего корректного фильтра.
|
||||
error = str(exc) # Сохраняем объяснение для итоговой подписи после очистки строк.
|
||||
ids, gas_ids = set(), None # Пустое множество CAN ID даёт пустую видимую выборку.
|
||||
filtered = ids is not None or gas_ids is not None # Нижняя таблица нужна лишь при наличии хотя бы одного непустого условия.
|
||||
self.history.horizontalHeaderItem(7).setText("Данные (DEC)" if self.data_format.isChecked() else "Данные (HEX)") # Заголовок соответствует выбранному представлению байтов.
|
||||
self.history.setColumnHidden(8, self.raw.isChecked()) # Сырой режим скрывает расшифровку независимо от способа обновления.
|
||||
self.history.setVisible(filtered) # Без ограничений сохраняем компактный вид основной таблицы.
|
||||
updates = self.history.updatesEnabled() # Запоминаем исходный режим отрисовки, чтобы не включать её вопреки владельцу.
|
||||
self.history.setUpdatesEnabled(False) # Пачка изменений не должна вызывать промежуточную перерисовку и перерасчёт геометрии.
|
||||
blocked = self.history.blockSignals(True) # Программное заполнение не должно вызывать обработчики отдельных изменённых ячеек.
|
||||
try: # Восстановление состояния Qt гарантируется также при ошибке декодирования.
|
||||
if rebuild or not filtered or error is not None: # Смена условий и недопустимый ввод отменяют прежнее соответствие ключей строкам.
|
||||
self.history.setRowCount(0) # Полная очистка выполняется по настройке, а не каждые 250 мс при приёме.
|
||||
self._history_rows.clear() # Индексы строк больше не относятся к новой выборке.
|
||||
self._history_total = 0 # Сумма повторов пересчитывается для нового набора подходящих кадров.
|
||||
if filtered and error is None: # Скрытая таблица и некорректные условия не требуют фильтрации или декодирования истории.
|
||||
keys = self.session.unique_frames if rebuild else self._pending_frames # Только явная перестройка перебирает всю сессию; таймер берёт изменённые ключи.
|
||||
for key in keys: # Словари сохраняют порядок первого появления уникальных кадров, даже если между ними пришли повторы.
|
||||
values, count = self.session.unique_frames[key] # Получаем последние время и счётчик с учётом всех повторов в текущей пачке.
|
||||
previous = self._history_rows.get(key) # Уже показанный кадр прошёл неизменные фильтры и не нуждается в повторной расшифровке.
|
||||
if previous is not None: # У повторов меняются только время последнего приёма и число физических кадров.
|
||||
row, old_count = previous # Сохраняем прежнюю сумму, чтобы добавить только новые приёмы.
|
||||
display = ((0, values[0]), (6, count)) # Колонки 0 и 6 содержат время и счётчик, остальные данные идентичны по ключу.
|
||||
else: # Новый ключ необходимо проверить по обоим активным условиям.
|
||||
data = bytes.fromhex(values[6]) # Данные нужны для GAS-отбора и однократной расшифровки новой строки.
|
||||
if not matches_filters(int(values[3], 16), data, values[2] == "EXT", bool(values[4]), can_ids=ids, gas_ids=gas_ids): # Проверяем пересечение CAN/GAS с учётом формата и RTR.
|
||||
continue # Неподходящий кадр остаётся в полной сессии для сохранения и последующей смены фильтров.
|
||||
row, old_count = self.history.rowCount(), 0 # Новая уникальная посылка добавляется в конец с её полным счётчиком с начала сессии.
|
||||
self.history.insertRow(row) # Существующие строки и выделение не пересоздаются при поступлении новой посылки.
|
||||
summary = "" # В режиме без парса не вызываем декодер даже при первом отображении кадра.
|
||||
if not self.raw.isChecked(): # Расшифровка вычисляется только для новой строки либо при явной перестройке настроек.
|
||||
frame = build_frame(int(values[3], 16), data, ide=values[2] == "EXT", rtr=bool(values[4]), to_can=values[1] == "TX") # Восстанавливаем исходную метаинформацию сохранённой посылки.
|
||||
summary = self.decode(frame).summary # Используем выбранные протокол, карту адресов и номер устройства.
|
||||
display = enumerate(values[:6] + (count, self.format_data(data), summary)) # Новая строка заполняется целиком в порядке заголовков таблицы.
|
||||
for column, value in display: # У повторов этот цикл касается двух ячеек вместо всей накопленной таблицы.
|
||||
item = self.history.item(row, column) # Повторно используем существующий объект ячейки для сохранения выделения.
|
||||
if item is None: # Ячейки создаются только при добавлении новой уникальной посылки.
|
||||
item = QTableWidgetItem() # Пустой объект получает текст общим путём ниже.
|
||||
self.history.setItem(row, column, item) # Таблица принимает владение созданной ячейкой.
|
||||
if item.text() != str(value): # Не уведомляем модель Qt о фактически неизменившемся значении.
|
||||
item.setText(str(value)) # Преобразование сохраняет прежнее отображение чисел и меток времени.
|
||||
if column == 8: # Последний столбец содержит длинную расшифровку, которую удобно читать в подсказке.
|
||||
item.setToolTip(str(value)) # Подсказка обновляется вместе с новой расшифровкой при смене настроек.
|
||||
self._history_rows[key] = (row, count) # Запоминаем актуальные индекс и показанный счётчик для следующей пачки повторов.
|
||||
self._history_total += count - old_count # Добавляем только новые физические приёмы без суммирования всей истории.
|
||||
self._pending_frames.clear() # Все поступившие ключи учтены либо скрыты неизменными фильтрами.
|
||||
self._history_needs_reset = False # Сверка после ошибки успешно завершена и больше не требует полного обхода.
|
||||
total = self._history_total if filtered else sum(self.session.counts.values()) # Без фильтра подпись относится ко всей сессии, хотя сама таблица скрыта.
|
||||
unique = len(self._history_rows) if filtered else len(self.session.unique_frames) # Число уникальных кадров берём из готового индекса без повторного отбора.
|
||||
self.count.setText(error if error is not None else "Кадров: %d; уникальных: %d" % (total, unique)) # При ошибке оставляем причину, иначе показываем согласованные счётчики выборки.
|
||||
finally: # Любой выход должен вернуть исходное поведение сигналов и перерисовки Qt.
|
||||
self.history.blockSignals(blocked) # Восстанавливаем состояние, установленное владельцем до обновления.
|
||||
self.history.setUpdatesEnabled(updates) # Готовая пачка отображается за одно обновление виджета.
|
||||
|
||||
File diff suppressed because one or more lines are too long
@@ -0,0 +1,33 @@
|
||||
"""Необязательные известные элементы последовательного эквивалента RLC.""" # Ввод не смешивает номиналы реального RC-снаббера с параметрами идентифицируемых полюсов.
|
||||
try: # Поддерживаем современные и совместимые Windows-сборки.
|
||||
from PySide6.QtCore import Signal # Одно изменение любого элемента делает старый подбор моделей неактуальным.
|
||||
from PySide6.QtWidgets import QDoubleSpinBox, QHBoxLayout, QLabel, QWidget # Используем стандартные числовые поля Qt6.
|
||||
except ImportError: # Qt5 получает тот же интерфейс без дополнительных зависимостей.
|
||||
from PySide2.QtCore import Signal # Контракт сигналов одинаков на Windows 7 и новых системах.
|
||||
from PySide2.QtWidgets import QDoubleSpinBox, QHBoxLayout, QLabel, QWidget # Набор полей и единицы не зависят от версии Qt.
|
||||
|
||||
|
||||
class CircuitParameters(QWidget): # Компонент можно встроить в подробные параметры любого вида сравнения.
|
||||
changed = Signal() # Владелец решает, запускать ли автоматический пересчёт или ожидать кнопку.
|
||||
|
||||
def __init__(self, parent=None): # По умолчанию ни один электрический элемент не предполагается известным.
|
||||
super().__init__(parent) # Жизненным циклом компонента управляет родительская панель сравнения.
|
||||
row = QHBoxLayout(self) # Три поля и пояснение занимают одну строку.
|
||||
row.setContentsMargins(0, 0, 0, 0) # Сохраняем существующие отступы формы.
|
||||
row.addWidget(QLabel('Эквивалентный последовательный RLC:')) # Явно называем топологию, к которой относятся формулы R/L и LC.
|
||||
self.inductance, self.capacitance, self.resistance = QDoubleSpinBox(), QDoubleSpinBox(), QDoubleSpinBox() # Отдельное неизвестное значение разрешено у каждого элемента.
|
||||
self.controls = (self.inductance, self.capacitance, self.resistance) # Общий список позволяет блокировать ввод во время рабочего задания.
|
||||
for title, box, suffix in (('L', self.inductance, ' нГн'), ('C', self.capacitance, ' нФ'), ('R', self.resistance, ' Ом')): # Удобные единицы соответствуют обычным масштабам коммутационного контура.
|
||||
row.addWidget(QLabel(title)) # Подпись отделяет физическую величину от единицы в поле.
|
||||
box.setDecimals(6) # Дробные нГн, нФ и Ом сохраняются без грубого округления.
|
||||
box.setRange(0., 1e12) # Ноль означает неизвестное значение; отрицательные пассивные элементы не допускаются.
|
||||
box.setSpecialValueText('неизвестно') # Не скрываем отсутствие исходных электрических данных за произвольным номиналом.
|
||||
box.setSuffix(suffix) # Единица видна при вводе любого положительного значения.
|
||||
box.setMaximumWidth(170) # Ширина в логических пикселях оставляет место всем трём элементам.
|
||||
box.setToolTip('Введите известный элемент последовательного эквивалента. Ноль — неизвестно. Это не автоматическая модель топологии RC-снаббера.') # Объяснение предотвращает неверную интерпретацию восстановленных номиналов.
|
||||
box.valueChanged.connect(lambda _value: self.changed.emit()) # Любое изменение требует нового численного подбора и отчёта.
|
||||
row.addWidget(box) # Поля располагаются в порядке L, C и R.
|
||||
row.addStretch(1) # Свободная ширина не растягивает числовые поля.
|
||||
|
||||
def values(self): # Снимок значений фиксируется до запуска фоновой идентификации.
|
||||
return dict(inductance_h=self.inductance.value() * 1e-9, capacitance_f=self.capacitance.value() * 1e-9, resistance_ohm=self.resistance.value()) # нГн и нФ переводятся в СИ; Ом уже соответствует внутренним формулам.
|
||||
@@ -2,6 +2,8 @@
|
||||
from collections import deque # Кольцевая история ограничивает память при непрерывном обмене.
|
||||
from html import escape # Текст устройства не должен становиться HTML-разметкой журнала.
|
||||
from pathlib import Path # Экспорт сохраняет явно выбранный пользователем файл в UTF-8.
|
||||
import csv # Стандартный CSV корректно экранирует кавычки, разделители и пустые строки журнала.
|
||||
import json # JSON сохраняет строки с кириллицей без потери символов и дополнительного разбора протоколов.
|
||||
import re # Метки направления извлекаются только из начала строки после необязательного времени.
|
||||
try: # Поддерживаем актуальный Qt и существующие установки на Python для Windows 7.
|
||||
from PySide6.QtCore import QTimer, Signal # Таймер объединяет обновления заполненного журнала.
|
||||
@@ -48,12 +50,12 @@ class ConsoleView(QPlainTextEdit): # Наследование сохраняе
|
||||
self.search = QLineEdit() # Фильтр работает по обычному тексту всех сохранённых строк.
|
||||
self.search.setPlaceholderText("Поиск / фильтр текста") # Подпись показывает, что скрытые строки остаются в истории.
|
||||
filters.addWidget(self.search, 1) # Поле поиска получает свободную ширину консоли.
|
||||
self.show_tx, self.show_rx = QCheckBox("TX"), QCheckBox("RX") # Служебные сообщения не относятся ни к одному направлению.
|
||||
self.show_tx, self.show_rx = QCheckBox("TX", self.panel), QCheckBox("RX", self.panel) # Родитель назначается до setVisible, чтобы фильтры направлений не появлялись отдельными окнами при сборке консоли.
|
||||
for control in (self.show_tx, self.show_rx): # Оба фильтра действуют независимо и применяются к истории.
|
||||
control.setChecked(True) # Первое открытие показывает весь обмен.
|
||||
control.setVisible(directions) # Потребители со своими фильтрами могут скрыть дублирующие элементы.
|
||||
filters.addWidget(control) # Направления расположены рядом с текстовым фильтром.
|
||||
self.display = QComboBox() # Формат байтов относится только к сообщениям с явно переданным payload.
|
||||
self.display = QComboBox(self.panel) # Родитель исключает отдельное окно при setVisible(payloads); формат относится только к сообщениям с явно переданными байтами.
|
||||
self.display.addItems(("Как получено", "HEX", "ASCII", "HEX + ASCII")) # Обычный текст и ответы устройства не перекодируются.
|
||||
self.display.setToolTip("HEX/ASCII применяется к байтам, переданным через append_message(payload=…).") # Приложение явно определяет границы полезной нагрузки.
|
||||
self.display.setVisible(payloads) # Выбор байтового представления показывается только потребителю с явным payload.
|
||||
@@ -103,7 +105,6 @@ class ConsoleView(QPlainTextEdit): # Наследование сохраняе
|
||||
def setPlainText(self, text): # Снимок внешней истории полностью заменяет данные этого представления.
|
||||
self.timer.stop() # Старое отложенное обновление не должно вернуть предыдущий снимок.
|
||||
self.records.clear() # Сохраняется только актуальный результат форматирования потребителя.
|
||||
if not self.pause.isChecked(): super().clear() # При паузе прежний экран сохраняется до возобновления.
|
||||
if text: self.append_message(text, _defer=True) # Пустой снимок не создаёт фиктивную запись.
|
||||
self.refresh() # Поиск и фильтры применяются к новому снимку целиком.
|
||||
|
||||
@@ -124,6 +125,7 @@ class ConsoleView(QPlainTextEdit): # Наследование сохраняе
|
||||
def _append_record(self, record): # Добавляем одну подготовленную запись, учитывая формат и положение прокрутки.
|
||||
text, html, _role, payload = record # Байты присутствуют только при явной передаче payload приложением.
|
||||
bar, position = self.verticalScrollBar(), self.verticalScrollBar().value() # Запоминаем позицию до изменения размера документа.
|
||||
horizontal, offset = self.horizontalScrollBar(), self.horizontalScrollBar().value() # Автопрокрутка по вертикали не должна сбрасывать просмотр длинной строки по горизонтали.
|
||||
mode = self.display.currentIndex() # Нулевой режим сохраняет текст и цвета, заданные потребителем.
|
||||
if payload is not None and mode: # Формат меняет только подписанную приложением полезную нагрузку.
|
||||
hexadecimal = payload.hex(" ").upper() # HEX показывает каждый исходный байт двумя цифрами.
|
||||
@@ -132,25 +134,47 @@ class ConsoleView(QPlainTextEdit): # Наследование сохраняе
|
||||
elif html: super().appendHtml(html) # Сохраняем безопасное оформление или прежний фрагмент приложения.
|
||||
else: super().appendPlainText(text) # Обычный текст не интерпретируется как HTML.
|
||||
bar.setValue(bar.maximum() if self.follow.isChecked() else position) # Отключённая автопрокрутка сохраняет место чтения.
|
||||
horizontal.setValue(offset) # Дописывание строки сохраняет выбранный горизонтальный участок журнала.
|
||||
|
||||
def refresh(self, *_args): # Сигналы Qt могут передавать индекс, флаг или текст.
|
||||
self.timer.stop() # Немедленное обновление заменяет ожидающее пакетное перестроение.
|
||||
if self.pause.isChecked(): return # Изменения фильтров во время паузы применятся после её снятия.
|
||||
bar, position = self.verticalScrollBar(), self.verticalScrollBar().value() # Сохраняем место чтения до очистки документа.
|
||||
horizontal, offset = self.horizontalScrollBar(), self.horizontalScrollBar().value() # Фильтрация и пакетное обновление не должны возвращать длинные строки к левому краю.
|
||||
super().clear() # Очищаем только документ, сохраняя ограниченную историю.
|
||||
for record in self.records: # Показываем оставшиеся записи в исходном порядке.
|
||||
if self._visible(record): self._append_record(record) # Скрытые строки остаются доступными для следующего выбора фильтра.
|
||||
bar.setValue(bar.maximum() if self.follow.isChecked() else min(position, bar.maximum())) # При сокращении документа ограничиваем прежнюю позицию новым диапазоном.
|
||||
horizontal.setValue(offset) # Qt ограничивает прежнее смещение текущей шириной документа после перестроения.
|
||||
self.count.setText("%d строк" % len(self.records)) # Счётчик включает временно скрытые записи.
|
||||
|
||||
def copy_visible(self): # Экспортируется фактически показанный текст, включая состояние паузы и фильтра.
|
||||
QApplication.clipboard().setText(self.toPlainText()) # Копирование всей видимой консоли не требует ручного выделения.
|
||||
|
||||
def save_to(self, path): # Отдельный метод позволяет проверить экспорт без системного диалога.
|
||||
Path(path).write_text(self.toPlainText(), encoding="utf-8") # UTF-8 сохраняет русские сообщения и расшифровки протоколов.
|
||||
def save_to(self, path, file_format=None): # Явный формат используется диалогом, а прямой вызов определяет формат по расширению файла.
|
||||
destination = Path(path) # Путь может поступить строкой от Qt или объектом Path от вызывающего кода.
|
||||
file_format = (file_format or destination.suffix.lstrip(".") or "txt").lower() # Имена расширений нечувствительны к регистру; без расширения сохраняется прежний TXT.
|
||||
if file_format not in ("csv", "json", "txt"): # Не допускаем сохранения текста под видом неподдерживаемого формата.
|
||||
raise ValueError("Выберите формат CSV, JSON или TXT") # Ошибка доступна как прямому вызывающему коду, так и диалогу.
|
||||
text = self.toPlainText() # Единый снимок учитывает фильтры, формат байтов и замороженный на паузе экран.
|
||||
rows = [{"line": index, "text": line} for index, line in enumerate(text.split("\n"), 1)] if text else [] # Нумерация с единицы сохраняет порядок и пустые строки расшифровки.
|
||||
if file_format == "csv": # Табличное представление содержит номер строки и её полный текст.
|
||||
with destination.open("w", encoding="utf-8-sig", newline="") as stream: # BOM помогает Excel распознать кириллицу; newline исключает лишние пустые строки в Windows.
|
||||
writer = csv.DictWriter(stream, fieldnames=("line", "text")) # Стабильные имена столбцов позволяют обрабатывать журналы скриптами.
|
||||
writer.writeheader() # Даже пустой журнал получает корректную схему CSV.
|
||||
writer.writerows(rows) # Стандартный писатель экранирует кавычки и запятые без изменения содержимого.
|
||||
elif file_format == "json": # Массив объектов сохраняет ту же схему строк, что CSV.
|
||||
destination.write_text(json.dumps(rows, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") # Читаемый UTF-8 сохраняет кириллицу и валидный пустой массив.
|
||||
else: # TXT остаётся точной текстовой копией показанного журнала.
|
||||
destination.write_text(text, encoding="utf-8") # Прежний контракт сохранения TXT не добавляет заголовки или номера строк.
|
||||
|
||||
def save_dialog(self): # Пользователь самостоятельно выбирает назначение журнала.
|
||||
path, _filter = QFileDialog.getSaveFileName(self, "Сохранить консоль", "console.txt", "Текст UTF-8 (*.txt);;Все файлы (*)") # Диалог не выполняет автоматической записи при отмене.
|
||||
filters = "CSV UTF-8 (*.csv);;JSON UTF-8 (*.json);;Текст UTF-8 (*.txt)" # Все консоли предлагают одинаковые три формата; CSV выбран первым.
|
||||
path, selected_filter = QFileDialog.getSaveFileName(self, "Сохранить консоль", "console", filters) # Имя без расширения позволяет выбрать любой формат без ручной замены суффикса.
|
||||
if path: # Записываем только явно выбранный файл.
|
||||
try: self.save_to(path) # Обрабатываем отказ файловой системы без прерывания приёма данных.
|
||||
except OSError as error: QMessageBox.warning(self, "Сохранение консоли", str(error)) # Причина ошибки остаётся доступна оператору.
|
||||
file_format = Path(path).suffix.lstrip(".").lower() # Явно введённое поддерживаемое расширение имеет приоритет над фильтром диалога.
|
||||
if file_format not in ("csv", "json", "txt"): # Если расширение отсутствует или неизвестно, применяем выбранный формат.
|
||||
file_format = "json" if "*.json" in selected_filter else "txt" if "*.txt" in selected_filter else "csv" # При отсутствии фильтра Qt используется первый предложенный формат CSV.
|
||||
path += "." + file_format # Итоговое расширение всегда соответствует фактически записанному формату.
|
||||
try: self.save_to(path, file_format) # Обрабатываем отказ файловой системы без прерывания приёма данных.
|
||||
except (OSError, ValueError) as error: QMessageBox.warning(self, "Сохранение консоли", str(error)) # Причина ошибки остаётся доступна оператору.
|
||||
|
||||
@@ -14,7 +14,7 @@ except ImportError:
|
||||
|
||||
|
||||
DRAG_HINT = ('ЛКМ рядом с маркером — двигать маркер; ЛКМ на свободном поле — '
|
||||
'перемещение по X; Ctrl + ЛКМ или Shift + ЛКМ — перемещение по Y. '
|
||||
'перемещение по X; Ctrl + ЛКМ — перемещение по Y; Shift + ЛКМ — по Y со стороны начала жеста. ' # Для двух шкал Shift выбирает сторону в точке нажатия и сохраняет её до отпускания кнопки.
|
||||
'Щелчок мимо маркеров — одиночный курсор.')
|
||||
|
||||
|
||||
@@ -34,7 +34,7 @@ def cursor_hit(plot, position, value, event, radius=8):
|
||||
class PlotDragInteraction:
|
||||
"""Capture a hit marker or pan one axis, chosen at the start of the drag."""
|
||||
|
||||
def _capture_y_pan(self):
|
||||
def _capture_y_pan(self, event=None): # Необязательное событие нажатия позволяет владельцу двух шкал выбрать одну Y; клавиатура передаёт только исходную область.
|
||||
return self.viewport
|
||||
|
||||
def _apply_y_pan(self, fraction, initial):
|
||||
@@ -58,7 +58,7 @@ class PlotDragInteraction:
|
||||
self.setFocus(Qt.MouseFocusReason)
|
||||
self._press = QPointF(pos)
|
||||
self._press_viewport = self.viewport
|
||||
self._press_y_pan = self._capture_y_pan()
|
||||
self._press_y_pan = self._capture_y_pan(event) # Фиксируем выбранную шкалу и её исходный диапазон при нажатии, чтобы пересечение центра не меняло цель перетаскивания.
|
||||
self._press_markers = self.markers
|
||||
self._press_bounds = self.visible_bounds
|
||||
self._pan_vertical = vertical_pan_requested(event)
|
||||
|
||||
@@ -8,18 +8,28 @@ except ImportError:
|
||||
from PySide2.QtCore import QPointF, Qt
|
||||
from PySide2.QtGui import QColor
|
||||
from protocan.plot import Bounds, Viewport
|
||||
from set_devices.plot_ticks import tick_precision # Обе амплитудные шкалы должны различать соседние деления даже при сильном приближении.
|
||||
|
||||
|
||||
def amplitude_axis_margin(widget, bounds): # Отступ правой шкалы зависит от ширины её уточнённых подписей в текущем шрифте виджета.
|
||||
step = (bounds.top - bounds.bottom) / max(100, widget.height() / 50) # Консервативная плотность делений даёт запас точности без обращения к геометрии, которая сама вычисляет этот отступ.
|
||||
labels = [f'{value:.{tick_precision(value, step)}g}' for value in (bounds.bottom, bounds.top)] # Оцениваем самые длинные крайние подписи в том же формате, что используется при отрисовке шкалы.
|
||||
return max(72, 14 + max(widget.fontMetrics().horizontalAdvance(label) for label in labels)) # Прежний минимум 72 пикселя и запас 14 пикселей сохраняют обычный вид и предотвращают обрезание длинных чисел.
|
||||
|
||||
|
||||
def small_amplitude(values, threshold=30):
|
||||
extent = getattr(values, "finite_extent", None)
|
||||
if extent is not None:
|
||||
return max(abs(extent[0]), abs(extent[1])) <= threshold
|
||||
magnitude = max((abs(v) for v in values if math.isfinite(v)), default=None)
|
||||
return magnitude is not None and magnitude <= threshold
|
||||
|
||||
|
||||
def split_amplitudes(series, threshold=30):
|
||||
def split_amplitudes(series, threshold=30, *, include_hidden=False): # Порог 30 в единицах канала разделяет шкалы; файловый canvas может сохранить в них скрытые ряды.
|
||||
"""Channels with finite peak magnitude <= 30 use the right amplitude axis."""
|
||||
result = set()
|
||||
for channel in series:
|
||||
if not channel.visible or channel.discrete:
|
||||
if (not channel.visible and not include_hidden) or channel.discrete: # По умолчанию скрытые каналы исключены; независимая политика границ может учитывать их для сохранения масштаба.
|
||||
continue
|
||||
if small_amplitude(channel.values, threshold):
|
||||
result.add(channel.key)
|
||||
@@ -29,7 +39,8 @@ def split_amplitudes(series, threshold=30):
|
||||
class DualAxisPlot:
|
||||
"""Mixin: left axis for large channels, right for small channels.
|
||||
|
||||
Shift-wheel selects the axis by the pointer's half of the analog pane.
|
||||
Ctrl + колесо выбирает шкалу по половине аналоговой области под указателем.
|
||||
Shift + ЛКМ перемещает одну Y, выбранную стороной графика при нажатии.
|
||||
The host supplies series_bounds/project_series rendering hooks.
|
||||
"""
|
||||
def __init__(self, *args, **kwargs):
|
||||
@@ -40,8 +51,8 @@ class DualAxisPlot:
|
||||
super().__init__(*args, **kwargs)
|
||||
|
||||
def _sync_bounds(self):
|
||||
keys = split_amplitudes(self._series)
|
||||
if keys != self.right_axis_keys:
|
||||
keys = split_amplitudes(self._bounds_series(), include_hidden=True) # Выбираем правые каналы из того же набора, что задаёт общие границы: LogsPlot сохраняет в нём скрытые источники.
|
||||
if not keys.intersection(self.right_axis_keys): # Сохраняем масштаб при добавлении или временном пересоздании эталона, пока на правой Y остаётся хотя бы один прежний канал.
|
||||
self.right_viewport = Viewport()
|
||||
self.right_axis_keys = keys
|
||||
super()._sync_bounds()
|
||||
@@ -49,10 +60,11 @@ class DualAxisPlot:
|
||||
def set_plot_bounds(self, bounds, has_data=True, x_origin=0):
|
||||
if self.right_axis_keys and self.has_left_axis():
|
||||
groups = [[], []]
|
||||
for series in self._series:
|
||||
if series.visible and not series.discrete:
|
||||
for series in self._bounds_series(): # Обе независимые Y соблюдают политику canvas, чтобы снятие флажка не подменяло диапазон токов диапазоном напряжений.
|
||||
if not series.discrete: # Дискретные дорожки не имеют общей амплитудной шкалы и не участвуют в её пределах.
|
||||
groups[series.key in self.right_axis_keys].extend(
|
||||
v for v in series.values if math.isfinite(v))
|
||||
getattr(series.values, "finite_extent", None) or
|
||||
(v for v in series.values if math.isfinite(v)))
|
||||
ranges = []
|
||||
for values in groups:
|
||||
low, high = (min(values), max(values)) if values else (0, 1)
|
||||
@@ -62,8 +74,8 @@ class DualAxisPlot:
|
||||
super().set_plot_bounds(bounds, has_data, x_origin)
|
||||
|
||||
def has_left_axis(self):
|
||||
return any(s.visible and not s.discrete and s.values and s.key not in self.right_axis_keys
|
||||
for s in self._series)
|
||||
return any(not s.discrete and s.values and s.key not in self.right_axis_keys # Наличие левой координатной системы определяется теми же рядами, что и её границы.
|
||||
for s in self._bounds_series()) # Файловый график сохраняет обе шкалы при скрытии линий; живой график учитывает только видимые каналы.
|
||||
|
||||
@property
|
||||
def right_visible_bounds(self):
|
||||
@@ -111,23 +123,28 @@ class DualAxisPlot:
|
||||
def plot_rect(self):
|
||||
rect = super().plot_rect()
|
||||
if self.right_axis_keys:
|
||||
rect.setWidth(max(1, rect.width() - 72))
|
||||
rect.setWidth(max(1, rect.width() - self.right_axis_margin())) # Уточнённые подписи правой Y получают достаточно места без выхода за границы виджета.
|
||||
return rect
|
||||
|
||||
def right_axis_margin(self):
|
||||
return 72 if self.right_axis_keys else 0
|
||||
return amplitude_axis_margin(self, self.right_visible_bounds) if self.right_axis_keys else 0 # Используем фактический правый диапазон и текущий шрифт; при отсутствии правой шкалы отступ не нужен.
|
||||
|
||||
def reset_viewport(self):
|
||||
self.right_viewport = Viewport()
|
||||
super().reset_viewport()
|
||||
|
||||
def _capture_y_pan(self):
|
||||
return super()._capture_y_pan(), self.right_viewport
|
||||
def _capture_y_pan(self, event=None): # Снимок содержит области выбранных шкал; None исключает другую шкалу из всего текущего жеста.
|
||||
left, right = super()._capture_y_pan(event), self.right_viewport # Сохраняем начальные области до движения, чтобы смещение считалось от точки нажатия без накопления ошибок.
|
||||
if event is not None and event.modifiers() & Qt.ShiftModifier and self.right_axis_keys and self.has_left_axis(): # Выбор стороны нужен только для Shift с двумя отдельными Y; Ctrl, стрелки и единственная Y сохраняют общий перенос.
|
||||
position = event.position() if hasattr(event, 'position') else event.localPos() # Получаем локальную точку нажатия одинаково для Qt 6 и Qt 5.
|
||||
return (None, right) if position.x() >= self.value_rect().center().x() else (left, None) # Центр аналоговой области разделяет стороны; на самой границе выбираем правую Y, как при Ctrl с колесом.
|
||||
return left, right # Общие команды перемещения получают обе области, а график с одной Y использует свою основную область.
|
||||
|
||||
def _apply_y_pan(self, fraction, initial):
|
||||
left, right = initial
|
||||
super()._apply_y_pan(fraction, left)
|
||||
if self.core and not self.lock_y and self.right_axis_keys and self.has_left_axis():
|
||||
if left is not None: # Отсутствующая левая область означает, что Shift выбрал только правую шкалу при нажатии.
|
||||
super()._apply_y_pan(fraction, left) # Общий обработчик перемещает левую Y и учитывает её фиксацию без изменения временной оси.
|
||||
if right is not None and self.core and not self.lock_y and self.right_axis_keys and self.has_left_axis(): # Правая Y сдвигается лишь при включении в снимок жеста, наличии двух шкал и снятой общей фиксации Y.
|
||||
self.right_viewport = right.transform(self.core, pan_y=fraction)
|
||||
|
||||
def reset_interaction(self):
|
||||
@@ -135,7 +152,7 @@ class DualAxisPlot:
|
||||
super().reset_interaction()
|
||||
|
||||
def wheelEvent(self, event):
|
||||
if not event.modifiers() & Qt.ShiftModifier:
|
||||
if not event.modifiers() & Qt.ControlModifier: # Ctrl включает масштаб Y выбранной стороны; колесо без Ctrl, включая Shift, передаётся общей навигации по X.
|
||||
return super().wheelEvent(event)
|
||||
pos = event.position() if hasattr(event, 'position') else event.posF()
|
||||
rect = self.value_rect()
|
||||
@@ -173,7 +190,7 @@ def paint_right_axis(painter, core, rect, bounds):
|
||||
for index in range(count):
|
||||
value = (first + index) * step
|
||||
y = rect.top() + bounds.fraction(core, value, True) * rect.height()
|
||||
painter.drawText(QPointF(rect.right() + 7, y + 4), f'{value:.4g}')
|
||||
painter.drawText(QPointF(rect.right() + 7, y + 4), f'{value:.{tick_precision(value, step)}g}') # Сохраняем четыре значащие цифры при обычном масштабе и добавляем разряды по шагу правой шкалы при приближении.
|
||||
painter.restore()
|
||||
|
||||
|
||||
@@ -185,7 +202,7 @@ class SingleAmplitudeAxis:
|
||||
def plot_rect(self):
|
||||
rect = super().plot_rect()
|
||||
if not self.has_left_axis():
|
||||
rect.setWidth(max(1, rect.width() - 72))
|
||||
rect.setWidth(max(1, rect.width() - amplitude_axis_margin(self, self.visible_bounds))) # Единственная правая шкала тренда или спектра получает тот же запас для длинных подписей при приближении.
|
||||
return rect
|
||||
|
||||
def paint_axes(self, painter):
|
||||
|
||||
@@ -10,7 +10,8 @@ except ImportError:
|
||||
from PySide2.QtCore import Qt
|
||||
from PySide2.QtWidgets import QScrollArea
|
||||
|
||||
NAVIGATION_HINT = ('Колесо и +/− — масштаб X; Ctrl + колесо и Ctrl + +/− — масштаб Y. '
|
||||
NAVIGATION_HINT = ('Колесо и +/− — масштаб X; Ctrl + колесо — масштаб Y со стороны указателя; ' # Поясняем выбор левой или правой амплитудной шкалы по положению указателя при удерживаемом Ctrl.
|
||||
'Ctrl + +/− — масштаб Y. ' # Клавиатурный масштаб Y сохраняет прежнее поведение без выбора стороны указателем.
|
||||
'ЛКМ — перемещение по X; Ctrl + ЛКМ — по Y; '
|
||||
'←/→ — перемещение по X; ↑/↓ — по Y; Home/End — начало/конец.')
|
||||
|
||||
|
||||
@@ -21,7 +21,7 @@ except ImportError:
|
||||
QVBoxLayout, QWidget,
|
||||
)
|
||||
|
||||
from set_devices.signal_reconstruction import METHODS
|
||||
from set_devices.signal_reconstruction import BACKENDS, MAX_OUTPUT_POINTS, METHODS # Используем единый список вариантов расчёта для панели и подписей результатов.
|
||||
from set_devices.plot_processing import Snapshot, prepare, process, write_csv
|
||||
|
||||
RESULT_COLORS = ("#FF70D0", "#50D5FF", "#FFD166", "#83E377", "#B99AFF", "#FF9870")
|
||||
@@ -78,6 +78,11 @@ class SignalProcessingPanel(QWidget):
|
||||
self.method.addItem(title, key)
|
||||
self.method.setCurrentIndex(2)
|
||||
row.addWidget(self.method)
|
||||
self.backend = QComboBox() # Явный переключатель позволяет сравнить прежний МНК и новый Eigen на одном снимке данных.
|
||||
for key, title in BACKENDS.items(): # Порядок оставляет исходный решатель значением по умолчанию.
|
||||
self.backend.addItem(title, key) # В данных элемента хранится стабильный ключ, независимый от русского названия.
|
||||
self.backend.setToolTip("Вариант полиномиального МНК. Рассчитайте оба: кривые сохранятся вместе, подписи и время помогут сравнению.") # Объясняем практический способ сравнения непосредственно рядом с выбором.
|
||||
row.addWidget(self.backend) # Располагаем вариант рядом с методом, к которому он относится.
|
||||
row.addStretch(1)
|
||||
layout.addLayout(row)
|
||||
row = QHBoxLayout()
|
||||
@@ -88,8 +93,8 @@ class SignalProcessingPanel(QWidget):
|
||||
row.addWidget(self.degree)
|
||||
row.addWidget(QLabel("Точек результата"))
|
||||
self.count = QSpinBox()
|
||||
self.count.setRange(2, 10000)
|
||||
self.count.setValue(1000)
|
||||
self.count.setRange(2, MAX_OUTPUT_POINTS)
|
||||
self.count.setValue(10000)
|
||||
row.addWidget(self.count)
|
||||
self.apply_button = QPushButton("Рассчитать")
|
||||
self.apply_button.clicked.connect(self.calculate)
|
||||
@@ -110,15 +115,18 @@ class SignalProcessingPanel(QWidget):
|
||||
"Полином МНК — сглаживание шумных данных. Линейная — отрезки между точками.\n"
|
||||
"PCHIP — сохранение формы без выбросов. Сплайн — гладкая кривая, возможны выбросы.\n"
|
||||
"Восстановление — оценка между измерениями; утраченные детали не определяются однозначно.")
|
||||
for widget in (self.channel, self.method):
|
||||
widget.currentIndexChanged.connect(self._parameters_changed)
|
||||
for widget in (self.channel, self.method, self.backend): # Смена решателя делает текущий запрос новым, сохраняя предыдущие слои.
|
||||
widget.currentIndexChanged.connect(self._parameters_changed) # Общая проверка предотвращает принятие результата для уже изменённого выбора.
|
||||
for widget in (self.degree, self.count):
|
||||
widget.valueChanged.connect(self._parameters_changed)
|
||||
self._update_actions()
|
||||
|
||||
def _signature(self):
|
||||
return prepare(self._snapshot, self.channel.currentData(), self.method.currentData(),
|
||||
self.count.value(), self.degree.value())
|
||||
self.count.value(), self.degree.value(), self._backend()) # Вариант участвует в идентичности снимка и результата.
|
||||
|
||||
def _backend(self): # Для методов без альтернативы всегда используем исходный алгоритм, сохраняя последний выбор МНК в списке.
|
||||
return self.backend.currentData() if self.method.currentData() == "polynomial" else "native" # Переключение на интерполяцию не выдаёт её за расчёт Eigen.
|
||||
|
||||
def _current_request_for(self, signature):
|
||||
if not self.preserve_on_view_change or signature is None:
|
||||
@@ -126,7 +134,7 @@ class SignalProcessingPanel(QWidget):
|
||||
# Validate the original calculation domain, independently of navigation.
|
||||
return prepare(replace(self._snapshot, x_range=signature.x_range),
|
||||
self.channel.currentData(), self.method.currentData(),
|
||||
self.count.value(), self.degree.value())
|
||||
self.count.value(), self.degree.value(), self._backend()) # Сохранённое окно проверяется вместе с текущим вариантом решателя.
|
||||
|
||||
def set_snapshot(self, snapshot):
|
||||
previous = self._job.signature if self._job is not None else self._signature()
|
||||
@@ -154,7 +162,7 @@ class SignalProcessingPanel(QWidget):
|
||||
# depend on samples/units, not the source curve's checkbox.
|
||||
source = replace(source, series=tuple(replace(series, visible=True)
|
||||
for series in source.series))
|
||||
if self.preserve_on_data_change or prepare(source, request.series.key, request.method, request.output_count, request.degree) == request:
|
||||
if self.preserve_on_data_change or prepare(source, request.series.key, request.method, request.output_count, request.degree, request.backend) == request: # Проверяем каждый слой с его собственным решателем, чтобы оба варианта оставались на графике.
|
||||
retained.append(result)
|
||||
if len(retained) != len(self._results):
|
||||
self._results = retained
|
||||
@@ -173,6 +181,7 @@ class SignalProcessingPanel(QWidget):
|
||||
|
||||
def _update_actions(self):
|
||||
self.degree.setEnabled(self.method.currentData() == "polynomial")
|
||||
self.backend.setEnabled(self.method.currentData() == "polynomial") # Выбор решателя доступен только для метода МНК, где есть два разных алгоритма.
|
||||
request = self._signature()
|
||||
self.apply_button.setEnabled(self._job is None and request is not None and
|
||||
len(request.series.points) >= 2)
|
||||
@@ -250,9 +259,12 @@ class SignalProcessingPanel(QWidget):
|
||||
duplicates = result.input_count - result.unique_count
|
||||
self.status.setText(
|
||||
f"{self.channel.currentText()}: {result.unique_count} исходных → {len(result.points)} расчётных точек; "
|
||||
f"СКО на измерениях: {result.rmse:.6g}. "
|
||||
f"СКО на измерениях: {result.rmse:.6g}; расчёт: {result.elapsed_ms:.3f} мс. " # Показываем точность и время одного и того же результата, включая преобразование буферов.
|
||||
+ (f"Повторы X усреднены: {duplicates}. " if duplicates else "")
|
||||
+ f"Расчётных кривых: {len(self._results)}. Исходные данные сохранены.")
|
||||
comparable = [curve for curve in self._results if replace(curve.request, backend=signature.backend) == signature] if signature.method == "polynomial" else [] # Сопоставляем только одинаковые данные, степень, сетку и окно; различается исключительно решатель.
|
||||
if len(comparable) > 1: # Сравнение появляется после явного расчёта обоих вариантов на одном наборе данных.
|
||||
self.status.setText(self.status.text() + "\n" + " | ".join(f"{BACKENDS[curve.request.backend]}: СКО {curve.rmse:.6g}, {curve.elapsed_ms:.3f} мс" for curve in comparable)) # Сохраняем метрики обоих запусков рядом, не объявляя победителя по единичному замеру.
|
||||
self._update_actions()
|
||||
self.changed.emit()
|
||||
|
||||
|
||||
@@ -1,24 +1,27 @@
|
||||
"""Reusable background workers for dense plots and viewport measurements."""
|
||||
from collections import deque # Кольцевые очереди живого графика требуют единого снимка между проходами амплитудной статистики и частоты.
|
||||
try:
|
||||
from PySide6.QtCore import QObject, QRunnable, Signal
|
||||
except ImportError:
|
||||
from PySide2.QtCore import QObject, QRunnable, Signal
|
||||
from set_devices.plot_decimation import pixel_envelope, viewport_samples
|
||||
from set_devices.plot_decimation import pixel_envelope, render_envelope, viewport_samples # Рабочее задание поддерживает точный прежний формат и компактную экранную огибающую для аналогового графика.
|
||||
from set_devices.oscilloscope import measurements
|
||||
from set_devices.background_work import WorkBudget # Даже фоновый Python-расчёт должен регулярно отдавать GIL многочисленным обработчикам интерфейса Qt.
|
||||
|
||||
class EnvelopeSignals(QObject):
|
||||
ready = Signal(str, object, object)
|
||||
|
||||
|
||||
class EnvelopeJob(QRunnable):
|
||||
def __init__(self, key, geometry, timestamps, values, left, right, width, signals):
|
||||
def __init__(self, key, geometry, timestamps, values, left, right, width, signals, compact=False): # Необязательный режим оставляет прежний контракт внешних пользователей, а аналоговый график включает два экстремума на столбец.
|
||||
super().__init__()
|
||||
self.args = (timestamps, values, left, right, width)
|
||||
self.key, self.geometry, self.signals = key, geometry, signals
|
||||
self.select = render_envelope if compact else pixel_envelope # Выбор алгоритма выполняется один раз при создании задания, не внутри многомиллионного обхода.
|
||||
|
||||
def run(self):
|
||||
try:
|
||||
points = tuple(pixel_envelope(*self.args))
|
||||
points = tuple(self.select(*self.args)) # Фоновый результат сохраняет точные пики и разрывы в согласованном с рисователем экранном бюджете.
|
||||
except Exception:
|
||||
points = None
|
||||
try:
|
||||
@@ -31,18 +34,43 @@ class NavigationSignals(QObject):
|
||||
ready = Signal(int, object, object)
|
||||
|
||||
|
||||
class _NavigationSamples: # Повторяемая выборка окна позволяет измерять исходные ряды без копии миллионов пар координат.
|
||||
def __init__(self, times, values, bounds, check_cancelled): # Храним источники задания; вызывающий код создаёт снимок изменяемых очередей перед численными проходами.
|
||||
self.times, self.values, self.bounds, self.check_cancelled = times, values, bounds, check_cancelled # Ссылки сохраняют исходную точность и порядок без экранного сокращения.
|
||||
self.count = 0 # Число отсчётов определяется при первом полном проходе и включает нечисловые амплитуды, как прежний список.
|
||||
|
||||
def __iter__(self): # Статистики и частота независимо обходят то же окно, не удерживая промежуточные пары в памяти.
|
||||
count = 0 # Каждый проход считает только точки внутри включительных временных границ.
|
||||
for index, (x, y) in enumerate(viewport_samples(self.times, self.values, self.bounds.left, self.bounds.right)): # Индексируемый источник ищет окно двоичным поиском; потоковый сохраняет прежний порядок.
|
||||
if index % 1024 == 0: # Проверяем отмену через 1024 просмотренных отсчёта, даже когда неупорядоченный ряд лежит вне окна.
|
||||
self.check_cancelled() # Не продолжаем чтение старого диапазона после нового жеста навигации.
|
||||
if self.bounds.left <= x <= self.bounds.right: # Включаем обе границы и все дубликаты временных меток, как исходная реализация.
|
||||
count += 1 # Счётчик соответствует прежнему len(points), независимо от конечности амплитуды.
|
||||
yield x, y # Пара существует только на время текущего численного прохода и не копируется в большой список.
|
||||
self.count = count # Публикуем количество только после полного прохода, чтобы отменённая выборка не выдавала частичный результат.
|
||||
|
||||
|
||||
class NavigationJob(QRunnable):
|
||||
def __init__(self, revision, series, bounds, emitter):
|
||||
def __init__(self, revision, series, bounds, emitter, cancelled=None): # Необязательное событие отмены сохраняет совместимость общих графиков и останавливает устаревшие измерения.
|
||||
super().__init__()
|
||||
self.revision, self.series, self.bounds, self.emitter = revision, series, bounds, emitter
|
||||
self.cancelled = cancelled # Событие принадлежит одному заданию и не сбрасывается при запуске расчёта нового окна.
|
||||
self.work_budget = WorkBudget(cancelled) # Короткие добровольные паузы предотвращают многосекундное ожидание GIL главным потоком.
|
||||
|
||||
def _check_cancelled(self): # Проверяем отмену на границах этапов и небольших блоков исходных отсчётов.
|
||||
self.work_budget() # Одновременно прекращаем устаревшие измерения и регулярно освобождаем GIL для рисования и событий мыши.
|
||||
|
||||
def run(self):
|
||||
stats = {}
|
||||
try:
|
||||
for key, times, values in self.series:
|
||||
points = [(x, y) for x, y in viewport_samples(times, values, self.bounds.left, self.bounds.right)
|
||||
if self.bounds.left <= x <= self.bounds.right]
|
||||
stats[key] = measurements(points), len(points)
|
||||
self._check_cancelled() # Не начинаем обход следующего канала после возобновления перемещения или изменения масштаба.
|
||||
samples = _NavigationSamples(times, values, self.bounds, self._check_cancelled) # Повторяемый вид файлового окна устраняет копирование миллионов пар и сохраняет отмену чтения источника.
|
||||
ordered = getattr(times, "ordered", isinstance(times, (list, tuple, range))) # Применяем тот же контракт упорядоченности, что и viewport_samples, включая смещённые файловые координаты.
|
||||
points = tuple(samples) if isinstance(times, deque) or isinstance(values, deque) or not ordered else samples # Только живые очереди и неупорядоченный путь получают единый снимок для согласованных амплитуд и частоты.
|
||||
result = measurements(points, self._check_cancelled) # Передаём отмену внутрь всех численных этапов, чтобы новый жест не ждал окончания полного среднего или СКЗ.
|
||||
stats[key] = result, samples.count # Количество относится к завершённому проходу того же окна либо к первоначальному снимку живого ряда.
|
||||
self._check_cancelled() # При отмене во время вычислений не продолжаем остальные каналы и не публикуем устаревшие значения.
|
||||
self.emitter.ready.emit(self.revision, stats, self.bounds)
|
||||
except Exception:
|
||||
try:
|
||||
|
||||
@@ -6,6 +6,8 @@ from pathlib import Path
|
||||
import subprocess
|
||||
import tempfile
|
||||
from threading import Lock
|
||||
import math # Кодируем разрывы кривой нечисловыми значениями Y, сохраняя упорядоченные координаты X для нативного движка.
|
||||
from set_devices.plot_decimation import pixel_envelope # Передаём движку только точки, различимые при текущем масштабе изображения.
|
||||
try:
|
||||
from PySide6.QtCore import QObject, QRunnable, Signal
|
||||
except ImportError:
|
||||
@@ -44,19 +46,26 @@ class NativePlotEngine:
|
||||
self.process = subprocess.Popen([str(self.executable)], stdin=subprocess.PIPE,
|
||||
stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, env=env, bufsize=0,
|
||||
creationflags=getattr(subprocess, 'CREATE_NO_WINDOW', 0), cwd=self.executable.parent)
|
||||
key = (id(times), id(values))
|
||||
key = (id(times), id(values), len(times), len(values), bounds.left, bounds.right, width) # Выборка зависит от исходного снимка, окна X и физической ширины изображения; масштаб Y её не меняет.
|
||||
record = self.records.get(key)
|
||||
if record is None:
|
||||
self.serial += 1
|
||||
path = Path(self.directory.name) / f'{self.serial}.bin'
|
||||
points = [] # Временный список ограничен экранной шириной и не содержит миллионов исходных измерений.
|
||||
for point in pixel_envelope(times, values, bounds.left, bounds.right, width): # Сохраняем первый, минимальный, максимальный и последний отсчёты каждого пиксельного столбца.
|
||||
if point is not None: # Конечные измерения передаются с исходными координатами и амплитудами.
|
||||
points.append(point) # Экстремумы остаются видимыми даже для импульса длиной в один исходный отсчёт.
|
||||
elif points and math.isfinite(points[-1][1]): # Повторные маркеры одного разрыва не должны увеличивать размер передаваемого ряда.
|
||||
points.append((points[-1][0], math.nan)) # Дублированная метка времени и NaN в Y разрывают путь без нарушения порядка X.
|
||||
with path.open('wb') as stream:
|
||||
array('d', times).tofile(stream)
|
||||
array('d', values).tofile(stream)
|
||||
record = (path, times, values)
|
||||
array('d', (point[0] for point in points)).tofile(stream) # Записываем только экранные координаты X в прежнем формате 64-битных чисел.
|
||||
array('d', (point[1] for point in points)).tofile(stream) # Массив Y соответствует сокращённому X и включает маркеры разрывов.
|
||||
record = (path, times, values, len(points)) # Ссылки сохраняют идентичность исходного снимка; длина описывает только передаваемый экранный ряд.
|
||||
self.records[key] = record
|
||||
if len(self.records) > 4:
|
||||
self.records.pop(next(iter(self.records)))
|
||||
request = dict(file=str(record[0]), count=len(times), width=width, height=height,
|
||||
expired = self.records.pop(next(iter(self.records))) # Оставляем четыре последние экранные выборки, как и в кэше нативного процесса.
|
||||
expired[0].unlink(missing_ok=True) # Освобождаем устаревший временный файл, чтобы навигация не накапливала данные на диске.
|
||||
request = dict(file=str(record[0]), count=record[3], width=width, height=height, # Нативному процессу сообщается фактическое число отрисовываемых точек вместо полного размера записи.
|
||||
left=bounds.left, right=bounds.right, bottom=bounds.bottom, top=bounds.top, color=color)
|
||||
self.process.stdin.write((json.dumps(request)+'\n').encode())
|
||||
self.process.stdin.flush()
|
||||
|
||||
@@ -0,0 +1,375 @@
|
||||
"""Переиспользуемые Qt-панель и диалог сравнения с CSV-эталоном.""" # График, контейнер кривой и папки передаются потребителем.
|
||||
import json # Отчёт сохраняет показатели и параметры сравнения в переносимом формате.
|
||||
from pathlib import Path # Имя файла используется в статусе, полный путь — при записи отчёта.
|
||||
import re # Единицы в скобках проверяются до сравнения каналов.
|
||||
|
||||
try: # Один порт поддерживает современные и совместимые Windows-сборки.
|
||||
from PySide6.QtCore import QThread, Qt, Signal # Qt6 доставляет результаты рабочего потока в интерфейс.
|
||||
from PySide6.QtWidgets import QApplication, QCheckBox, QComboBox, QDialog, QDoubleSpinBox, QFileDialog, QHBoxLayout, QHeaderView, QLabel, QPushButton, QSplitter, QTableWidget, QVBoxLayout, QWidget # Используем стандартные элементы Qt6; создание ячеек с единицами и подсказками выполняет общий заполнитель таблицы.
|
||||
except ImportError: # Qt5 доступен на системах, где Qt6 не поддерживается.
|
||||
from PySide2.QtCore import QThread, Qt, Signal # Сохраняем тот же контракт сигналов и отмены на Qt5.
|
||||
from PySide2.QtWidgets import QApplication, QCheckBox, QComboBox, QDialog, QDoubleSpinBox, QFileDialog, QHBoxLayout, QHeaderView, QLabel, QPushButton, QSplitter, QTableWidget, QVBoxLayout, QWidget # Qt5 использует тот же заполнитель ячеек с единицами и подсказками, что современный порт.
|
||||
|
||||
from set_devices.signal_reference import compare, read_reference, trace_from_pairs # Единственное вычислительное ядро работает по всем исходным отсчётам.
|
||||
from set_devices.qt_ports.circuit_parameters import CircuitParameters # Необязательные известные R/L/C ограничивают идентификацию электрического эквивалента.
|
||||
from protocan.plot import Viewport # Общий контейнер области просмотра не зависит от конкретного виджета графика.
|
||||
from set_devices.qt_ports.reference_results import ComparisonAnalysis, populate_comparison_table # Анализ, единицы показателей и подсказки одинаковы в отдельном и встроенном виде.
|
||||
|
||||
|
||||
def _model_channels(sources, references, cache, cancel): # Подготовка связанных физических каналов выполняется только в рабочем потоке.
|
||||
measured = {} # Сохраняем исходные временные метки для совместной проверки Uce/Uge/Ic.
|
||||
for index, (signal, points) in enumerate(sources): # Истории и преобразования соответствуют одному снимку измерительной записи.
|
||||
if re.match(r'^\s*(uce|uge|ic)\b', signal.name, re.IGNORECASE): # Не копируем произвольные дополнительные каналы, не участвующие в электрической модели.
|
||||
if not points: # Отсутствующий связанный канал не должен ломать корректное сравнение выбранного измерения.
|
||||
continue # Совместный анализ сообщит недостаточный набор физических наблюдений.
|
||||
trace = cache.get(index) # Выбранный канал уже подготовлен основным сравнением.
|
||||
if trace is None: # Остальные физические каналы преобразуются только при первом использовании.
|
||||
trace = trace_from_pairs(signal.name, points, signal.display_value, cancel) # Множители применяются в точности как на исходном графике.
|
||||
cache[index] = trace # Следующая настройка RLC не требует повторной копии полной истории.
|
||||
measured[str(index)] = trace # Индекс сохраняет неоднозначные одинаковые имена для проверки, не затирая их словарём.
|
||||
return dict(measured=measured, reference=references) # Сдвиг и общие начала координат добавляет независимое вычислительное ядро.
|
||||
|
||||
|
||||
def _stop_owned_worker(state): # Уничтожение родителя QWidget может обойти closeEvent вложенной панели.
|
||||
worker = state[0] # Состояние не обращается к уже уничтожаемой Python-обёртке виджета.
|
||||
if worker is not None: # Завершённые задания удаляются из держателя заранее.
|
||||
worker.requestInterruption() # Операция увидит отмену через штатный callback QThread.
|
||||
worker.wait() # QObject удаляет дочерний QThread только после выхода его run.
|
||||
|
||||
|
||||
class ComparisonWorker(QThread): # Чтение CSV и численный проход выполняются вне главного потока Qt.
|
||||
result = Signal(object) # Готовый результат передаётся интерфейсу без изменения исходных данных.
|
||||
failed = Signal(str) # Ошибка передаётся текстом и не оставляет частичный отчёт.
|
||||
|
||||
def __init__(self, operation, parent): # Операция принимает callback проверки отмены.
|
||||
super().__init__(parent) # Диалог владеет временем жизни рабочего потока.
|
||||
self.operation = operation # Одинаковый worker обслуживает загрузку и расчёт.
|
||||
|
||||
def run(self): # Qt вызывает этот метод в отдельном потоке.
|
||||
try: # Любая ошибка должна вернуться в UI, а не прервать главный цикл событий.
|
||||
self.result.emit(self.operation(self.isInterruptionRequested)) # Передаём операции штатный запрос отмены QThread.
|
||||
except (ValueError, OSError, InterruptedError) as error: # Ошибки данных, файлов и отмена уже содержат понятную причину.
|
||||
self.failed.emit(str(error)) # Показываем исходную причину без дополнительной обёртки.
|
||||
except Exception as error: # Неожиданная ошибка также должна завершить состояние занятости.
|
||||
self.failed.emit(f'Ошибка сравнения: {error}') # Уточняем источник неизвестной ошибки для пользователя.
|
||||
|
||||
|
||||
class _ReferenceComparisonView: # Панель и отдельный диалог используют одну реализацию параметров, worker и результата.
|
||||
def __init__(self, sources, parent=None, source_path='', *, plot_factory, series_factory, path_provider=None): # sources содержит пары объекта с name/display_value и неизменяемой полной истории.
|
||||
super().__init__(parent) # Родитель определяет окно и владение диалогом.
|
||||
self._series_factory = series_factory # Фабрика адаптирует общие Trace к кривым графика потребителя.
|
||||
self._dialog_path = path_provider or (lambda filename: filename) # Без callback используем стандартные относительные имена файлов.
|
||||
self.setWindowTitle('Сравнение с эталоном') # Заголовок одинаков для всех приложений, использующих порт.
|
||||
self.sources = sources # История фиксируется вызывающей стороной на время жизни диалога.
|
||||
self.source_path = source_path # Происхождение измерения включается в JSON-отчёт.
|
||||
self.references = {} # Каналы эталона появятся после успешного чтения CSV.
|
||||
self.reference_path = '' # Путь изменяется только после принятия загруженного эталона.
|
||||
self._source_cache = {} # Повторный расчёт не должен повторно применять множители к измерению.
|
||||
self._worker = None # Одновременно допускается только одна загрузка или вычисление.
|
||||
self._worker_state = [None] # Независимый держатель доступен обработчику destroyed без обращения к self.
|
||||
self.destroyed.connect(lambda *_args, state=self._worker_state: _stop_owned_worker(state)) # Останавливаем поток до удаления C++-детей даже при deleteLater родителя.
|
||||
self._closing = False # Флаг откладывает закрытие до завершения отменённого worker.
|
||||
self.comparison = None # До расчёта отчёт и график результата отсутствуют.
|
||||
root = QVBoxLayout(self) # Вертикальный макет объединяет параметры, результат и экспорт.
|
||||
row = QHBoxLayout() # Первая строка отвечает за выбор файлов и каналов.
|
||||
self.load_button = QPushButton('Открыть эталон CSV…') # Эталон загружается отдельно от исходного измерения.
|
||||
self.load_button.clicked.connect(self._open_reference) # Выбор файла запускает фоновое чтение.
|
||||
self.source_combo, self.reference_combo = QComboBox(), QComboBox() # Каналы измерения и эталона выбираются независимо.
|
||||
for signal, _ in sources: # Показываем все переданные каналы с непустой историей.
|
||||
self.source_combo.addItem(signal.name) # Имя берётся из общего контракта источника.
|
||||
row.addWidget(self.load_button) # Кнопка открытия предшествует выбору каналов.
|
||||
for label, control in (('Измерение', self.source_combo), ('Эталон', self.reference_combo)): # Подписи явно различают обе стороны сравнения.
|
||||
row.addWidget(QLabel(label)) # Подпись относится к следующему списку каналов.
|
||||
row.addWidget(control, 1) # Оба списка делят свободное место поровну.
|
||||
root.addLayout(row) # Завершаем строку выбора данных.
|
||||
row = QHBoxLayout() # Вторая строка задаёт временное совмещение и допуски.
|
||||
self.align_start = QCheckBox('Совместить начала записей') # Позволяет сравнивать записи с разными абсолютными началами.
|
||||
self.align_start.setChecked(True) # По умолчанию сравниваем форму от начала каждой записи.
|
||||
self.align_start.setToolTip('Совмещает первые отсчёты. Задержка самого переключения сохраняется.') # Объясняем отличие совмещения начала от поиска фронта.
|
||||
self.shift = self._number(-1e12, 1e12, 6) # Диапазон ±10^12 мкс и шесть знаков сохраняет прежнюю точность ввода сдвига.
|
||||
self.shift.setSuffix(' мкс') # В интерфейсе время вводится в микросекундах.
|
||||
self.shift.setToolTip('Положительное значение сдвигает эталон вправо') # Явно задаём знак временного сдвига.
|
||||
self.absolute = self._number(0., 1e12, 6) # Абсолютный допуск неотрицателен и измеряется в единицах канала.
|
||||
self.relative = self._number(0., 10000., 4) # Относительная часть допуска задаётся в процентах с четырьмя знаками.
|
||||
self.relative.setSuffix(' %') # Единица отделяет проценты от абсолютной амплитуды.
|
||||
row.addWidget(self.align_start) # Опция совмещения находится рядом со сдвигом.
|
||||
for label, control in (('Сдвиг эталона', self.shift), ('Допуск ±', self.absolute), ('+ от |эталона|', self.relative)): # Подписи отражают сумму абсолютной и процентной частей.
|
||||
row.addWidget(QLabel(label)) # Связываем пояснение с соответствующим полем.
|
||||
row.addWidget(control) # Ограниченные по ширине поля оставляют место всем параметрам.
|
||||
root.addLayout(row) # Добавляем настройки совмещения в общий макет.
|
||||
row = QHBoxLayout() # Третья строка управляет интервалом, расчётом и видом результата.
|
||||
self.limit_interval = QCheckBox('Только интервал, мкс') # Флажок включает ограничение расчёта по времени.
|
||||
self.start, self.stop = self._number(-1e12, 1e12, 6), self._number(-1e12, 1e12, 6) # Границы используют ту же шкалу мкс и точность, что сдвиг.
|
||||
self.stop.setValue(300.) # Начальный интервал 0–300 мкс сохраняет прежнее поведение диалога.
|
||||
self.visible_button = QPushButton('Из видимого участка') # Текущий масштаб графика можно использовать как интервал расчёта.
|
||||
self.visible_button.clicked.connect(self._visible_interval) # Переводим границы графика из мс в мкс.
|
||||
self.calculate_button = QPushButton('Сравнить') # Расчёт запускается явно после выбора параметров.
|
||||
self.calculate_button.clicked.connect(self._calculate) # Параметры фиксируются перед запуском worker.
|
||||
self.cancel_button = QPushButton('Отмена расчёта') # Длинную загрузку или расчёт можно прервать.
|
||||
self.cancel_button.clicked.connect(self._cancel) # Используем кооперативную отмену без остановки потока извне.
|
||||
self.mode = QComboBox() # Режим отображения не меняет уже вычисленные показатели.
|
||||
self.mode.addItems(['Наложение', 'Отклонение: измерение − эталон']) # Сначала показываем две кривые в общем масштабе.
|
||||
self.mode.currentIndexChanged.connect(self._show_plot) # Переключаем кривые без повторного численного прохода.
|
||||
for control in (self.limit_interval, self.start, QLabel('…'), self.stop, self.visible_button, self.calculate_button, self.cancel_button, self.mode): # Сохраняем порядок интервал → расчёт → вид.
|
||||
row.addWidget(control) # Каждый элемент относится к одной строке управления результатом.
|
||||
root.addLayout(row) # Завершаем область параметров.
|
||||
self.status = QLabel('Откройте эталон. Сравниваются все отсчёты выбранного канала после преобразования амплитуды.') # Общий порт не предполагает конкретный формат преобразования источника.
|
||||
self.status.setWordWrap(True) # Длинные ошибки CSV не расширяют окно.
|
||||
root.addWidget(self.status) # Состояние видно над графиком.
|
||||
self.circuit = CircuitParameters(self) # Неизвестные элементы по умолчанию не подменяются учебными номиналами.
|
||||
self.circuit.changed.connect(self._invalidate) # Изменение электрического ограничения делает прежние параметры модели неактуальными.
|
||||
root.addWidget(self.circuit) # Опциональные R/L/C доступны перед строкой анализа и результатами.
|
||||
self.analysis = ComparisonAnalysis(self) # Строка возможной причины и подробный отчёт повторяют подход Android GUI.
|
||||
root.addWidget(self.analysis) # Анализ располагается рядом с результатом, не изменяя исходные кривые.
|
||||
self.legend = QLabel() # Цветная легенда поясняет текущие кривые.
|
||||
root.addWidget(self.legend) # Легенда отделена от численной таблицы.
|
||||
splitter = QSplitter(Qt.Orientation.Horizontal) # Пользователь меняет соотношение ширины графика и таблицы.
|
||||
self.plot = plot_factory() # Конкретный canvas создаётся и настраивается адаптером приложения.
|
||||
splitter.addWidget(self.plot) # QSplitter принимает любой совместимый QWidget графика.
|
||||
self.table = QTableWidget(0, 2) # Каждому показателю соответствует название и значение.
|
||||
self.table.setHorizontalHeaderLabels(['Показатель', 'Значение']) # Заголовки поясняют две колонки отчёта.
|
||||
self.table.setEditTriggers(QTableWidget.EditTrigger.NoEditTriggers) # Показатели расчёта недоступны для ручной правки.
|
||||
self.table.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeMode.ResizeToContents) # Названия и числа видны полностью по содержимому.
|
||||
self.table.setMinimumWidth(370) # Минимум 370 логических пикселей сохраняет читаемость показателей.
|
||||
splitter.addWidget(self.table) # Таблица располагается справа от кривых.
|
||||
splitter.setSizes([920, 380]) # Начальные ширины в логических пикселях отдают большую часть окна графику.
|
||||
root.addWidget(splitter, 1) # Результат получает всё свободное место по высоте.
|
||||
row = QHBoxLayout() # Нижняя строка содержит экспорт и пояснение алгоритма.
|
||||
self.report_button = QPushButton('Сохранить отчёт JSON…') # Экспорт доступен только для актуального результата.
|
||||
self.report_button.clicked.connect(self._save_report) # Имя файла предлагает внедрённый provider путей.
|
||||
row.addWidget(self.report_button) # Кнопка экспорта расположена перед пояснением.
|
||||
note = QLabel('Δ = измерение − эталон. Линейная интерполяция эталона; без экстраполяции и заполнения пропусков.') # Формула и ограничения относятся ко всем приложениям-потребителям.
|
||||
note.setWordWrap(True) # Текст остаётся читаемым при изменении размера окна.
|
||||
row.addWidget(note, 1) # Пояснение занимает оставшуюся ширину строки.
|
||||
root.addLayout(row) # Завершаем макет экспорта.
|
||||
self._inputs = [self.load_button, self.source_combo, self.reference_combo, self.align_start, self.shift, self.absolute, self.relative, self.limit_interval, self.start, self.stop, self.visible_button] # Во время расчёта входные данные не меняются.
|
||||
self._inputs.extend(self.circuit.controls) # Электрические ограничения также фиксируются на время рабочего задания.
|
||||
for control in (self.shift, self.absolute, self.relative, self.start, self.stop): # Любое числовое изменение делает результат устаревшим.
|
||||
control.valueChanged.connect(self._invalidate) # Сбрасываем старые кривые и отчёт до следующего расчёта.
|
||||
for control in (self.align_start, self.limit_interval): # Флажки также влияют на вычисляемую временную сетку.
|
||||
control.toggled.connect(self._invalidate) # Показатели не должны относиться к прежним условиям.
|
||||
self.source_combo.currentIndexChanged.connect(self._match_reference) # При смене измерения ищем одноимённый эталон.
|
||||
self.reference_combo.currentIndexChanged.connect(self._invalidate) # Смена эталонного канала требует нового расчёта.
|
||||
self._busy(False) # Настраиваем начальную доступность кнопок.
|
||||
QApplication.instance().aboutToQuit.connect(self._shutdown) # Завершение приложения дожидается отмены рабочего потока.
|
||||
|
||||
@staticmethod # Фабрика числового поля не зависит от состояния диалога.
|
||||
def _number(low, high, decimals): # Границы и число десятичных знаков задаются для конкретной величины.
|
||||
box = QDoubleSpinBox() # Штатный элемент проверяет числовой ввод.
|
||||
box.setDecimals(decimals) # Сохраняем требуемую точность времени или допуска.
|
||||
box.setRange(low, high) # Ограничиваем значения допустимым диапазоном параметра.
|
||||
box.setMaximumWidth(150) # Ширина 150 логических пикселей сохраняет компактную строку параметров.
|
||||
return box # Вызывающий код задаёт единицы и обработчик изменений.
|
||||
|
||||
def _busy(self, busy): # Единый переход состояния используется загрузкой и расчётом.
|
||||
for control in self._inputs: # Все параметры относятся к одному снимку задания.
|
||||
control.setEnabled(not busy) # Исключаем изменение входа работающего worker.
|
||||
self.calculate_button.setEnabled(not busy and bool(self.references) and bool(self.sources)) # Без измерения или эталона расчёт невозможен.
|
||||
self.cancel_button.setEnabled(busy) # Отменять можно только существующее задание.
|
||||
self.report_button.setEnabled(not busy and self.comparison is not None) # Отчёт относится исключительно к завершённому результату.
|
||||
|
||||
def _start_work(self, operation, receive): # Операция и получатель отделяют чтение файла от численного расчёта.
|
||||
self._busy(True) # Блокируем параметры до запуска потока.
|
||||
worker = ComparisonWorker(operation, self) # Диалог сохраняет владение worker до его завершения.
|
||||
self._worker = worker # Ссылка используется для отмены и отложенного закрытия.
|
||||
self._worker_state[0] = worker # Сигнал уничтожения владельца получает актуальную задачу.
|
||||
worker.result.connect(receive) # Результат применяется в главном потоке Qt.
|
||||
worker.failed.connect(self.status.setText) # Ошибка появляется в общей строке состояния.
|
||||
worker.finished.connect(self._finished) # Освобождение worker восстанавливает доступность элементов.
|
||||
worker.start() # Начинаем фоновое чтение или расчёт.
|
||||
|
||||
def _finished(self): # Вызывается после штатного завершения и после отмены.
|
||||
worker, self._worker = self._worker, None # Снимаем состояние занятости до возможного закрытия диалога.
|
||||
self._worker_state[0] = None # Уничтожение родителя больше не обращается к завершённому worker.
|
||||
if worker is None: # Синхронное закрытие могло уже очистить поток до доставки queued-сигнала.
|
||||
return # Не повторяем удаление и не обновляем закрытую панель.
|
||||
worker.deleteLater() # Qt безопасно удаляет завершившийся поток через очередь событий.
|
||||
self._busy(False) # Разрешаем новый расчёт либо экспорт принятого результата.
|
||||
if self._closing: # Запрос закрытия во время работы должен завершиться автоматически.
|
||||
self.close() # Повторное закрытие уже не встречает активный worker.
|
||||
|
||||
def _cancel(self): # Отмена кооперативна и проверяется вычислительным ядром.
|
||||
if self._worker is not None: # Не обращаемся к уже завершённому потоку.
|
||||
self._worker.requestInterruption() # Ядро увидит запрос в ближайшей контрольной точке.
|
||||
self.status.setText('Остановка расчёта…') # Пользователь видит, что запрос принят.
|
||||
|
||||
def _shutdown(self): # Перед выходом процесса нельзя уничтожать работающий QThread.
|
||||
self._closing = True # Поздние сигналы не должны публиковать результат в закрывающемся интерфейсе.
|
||||
if self._worker is not None: # Ожидание требуется только при активном задании.
|
||||
worker = self._worker # Сохраняем объект до очистки общего держателя.
|
||||
worker.requestInterruption() # Просим ядро прервать чтение или расчёт.
|
||||
worker.wait() # Дожидаемся остановки до уничтожения объектов Qt.
|
||||
self._worker = None # Смена записи может немедленно удалить закрытую панель.
|
||||
self._worker_state[0] = None # Сигнал destroyed не обращается к удалённому потоку повторно.
|
||||
worker.deleteLater() # Завершённый QThread безопасно освобождается очередью Qt.
|
||||
|
||||
def _invalidate(self, *_): # Аргументы сигналов Qt не нужны для сброса результата.
|
||||
self.comparison = None # Старые показатели больше не соответствуют выбранным параметрам.
|
||||
self.analysis.set_result(None) # После изменения ввода прежняя гипотеза больше не является актуальной.
|
||||
self.table.setRowCount(0) # Убираем устаревшие численные значения.
|
||||
self.report_button.setEnabled(False) # Запрещаем экспорт прежнего результата.
|
||||
self.plot._series = [] # Старые кривые также не должны выглядеть актуальными.
|
||||
self.legend.clear() # Легенда очищается вместе с кривыми.
|
||||
self.plot._sync_bounds() # Адаптер графика пересчитывает пустую область просмотра.
|
||||
self.plot.update() # Запрашиваем перерисовку в главном потоке.
|
||||
if self.references: # После загрузки эталона подсказываем следующий шаг.
|
||||
self.status.setText('Параметры изменены — нажмите «Сравнить».') # Новый результат получается только явным расчётом.
|
||||
|
||||
def _match_reference(self, *_): # Смена канала измерения ищет одноимённый столбец эталона.
|
||||
name = self.source_combo.currentText().strip().casefold() # Регистр и крайние пробелы не мешают совпадению имён.
|
||||
for index in range(self.reference_combo.count()): # Проверяем доступные каналы текущего эталона.
|
||||
if self.reference_combo.itemText(index).strip().casefold() == name: # Сопоставляем полное имя вместе с единицами.
|
||||
self.reference_combo.setCurrentIndex(index) # Предлагаем канал, соответствующий измерению.
|
||||
break # Уникальные имена не требуют дальнейшего поиска.
|
||||
self._invalidate() # Даже без совпадения старые показатели должны быть удалены.
|
||||
|
||||
def _open_reference(self): # Правила начальной папки задаёт callback приложения.
|
||||
path, _ = QFileDialog.getOpenFileName(self, 'Открыть эталон', self._dialog_path(''), 'CSV (*.csv)') # Общая библиотека не создаёт каталоги самостоятельно.
|
||||
if path: # Отмена выбора файла сохраняет текущий эталон.
|
||||
self.load_reference(path) # Чтение выполняется отдельным worker.
|
||||
|
||||
def load_reference(self, path): # Публичный вход позволяет потребителю открыть эталон программно.
|
||||
self._invalidate() # Новая загрузка не должна показывать старый отчёт как актуальный.
|
||||
self.status.setText('Загрузка эталона…') # Состояние обновляется до запуска чтения.
|
||||
def receive(traces): # Этот обработчик выполняется в потоке интерфейса.
|
||||
if self._closing: # Синхронное закрытие могло опередить доставку готового чтения.
|
||||
return # Не обновляем элементы закрываемой панели поздним результатом.
|
||||
self.references = traces # Принимаем только полностью прочитанный набор каналов.
|
||||
self.reference_path = str(path) # Путь отчёта соответствует принятому файлу.
|
||||
self.reference_combo.clear() # Удаляем имена каналов предыдущего эталона.
|
||||
self.reference_combo.addItems(list(traces)) # Сохраняем порядок столбцов CSV.
|
||||
self._match_reference() # Автоматически выбираем одноимённый канал при наличии.
|
||||
self.status.setText(f'Эталон: {Path(path).name}. Выберите каналы и нажмите «Сравнить».') # Подтверждаем успешную загрузку файла.
|
||||
self._start_work(lambda cancel: read_reference(path, cancel), receive) # Ядро получает callback отмены чтения.
|
||||
|
||||
def _visible_interval(self): # Видимая область графика задаёт границы расчёта.
|
||||
bounds = self.plot.visible_bounds # Контракт графика возвращает время в миллисекундах.
|
||||
left, right = bounds.left * 1000, bounds.right * 1000 # Множитель 1000 переводит миллисекунды в микросекунды UI.
|
||||
self.limit_interval.setChecked(True) # Явно включаем использование выбранных границ.
|
||||
self.start.setValue(left) # Левая граница отсчитывается от начала измерения.
|
||||
self.stop.setValue(right) # Правая граница выражена в той же шкале.
|
||||
|
||||
def _calculate(self): # Фиксируем параметры до передачи задания в поток.
|
||||
if not self.references or not self.sources or self._worker is not None: # Не запускаем неполное или параллельное сравнение.
|
||||
return # Сохраняем существующее задание и состояние входов.
|
||||
source_index = self.source_combo.currentIndex() # Индекс связывает выбранное имя с исходным снимком.
|
||||
signal, points = self.sources[source_index] # Полная история не зависит от экранного окна.
|
||||
reference = self.references[self.reference_combo.currentText()] # Выбираем один канал загруженного эталона.
|
||||
units = [re.search(r'\(([^()]*)\)\s*$', name) for name in (signal.name, reference.name)] # Единицы распознаются по конечным скобкам имени.
|
||||
if all(units) and units[0].group(1) != units[1].group(1): # Явно разные единицы нельзя сравнивать как одинаковые амплитуды.
|
||||
self._invalidate() # Предыдущий результат не относится к новому сочетанию каналов.
|
||||
self.status.setText('Единицы каналов различаются. Выберите каналы с одинаковыми единицами.') # Пользователь выбирает корректную пару.
|
||||
return # Не выполняем численный проход с несовместимыми единицами.
|
||||
options = dict(align_start=self.align_start.isChecked(), shift_ms=self.shift.value() / 1000., # Деление на 1000 переводит микросекунды UI в миллисекунды ядра.
|
||||
absolute_tolerance=self.absolute.value(), relative_tolerance_pct=self.relative.value(), # Допуски уже заданы в единицах ядра.
|
||||
interval=(self.start.value() / 1000., self.stop.value() / 1000.) if self.limit_interval.isChecked() else None) # Ограничение времени также переводится из мкс в мс.
|
||||
self._invalidate() # До расчёта удаляем старые кривые и показатели.
|
||||
self.status.setText('Сравнение всех отсчётов…') # Явно указываем работу с полной записью.
|
||||
options['circuit'] = self.circuit.values() # Значения GUI переводятся в СИ до перехода в рабочий поток.
|
||||
sources, references = self.sources, self.references # Сохраняем единый снимок связанных каналов и выбранного CSV.
|
||||
def operation(cancel): # Подготовка амплитуд и сравнение выполняются в worker.
|
||||
measured = self._source_cache.get(source_index) # Кэш привязан к неизменяемому снимку канала.
|
||||
if measured is None: # Преобразуем исходные значения только при первом использовании канала.
|
||||
measured = trace_from_pairs(signal.name, points, signal.display_value, cancel) # Применяем предоставленное источником преобразование амплитуд.
|
||||
self._source_cache[source_index] = measured # Повторные настройки допуска не требуют новой подготовки измерения.
|
||||
channels = _model_channels(sources, references, self._source_cache, cancel) # Синхронные Uce/Uge/Ic подготавливаются теми же преобразованиями амплитуд.
|
||||
return compare(measured, reference, cancel=cancel, channels=channels, **options) # Общее ядро выполняет полную статистику и идентификацию электрических моделей.
|
||||
self._start_work(operation, self._received) # Получатель публикует целый результат в главном потоке.
|
||||
|
||||
def _received(self, result): # Таблица и график обновляются из одного результата.
|
||||
if self._closing: # Готовый результат мог стоять в очереди во время смены записи.
|
||||
return # Закрытая панель не должна публиковать устаревшие метрики.
|
||||
self.comparison = result # Сохраняем данные для переключения вида и экспорта.
|
||||
self.analysis.set_result(result) # Краткий вывод обновляется вместе с полной таблицей сравнения.
|
||||
populate_comparison_table(self.table, result) # Единицы и подсказки названий и чисел совпадают с боковой таблицей исходного графика.
|
||||
self.status.setText(f'{result.measured.name} ↔ {Path(self.reference_path).name}: {result.reference.name}. ' # Статус указывает фактически сравниваемые каналы и файл.
|
||||
'Время от начала измерения; абсолютные ошибки — в единицах выбранного канала.') # Поясняем шкалу и единицы результата.
|
||||
self._show_plot() # Показываем текущий режим кривых без повторного расчёта.
|
||||
|
||||
def _show_plot(self, *_): # Сигнал выбора режима может передавать неиспользуемый индекс.
|
||||
if self.comparison is None: # До успешного расчёта график результата отсутствует.
|
||||
return # Не создаём кривые из устаревших данных.
|
||||
result = self.comparison # Кривые и остаток принадлежат одному расчёту.
|
||||
curves = [(result.measured, 'Измерение', '#2f91ff'), (result.reference, 'Эталон', '#ffae42')] # Синий и оранжевый различают стороны наложения.
|
||||
self.legend.setText('<span style="color:#2f91ff">━━ Измерение</span> ' # Цвет легенды совпадает с измеренной кривой.
|
||||
'<span style="color:#ffae42">━━ Эталон</span> — общий масштаб Y') # Адаптер обязан сохранить единую амплитудную шкалу.
|
||||
if self.mode.currentIndex() == 1: # Второй режим показывает только рассчитанную разность.
|
||||
curves = [(result.difference, 'Δ', '#ff7b7b')] # Красноватый цвет отделяет остаток от исходных кривых.
|
||||
self.legend.setText('<span style="color:#ff7b7b">━━ Δ = измерение − эталон</span>') # Формула фиксирует знак ошибки.
|
||||
self.plot._series = [self._series_factory(str(i), f'{label}: {trace.name}', color=color, timestamps=trace.times, values=trace.values) # Фабрика создаёт контейнер конкретного canvas без импорта приложения.
|
||||
for i, (trace, label, color) in enumerate(curves)] # Передаём полные массивы без экранного сокращения.
|
||||
self.plot.reset_interaction() # Новый вид начинает с нейтрального состояния навигации.
|
||||
self.plot.axis_lock_x.setChecked(False) # Освобождаем X для корректного показа нового результата.
|
||||
self.plot.axis_lock_y.setChecked(False) # Общий масштаб Y не наследует ручную фиксацию предыдущего режима.
|
||||
self.plot.axis_limits = None # Удаляем прежние ручные границы осей.
|
||||
self.plot._sync_bounds() # Адаптер рассчитывает общую область кривых.
|
||||
interval = result.metrics['interval_ms'] # При ограниченном расчёте показываем выбранный интервал.
|
||||
if interval is not None: # Полная запись остаётся видимой при отсутствии ограничения.
|
||||
bounds = self.plot.visible_bounds # После сброса границы соответствуют полной области результата.
|
||||
span = bounds.right - bounds.left # Нормируем миллисекунды в долю общей длительности.
|
||||
self.plot.viewport = Viewport(x=(interval[0] - bounds.left) / span, width=(interval[1] - interval[0]) / span) # Масштаб X соответствует выбранному интервалу ядра.
|
||||
self.plot.update() # Отложенная перерисовка выполняется главным потоком Qt.
|
||||
|
||||
def report(self): # Структуру можно получить программно без диалога сохранения.
|
||||
if self.comparison is None: # Экспортировать устаревший или отсутствующий результат запрещено.
|
||||
return None # Отсутствие результата обозначается явно.
|
||||
return dict(measured_file=self.source_path, measured_channel=self.comparison.measured.name, # Источник измерения сохраняется рядом с выбранным каналом.
|
||||
reference_file=self.reference_path, reference_channel=self.comparison.reference.name, # Эталонный файл и канал определяют вторую сторону сравнения.
|
||||
time_unit='ms from first measured sample', # Машиночитаемый отчёт использует миллисекунды ядра.
|
||||
interpolation='linear; no extrapolation; gaps excluded', # Ограничения интерполяции сохраняются вместе с результатом.
|
||||
tolerance='absolute + relative_pct / 100 * abs(reference)', # Формула позволяет воспроизвести коридор допуска.
|
||||
metrics=self.comparison.metrics, analysis=self.comparison.analysis) # Отчёт сохраняет также гипотезы, признаки и ограничения анализа.
|
||||
|
||||
def _save_report(self): # Сохранение файла выполняется только по явному действию пользователя.
|
||||
if self.comparison is None: # Защищаемся от программного вызова без расчёта.
|
||||
return # Не создаём пустой отчёт.
|
||||
path, _ = QFileDialog.getSaveFileName(self, 'Отчёт сравнения', self._dialog_path('reference_comparison.json'), 'JSON (*.json)') # Provider определяет начальную папку приложения.
|
||||
if path: # Отмена выбора не меняет состояние результата.
|
||||
try: # Файловые ошибки должны отображаться без закрытия диалога.
|
||||
Path(path).write_text(json.dumps(self.report(), ensure_ascii=False, indent=2) + '\n', encoding='utf-8') # UTF-8 и отступ в два пробела сохраняют читаемость русских имён.
|
||||
self.status.setText(f'Отчёт сохранён: {path}') # Подтверждаем фактический путь записанного отчёта.
|
||||
except OSError as error: # Недоступный каталог или файл не уничтожает рассчитанные данные.
|
||||
self.status.setText(str(error)) # Пользователь может выбрать другое место и повторить сохранение.
|
||||
|
||||
|
||||
class ReferenceComparisonPanel(_ReferenceComparisonView, QWidget): # Встроенный вид занимает область существующего графика без отдельного окна.
|
||||
back_requested = Signal() # Потребитель решает, какую страницу показать при возврате к записи.
|
||||
|
||||
def __init__(self, *args, **kwargs): # Контракт данных и фабрик совпадает с отдельным диалогом.
|
||||
super().__init__(*args, **kwargs) # Создаём общие параметры, таблицу и график через QWidget.
|
||||
self.back_button = QPushButton('К записи') # Возврат сохраняет загруженный эталон и параметры скрытой панели.
|
||||
self.back_button.clicked.connect(self.back_requested.emit) # Не связываем общую библиотеку с компоновкой конкретной вкладки.
|
||||
row = QHBoxLayout() # Отдельная короткая строка не сжимает параметры сравнения.
|
||||
row.addWidget(self.back_button) # Кнопка размещается у начала панели.
|
||||
row.addStretch(1) # Свободная ширина остаётся справа от кнопки возврата.
|
||||
self.layout().insertLayout(0, row) # Навигация предшествует выбору файлов и каналов.
|
||||
|
||||
def closeEvent(self, event): # Родитель может удалить панель сразу после close при смене записи.
|
||||
self._closing = True # Сигнал завершения worker больше не должен возобновлять использование панели.
|
||||
self._shutdown() # Синхронно отменяем и дожидаемся потока перед возможным deleteLater родителя.
|
||||
self.plot.close() # Освобождаем ресурсы графика после завершения вычислений.
|
||||
super().closeEvent(event) # QWidget принимает закрытие встроенной панели.
|
||||
|
||||
|
||||
class ReferenceComparisonDialog(_ReferenceComparisonView, QDialog): # Отдельное окно остаётся доступным другим потребителям общего модуля.
|
||||
def __init__(self, *args, **kwargs): # Используем тот же контракт источников и внедряемых фабрик.
|
||||
super().__init__(*args, **kwargs) # Общая реализация строит элементы внутри QDialog.
|
||||
self.setWindowModality(Qt.WindowModality.WindowModal) # Модальность ограничивается родительским окном.
|
||||
self.resize(1350, 880) # Размер в логических пикселях сохраняет прежний макет отдельного окна.
|
||||
|
||||
def reject(self): # Escape и программное закрытие откладываются до остановки worker.
|
||||
if self._worker is not None: # Работающий поток должен закончиться раньше удаления диалога.
|
||||
self._closing = True # Запоминаем запрос закрытия до сигнала finished.
|
||||
self._cancel() # Кооперативно прерываем операцию ядра.
|
||||
return # Слот _finished завершит закрытие после остановки.
|
||||
self.plot.close() # Освобождаем ресурсы конкретного canvas.
|
||||
super().reject() # Сохраняем стандартный API и сигналы QDialog.
|
||||
|
||||
def closeEvent(self, event): # Системная кнопка закрытия соблюдает тот же порядок отмены.
|
||||
if self._worker is not None: # Не уничтожаем QThread во время операции.
|
||||
self._closing = True # Запоминаем отложенное закрытие.
|
||||
self._cancel() # Запрос будет замечен ядром в контрольной точке.
|
||||
event.ignore() # Диалог существует до завершения worker.
|
||||
else: # Завершённый расчёт не препятствует закрытию.
|
||||
self.plot.close() # График завершает собственную фоновую работу.
|
||||
super().closeEvent(event) # Передаём QDialog штатное закрытие.
|
||||
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
@@ -7,8 +7,11 @@
|
||||
from __future__ import annotations
|
||||
|
||||
from dataclasses import dataclass
|
||||
from collections import deque # Храним ограниченную историю FD для отдельного просмотра диагностики.
|
||||
from ..can_adapter_settings import SlcanOptions, FD_LENGTHS # Профиль прошивки определяет команды и допустимые длины CAN FD.
|
||||
import re # Поиск ближайшего служебного байта за один проход сохраняет скорость при пакетном приёме большого числа CAN-кадров.
|
||||
|
||||
from .qt_compat import QObject, Signal
|
||||
from .qt_compat import QObject, Signal, QElapsedTimer, QTimer # Таймеры ограничивают ожидание ответов и откладывают выдачу кадров до окончания настройки.
|
||||
from .qt_compat import QSerialPort, QSerialPortInfo
|
||||
|
||||
|
||||
@@ -33,11 +36,7 @@ class SlcanChannel:
|
||||
return "slcan"
|
||||
|
||||
|
||||
_BITRATE_COMMANDS = {
|
||||
10_000: "S0", 20_000: "S1", 50_000: "S2", 100_000: "S3",
|
||||
125_000: "S4", 250_000: "S5", 500_000: "S6", 800_000: "S7",
|
||||
1_000_000: "S8",
|
||||
}
|
||||
_RECORD_END = re.compile(rb"[\r\n\x07]") # CR, LF и BEL имеют коды ASCII 13, 10 и 7; любой из них завершает запись протокола.
|
||||
|
||||
|
||||
def encode_frame(can_id: int, data: bytes, *, extended: bool | None = None) -> bytes:
|
||||
@@ -80,6 +79,7 @@ class SlcanAdapter(QObject):
|
||||
frame_received = Signal(int, bytes)
|
||||
capture_received = Signal(int, bytes, bool, bool)
|
||||
connection_lost = Signal(str)
|
||||
fd_received = Signal(int, bytes, bool, int, int) # Отдельный маршрут FD исключает ошибочный разбор кадра как Classic CAN.
|
||||
|
||||
def __init__(self, parent: QObject | None = None) -> None:
|
||||
super().__init__(parent)
|
||||
@@ -88,10 +88,19 @@ class SlcanAdapter(QObject):
|
||||
self._serial.errorOccurred.connect(self._error)
|
||||
self._buffer = bytearray()
|
||||
self._listen_only = False
|
||||
self.options = SlcanOptions() # Без расширенных параметров остаётся прежний подтверждаемый протокол Lawicel.
|
||||
self.fd_history = deque(maxlen=500) # Не более 500 последних FD-кадров сохраняется между открытиями окна просмотра.
|
||||
self._query_prefix = None # Диагностические ответы отличаем от подтверждений настройки и CAN-кадров.
|
||||
self._query_reply = None # Полная строка ответа сохраняется только во время явного диагностического запроса.
|
||||
self._initializing = False # Открытие COM-порта ещё не подтверждает настройку CAN-контроллера.
|
||||
self._waiting_command = False # Отличаем подтверждение текущей команды от служебных строк рабочего потока.
|
||||
self._command_reply: bool | None = None # None означает ожидание, True — CR/ACK, False — BEL/отказ прошивки.
|
||||
self._after_cr = False # Следующий LF после CR относится к тому же окончанию строки, даже при раздельных USB-пакетах.
|
||||
self._pending_frames: list[tuple[int, bytes, bool]] = [] # Кадры при открытии CAN сохраняются до готовности подписчиков монитора.
|
||||
|
||||
@property
|
||||
def connected(self) -> bool:
|
||||
return self._serial.isOpen()
|
||||
return self._serial.isOpen() and not self._initializing # Считаем соединение готовым только после подтверждения всех команд настройки.
|
||||
|
||||
def scan(self) -> list[SlcanChannel]:
|
||||
# Windows не предоставляет надёжного признака протокола SLCAN.
|
||||
@@ -102,11 +111,11 @@ class SlcanAdapter(QObject):
|
||||
|
||||
def connect_channel(self, channel: SlcanChannel, bitrate: int,
|
||||
host_baudrate: int = 115200,
|
||||
listen_only: bool = False) -> None:
|
||||
listen_only: bool = False, *, options: SlcanOptions | None = None) -> None: # Расширенные параметры передаются отдельно от прежнего контракта подключения.
|
||||
selected = options or SlcanOptions() # Дефолт сохраняет C, Sn и O/L с ожиданием CR/BEL.
|
||||
commands = selected.commands(bitrate, listen_only) # Проверяем весь профиль до закрытия прежнего соединения и открытия COM.
|
||||
self.disconnect_channel()
|
||||
command = _BITRATE_COMMANDS.get(bitrate)
|
||||
if command is None:
|
||||
raise SlcanError(f"SLCAN не поддерживает {bitrate} бит/с")
|
||||
self.options = selected # Настройка ожидания команд нужна уже во время инициализации порта.
|
||||
self._serial.setPortName(channel.path)
|
||||
if host_baudrate not in (9600, 19200, 38400, 57600, 115200,
|
||||
230400, 460800, 921600):
|
||||
@@ -119,23 +128,67 @@ class SlcanAdapter(QObject):
|
||||
if not self._serial.open(QSerialPort.OpenModeFlag.ReadWrite):
|
||||
raise SlcanError(f"Не удалось открыть {channel.path}: {self._serial.errorString()}")
|
||||
self._buffer.clear()
|
||||
self.fd_history.clear() # Журнал нового подключения не содержит сообщений прежнего устройства.
|
||||
self._listen_only = listen_only
|
||||
# Close first so reconnecting also works after an interrupted session.
|
||||
open_command = "L" if listen_only else "O"
|
||||
if self._serial.write(f"C\r{command}\r{open_command}\r".encode("ascii")) < 0:
|
||||
message = self._serial.errorString()
|
||||
self._serial.close()
|
||||
self._listen_only = False
|
||||
raise SlcanError(f"Не удалось настроить SLCAN: {message}")
|
||||
self._initializing = True # Во время настройки не выдаём ложный статус готовности и первые кадры с прежней скоростью CAN.
|
||||
try: # Любой отказ настройки должен закрыть порт и разрешить повторную попытку подключения.
|
||||
self._command("C", allow_rejection=True) # Закрываем прежний канал; BEL допустим, если канал уже закрыт по правилам Lawicel.
|
||||
for command in commands: # Профиль определяет порядок скорости, режима, фильтров, повторов и открытия.
|
||||
self._command(command) # Любой отказ прекращает настройку без опасного возврата к активному режиму.
|
||||
except SlcanError: # Отказ прошивки, неполная запись и отсутствие ответа одинаково означают неудачное подключение.
|
||||
self._serial.close() # Освобождаем COM-порт, чтобы пользователь мог исправить скорость или тип адаптера.
|
||||
self._buffer.clear() # Остатки неудачного обмена не должны повреждать строки следующего подключения.
|
||||
self._pending_frames.clear() # Не отправляем в монитор данные сеанса, который не удалось открыть.
|
||||
self._listen_only = False # Сбрасываем ограничение режима вместе с неудачным подключением.
|
||||
raise # Сохраняем точную причину отказа для статусной строки вызывающей вкладки.
|
||||
finally: # Признак настройки должен сбрасываться как при успехе, так и при исключении.
|
||||
self._initializing = False # После возврата вызывающая вкладка сможет установить правильную скорость и статус.
|
||||
QTimer.singleShot(0, self._read) # Выдаём накопленные первые кадры в следующем цикле Qt, после обновления настроек монитора.
|
||||
|
||||
def _command(self, command: str, *, allow_rejection: bool = False) -> None: # Последовательный обмен сохраняет синхронный контракт подключения всех вкладок.
|
||||
self._read() # Убираем ранее пришедшие ответы до начала ожидания новой команды.
|
||||
self._command_reply = None # Старое подтверждение не может подтверждать следующую настройку.
|
||||
self._waiting_command = True # Пустая строка CR или отдельный BEL теперь относятся к текущей команде.
|
||||
packet = (command + "\r").encode("ascii") # Каждая команда Lawicel передаётся отдельной строкой с завершающим ASCII CR.
|
||||
elapsed = QElapsedTimer() # Монотонное время не зависит от перевода системных часов Windows.
|
||||
elapsed.start() # Общий срок ожидания включает запись команды и все фрагменты ответа.
|
||||
try: # Флаг ожидания обязательно очищается при любом результате обмена.
|
||||
if self._serial.write(packet) != len(packet): # Частичная локальная запись также не гарантирует передачу полной команды адаптеру.
|
||||
raise SlcanError(f"SLCAN: не удалось передать {command}: {self._serial.errorString()}") # Указываем неотправленную команду и причину драйвера.
|
||||
if self.options.profile in ("canable", "canable2"): # Эти прошивки не предоставляют CR/BEL для подтверждения конфигурации.
|
||||
if self._serial.bytesToWrite() and not self._serial.waitForBytesWritten(self.options.command_timeout_ms): # Ждём фактическую передачу очереди Qt в драйвер, а не выдуманный ACK.
|
||||
raise SlcanError(f"CANable: не удалось отправить {command}") # Ошибка локального драйвера не считается успешным подключением.
|
||||
self._serial.waitForReadyRead(20) # Пауза до 20 мс даёт прошивке обработать отдельную команду USB CDC.
|
||||
self._read() # Сохраняем уже пришедшие CAN-кадры, не требуя неподдерживаемого служебного ответа.
|
||||
if self._command_reply is False or not self._serial.isOpen(): # Не игнорируем явный BEL и отключение даже в профиле без ACK.
|
||||
raise SlcanError(f"CANable: отказ при выполнении {command}") # Пользователь получает конкретный этап неудачной настройки.
|
||||
return # Статус интерфейса отдельно сообщает, что профиль не подтверждает команды.
|
||||
while self._command_reply is None and self._serial.isOpen(): # CAN-кадры между служебными ответами не заменяют подтверждение команды.
|
||||
remaining = self.options.command_timeout_ms - elapsed.elapsed() # Общий выбранный тайм-аут включает все фрагменты ответа команды.
|
||||
if remaining <= 0: # Поток посторонних байтов не должен удерживать подключение в ожидании навсегда.
|
||||
break # Далее сформируем понятную ошибку отсутствия SLCAN-ответа.
|
||||
if self._serial.bytesAvailable() or self._serial.waitForReadyRead(remaining): # Используем уже поступившие байты или ждём только в пределах общего срока.
|
||||
self._read() # Тот же обработчик разбирает ответы CR/BEL и сохраняет встреченные CAN-кадры.
|
||||
else: # Драйвер завершил ожидание без новых данных либо порт был отключён.
|
||||
break # Не запускаем повторный полный тайм-аут на ту же команду.
|
||||
if not self._serial.isOpen(): # Физическое отключение во время настройки не является подтверждением команды.
|
||||
raise SlcanError(f"SLCAN: порт закрыт при выполнении {command}: {self._serial.errorString()}") # Сообщаем о потере порта на конкретном этапе.
|
||||
if self._command_reply is None: # Успешное открытие COM и запись в драйвер сами по себе не доказывают поддержку Lawicel.
|
||||
raise SlcanError(f"SLCAN: нет ответа на {command}; проверьте тип адаптера и скорость COM") # Направляем пользователя к настройкам, влияющим на обмен ASCII-командами.
|
||||
if not self._command_reply and not allow_rejection: # Только отказ повторного C при уже закрытом канале допускается протоколом настройки.
|
||||
raise SlcanError(f"SLCAN: адаптер отклонил команду {command} (BEL)") # Отказ скорости или режима CAN больше не маскируется статусом подключения.
|
||||
finally: # После команды подтверждения рабочего потока больше не меняют результат настройки.
|
||||
self._waiting_command = False # Возвращаем обработчик приёма в обычный режим.
|
||||
|
||||
def disconnect_channel(self) -> None:
|
||||
if not self._serial.isOpen():
|
||||
return
|
||||
self._serial.write(b"C\r")
|
||||
self._serial.waitForBytesWritten(100)
|
||||
self._serial.close()
|
||||
self._buffer.clear()
|
||||
self._listen_only = False
|
||||
if self._serial.isOpen(): # Команда закрытия нужна только для реально открытого COM-порта.
|
||||
self._serial.write(b"C\r") # Просим прошивку остановить CAN до освобождения порта.
|
||||
self._serial.waitForBytesWritten(100) # Ограничиваем ожидание отправки закрытия ста миллисекундами, чтобы не задерживать выход.
|
||||
self._serial.close() # Освобождаем порт независимо от доступности прошивки.
|
||||
self._buffer.clear() # Частичная строка прежнего сеанса не должна приклеиваться к первому кадру нового подключения.
|
||||
self._pending_frames.clear() # Отложенный обработчик Qt не должен выдавать кадры после отключения или переподключения.
|
||||
self._after_cr = False # Новый сеанс начинает разбор окончаний строк без состояния предыдущего CR.
|
||||
self._listen_only = False # Отключённый транспорт не сохраняет ограничение старого режима.
|
||||
|
||||
def send(self, can_id: int, data: bytes, *, extended: bool = True) -> None:
|
||||
if not self.connected:
|
||||
@@ -149,24 +202,109 @@ class SlcanAdapter(QObject):
|
||||
raise SlcanError(f"SLCAN не передал CAN-кадр: {self._serial.errorString()}")
|
||||
|
||||
def _read(self) -> None:
|
||||
self._buffer.extend(bytes(self._serial.readAll()))
|
||||
while b"\r" in self._buffer:
|
||||
raw, _, remainder = self._buffer.partition(b"\r")
|
||||
self._buffer[:] = remainder
|
||||
frame = decode_frame(raw)
|
||||
if frame is not None:
|
||||
self.capture_received.emit(frame[0], frame[1], raw[:1] == b'T', False)
|
||||
self.frame_received.emit(*frame)
|
||||
if not self._serial.isOpen(): # Отложенное чтение после закрытия не должно обращаться к неоткрытому драйверу.
|
||||
return # Отключение уже очистило очередь и неполную строку.
|
||||
self._buffer.extend(bytes(self._serial.readAll())) # Накапливаем фрагменты USB/COM до полного кадра или служебного ответа.
|
||||
while self._buffer: # За одно чтение драйвер может вернуть несколько кадров и подтверждений команд.
|
||||
if self._after_cr: # CR+LF считается одним окончанием, даже если LF пришёл в следующем чтении.
|
||||
self._after_cr = False # Состояние относится только к ближайшему байту после CR.
|
||||
if self._buffer[0] == 10: # ASCII LF имеет код 10 и не является началом следующего SLCAN-кадра.
|
||||
del self._buffer[0] # Удаляем дополнительный LF, чтобы он не мешал распознаванию t/T и не давал второй ACK.
|
||||
continue # Продолжаем с первого байта следующей записи, если он уже поступил.
|
||||
boundary = _RECORD_END.search(self._buffer) # Ищем первый разделитель, не сканируя весь остаток пакета отдельно для отсутствующих LF и BEL.
|
||||
if boundary is None: # Неполную строку нельзя декодировать до поступления окончания.
|
||||
break # Сохраняем её в буфере для следующего readyRead.
|
||||
end = boundary.start() # Ближайшая граница сохраняет исходный порядок кадров и подтверждений команд.
|
||||
raw = bytes(self._buffer[:end]) # Получаем строку без служебного разделителя.
|
||||
separator = self._buffer[end] # Тип разделителя отличает подтверждение команды от BEL.
|
||||
del self._buffer[:end + 1] # Удаляем обработанную запись, не теряя оставшуюся часть потока.
|
||||
self._after_cr = separator == 13 # ASCII CR имеет код 13; следующий LF принадлежит этому же окончанию.
|
||||
if separator == 7: # ASCII BEL имеет код 7 и сообщает об отклонении последней команды.
|
||||
if self._waiting_command and self._command_reply is None: # Принимаем только первый ответ текущего этапа настройки.
|
||||
self._command_reply = False # Сохраняем отказ для проверки в последовательном обмене командами.
|
||||
continue # BEL не должен приклеиваться к следующему CAN-кадру.
|
||||
if self.options.fd and raw[:1] in (b"d", b"D", b"b", b"B") and self._receive_fd(raw): # Только корректная FD-строка забирается отдельным маршрутом; версия CANable может начинаться с HEX-буквы.
|
||||
continue # Даже FD с данными до восьми байтов не меняет тип при передаче подписчикам.
|
||||
frame = decode_frame(raw) # Кадры STD/EXT декодируются прежним публичным кодеком.
|
||||
if frame is not None: # Служебные строки и ответы прошивки не попадают в общий монитор CAN.
|
||||
self._pending_frames.append((frame[0], frame[1], raw[:1] == b"T")) # Сохраняем данные и признак EXT, включая первые кадры во время открытия.
|
||||
elif raw and self._query_prefix is not None and raw.startswith(self._query_prefix): # Диагностические строки распознаются только после исключения CAN-кадров.
|
||||
self._query_reply = raw.decode("ascii", errors="replace") # Версия CANable не имеет префикса V, поэтому допускается пустой ожидаемый префикс.
|
||||
elif not raw and self._waiting_command and self._command_reply is None: # Пустая строка CR означает ACK по Lawicel; строка с CAN-кадром не подтверждает команду.
|
||||
self._command_reply = True # Разрешаем отправку следующей команды только после реального подтверждения.
|
||||
if not self._initializing: # Первые кадры выдаются после возврата подключения, когда вкладка уже установила скорость CAN.
|
||||
pending, self._pending_frames = self._pending_frames, [] # Отделяем очередь до вызова подписчиков, чтобы повторное чтение не дублировало кадры.
|
||||
for can_id, data, extended in pending: # Выдаём все накопленные кадры в исходном порядке.
|
||||
self.capture_received.emit(can_id, data, extended, False) # Полные метаданные наполняют общий CAN-монитор.
|
||||
self.frame_received.emit(can_id, data) # Совместимый сигнал сохраняет работу существующих клиентов ProtoCAN.
|
||||
|
||||
def _error(self, error: QSerialPort.SerialPortError) -> None:
|
||||
if error in (QSerialPort.SerialPortError.NoError,
|
||||
QSerialPort.SerialPortError.NotOpenError):
|
||||
return
|
||||
if error in (QSerialPort.SerialPortError.NoError, # Сигнал NoError не означает потерю соединения.
|
||||
QSerialPort.SerialPortError.NotOpenError, # Обращение после закрытия не требует повторного отключения.
|
||||
QSerialPort.SerialPortError.TimeoutError): # Тайм-аут синхронного ожидания проверяет сама команда; порт при этом остаётся исправным.
|
||||
return # Не превращаем отсутствие ответа на команду в ошибку физического соединения.
|
||||
if self._serial.isOpen():
|
||||
message = self._serial.errorString()
|
||||
self._serial.close()
|
||||
self._listen_only = False
|
||||
self.connection_lost.emit(f"Связь с SLCAN прервана: {message}")
|
||||
if not self._initializing: # При настройке исключение возвращает connect_channel, избегая повторного отключения из обработчика GUI.
|
||||
self.connection_lost.emit(f"Связь с SLCAN прервана: {message}") # Во время обычного приёма уведомляем вкладку о настоящем обрыве.
|
||||
|
||||
def close(self) -> None:
|
||||
self.disconnect_channel()
|
||||
|
||||
def _receive_fd(self, raw: bytes) -> bool: # Результат отличает корректный FD от диагностической строки с похожей первой буквой.
|
||||
extended = raw[:1] in (b"D", b"B") # Заглавная буква означает идентификатор длиной восемь HEX-цифр.
|
||||
width = 8 if extended else 3 # Стандартный ID занимает три HEX-цифры в ASCII-протоколе.
|
||||
try: # Сохраняем устойчивость потока при повреждённых USB/COM-строках.
|
||||
identifier = int(raw[1:1 + width], 16) # Извлекаем числовой ID без префикса команды.
|
||||
length = FD_LENGTHS[int(raw[1 + width:2 + width], 16)] # Четырёхбитный DLC переводится в фактическое число байтов.
|
||||
payload = bytes.fromhex(raw[2 + width:].decode("ascii")) # Для CANable FD не документирован дополнительный суффикс временной метки.
|
||||
except (ValueError, UnicodeError, IndexError): # Неполный ID, DLC или HEX-пара отклоняют только текущую запись.
|
||||
return False # Неподходящая строка ещё может оказаться ответом версии CANable.
|
||||
if len(payload) != length or not 0 <= identifier <= (0x1FFFFFFF if extended else 0x7FF): # Не обрезаем лишние байты и не принимаем отрицательный ID или идентификатор другого формата.
|
||||
return False # Повреждённые данные не должны выглядеть успешным приёмом.
|
||||
record = (identifier, payload, extended, 2 | (4 if raw[:1] in (b"b", b"B") else 0), 0) # CANable не предоставляет аппаратную метку; ноль явно обозначает её отсутствие.
|
||||
self.fd_history.append(("RX", record)) # История ограничена размером deque и доступна после открытия диагностики.
|
||||
self.fd_received.emit(*record) # В мост и прикладной декодер Classic этот кадр не поступает.
|
||||
return True # Вызывающий обработчик не должен повторно трактовать этот кадр как служебный ответ.
|
||||
|
||||
def send_fd(self, can_id: int, data: bytes, *, extended: bool = True, brs: bool = True) -> None: # Используем документированные команды расширения CANable 2.0.
|
||||
if not self.connected or self._listen_only or not self.options.fd: # Проверка защищает передачу независимо от состояния кнопок GUI.
|
||||
raise SlcanError("Передача FD требует активного подключения CAN FD") # Пассивный режим не допускает обхода через API.
|
||||
if len(data) not in FD_LENGTHS or not 0 <= can_id <= (0x1FFFFFFF if extended else 0x7FF): # Разрешаем только точные длины DLC без скрытого дополнения.
|
||||
raise SlcanError("Неверный CAN ID или длина CAN FD (0…8, 12, 16, 20, 24, 32, 48, 64)") # Сообщаем фактический набор допустимых размеров.
|
||||
prefix = ("B" if extended else "b") if brs else ("D" if extended else "d") # BRS выбирается буквой команды, а не полем ASCII-пакета.
|
||||
packet = f"{prefix}{can_id:0{8 if extended else 3}X}{FD_LENGTHS.index(len(data)):X}{data.hex().upper()}\r".encode("ascii") # ID, DLC и данные образуют одну завершённую строку SLCAN.
|
||||
if self._serial.write(packet) != len(packet): # Частичная запись не гарантирует доставку последнего CR в прошивку.
|
||||
raise SlcanError("SLCAN не передал CAN FD") # Причина остаётся видимой в диагностическом окне отправки.
|
||||
self.fd_history.append(("TX queued", (can_id, bytes(data), extended, 2 | (4 if brs else 0), 0))) # Локальная запись не выдаётся за подтверждение передачи на CAN.
|
||||
|
||||
def diagnostics(self) -> str: # Явная диагностика не меняет режим CAN и не выполняется фоновым таймером.
|
||||
if not self.connected: # Чтение версии не должно захватывать ещё не выбранный COM-порт.
|
||||
raise SlcanError("Сначала подключите адаптер") # Настройка и жизненный цикл подключения остаются под управлением пользователя.
|
||||
lines = [] # Ответы V и N читают сведения, F дополнительно сбрасывает индикатор ошибки согласно Lawicel.
|
||||
canable = self.options.profile != "lawicel" # CANable возвращает V без буквенного префикса, а регистр E иногда без завершающего CR.
|
||||
if canable: # Отсутствие подтверждения настроек сообщается независимо от успешного чтения версии.
|
||||
lines.append(f"Профиль {self.options.profile}: команды конфигурации без ACK/NACK; применение настроек не подтверждается прошивкой.") # Диагностика не превращает ответ V в подтверждение предыдущих M/A/Y.
|
||||
for command in (("V", "E") if canable else ("V", "N", "F")): # Набор фиксирован спецификацией выбранной прошивки.
|
||||
self._read() # Сначала выдаём уже накопленные CAN-кадры, не смешивая их с ответом запроса.
|
||||
self._query_prefix, self._query_reply = (b"" if canable else command.encode("ascii")), None # CANable не использует префикс V в строке версии.
|
||||
elapsed = QElapsedTimer() # Ограничиваем полный запрос монотонным временем, а не числом фрагментов.
|
||||
elapsed.start() # Тайм-аут включает отправку и все поступившие строки CAN.
|
||||
try: # Состояние запроса очищается также при ошибке записи или обрыве порта.
|
||||
packet = (command + "\r").encode("ascii") # Все команды завершаются одиночным CR протокола Lawicel.
|
||||
if self._serial.write(packet) != len(packet): # Локальная ошибка передачи должна быть видна вызывающему коду.
|
||||
raise SlcanError(f"Не удалось отправить {command}") # Указываем конкретный отказавший диагностический запрос.
|
||||
while self._query_reply is None and self.connected: # Приём CAN-кадров продолжается тем же обработчиком.
|
||||
remaining = self.options.command_timeout_ms - elapsed.elapsed() # Поток кадров не должен бесконечно продлевать ожидание версии.
|
||||
if remaining <= 0 or not (self._serial.bytesAvailable() or self._serial.waitForReadyRead(remaining)): # Отсутствие ответа завершает только текущий запрос.
|
||||
break # Следующие строки диагностики покажут, какая команда не поддерживается.
|
||||
self._read() # Ответ распознаётся по префиксу, а CAN продолжает поступать обычным подписчикам.
|
||||
if command == "E" and self._buffer.startswith(b"CANable Error Register:"): # Документированная исходная прошивка может возвращать E без CR.
|
||||
self._query_reply = bytes(self._buffer).decode("ascii", errors="replace") # Такой ответ принимаем только после завершения ожидания, не обрезая поток CAN.
|
||||
self._buffer.clear() # Нетерминированная служебная строка не должна приклеиваться к следующему CAN-кадру.
|
||||
lines.append(self._query_reply or f"{command}: нет ответа") # Отсутствие данных не заменяем выдуманными версией или нулевыми ошибками.
|
||||
finally: # Следующий обычный приём не должен сохранять посторонние строки как ответ старого запроса.
|
||||
self._query_prefix = None # Завершаем явную диагностическую транзакцию.
|
||||
return "\n".join(lines) # Текст можно скопировать для анализа состояния устройства.
|
||||
|
||||
@@ -11,12 +11,15 @@ from protocan import tms_firmware as wire
|
||||
class TmsBootloader(QObject):
|
||||
progress = Signal(int, str)
|
||||
finished = Signal(bool, str)
|
||||
request_sent = Signal(bytes)
|
||||
|
||||
def __init__(self, parent=None):
|
||||
super().__init__(parent)
|
||||
self._serial = QSerialPort(self)
|
||||
self._serial.readyRead.connect(self._read)
|
||||
self._serial.errorOccurred.connect(self._error)
|
||||
self._owned_serial = self._serial
|
||||
self._owns_serial = True
|
||||
self._timeout = QTimer(self)
|
||||
self._timeout.setSingleShot(True)
|
||||
self._timeout.timeout.connect(lambda: self._finish(False, f"Тайм-аут {self._stage}"))
|
||||
@@ -31,6 +34,7 @@ class TmsBootloader(QObject):
|
||||
self._active = False
|
||||
self._waiting = False
|
||||
self._rx = bytearray()
|
||||
self.readback = bytearray()
|
||||
self._stage = ""
|
||||
|
||||
def start(self, image, port: str, baud: int, target: wire.TmsTarget):
|
||||
@@ -45,6 +49,8 @@ class TmsBootloader(QObject):
|
||||
return
|
||||
self._image, self._target = image, target
|
||||
self._active = True
|
||||
self._serial = self._owned_serial
|
||||
self._owns_serial = True
|
||||
self._serial.setPortName(port)
|
||||
self._serial.setBaudRate(baud)
|
||||
self._serial.setDataBits(QSerialPort.DataBits.Data8)
|
||||
@@ -54,8 +60,29 @@ class TmsBootloader(QObject):
|
||||
if not self._serial.open(QSerialPort.OpenModeFlag.ReadWrite):
|
||||
self._finish(False, self._serial.errorString())
|
||||
return
|
||||
self._begin()
|
||||
|
||||
def start_connected(self, image, serial, target: wire.TmsTarget):
|
||||
"""Use an existing port; its owner must forward RX and handle errors."""
|
||||
if self._active:
|
||||
return
|
||||
try:
|
||||
target.validate(len(image.data))
|
||||
if not serial.isOpen() or serial.baudRate() <= 0:
|
||||
raise ValueError("Подключите COM-порт в настройках 2812")
|
||||
except ValueError as error:
|
||||
self.finished.emit(False, str(error))
|
||||
return
|
||||
self._image, self._target = image, target
|
||||
self._serial = serial
|
||||
self._owns_serial = False
|
||||
self._active = True
|
||||
self._begin()
|
||||
|
||||
def _begin(self):
|
||||
self.readback.clear()
|
||||
self._response = None
|
||||
self._steps = wire.programming_steps(image.data, target)
|
||||
self._steps = wire.programming_steps(self._image.data, self._target)
|
||||
self._advance()
|
||||
|
||||
def _advance(self):
|
||||
@@ -66,6 +93,7 @@ class TmsBootloader(QObject):
|
||||
except StopIteration:
|
||||
self._finish(True, "Образ загружен в RAM TMS" if self._target.load_only
|
||||
else "Запись Spartan-6 подтверждена платой" if self._target.kind == "spartan6"
|
||||
else "Прошивка записана; проверка отключена" if not self._target.verify
|
||||
else "Прошивка завершена, записанные данные проверены")
|
||||
return
|
||||
except (ValueError, RuntimeError) as error:
|
||||
@@ -79,11 +107,15 @@ class TmsBootloader(QObject):
|
||||
if self._serial.write(request) != len(request):
|
||||
self._finish(False, "Ошибка передачи " + self._stage)
|
||||
return
|
||||
self.request_sent.emit(request)
|
||||
if self._active:
|
||||
self._timeout.start(timeout + int(len(request) * 10000 / self._serial.baudRate()))
|
||||
self._timeout.start(timeout + int((len(request) + self._size) * 10000 / self._serial.baudRate()))
|
||||
|
||||
def _read(self):
|
||||
chunk = bytes(self._serial.readAll())
|
||||
self.receive(bytes(self._serial.readAll()))
|
||||
|
||||
def receive(self, chunk):
|
||||
"""Forward fragments from a shared port without reading it twice."""
|
||||
if not self._waiting:
|
||||
return
|
||||
self._rx.extend(chunk)
|
||||
@@ -116,6 +148,10 @@ class TmsBootloader(QObject):
|
||||
self._timeout.stop()
|
||||
self._settle.stop()
|
||||
self._waiting = False
|
||||
if self._command == wire.CMD_UPLOAD and self._target.kind == "tms":
|
||||
data = wire.decode_upload_reply(reply, self._target.controller, self._size - 8)
|
||||
remaining = len(self._image.data) - len(self.readback)
|
||||
self.readback.extend(data[:remaining])
|
||||
self._response = reply
|
||||
self._delay.start()
|
||||
|
||||
@@ -133,8 +169,10 @@ class TmsBootloader(QObject):
|
||||
self._active = self._waiting = False
|
||||
for timer in (self._timeout, self._settle, self._delay):
|
||||
timer.stop()
|
||||
if self._serial.isOpen():
|
||||
if self._owns_serial and self._serial.isOpen():
|
||||
self._serial.close()
|
||||
if not success:
|
||||
self.readback.clear()
|
||||
if success:
|
||||
self.progress.emit(100, message)
|
||||
self.finished.emit(success, message)
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
"""Debounced viewport statistics shared by desktop charts."""
|
||||
import time
|
||||
from threading import Event # Сигнал отмены позволяет фоновому расчёту прекращать обработку старого окна при продолжении масштабирования.
|
||||
from dataclasses import replace
|
||||
try:
|
||||
from PySide6.QtCore import QObject, QTimer, QThreadPool, Qt
|
||||
@@ -16,6 +17,7 @@ class ViewportNavigation(QObject):
|
||||
self.chart = chart
|
||||
self._navigation_revision = 0
|
||||
self._navigation_busy = False
|
||||
self._navigation_cancel = Event() # Отдельное потокобезопасное событие относится к текущему фоновому расчёту измерений.
|
||||
self._navigation_emitter = _NavigationSignals(self)
|
||||
self._navigation_emitter.ready.connect(self._navigation_ready, Qt.ConnectionType.QueuedConnection)
|
||||
self._navigation_timer = QTimer(self)
|
||||
@@ -23,9 +25,13 @@ class ViewportNavigation(QObject):
|
||||
self._navigation_timer.setInterval(180)
|
||||
self._navigation_timer.timeout.connect(self._navigation_finished)
|
||||
|
||||
def needs_worker(self): # Общая нагрузка всех каналов определяет допустимость синхронного расчёта, а не длина самого длинного ряда.
|
||||
return sum(len(series.values) for series in self.chart.plot._series) > 20000 # Бюджет 20000 исходных значений сохраняет быстрый путь малых записей и отправляет многоканальные окна в фон.
|
||||
|
||||
def _navigation_changed(self):
|
||||
self._navigation_revision += 1
|
||||
if max((len(s.values) for s in self.chart.plot._series), default=0) <= 20000:
|
||||
self._navigation_cancel.set() # Сразу отменяем статистику предыдущего окна, чтобы она не конкурировала с новой отрисовкой миллионов отсчётов.
|
||||
if not self.needs_worker(): # Проверяем суммарный объём тем же правилом, что используют панель измерений и легенда.
|
||||
self.chart._scope_measurements()
|
||||
self.chart._refresh_processing()
|
||||
self.chart._refresh_legend()
|
||||
@@ -35,7 +41,7 @@ class ViewportNavigation(QObject):
|
||||
def _navigation_finished(self):
|
||||
if False:
|
||||
return
|
||||
if max((len(s.values) for s in self.chart.plot._series), default=0) <= 20000:
|
||||
if not self.needs_worker(): # После задержки повторно проверяем текущие данные: источник мог измениться во время ожидания.
|
||||
self.chart._scope_measurements()
|
||||
self.chart._refresh_processing()
|
||||
return
|
||||
@@ -43,15 +49,16 @@ class ViewportNavigation(QObject):
|
||||
self._navigation_timer.start()
|
||||
return
|
||||
self._navigation_busy = True
|
||||
self._navigation_cancel = Event() # После окончания перемещения создаём новый независимый сигнал отмены для актуального окна.
|
||||
bounds = self.chart.plot.visible_bounds
|
||||
panel = self.chart.processing
|
||||
offset = self.chart._plot_time_offset if not self.chart.fft.isChecked() else 0.
|
||||
# Navigation changes the next calculation's domain; retained curves keep
|
||||
# their original domain. Avoid preparing millions of inputs on the UI.
|
||||
panel._snapshot = replace(panel._snapshot, x_range=(bounds.left + offset, bounds.right + offset))
|
||||
series = [(s.key, s.timestamps, s.values) for s in self.chart.plot._series if not s.discrete]
|
||||
QThreadPool.globalInstance().start(_NavigationJob(self._navigation_revision, series, bounds,
|
||||
self._navigation_emitter))
|
||||
series = [(s.key, s.timestamps, s.values) for s in self.chart.plot._series if s.visible and not s.discrete] # Скрытые каналы не занимают процессор повторным расчётом статистики при перемещении графика.
|
||||
QThreadPool.globalInstance().start(_NavigationJob(self._navigation_revision, series, bounds, # Фоновый расчёт использует полные исходные значения только актуального видимого окна.
|
||||
self._navigation_emitter, self._navigation_cancel)) # Передаём событие отмены вместе с существующими ревизией и каналом результата.
|
||||
|
||||
def _navigation_ready(self, revision, stats, bounds):
|
||||
self._navigation_busy = False
|
||||
|
||||
@@ -57,7 +57,14 @@ class WaveTransfer(QRunnable):
|
||||
result = protocol.status(words)
|
||||
if result['version'] >= 2:
|
||||
result = protocol.status(words, exchange(8)[0])
|
||||
return result
|
||||
try: # Дополнительные регистры объявляют XY независимо от версии прежнего восьмисловного статуса.
|
||||
channels,selected,maximum,other=exchange(12) # Четыре слова 0x1309…0x130C читаются общим C-кодеком.
|
||||
result.update(channels=channels,selected=selected,max_channels=maximum,received_other=other) # Сохраняет фактические возможности порта и состояние обеих таблиц.
|
||||
except ValueError as error: # Старые WG v1/v2/v3 отвечают исключением адреса либо имеют прежний native-кодек.
|
||||
if "(-102)" not in str(error) and "Недопустимая команда" not in str(error): # Ошибки CRC и структуры ответа нельзя скрывать как одноканальную плату.
|
||||
raise # Сохраняет штатный отказ передачи при повреждённом ответе.
|
||||
result.update(channels=1,max_channels=1) # Старый клиент и прошивка сохраняют одноканальную работу без новых записей.
|
||||
return result # Возможности XY проверяются до stop и изменения таблиц устройства.
|
||||
|
||||
status = read_status() # Positive device identification before any write.
|
||||
if self.action == "upload":
|
||||
@@ -66,27 +73,40 @@ class WaveTransfer(QRunnable):
|
||||
raise ValueError("Таблица не помещается в память устройства")
|
||||
if status['version'] == 1 and wave.sample_rate > 50000:
|
||||
raise ValueError("Для частоты выше 50 000 отсчётов/с обновите прошивку МК: нужна карта генератора версии 2")
|
||||
channel_codes=(wave.codes,) if not hasattr(wave,"codes_y") else (wave.codes,wave.codes_y) # Одна временная сетка содержит один канал либо обе координаты XY.
|
||||
if len(channel_codes)>status["max_channels"]: # Устройство обязано явно подтвердить аппаратный порт второго канала.
|
||||
raise ValueError("Для XY нужны прошивка F407/HOPE и native-кодек templates с поддержкой двух каналов") # Отказ происходит до остановки ранее работающего выхода.
|
||||
if any(len(codes)!=len(wave.codes) for codes in channel_codes): # Нельзя загружать пару с разными длинами даже из вручную созданного задания.
|
||||
raise ValueError("X и Y должны иметь одинаковую длину") # Не меняет оборудование при несовместимой временной сетке.
|
||||
exchange(1)
|
||||
if status["max_channels"]>=2: # Новый порт явно сбрасывает формат перед каждой загрузкой, включая возврат XY→mono.
|
||||
exchange(10,value=len(channel_codes)) # Выбирает число одновременно воспроизводимых каналов и инвалидирует обе прежние таблицы.
|
||||
if status['version'] >= 2:
|
||||
exchange(9, value=wave.sample_rate >> 16)
|
||||
exchange(2, value=wave.sample_rate & 0xffff)
|
||||
exchange(3, value=len(wave.codes))
|
||||
blocks = status['version'] >= 3 and getattr(port, 'supports_wave_blocks', False)
|
||||
step = 120 if blocks else 1
|
||||
for index in range(0, len(wave.codes), step):
|
||||
values = wave.codes[index:index + step]
|
||||
if blocks:
|
||||
transfer(protocol.block_request(index, values), protocol.block_response)
|
||||
else:
|
||||
exchange(4, index, values[0])
|
||||
self.signals.progress.emit(int((index + len(values)) * 50 / len(wave.codes)))
|
||||
for index in range(0, len(wave.codes), step):
|
||||
values = wave.codes[index:index + step]
|
||||
actual = (transfer(protocol.block_request(index, count=len(values)), protocol.block_response)
|
||||
if blocks else exchange(7, index))
|
||||
if tuple(actual) != tuple(values):
|
||||
raise ValueError(f"Проверка таблицы не пройдена: отсчёты с {index}")
|
||||
self.signals.progress.emit(50 + int((index + len(values)) * 50 / len(wave.codes)))
|
||||
total=len(wave.codes)*len(channel_codes)*2 # Прогресс учитывает запись и чтение каждого кода обеих координат.
|
||||
completed=0 # Общий счётчик исключает откат процентов при переходе от X к Y.
|
||||
for channel,codes in enumerate(channel_codes): # Загружает и проверяет X, затем Y без промежуточного пуска.
|
||||
if status["max_channels"]>=2: # Прежняя прошивка не получает неподдерживаемый селектор окна.
|
||||
exchange(11,value=channel) # Одинаковые block/sample команды адресуют выбранную координату через общий регистр 0x130A.
|
||||
for reading in (False,True): # Обратное чтение всей координаты обязательно до общего commit пары.
|
||||
for index in range(0,len(codes),step): # Блочный транспорт ограничен прежними 120 кодами на запрос.
|
||||
values=codes[index:index+step] # Последний блок содержит только действительные отсчёты без дополнения.
|
||||
if reading: # Проверка использует ту же границу блока и тот же селектор, что запись.
|
||||
actual=transfer(protocol.block_request(index,count=len(values)),protocol.block_response) if blocks else exchange(7,index) # Читает реальные коды из памяти устройства.
|
||||
if tuple(actual)!=tuple(values): # Любое расхождение запрещает общий commit и дальнейший пуск.
|
||||
raise ValueError(f"Проверка {'XY'[channel]} не пройдена: отсчёты с {index}") # Показывает ошибочную координату и начало блока.
|
||||
elif blocks: # SET v2 переносит тот же атомарно проверяемый RTU-блок из общего ядра templates.
|
||||
transfer(protocol.block_request(index,values),protocol.block_response) # Подтверждает запись всего блока до следующего запроса.
|
||||
else: # Старый UART/RTU клиент сохраняет поотсчётную загрузку без смены wire-контракта.
|
||||
exchange(4,index,values[0]) # Записывает очередной код выбранной координаты.
|
||||
completed+=len(values) # Каждый подтверждённый код учитывается ровно один раз на фазу.
|
||||
self.signals.progress.emit(int(completed*100/total)) # Общий прогресс монотонно достигает 100 % после проверки обеих таблиц.
|
||||
if status["max_channels"]>=2: # Итоговый статус возвращается к X для одинакового отображения mono и XY.
|
||||
exchange(11,value=0) # Не меняет содержимое пар и не запускает аппаратный вывод.
|
||||
exchange(5)
|
||||
elif self.action == "start":
|
||||
if not status["ready"]:
|
||||
@@ -98,6 +118,7 @@ class WaveTransfer(QRunnable):
|
||||
raise ValueError("Неизвестное действие")
|
||||
result = read_status()
|
||||
if self.action == "upload" and (not result["ready"] or result["running"] or
|
||||
result.get("channels",1)!=(2 if hasattr(self.waveform,"codes_y") else 1) or # Итоговое число каналов обязано совпасть с подготовленным mono/XY заданием.
|
||||
result["count"] != len(self.waveform.codes) or result["rate"] != self.waveform.sample_rate):
|
||||
raise ValueError("Устройство не подтвердило загруженную таблицу")
|
||||
if self.action in ("start", "stop") and result["running"] != (self.action == "start"):
|
||||
|
||||
Reference in New Issue
Block a user