Добавить USART USB мост G474 и общий четырёхканальный терминал

This commit is contained in:
2026-11-16 18:15:48 +03:00
parent 28fe22439c
commit 34d9016118
11 changed files with 827 additions and 0 deletions
@@ -0,0 +1,163 @@
"""Четырёхканальный терминал USB USART для страницы STM32G474VET6.""" # Общая панель используется SETGUI через тонкую интеграцию страницы MCU.
import queue # Ограничивает очередь команд GUI, чтобы ввод не вытеснял приём данных.
import time # Использует монотонные сроки подтверждений и обновления экрана.
from pathlib import Path # Создаёт раздельные бинарные журналы в выбранном пользователем каталоге.
from ..uart_usb import Native, Usb # Получает команды и проверенные события исключительно через C-ядро templates.
try: # Поддерживает штатную сборку SETGUI на современном Qt.
from PySide6.QtCore import QThread, Signal # Передаёт данные между USB worker и GUI очередью Qt.
from PySide6.QtWidgets import QWidget, QVBoxLayout, QHBoxLayout, QGridLayout, QLabel, QComboBox, QPushButton, QPlainTextEdit, QLineEdit, QFileDialog, QMessageBox, QCheckBox # Создаёт компактный терминал без отдельного главного окна.
except ImportError: # Сохраняет совместимость той же панели со сборкой Qt5 для Windows 7.
from PySide2.QtCore import QThread, Signal # Использует тот же контракт потока и сигналов на Qt5.
from PySide2.QtWidgets import QWidget, QVBoxLayout, QHBoxLayout, QGridLayout, QLabel, QComboBox, QPushButton, QPlainTextEdit, QLineEdit, QFileDialog, QMessageBox, QCheckBox # Подключает эквивалентные виджеты без второго UI.
class UsbWorker(QThread): # Выполняет все блокирующие WinUSB операции вне GUI потока.
data_ready = Signal(int, bytes, object) # Передаёт канал, ограниченный хвост данных и точное суммарное число принятых байтов.
stats_ready = Signal(int, object, object) # Передаёт 32-битные счётчики потерь и аппаратных ошибок без знакового ограничения Qt int.
status = Signal(str) # Показывает пользователю запуск, результат отправки либо причину отключения.
active = Signal(int) # Сообщает фактическое количество каналов из ACK прошивки после запуска.
def __init__(self, path, rates, directory=None, parent=None, native_factory=Native, usb_factory=Usb): # Позволяет проверять worker имитацией транспорта без подключённой платы.
super().__init__(parent) # Связывает жизненный цикл worker с панелью Qt.
self.path, self.rates, self.directory = path, rates, directory # Фиксирует параметры сессии до запуска фонового потока.
self.native_factory, self.usb_factory = native_factory, usb_factory # Обычная работа использует C DLL, тест может подставить ограниченный fake USB.
self.commands = queue.Queue(maxsize=4) # Не принимает бесконечное количество запросов передачи при медленном USART.
self.pending = [bytearray() for _ in range(4)] # Отделяет ограниченные хвосты предпросмотра каждого RX-канала.
self.totals, self.files = [0] * 4, [] # Считает все байты независимо от усечения экранного предпросмотра.
self.flush_at = time.monotonic() # Ограничивает частоту сигналов GUI, сохраняя непрерывное USB чтение.
def _read(self): # Принимает пакетную выдачу Windows-конвейера и классифицирует уже разобранные C события.
acknowledgements = [] # Собирает ACK отдельно от непрерывных RX и диагностических сообщений.
for event in self.native.feed(self.usb.read()): # Все длины, каналы и служебные поля проверены C parser и ub_describe.
if event.kind == 1: # Готовое ABI событие RX содержит только полезные байты одного канала.
index = event.channel - 1 # Переводит логический номер канала в индекс четырёх экранов и файлов.
self.totals[index] += len(event.data) # Учитывает каждый полученный байт до усечения предпросмотра.
self.pending[index].extend(event.data); del self.pending[index][:-8192] # Ограничивает накопление для GUI последними 8 КиБ на канал.
if self.files: self.files[index].write(event.data) # Записывает все бинарные байты без перекодирования, заголовков и усечения.
elif event.kind == 2: acknowledgements.append(event) # Передаёт ACK автомату ожидаемой команды без повторного разбора payload.
elif event.kind == 3: self.stats_ready.emit(event.channel, event.lost, event.errors) # Независимо обновляет счётчики потерь и ошибок прошивки.
self._flush() # Отправляет накопленный экранный хвост не чаще одного раза за 50 мс.
return acknowledgements # Возвращает только подтверждения для текущего синхронного шага worker.
def _flush(self, force=False): # Отделяет частоту отображения от скорости аппаратного потока.
if not force and time.monotonic() < self.flush_at: return # Уменьшает число queued signals при непрерывном потоке USB.
self.flush_at = time.monotonic() + 0.05 # Ограничивает обновление четырёх экранов частотой до 20 Гц.
for index, data in enumerate(self.pending): # Выдаёт независимые хвосты только изменившихся каналов.
if data: self.data_ready.emit(index + 1, bytes(data), self.totals[index]); data.clear() # Сохраняет точный общий счётчик даже при ограниченном предпросмотре.
def _exchange(self, name, channel=0, baud=0, data=b'', closing=False): # Отправляет ровно одну команду и ждёт её подтверждения, продолжая принимать RX.
deadline, command = time.monotonic() + 1.5, {'config': 1, 'start': 2, 'stop': 3, 'tx': 4}[name] # Связывает имена API с идентификаторами ACK, ограничивая шаг полутора секундами.
packet = self.native.make(name, channel, baud, data) # Передаёт построение всех wire-полей общему C-кодеку.
while time.monotonic() < deadline: # Повторяет только явно отвергнутые со статусом BUSY команды.
if self.isInterruptionRequested() and not closing: raise InterruptedError() # Даёт кнопке отключения прервать настройку либо длинную отправку.
self.usb.write(packet) # Передаёт один неизменяемый пакет без повторения после потери ACK.
while time.monotonic() < deadline: # Принимает USART во время ожидания соответствующего подтверждения.
for event in self._read(): # Чтение имеет системное ожидание не более 50 мс при пустой линии.
if event.command != command or event.channel != channel: continue # Не принимает подтверждение другой команды за завершение текущей.
if event.status == 0: return event # Сохраняет возможности прошивки из успешного ACK.
if event.status != 2: raise RuntimeError('Команда ' + name + ' отклонена: канал или скорость не поддерживаются') # Показывает явный отказ вместо скрытой работы с другой скоростью.
break # BUSY разрешает повтор, поскольку прошивка гарантирует отсутствие побочного действия отклонённой команды.
else: continue # Обычные RX пакеты не прерывают ожидание подтверждения.
break # Возвращает управление внешнему циклу для повтора команды после BUSY.
else: break # Не повторяет потенциально выполненную команду после таймаута потерянного ACK.
raise RuntimeError('Нет подтверждения USB USART: ' + name) # Завершает сессию при нарушении последовательного обмена.
def run(self): # Владеет USB, кодеком и файлами исключительно в одном фоновом потоке.
self.usb = None # Позволяет корректно очистить ресурсы при ошибке загрузки DLL.
try: # Любая аппаратная ошибка завершает сессию и возвращается видимым статусом GUI.
self.native = self.native_factory(); self.usb = self.usb_factory(self.native, self.path) # Открывает только выбранный интерфейс USART, сохраняя CAN-соединения.
info = self._exchange('stop', closing=True) # Получает число каналов и приводит ранее открытую прошивку к остановленному состоянию.
for channel in range(1, info.channels + 1): self._exchange('config', channel, self.rates[channel - 1]) # Настраивает только реально включённые в сборке приёмники.
if self.directory: # Создаёт двоичные журналы до START, чтобы не потерять начало захвата.
folder = Path(self.directory) / time.strftime('usart-%Y%m%d-%H%M%S') # Выделяет отдельную папку сессии внутри выбранного пользователем каталога.
folder.mkdir(parents=True, exist_ok=False) # Не перезаписывает ранее записанные пользовательские данные.
for channel in range(1, 5): self.files.append((folder / ('rx' + str(channel) + '.bin')).open('wb', buffering=65536)) # Сохраняет каналы раздельно с дисковым буфером 64 КиБ.
self.status.emit('Журнал: ' + str(folder)) # Показывает точное место записи до начала непрерывного потока.
self._exchange('start'); self.active.emit(info.channels) # Разрешает TX и сообщает реальное количество работающих RX только после ACK START.
while not self.isInterruptionRequested(): # Обслуживает приём до явного отключения или закрытия приложения.
try: data = self.commands.get_nowait() # Проверяет ограниченную очередь отправки без ожидания GUI.
except queue.Empty: data = None # При отсутствии TX непрерывно обслуживает USB IN.
if data is not None: # Одна пользовательская отправка разбивается на атомарные команды TX.
for offset in range(0, len(data), 60): self._exchange('tx', 1, data=data[offset:offset + 60]) # Общий C builder кодирует каждый пакет, а ACK BUSY обеспечивает обратное давление USART2.
self.status.emit('Передано в USART2: ' + str(len(data)) + ' байт') # Подтверждает приём данных аппаратным DMA передатчика.
self._read() # Обрабатывает RX и статистику между пользовательскими запросами TX.
except InterruptedError: pass # Явное отключение пользователем является штатным окончанием сессии.
except Exception as error: self.status.emit(str(error)) # Показывает ошибку DLL, USB, ACK либо записи файла без фонового traceback.
finally: # Освобождает аппаратуру и журналы при любом способе завершения потока.
if self.usb: # STOP возможен только после успешного открытия Windows handle.
try: self._exchange('stop', closing=True) # Останавливает захват, продолжая читать данные до подтверждения команды.
except Exception: pass # Физическое отключение уже остановило прошивку через USB lifecycle; закрытие handle остаётся обязательным.
self.usb.close() # Отменяет и дожидается всех шестнадцати pending USB чтений до освобождения памяти.
for file in self.files: file.close() # Сбрасывает дисковые буферы каждого бинарного журнала.
self._flush(force=True) # Передаёт последний ограниченный хвост предпросмотра перед сигналом finished.
class UartUsbTerminal(QWidget): # Встраивается непосредственно в страницу STM32G474VET6 главного приложения.
def __init__(self, parent=None): # Не загружает DLL и не открывает оборудование при создании вкладки.
super().__init__(parent); self.worker = None; self.directory = None # Начинает с отключённой сессии и выключенной записи на диск.
self.buffers = [bytearray() for _ in range(4)]; self.rates = []; self.views = []; self.counters = [] # Разделяет отображение и скорости всех четырёх физических входов.
layout = QVBoxLayout(self) # Позволяет панели растягиваться внутри существующей MCU страницы.
layout.addWidget(QLabel('USART → USB · RX1 PA3 / RX2 PB11 / RX3 PC11 / RX4 PD2 · TX1 PA2 · 8N1')) # Показывает проверенную разводку до подключения проводов.
controls = QHBoxLayout(); self.devices = QComboBox(); self.devices.setMinimumContentsLength(35) # Делает выбор нескольких USB адаптеров читаемым в обычном окне.
self.refresh = QPushButton('Обновить USB'); self.connect = QPushButton('Запустить'); self.record = QPushButton('Запись RX…') # Разделяет поиск, начало захвата и выбор места бинарных журналов.
for widget in (self.devices, self.refresh, self.connect, self.record): controls.addWidget(widget) # Сохраняет основные действия в одной строке над потоками.
layout.addLayout(controls); grid = QGridLayout(); layout.addLayout(grid) # Показывает четыре RX-экрана одновременно в сетке 2×2.
for index, peripheral in enumerate(('USART2', 'USART3', 'UART4', 'UART5')): # Имена соответствуют единственному аппаратному порту G474 из templates.
container = QWidget(); column = QVBoxLayout(container); row = QHBoxLayout(); rate = QComboBox(); rate.setEditable(True) # Каждому входу назначает независимый редактор скорости.
rate.addItems(['115200', '512000', '1000000', '2000000', '3000000', '6000000']); rate.setCurrentText('1000000') # Начальная скорость совпадает с прошивкой: 1 Мбит/с, формат 8N1.
row.addWidget(QLabel('RX' + str(index + 1) + ' · ' + peripheral)); row.addWidget(rate); column.addLayout(row) # Размещает скорость рядом с однозначным номером канала.
view = QPlainTextEdit(); view.setReadOnly(True); view.setMinimumHeight(110) # Не позволяет случайному вводу в RX экран отправлять байты устройству.
counter = QLabel('0 байт · потери 0 · ошибки 0'); column.addWidget(counter); column.addWidget(view) # Сохраняет диагностику отдельно от текста необработанной линии.
grid.addWidget(container, index // 2, index % 2); self.rates.append(rate); self.views.append(view); self.counters.append(counter) # Сохраняет управление каналами без дублирования четырёх обработчиков.
sending = QHBoxLayout(); self.input = QLineEdit(); self.hex = QCheckBox('HEX'); self.send = QPushButton('Передать TX1 / PA2'); self.send.setEnabled(False) # Передача доступна только после подтверждённого START и только на первом канале.
for widget in (self.input, self.hex, self.send): sending.addWidget(widget) # Формат HEX применяется к пользовательским байтам, а не к служебному USB заголовку.
layout.addLayout(sending); self.hex_view = QCheckBox('Показывать RX в HEX'); layout.addWidget(self.hex_view) # Позволяет читать двоичный поток без потери исходных байтов журнала.
self.message = QLabel('Отключено. Для непрерывного потока выберите запись RX; экран показывает последние 8 КиБ каждого канала.'); self.message.setWordWrap(True); layout.addWidget(self.message) # Объясняет ограничение предпросмотра до начала длительного захвата.
self.counts = [0] * 4; self.lost = [0] * 4; self.errors = [0] * 4 # Разделяет счётчики хоста и сообщённые прошивкой потери.
self.refresh.clicked.connect(self.refresh_devices); self.connect.clicked.connect(self.toggle); self.record.clicked.connect(self.choose_directory); self.send.clicked.connect(self.transmit); self.input.returnPressed.connect(self.transmit) # Связывает действия с общими обработчиками без открытия транспорта при создании UI.
self.hex_view.toggled.connect(self.render_all) # Меняет только представление уже принятых байтов.
def refresh_devices(self): # Поиск выполняется только по явной кнопке пользователя.
try: # Ошибка установки DLL должна быть видна на этой же странице.
paths = Native().paths(); self.devices.clear() # Сканирует только USART интерфейс 2, сохраняя отдельный CAN интерфейс свободным.
for index, path in enumerate(paths): self.devices.addItem('G474 USB USART ' + str(index + 1) + ' · ' + path.split('#')[2], path) # Хранит полный Windows путь в userData, а не восстанавливает его из подписи.
self.message.setText('Найдено USART-интерфейсов: ' + str(len(paths))) # Пустой список корректно сообщает об отсутствии новой прошивки либо WinUSB.
except Exception as error: self.message.setText(str(error)) # Не подменяет отсутствующую DLL альтернативным протоколом Python.
def choose_directory(self): # Выбирает существующую пользовательскую папку до начала сессии.
if self.directory: self.directory = None; self.record.setText('Запись RX…'); return # Повторное нажатие явно выключает запись до следующего START.
directory = QFileDialog.getExistingDirectory(self, 'Каталог бинарных журналов RX') # Пользователь явно определяет место длительной записи.
if directory: self.directory = directory; self.record.setText('Запись RX: включена') # Отдельная подпапка и четыре bin файла создаются worker при START.
def toggle(self): # Кнопка запуска меняет состояние только существующей сессии этой панели.
if self.worker and self.worker.isRunning(): self.worker.requestInterruption(); self.connect.setEnabled(False); return # Просит worker штатно завершить TX, STOP и закрытие файлов без блокирования GUI.
if not self.devices.currentData(): self.refresh_devices() # Первый запуск помогает обнаружить устройство без дополнительного шага пользователя.
if not self.devices.currentData(): return # Не создаёт worker с пустым либо выдуманным USB путём.
try: rates = [int(rate.currentText()) for rate in self.rates] # Читает независимые скорости в битах в секунду перед фиксацией сессии.
except ValueError: self.message.setText('Скорость должна быть целым числом бит/с'); return # Оставляет соединение выключенным при незавершённом вводе.
if any(rate < 1200 or rate > 6000000 for rate in rates): self.message.setText('Допустимые скорости: 1200…6000000 бит/с'); return # Не посылает заведомо неподдерживаемую скорость; точную погрешность проверяет MCU.
self.buffers = [bytearray() for _ in range(4)]; self.counts = [0] * 4; self.lost = [0] * 4; self.errors = [0] * 4; self.render_all() # Начинает новую экранную сессию без счётчиков предыдущего захвата.
self.worker = UsbWorker(self.devices.currentData(), rates, self.directory, self) # Передаёт потоку неизменяемые параметры выбранного оборудования.
self.worker.data_ready.connect(self.received); self.worker.stats_ready.connect(self.statistics); self.worker.status.connect(self.message.setText); self.worker.active.connect(self.started); self.worker.finished.connect(self.finished) # Все изменения виджетов выполняются через queued Qt сигналы GUI потока.
for widget in [self.devices, self.refresh, self.record] + self.rates: widget.setEnabled(False) # Исключает изменение параметров уже открытого USB-сеанса.
self.connect.setText('Отключить'); self.message.setText('Подключение и настройка USART…'); self.worker.start() # Запускает ограниченные ожидания USB в фоне.
def started(self, channels): # Показывает возможности, которые реально подтвердила прошивка.
self.send.setEnabled(True); self.message.setText('Захват активен: RX ' + str(channels) + ', TX только канал 1 / PA2') # Не разрешает TX до ACK команды START.
for index, view in enumerate(self.views): view.setEnabled(index < channels) # Отражает сборки с двумя и тремя входами без ложного ожидания четырёх потоков.
def finished(self): # Возвращает элементы управления только после закрытия USB и файлов worker.
self.send.setEnabled(False); self.connect.setEnabled(True); self.connect.setText('Запустить') # Завершённая сессия больше не принимает данные передатчика.
for widget in [self.devices, self.refresh, self.record] + self.rates: widget.setEnabled(True) # Разрешает выбор следующего устройства и независимых скоростей.
self.worker.deleteLater(); self.worker = None # Освобождает завершённый QThread после обработки его последнего queued сигнала.
def transmit(self): # Отправляет пользовательские данные только через единственный доступный TX.
if not self.worker or not self.worker.isRunning() or not self.send.isEnabled(): return # Не ставит команды в закрытую либо ещё настраиваемую сессию.
try: data = bytes.fromhex(self.input.text()) if self.hex.isChecked() else self.input.text().encode('utf-8') # HEX ввод задаёт двоичные байты, текст использует явно выбранную кодировку UTF-8.
except ValueError: self.message.setText('HEX: введите пары шестнадцатеричных цифр'); return # Не меняет пользовательский ввод при ошибочном двоичном формате.
if not data or len(data) > 65536: self.message.setText('Одна отправка: 1…65536 байт'); return # Ограничивает память и время обслуживания одной GUI-команды.
try: self.worker.commands.put_nowait(data) # Передаёт неизменяемые байты worker без ожидания подтверждения в GUI.
except queue.Full: self.message.setText('Очередь TX занята, дождитесь передачи'); return # Явно сообщает обратное давление вместо роста памяти.
self.input.clear() # Удаляет ввод только после успешной постановки всей отправки в очередь.
def received(self, channel, data, total): # Обновляет только экран конкретного входа, сохраняя полный журнал в worker.
index = channel - 1; self.buffers[index].extend(data); del self.buffers[index][:-8192]; self.counts[index] = total # Держит ограниченный хвост и точный монотонный счётчик байтов хоста.
self.render(index) # Перерисовывает лишь изменившийся RX экран.
def statistics(self, channel, lost, errors): # Принимает готовые счётчики из C-модели, не разбирая пакет самостоятельно.
index = channel - 1; self.lost[index] = lost; self.errors[index] = errors; self.render(index) # Не смешивает потери микроконтроллера с усечением экранного предпросмотра.
def render(self, index): # Выполняет только визуальное преобразование пользовательских байтов.
data = bytes(self.buffers[index]); text = ' '.join(format(byte, '02X') for byte in data) if self.hex_view.isChecked() else data.decode('utf-8', errors='replace') # Бинарный журнал остаётся точным независимо от режима отображения.
self.views[index].setPlainText(text); bar = self.views[index].verticalScrollBar(); bar.setValue(bar.maximum()) # Показывает последние данные в ограниченном по памяти документе.
self.counters[index].setText(str(self.counts[index]) + ' байт · потери ' + str(self.lost[index]) + ' · ошибки ' + str(self.errors[index])) # Явно отображает переполнение USB и аппаратные нарушения линии.
def render_all(self, checked=False): # Перерисовывает сохранённые хвосты после смены формата либо новой сессии.
for index in range(4): self.render(index) # Четыре одинаковых представления используют одну функцию форматирования.
def shutdown(self): # Главный SETGUI вызывает этот метод перед уничтожением панели.
if self.worker and self.worker.isRunning(): self.worker.requestInterruption(); return self.worker.wait(4000) # Даёт ограниченный срок STOP и отмене pending WinUSB I/O до удаления QThread.
return True # Закрытая сессия не задерживает завершение приложения.
def closeEvent(self, event): # Самостоятельная панель также корректно останавливает захват при закрытии окна.
if self.shutdown(): event.accept() # Закрывает виджет только после освобождения USB ресурсов worker.
else: event.ignore() # Не уничтожает память ещё работающего потока при редком системном зависании I/O.
File diff suppressed because one or more lines are too long