Добавить 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
+9
View File
@@ -0,0 +1,9 @@
cmake_minimum_required(VERSION 3.13) # Использует ту же минимальную версию CMake, что и проект потребителя прошивки.
project(uart_usb C) # Собирает единственный C99 кодек и соответствующий порт настольного транспорта.
add_library(uart_usb SHARED uart_usb.c) # Создаёт библиотеку для ctypes без второй реализации wire-протокола.
target_include_directories(uart_usb PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}) # Публикует общий стабильный ABI заголовка uart_usb.h.
set_target_properties(uart_usb PROPERTIES C_STANDARD 99 C_STANDARD_REQUIRED YES PREFIX "") # Сохраняет имя uart_usb.dll на Windows и требует переносимый стандарт C99.
if(WIN32) # Настольный USB транспорт этой версии реализован для штатного WinUSB.
target_sources(uart_usb PRIVATE ports/windows/uart_usb_winusb.c) # Добавляет очередь шестнадцати overlapped RX вместо синхронного опроса из GUI.
target_link_libraries(uart_usb PRIVATE winusb setupapi) # Использует системные библиотеки Windows без зависимости от libusb или PyUSB.
endif() # MCU компилирует uart_usb.c и stm32g474 порт напрямую своим проектом.
+119
View File
@@ -0,0 +1,119 @@
# USART → USB
Минимальный двоичный мультиплексор 2–4 UART-каналов в USB: независимый RX,
TX только на канале 1, настройка скорости, подтверждения и диагностика потерь.
Переносимое ядро C99 не содержит HAL, ОС, heap и глобального состояния.
Слои: SETGUI → Python/Qt порт → C-кодек / WinUSB → USB bulk → C-кодек →
STM32G474 DMA → USART. Применяется в `CAN_projects`, ветка `candle-g474`.
| Файл | Назначение | Зависимость |
|---|---|---|
| `uart_usb.h`, `uart_usb.c` | Формат, потоковый parser, builders, смысловые события ABI | C99, stdint, string |
| `ports/stm32g474/uart_usb_g474.*` | Кольцевой RX DMA, один TX DMA | CMSIS STM32G474 |
| `ports/windows/uart_usb_winusb.c` | 16 запросов IN одновременно, SetupDi, WinUSB | Windows 7+, WinUSB, SetupAPI |
| `python/set_devices/uart_usb.py` | ctypes, жизненный цикл USB handle | Python stdlib, собранная DLL |
| `python/set_devices/qt_ports/uart_usb_terminal.py` | Worker, четыре окна, запись исходных байтов | Qt5/Qt6 |
## Аппаратный порт STM32G474VET6
| Канал | Блок | RX | TX | DMAMUX RX |
|---|---|---|---|---|
| 1 | USART2 | PA3, AF7 | PA2, AF7 | 26 |
| 2 | USART3 | PB11, AF7 | выключен | 28 |
| 3 | UART4 | PC11, AF5 | выключен | 30 |
| 4 | UART5 | PD2, AF5 | выключен | 32 |
USART1 PA9/PA10 остаётся загрузчику. CAN PB8/PB9 и USB PA11/PA12 сохраняются.
Выводы сверены с таблицами alternate function
[STM32G474xE](https://www.st.com/resource/en/datasheet/stm32g474mb.pdf),
DMA — с [RM0440](https://www.st.com/resource/en/reference_manual/dm00355726-stm32g4-series-advanced-armbased-32bit-mcus-stmicroelectronics.pdf).
Используйте логические уровни платы и общую GND; внешний RS232/RS485 требует
соответствующего трансивера.
`UART_USB_CHANNELS=2`, `3` или `4` задаётся сборкой, по умолчанию 4.
DMA1 Channel1…4 обслуживают RX, Channel5 — USART2 TX.
PCLK1=144 МГц, 8N1, oversampling 16, диапазон 1200…6000000 бит/с,
погрешность BRR до 2%. По умолчанию каждый вход работает на 1000000 бит/с.
Одновременные четыре входа по 1 Мбит/с дают 400000 байт/с полезных данных.
USB FS имеет общую пропускную способность для всех USART и CAN; предел
каждого отдельного UART не является гарантией суммарной скорости USB.
Каждый вход имеет DMA-кольцо 4096 байт; при отставании потребителя сохраняется
новейшая половина кольца и точно увеличивается счётчик программно потерянных
байтов. Вторая половина оставляет запас от перезаписи во время копирования.
Аппаратные ORE/FE/NE/PE и TE считаются событиями; число утраченных до DMA байтов
при ORE аппаратурой не сообщается. Счётчики uint32 сбрасываются при START
и переполняются по модулю 2^32. STOP, USB reset и suspend прекращают захват;
оставшийся в DMA хвост не гарантирован после STOP. Resume требует нового START.
## Контракт порта
`ub_g474_init()`, `ub_g474_config(channel, baud)`, `ub_g474_start()`,
`ub_g474_stop()`, `ub_g474_tx(data, length)`, `ub_g474_read(channel, out, capacity)`,
`ub_g474_stats(channel, &lost, &errors)` и `ub_g474_abort()` вызываются одним
основным циклом с защитой от USB reset. Только обработчики DMA меняют счётчики
оборотов. Порт использует статическую память и не вызывает пользовательские
callbacks. `UB_BUSY` гарантирует отсутствие побочного действия команды.
## Протокол версии 1
USB interface 2: class `FF`, subclass `55`, protocol `01`, bulk IN `83`,
bulk OUT `03`, max packet 64. CAN и DFU сохраняют номера 0 и 1.
Windows получает WinUSB и стандартный GUID gs_usb через Microsoft OS 1.0.
Запись: `A7 | (type << 4) OR channel | length_lo | length_hi | payload`.
Payload 0…60 байт, длина little-endian. Данные не экранируются;
целостность обеспечивает USB CRC и повтор транзакций. Parser допускает
произвольные разрывы и несколько записей в одном системном чтении.
Повреждённый заголовок пропускается до следующей синхронизации.
| type | Направление | channel | payload |
|---|---|---|---|
| 1 CONFIG | host → MCU | 1…N | baud uint32 LE, только до START |
| 2 START | host → MCU | 0 | пусто; запускает все входы и обнуляет счётчики |
| 3 STOP | host → MCU | 0 | пусто; BUSY до окончания стопового бита TX |
| 4 TX | host → MCU | 1 | 1…60 исходных байтов |
| 8 ACK | MCU → host | как в команде | command, status, rx_channels, tx_channel; четыре uint8 |
| 9 RX | MCU → host | 1…N | 1…60 исходных байтов |
| 10 STATS | MCU → host | 1…N | lost uint32 LE, errors uint32 LE; раз в секунду |
Статусы: 0 OK, 1 INVALID, 2 BUSY. Одновременно ожидается один ACK.
Хост повторяет только явно отклонённые BUSY команды. После потери ACK
не повторяет TX: отключает сессию, исключая неопределённое дублирование байтов.
ACK TX означает принятие в DMA. STOP подтверждается после физического завершения TX.
Быстрый старт в C после открытия собственного USB IN:
```c
#include "uart_usb.h" /* Подключает общую структуру записи и parser. */
ub_parser parser = {0}; /* Выделяет независимое состояние одного USB-потока. */
ub_frame frame; /* Принимает один проверенный заголовок и его payload. */
ub_event event; /* Возвращает смысловые поля без ручного разбора смещений. */
uint8_t out[64]; /* Вмещает максимальную команду USB FS. */
uint16_t size = ub_make_config(1, 1000000, out); /* Настраивает RX1 на 1 Мбит/с. */
usb_write(out, size); /* Порт приложения передаёт команду выбранному интерфейсу. */
uint16_t used = ub_feed(&parser, incoming, received, &frame); /* Parser потребляет очередной фрагмент USB. */
if (frame.type && ub_describe(&frame, &event)) { /* Обрабатывает только целый корректный ответ. */
handle_event(&event); /* Приложение получает уже разобранную модель события. */
} /* Остаток incoming после used снова передаётся ub_feed. */
```
## Сборка DLL и проверки
Соберите `cmake -S templates/c/uart-usb -B build/uart-usb -A x64`, затем
`cmake --build build/uart-usb --config Release`. Для Win32 используйте отдельный
каталог и `-A Win32`. DLL должна совпадать по разрядности с Python/SETGUI.
Установите `uart_usb.dll` в `src/gui_desktop/native`, рядом с модулем Python
либо задайте `UART_USB_LIBRARY`. Отсутствие DLL является явной ошибкой установки.
Проверки: `python -m pytest templates/c/uart-usb/tests -q` при настроенных
`PYTHONPATH=templates/python` и `UART_USB_LIBRARY=<полный путь DLL>`.
Эталоны включают все 65 разрывов максимальной записи, шум, неправильные длины,
1000 сообщений в случайных фрагментах и несовместимые ACK.
Терминал обновляет только последние 8 КиБ каждого RX. Для полного захвата
выберите «Запись RX…» до START: worker создаст отдельную папку сессии
и `rx1.bin`…`rx4.bin` без служебных заголовков и перекодирования.
На неподключённой плате измерение реальной скорости и проверка проводов
не выполняются; это отдельная аппаратная проверка.
+139
View File
@@ -0,0 +1,139 @@
#include "uart_usb_g474.h" /* Подключает контракт единственного аппаратного порта этой версии. */
#include "uart_usb.h" /* Использует общие статусы протокола и максимальную длину TX. */
#include "stm32g4xx.h" /* Получает проверенные адреса и маски регистров из CMSIS производителя. */
#include <string.h> /* Копирует DMA-данные в буфер USB и собственный буфер передатчика. */
#define RX_SIZE 4096U /* Выделяет 4 КиБ SRAM на канал, то есть около 41 мс при 1 Мбит/с 8N1. */
static USART_TypeDef *const uart[4] = {USART2, USART3, UART4, UART5}; /* Отделяет захват от USART1, занятого действующим загрузчиком. */
static DMA_Channel_TypeDef *const dma[4] = {DMA1_Channel1, DMA1_Channel2, DMA1_Channel3, DMA1_Channel4}; /* Назначает отдельное кольцо DMA каждому приёмнику. */
static DMAMUX_Channel_TypeDef *const mux[4] = {DMAMUX1_Channel0, DMAMUX1_Channel1, DMAMUX1_Channel2, DMAMUX1_Channel3}; /* Связывает каналы DMA1 с соответствующими входами DMAMUX1. */
static const uint8_t requests[4] = {26U, 28U, 30U, 32U}; /* Номера USART2_RX, USART3_RX, UART4_RX, UART5_RX взяты из таблицы DMAMUX RM0440. */
static const IRQn_Type irqs[4] = {DMA1_Channel1_IRQn, DMA1_Channel2_IRQn, DMA1_Channel3_IRQn, DMA1_Channel4_IRQn}; /* Включает IRQ завершения оборота для точного учёта перезаписи. */
static uint8_t rx[UART_USB_CHANNELS][RX_SIZE]; /* Размещает входные кольца в SRAM1, доступной DMA, без динамического выделения. */
static volatile uint32_t rounds[UART_USB_CHANNELS]; /* IRQ увеличивает число полностью завершённых оборотов кольца. */
static uint32_t consumed[UART_USB_CHANNELS], lost_bytes[UART_USB_CHANNELS], error_count[UART_USB_CHANNELS]; /* Хранит курсор чтения и явную диагностику перегрузки USB. */
static uint32_t rates[UART_USB_CHANNELS]; /* Сохраняет индивидуальные скорости в битах в секунду. */
static uint8_t tx[UB_PAYLOAD]; /* Сохраняет пакет до завершения DMA USART2_TX независимо от USB OUT. */
static uint8_t running; /* Разрешает чтение только после явной команды START от терминала. */
static void pin(GPIO_TypeDef *gpio, uint32_t number, uint32_t af) { /* Настраивает один вывод без изменения соседних CAN, USB и BOOT. */
uint32_t shift = number * 2U; /* Каждый вывод занимает два бита MODER, PUPDR и OSPEEDR. */
gpio->MODER = (gpio->MODER & ~(3UL << shift)) | (2UL << shift); /* Режим 10 выбирает альтернативную функцию периферии. */
gpio->PUPDR = (gpio->PUPDR & ~(3UL << shift)) | (1UL << shift); /* Подтяжка вверх удерживает отключённый UART RX в состоянии покоя. */
gpio->OTYPER &= ~(1UL << number); /* Двухтактный выход обеспечивает фронты единственного TX при высокой скорости. */
gpio->OSPEEDR |= 3UL << shift; /* Максимальная скорость GPIO уменьшает искажения фронтов TX. */
shift = (number & 7U) * 4U; /* Каждый регистр AFR содержит восемь полей по четыре бита. */
gpio->AFR[number / 8U] = (gpio->AFR[number / 8U] & ~(15UL << shift)) | (af << shift); /* Выбирает AF из таблицы выводов STM32G474xE. */
} /* Завершает настройку одного физического контакта. */
void ub_g474_init(void) { /* Подготавливает только аппаратные ресурсы USART-моста. */
RCC->AHB1ENR |= RCC_AHB1ENR_DMA1EN | RCC_AHB1ENR_DMAMUX1EN; /* Включает DMA1 и маршрутизатор запросов периферии. */
RCC->AHB2ENR |= RCC_AHB2ENR_GPIOAEN | RCC_AHB2ENR_GPIOBEN | RCC_AHB2ENR_GPIOCEN | RCC_AHB2ENR_GPIODEN; /* Разрешает доступ к портам выбранных RX и единственного TX. */
RCC->APB1ENR1 |= RCC_APB1ENR1_USART2EN | RCC_APB1ENR1_USART3EN | RCC_APB1ENR1_UART4EN | RCC_APB1ENR1_UART5EN; /* Включает четыре доступных UART блока, не меняя USART1. */
RCC->CCIPR &= ~(RCC_CCIPR_USART2SEL | RCC_CCIPR_USART3SEL | RCC_CCIPR_UART4SEL | RCC_CCIPR_UART5SEL); /* Значение 00 выбирает PCLK1, равный 144 МГц в текущем профиле платы. */
(void)RCC->APB1ENR1; /* Завершает запись тактирования до первого обращения к USART. */
pin(GPIOA, 2U, 7U); /* PA2/AF7 — USART2_TX, логический передатчик канала 1. */
pin(GPIOA, 3U, 7U); /* PA3/AF7 — USART2_RX, логический приёмник канала 1. */
pin(GPIOB, 11U, 7U); /* PB11/AF7 — USART3_RX, логический приёмник канала 2. */
if (UART_USB_CHANNELS >= 3U) pin(GPIOC, 11U, 5U); /* PC11/AF5 — UART4_RX, логический приёмник канала 3. */
if (UART_USB_CHANNELS >= 4U) pin(GPIOD, 2U, 5U); /* PD2/AF5 — UART5_RX, логический приёмник канала 4. */
for (uint8_t i = 0U; i < UART_USB_CHANNELS; ++i) { /* Инициализирует только включённые сборкой каналы. */
rates[i] = 1000000UL; /* Начальная скорость 1 Мбит/с даёт суммарно 400 Кбайт/с для четырёх каналов 8N1. */
NVIC_SetPriority(irqs[i], 1U); /* IRQ оборота DMA имеет приоритет выше USB, чтобы не терять учёт кольца. */
NVIC_EnableIRQ(irqs[i]); /* Разрешает обработку завершённых оборотов входного DMA. */
} /* Завершает настройку аппаратных каналов. */
} /* До START приёмники выключены и данные не захватываются. */
uint8_t ub_g474_config(uint8_t channel, uint32_t baud) { /* Проверяет скорость до изменения аппаратных регистров. */
if (!channel || channel > UART_USB_CHANNELS || baud < 1200U || baud > 6000000UL) return UB_INVALID; /* Ограничивает скорости диапазоном 1200…6000000 бит/с при PCLK1=144 МГц. */
if (running) return UB_BUSY; /* Не обрывает непрерывный захват ради скрытой перенастройки канала. */
uint32_t divisor = (SystemCoreClock + baud / 2U) / baud; /* Округляет делитель BRR для oversampling 16 при PCLK1=SYSCLK. */
uint32_t actual = SystemCoreClock / divisor; /* Рассчитывает достижимую аппаратурой скорость в битах в секунду. */
uint32_t delta = actual > baud ? actual - baud : baud - actual; /* Находит абсолютную погрешность выбранного делителя. */
if (delta > baud / 50U) return UB_INVALID; /* Не допускает отклонение скорости более 2 процентов. */
rates[channel - 1U] = baud; /* Применяет новую скорость при следующем START. */
return UB_OK; /* Подтверждает, что конфигурация сохранена. */
} /* Завершает индивидуальную настройку канала. */
uint8_t ub_g474_start(void) { /* Перезапускает захват только из остановленного состояния. */
if (running) return UB_BUSY; /* Повторный START не сбрасывает уже полученные данные. */
for (uint8_t i = 0U; i < UART_USB_CHANNELS; ++i) { /* Подготавливает отдельный DMA для каждого входа. */
uart[i]->CR1 = 0U; /* Выключает USART перед записью формата и делителя. */
uart[i]->BRR = (SystemCoreClock + rates[i] / 2U) / rates[i]; /* Задаёт скорость 8N1, oversampling 16, в единицах тактов PCLK1. */
uart[i]->CR2 = 0U; /* Выбирает один стоповый бит и обычную полярность сигнала. */
uart[i]->CR3 = USART_CR3_DMAR | (i == 0U ? USART_CR3_DMAT : 0U); /* Разрешает RX DMA всем каналам, TX DMA только USART2. */
uart[i]->ICR = USART_ICR_ORECF | USART_ICR_FECF | USART_ICR_NECF | USART_ICR_PECF; /* Снимает аппаратные ошибки предыдущей сессии. */
uart[i]->RQR = USART_RQR_RXFRQ; /* Удаляет остаточный байт RDR перед началом новой сессии. */
dma[i]->CCR = 0U; /* Останавливает канал DMA перед изменением его адресов. */
DMA1->IFCR = 15UL << (i * 4U); /* Сбрасывает четыре флага GIF/TCIF/HTIF/TEIF выбранного DMA-канала. */
mux[i]->CCR = requests[i]; /* Направляет запрос соответствующего USART_RX в канал DMA1. */
dma[i]->CPAR = (uint32_t)&uart[i]->RDR; /* Источник DMA — байтовый регистр данных выбранного USART. */
dma[i]->CMAR = (uint32_t)rx[i]; /* Приёмник DMA — собственное кольцо канала в SRAM1. */
dma[i]->CNDTR = RX_SIZE; /* Счётчик DMA задаётся в байтах, поскольку PSIZE/MSIZE оставлены 8-битными. */
rounds[i] = consumed[i] = lost_bytes[i] = error_count[i] = 0U; /* Сбрасывает курсоры и диагностику новой явно запущенной сессии. */
dma[i]->CCR = DMA_CCR_MINC | DMA_CCR_CIRC | DMA_CCR_TCIE | DMA_CCR_TEIE | DMA_CCR_PL_1 | DMA_CCR_EN; /* Включает кольцо с инкрементом памяти и высоким приоритетом, без IRQ на каждый байт. */
uart[i]->CR1 = USART_CR1_RE | USART_CR1_UE | (i == 0U ? USART_CR1_TE : 0U); /* Включает приём на всех входах и передатчик только канала 1. */
} /* Все каналы работают независимо, без HAL IRQ на каждый байт. */
running = 1U; /* Разрешает перенос накопленных данных в USB. */
return UB_OK; /* Подтверждает успешный запуск всех сконфигурированных каналов. */
} /* Завершает запуск кольцевого захвата. */
void ub_g474_abort(void) { /* Освобождает аппаратные ресурсы при потере USB-сессии. */
DMA1_Channel5->CCR = 0U; /* Немедленно прерывает TX, поскольку хост уже отключён. */
for (uint8_t i = 0U; i < UART_USB_CHANNELS; ++i) { /* Последовательно выключает только каналы моста. */
dma[i]->CCR = 0U; /* Прекращает запись в кольцевой буфер SRAM. */
uart[i]->CR1 = 0U; /* Останавливает RX/TX выбранного USART, сохраняя USART1 загрузчика. */
} /* Завершает остановку аппаратуры без ожидания внешних событий. */
running = 0U; /* Не выдаёт накопленные данные в следующую USB-сессию. */
} /* Завершает аварийное закрытие транспорта. */
uint8_t ub_g474_stop(void) { /* Не обрывает последний стоповый бит обычной командой STOP. */
if (running && !(USART2->ISR & USART_ISR_TC)) return UB_BUSY; /* Хост повторяет STOP после завершения текущей передачи USART2. */
ub_g474_abort(); /* Выключает приёмники и DMA после освобождения передатчика. */
return UB_OK; /* Подтверждает остановку аппаратного захвата. */
} /* Завершает штатную остановку сессии. */
uint8_t ub_g474_tx(const uint8_t *data, uint16_t length) { /* Запускает одну неблокирующую передачу через канал 1. */
if (!running || !length || length > UB_PAYLOAD) return UB_INVALID; /* Требует активную сессию и пакет размером 1…60 байт. */
if ((DMA1_Channel5->CCR & DMA_CCR_EN) && DMA1_Channel5->CNDTR) return UB_BUSY; /* Не перезаписывает буфер, пока DMA ещё читает предыдущие данные. */
DMA1_Channel5->CCR = 0U; /* Отключает завершённый DMA перед повторной настройкой. */
memcpy(tx, data, length); /* Сохраняет USB-команду в памяти с временем жизни всей DMA-передачи. */
DMAMUX1_Channel4->CCR = 27U; /* USART2_TX имеет номер запроса 27 в таблице DMAMUX RM0440. */
DMA1_Channel5->CPAR = (uint32_t)&USART2->TDR; /* Направляет передаваемые байты в аппаратный USART2_TX. */
DMA1_Channel5->CMAR = (uint32_t)tx; /* Указывает стабильный буфер данных единственного передатчика. */
DMA1_Channel5->CNDTR = length; /* Ограничивает передачу точным количеством полученных байтов. */
DMA1->IFCR = 15UL << 16U; /* Снимает четыре флага DMA1 Channel5, расположенные в битах 16…19. */
DMA1_Channel5->CCR = DMA_CCR_MINC | DMA_CCR_DIR | DMA_CCR_EN; /* Запускает память→периферия с байтовыми элементами без блокирования CPU. */
return UB_OK; /* ACK означает постановку данных в DMA, а не физическое окончание стопового бита. */
} /* Завершает запуск аппаратной передачи. */
static void dma_irq(uint8_t i) { /* Учитывает обороты кольца и ошибки DMA в коротком обработчике. */
uint32_t flags = (DMA1->ISR >> (i * 4U)) & 15U; /* Выделяет четыре аппаратных флага соответствующего канала. */
DMA1->IFCR = flags << (i * 4U); /* Снимает только фактически установленные флаги выбранного канала. */
if (i >= UART_USB_CHANNELS) return; /* Защищает массивы при выключенном третьем или четвёртом канале. */
if (flags & 2U) ++rounds[i]; /* TCIF в позиции 1 означает запись очередных 4096 байт. */
if (flags & 8U) { ++error_count[i]; dma[i]->CCR &= ~DMA_CCR_EN; } /* TEIF в позиции 3 фиксирует отказ DMA и прекращает повреждённый захват. */
} /* Завершает обслуживание DMA без копирования полезных данных. */
void DMA1_Channel1_IRQHandler(void) { dma_irq(0U); } /* Обслуживает оборот кольца USART2_RX, логического канала 1. */
void DMA1_Channel2_IRQHandler(void) { dma_irq(1U); } /* Обслуживает оборот кольца USART3_RX, логического канала 2. */
void DMA1_Channel3_IRQHandler(void) { dma_irq(2U); } /* Обслуживает оборот кольца UART4_RX, логического канала 3. */
void DMA1_Channel4_IRQHandler(void) { dma_irq(3U); } /* Обслуживает оборот кольца UART5_RX, логического канала 4. */
uint16_t ub_g474_read(uint8_t channel, uint8_t *data, uint16_t capacity) { /* Переносит данные одного кольца с явным обнаружением переполнения. */
uint8_t i = channel - 1U; /* Переводит внешний номер 1…N во внутренний индекс массива. */
if (!running || !channel || channel > UART_USB_CHANNELS || !(dma[i]->CCR & DMA_CCR_EN)) return 0U; /* Не читает несуществующий, остановленный или аварийный DMA. */
uint32_t mask = __get_PRIMASK(); /* Сохраняет исходное разрешение IRQ для атомарного снимка курсора DMA. */
__disable_irq(); /* Исключает изменение счётчика rounds обработчиком между чтениями. */
if (DMA1->ISR & (DMA_ISR_TCIF1 << (i * 4U))) dma_irq(i); /* Учитывает оборот, IRQ которого ещё не успел выполниться. */
uint32_t remaining = dma[i]->CNDTR; /* Читает остаток DMA однократно, без ожидания аппаратной перезагрузки кольца. */
if (!remaining) { __set_PRIMASK(mask); return 0U; } /* Краткий ноль между оборотами обслуживается следующим проходом, исключая удвоение оборота и блокирование main. */
if (DMA1->ISR & (DMA_ISR_TCIF1 << (i * 4U))) { dma_irq(i); remaining = dma[i]->CNDTR; } /* Повторяет снимок, если оборот произошёл непосредственно при чтении остатка DMA. */
if (!remaining) { __set_PRIMASK(mask); return 0U; } /* Не ожидает зависшую либо ещё перезагружаемую аппаратуру при повторном снимке. */
uint32_t position = RX_SIZE - remaining; /* Получает курсор внутри кольца после согласования счётчика оборотов с флагом TC. */
uint32_t produced = rounds[i] * RX_SIZE + position; /* Получает монотонный 32-битный счётчик реально принятых байтов с модульной арифметикой. */
__set_PRIMASK(mask); /* Восстанавливает прежнее состояние IRQ, не включая их внутри чужой критической секции. */
uint32_t errors = uart[i]->ISR & (USART_ISR_ORE | USART_ISR_FE | USART_ISR_NE | USART_ISR_PE); /* Проверяет переполнение USART и ошибки линии независимо от содержимого данных. */
if (errors) { ++error_count[i]; uart[i]->ICR = errors; } /* Фиксирует событие и снимает соответствующие флаги ICR с теми же битовыми позициями. */
uint32_t available = produced - consumed[i]; /* Вычитание без знака сохраняет корректность после переполнения счётчика 32 бит. */
if (available > RX_SIZE / 2U) { lost_bytes[i] += available - RX_SIZE / 2U; consumed[i] = produced - RX_SIZE / 2U; available = RX_SIZE / 2U; } /* Сохраняет новейшую половину кольца и запас от DMA, явно считая отброшенные байты. */
uint32_t offset = consumed[i] % RX_SIZE; /* Находит начало непрочитанной области внутри физического кольца. */
uint32_t count = available < capacity ? available : capacity; /* Ограничивает копирование вместимостью полезной части USB-пакета. */
if (count > RX_SIZE - offset) count = RX_SIZE - offset; /* Не пересекает конец кольца за одно копирование; остаток уйдёт следующим пакетом. */
memcpy(data, rx[i] + offset, count); /* Забирает неизменяемую DMA область с запасом не менее половины кольца. */
consumed[i] += count; /* Отмечает данные переданными во владение стабильного USB IN буфера. */
return (uint16_t)count; /* Возвращает число бинарных байтов выбранного канала. */
} /* Завершает неблокирующее чтение с честным учётом перегрузки. */
void ub_g474_stats(uint8_t channel, uint32_t *lost, uint32_t *errors) { /* Даёт терминалу накопленные счётчики текущей сессии. */
*lost = lost_bytes[channel - 1U]; /* Возвращает точное число программно отброшенных байтов при переполнении кольца. */
*errors = error_count[channel - 1U]; /* Возвращает количество замеченных аппаратных событий USART и DMA. */
} /* Завершает чтение диагностики существующего канала. */
@@ -0,0 +1,16 @@
#pragma once /* Защищает аппаратный интерфейс STM32G474 от повторного объявления. */
#include <stdint.h> /* Фиксирует размеры счётчиков и длины буферов порта. */
#ifndef UART_USB_CHANNELS /* Позволяет сборке выбрать от двух до четырёх физических входов. */
#define UART_USB_CHANNELS 4U /* По умолчанию включает USART2, USART3, UART4 и UART5. */
#endif /* Сохраняет явно заданное сборкой количество каналов. */
#if UART_USB_CHANNELS < 2 || UART_USB_CHANNELS > 4 /* Ограничивает конфигурации реально предусмотренными каналами. */
#error UART_USB_CHANNELS_must_be_2_to_4 /* Прерывает сборку при ошибке аппаратной конфигурации. */
#endif /* Завершает проверку количества каналов. */
void ub_g474_init(void); /* Готовит тактирование и выводы, оставляя захват выключенным. */
uint8_t ub_g474_config(uint8_t channel, uint32_t baud); /* Настраивает выключенный канал 1…N; возвращает UB_OK, UB_BUSY либо UB_INVALID. */
uint8_t ub_g474_start(void); /* Запускает кольцевой DMA всех выбранных каналов с чистыми счётчиками. */
uint8_t ub_g474_stop(void); /* Останавливает захват после завершения единственного аппаратного TX. */
uint8_t ub_g474_tx(const uint8_t *data, uint16_t length); /* Копирует до 60 байт и запускает DMA USART2_TX без ожидания. */
uint16_t ub_g474_read(uint8_t channel, uint8_t *data, uint16_t capacity); /* Забирает очередную непрерывную часть кольца и учитывает перезапись. */
void ub_g474_stats(uint8_t channel, uint32_t *lost, uint32_t *errors); /* Возвращает накопленные потери и число аппаратных ошибок канала. */
void ub_g474_abort(void); /* Немедленно выключает мост при USB reset, suspend или отключении. */
@@ -0,0 +1,94 @@
#define WIN32_LEAN_AND_MEAN /* Исключает лишние Windows API из переносимого по разрядности host-порта. */
#include <windows.h> /* Предоставляет handles, события и overlapped I/O для высокоскоростного USB. */
#include <setupapi.h> /* Перечисляет интерфейсы устройства по опубликованному прошивкой GUID. */
#include <winusb.h> /* Использует штатный драйвер WinUSB без установки Python USB-пакетов. */
#include <stdlib.h> /* Выделяет память только в настольном порте; MCU-ядро остаётся без heap. */
#include <string.h> /* Копирует завершённые USB-пакеты в буфер Python-клиента. */
#include "uart_usb.h" /* Экспортирует Windows транспорт рядом с единственным C-кодеком протокола. */
#define USB_READS 16U /* Держит шестнадцать запросов IN одновременно, исключая паузы между вызовами Python. */
static const GUID interface_guid = {0xc15b4308, 0x04d3, 0x11e6, {0xb3, 0xea, 0x60, 0x57, 0x18, 0x9e, 0x64, 0x43}}; /* Совпадает со стандартным gs_usb GUID из Microsoft OS дескриптора прошивки. */
typedef struct { OVERLAPPED io; uint8_t bytes[64]; uint8_t queued; } usb_read; /* Каждый запрос владеет событием, буфером USB FS и флагом фактической постановки I/O. */
typedef struct { HANDLE file; WINUSB_INTERFACE_HANDLE usb; usb_read reads[USB_READS]; unsigned next; } usb_context; /* Хранит все ресурсы одной выбранной USB-сессии, не затрагивая CAN handle. */
UB_API int ub_usb_paths(wchar_t *out, uint32_t capacity) { /* Возвращает список путей интерфейса 2 как MULTI_SZ с двойным завершающим нулём. */
HDEVINFO devices = SetupDiGetClassDevsW(&interface_guid, NULL, NULL, DIGCF_PRESENT | DIGCF_DEVICEINTERFACE); /* Перечисляет только подключённые WinUSB интерфейсы данного семейства. */
uint32_t used = 0U; /* Считает записанные wchar_t, а не байты, для совместимости x86/x64. */
if (!out || capacity < 2U || devices == INVALID_HANDLE_VALUE) return -1; /* Не записывает список при неверном буфере или отказе SetupDi. */
out[0] = out[1] = 0; /* Возвращает корректный пустой MULTI_SZ при отсутствии устройств. */
for (DWORD index = 0U;; ++index) { /* Обходит каждый опубликованный интерфейс независимо от физического CAN-порта. */
SP_DEVICE_INTERFACE_DATA item = {0}; item.cbSize = sizeof(item); /* Задаёт размер структуры SetupDi для текущей разрядности процесса. */
if (!SetupDiEnumDeviceInterfaces(devices, NULL, &interface_guid, index, &item)) break; /* Завершает перечисление после последнего доступного интерфейса. */
DWORD needed = 0U; /* Получает точный размер переменной структуры с DevicePath. */
SetupDiGetDeviceInterfaceDetailW(devices, &item, NULL, 0U, &needed, NULL); /* Запрашивает размер без фиксированного ограничения длины системного пути. */
PSP_DEVICE_INTERFACE_DETAIL_DATA_W detail = (PSP_DEVICE_INTERFACE_DETAIL_DATA_W)malloc(needed); /* Выделяет временную память в Windows-порту для пути устройства. */
if (!detail) { SetupDiDestroyDeviceInfoList(devices); return -1; } /* Освобождает SetupDi список при нехватке памяти. */
detail->cbSize = sizeof(*detail); /* Использует правильный размер структуры для ABI текущей Windows. */
if (SetupDiGetDeviceInterfaceDetailW(devices, &item, detail, needed, NULL, NULL) && wcsstr(detail->DevicePath, L"&mi_02")) { /* Отбирает отдельный USART-интерфейс 2, исключая CAN и DFU. */
uint32_t count = (uint32_t)wcslen(detail->DevicePath) + 1U; /* Учитывает завершающий ноль каждого системного пути. */
if (used + count + 1U > capacity) { free(detail); SetupDiDestroyDeviceInfoList(devices); return -2; } /* Явно сообщает недостаточную ёмкость, не возвращая обрезанный путь. */
memcpy(out + used, detail->DevicePath, count * sizeof(wchar_t)); used += count; out[used] = 0; /* Добавляет путь и сохраняет двойное завершение MULTI_SZ. */
} /* Дескрипторы неизвестного интерфейса никогда не открываются как USART. */
free(detail); /* Освобождает временную структуру после каждого элемента перечисления. */
} /* Завершает просмотр подключённых устройств. */
SetupDiDestroyDeviceInfoList(devices); /* Закрывает системный список независимо от количества найденных интерфейсов. */
return (int)used; /* Возвращает длину заполненной части списка в wchar_t. */
} /* Завершает перечисление без открытия или перенастройки CAN. */
static int queue_read(usb_context *context, unsigned index) { /* Немедленно возвращает свободный буфер в очередь аппаратного USB IN. */
usb_read *slot = &context->reads[index]; /* Выбирает один из шестнадцати независимых overlapped запросов. */
ResetEvent(slot->io.hEvent); /* Удаляет сигнал предыдущего завершения перед повторной постановкой I/O. */
BOOL result = WinUsb_ReadPipe(context->usb, 0x83U, slot->bytes, sizeof(slot->bytes), NULL, &slot->io); /* Запрашивает ровно один пакет, исключая зависание на полном 64-байтовом хвосте. */
slot->queued = result || GetLastError() == ERROR_IO_PENDING; /* Отмечает только успешно завершённый либо реально ожидающий I/O для безопасной очистки. */
if (result) SetEvent(slot->io.hEvent); /* Синхронное завершение также становится видимым обычному циклу ожидания. */
return slot->queued; /* Асинхронная постановка является успехом и не требует блокирования. */
} /* Завершает постановку непрерывного конвейера USB-чтения. */
UB_API void ub_usb_close(void *opaque) { /* Освобождает все I/O и handles одной настольной USB-сессии. */
usb_context *context = (usb_context *)opaque; /* Восстанавливает собственный контекст из непрозрачного ABI handle. */
if (!context) return; /* Допускает безопасное закрытие после неудачного подключения. */
if (context->file != INVALID_HANDLE_VALUE) CancelIoEx(context->file, NULL); /* Отменяет все ожидающие RX до освобождения их памяти. */
for (unsigned i = 0U; i < USB_READS; ++i) { /* Завершает все ранее выделенные overlapped события. */
if (context->reads[i].io.hEvent) { /* Не обращается к событию, которое не удалось создать при открытии. */
DWORD transferred = 0U; /* Принимает служебную длину отменённой транзакции. */
if (context->usb && context->reads[i].queued) WinUsb_GetOverlappedResult(context->usb, &context->reads[i].io, &transferred, TRUE); /* Дожидается только ранее поставленного I/O, исключая ожидание несигнального пустого события. */
CloseHandle(context->reads[i].io.hEvent); /* Закрывает собственное событие завершённого запроса. */
} /* Завершает очистку ресурсов одного приёмного запроса. */
} /* Все буферы больше не принадлежат драйверу USB. */
if (context->usb) WinUsb_Free(context->usb); /* Освобождает интерфейс WinUSB после завершения pending I/O. */
if (context->file != INVALID_HANDLE_VALUE) CloseHandle(context->file); /* Закрывает DevicePath, не затрагивая открытые handles CAN приложения. */
free(context); /* Освобождает память настольного контекста после системных ресурсов. */
} /* Закрытие завершается без оставленных фоновых чтений. */
UB_API void *ub_usb_open(const wchar_t *path) { /* Открывает только явно выбранный USART-интерфейс с проверкой его дескриптора. */
usb_context *context = (usb_context *)calloc(1U, sizeof(*context)); /* Обнуляет handles для корректной очистки при любой промежуточной ошибке. */
if (!context) return NULL; /* Сообщает нехватку памяти без частично созданной сессии. */
context->file = CreateFileW(path, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL); /* Открывает существующий WinUSB путь с поддержкой конвейера чтений. */
if (context->file == INVALID_HANDLE_VALUE || !WinUsb_Initialize(context->file, &context->usb)) { ub_usb_close(context); return NULL; } /* Не сохраняет контекст при отказе доступа или несовместимом драйвере. */
USB_INTERFACE_DESCRIPTOR descriptor; /* Проверяет назначение выбранного USB интерфейса до отправки команд устройству. */
if (!WinUsb_QueryInterfaceSettings(context->usb, 0U, &descriptor) || descriptor.bInterfaceNumber != 2U || descriptor.bInterfaceClass != 0xFFU || descriptor.bInterfaceSubClass != 0x55U || descriptor.bInterfaceProtocol != 1U) { ub_usb_close(context); return NULL; } /* Отвергает старую прошивку и чужие устройства даже при совпавшем GUID. */
ULONG timeout = 1000U; /* Ограничивает ожидание OUT-команды одной секундой при отключении устройства. */
if (!WinUsb_SetPipePolicy(context->usb, 0x03U, PIPE_TRANSFER_TIMEOUT, sizeof(timeout), &timeout)) { ub_usb_close(context); return NULL; } /* Не оставляет потенциально бесконечную синхронную запись в worker. */
for (unsigned i = 0U; i < USB_READS; ++i) { /* Заранее заполняет очередь драйвера шестнадцатью RX-пакетами. */
context->reads[i].io.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL); /* Каждый запрос получает собственное manual-reset событие завершения. */
if (!context->reads[i].io.hEvent || !queue_read(context, i)) { ub_usb_close(context); return NULL; } /* Закрывает все уже созданные ресурсы при отказе постановки RX. */
} /* Драйвер может принимать пакеты непрерывно независимо от частоты обновления GUI. */
return context; /* Возвращает непрозрачный handle исключительно worker потоку клиента. */
} /* Завершает открытие транспорта без автоматической команды START. */
UB_API int ub_usb_read(void *opaque, uint8_t *out, uint32_t capacity) { /* Собирает завершённые запросы в один блок, уменьшая накладные расходы ctypes. */
usb_context *context = (usb_context *)opaque; uint32_t used = 0U; /* Читает контекст текущего worker и считает выданные байты. */
if (!context || !out || capacity < 64U) return -1; /* Требует место хотя бы для одного максимального USB-пакета. */
while (capacity - used >= 64U) { /* Не извлекает транзакцию, если её возможные 64 байта не поместятся целиком. */
usb_read *slot = &context->reads[context->next]; /* Сохраняет порядок байтов согласно порядку постановки overlapped запросов. */
DWORD wait = WaitForSingleObject(slot->io.hEvent, used ? 0U : 50U); /* Первый пакет ожидает до 50 мс, остальные забираются только при готовности. */
if (wait == WAIT_TIMEOUT) break; /* Возвращает имеющийся блок либо ноль при отсутствии данных. */
if (wait != WAIT_OBJECT_0) return -1; /* Сообщает отказ системного события вместо бесконечного ожидания. */
DWORD count = 0U; /* Получает фактическую длину короткого или полного USB-пакета. */
if (!WinUsb_GetOverlappedResult(context->usb, &slot->io, &count, FALSE)) return -(int)GetLastError(); /* Передаёт ошибку отключённого устройства вызывающему worker. */
memcpy(out + used, slot->bytes, count); used += count; /* Копирует байты до повторного использования буфера драйвером. */
if (!queue_read(context, context->next)) return -1; /* Немедленно пополняет аппаратную очередь до возврата в Python. */
context->next = (context->next + 1U) % USB_READS; /* Циклически выбирает следующий ранее поставленный запрос. */
} /* Выполняет ограниченное количество готовых I/O без активного ожидания. */
return (int)used; /* Возвращает сырые записи для единственного общего C parser. */
} /* Завершает пакетное чтение с непрерывной аппаратной очередью. */
UB_API int ub_usb_write(void *opaque, const uint8_t *data, uint32_t length) { /* Передаёт одну ограниченную команду через USART OUT endpoint. */
usb_context *context = (usb_context *)opaque; ULONG written = 0U; /* Хранит фактически записанную длину для проверки короткой записи. */
if (!context || !data || length > 64U) return -1; /* Не допускает выхода за максимальный размер команды этого протокола. */
if (!WinUsb_WritePipe(context->usb, 0x03U, (PUCHAR)data, length, &written, NULL)) return -(int)GetLastError(); /* Использует таймаут OUT и возвращает системную ошибку отключения. */
return (int)written; /* Позволяет клиенту отвергнуть неполную запись команды. */
} /* Завершает Windows-порт, сохраняя кодирование протокола в общем C-ядре. */
+45
View File
@@ -0,0 +1,45 @@
"""Проверяет worker настоящего терминала с C-кодеком и имитацией USB устройства.""" # Не требует подключённой платы и не подменяет кодек реализацией Python.
import ctypes as ct # Передаёт входящие команды в общий C parser fake устройства.
from pathlib import Path # Проверяет точные бинарные журналы, сохранённые production worker.
from PySide6.QtWidgets import QApplication # Создаёт реальный Qt UI для проверки ограниченного предпросмотра.
from set_devices.uart_usb import Frame, Parser # Использует те же структуры C ABI, что и основной Python порт.
from set_devices.qt_ports.uart_usb_terminal import UsbWorker, UartUsbTerminal # Проверяет реальную панель и её единственный фоновый транспорт.
from test_uart_usb import native, encoded # Повторно использует загруженную DLL и builder эталонных ответов.
def test_worker_busy_tx_and_binary_logs(native, tmp_path): # Проверяет полный STOP→CONFIG→START→TX→STOP с записью всех двоичных байтов.
worker = UsbWorker('fake', [1000000] * 4, str(tmp_path), native_factory=lambda: native) # Запускает production автомат с настоящим C протоколом и тестовым USB handle.
payload, rx = b'\0\xa7\xffhello', b'\0\xff\xa7RX\r\n' # Данные включают нулевой байт, служебную синхронизацию и двоичное значение FF.
class FakeUsb: # Моделирует только аппаратное поведение устройства, используя общий C parser и builder.
def __init__(self, codec, path): # Получает тот же codec API, что обычный WinUSB порт.
self.queue, self.parser, self.tx, self.commands, self.attempts, self.closed = [], Parser(), [], [], 0, False # Разделяет состояние командного parser и ответного потока хоста.
def write(self, data): # Принимает уже готовые команды worker без локальной реализации wire заголовка.
source, frame = (ct.c_uint8 * len(data)).from_buffer_copy(data), Frame() # Выделяет проверяемую входную память команды.
assert native.lib.ub_feed(ct.byref(self.parser), source, len(data), ct.byref(frame)) == len(data) # Общий C parser должен потребить ровно одну целую команду.
self.commands.append((frame.type, frame.channel)); status = 0 # Сохраняет семантику принятой команды для проверки порядка.
if frame.type == 4: # Единственная передача сначала получает явный BUSY, затем принимается.
self.attempts += 1; status = 2 if self.attempts == 1 else 0 # BUSY не имеет побочного действия и разрешает безопасный повтор.
if not status: self.tx.append(bytes(frame.data[:frame.length])) # Сохраняет байты только после действительного принятия TX.
self.queue.append(encoded(native, 8, frame.channel, bytes([frame.type, status, 2, 1]))) # Fake прошивка объявляет два RX и единственный TX1 через общий ACK builder.
if frame.type == 2: self.queue.append(encoded(native, 9, 1, rx)) # Данные RX следуют сразу за START, проверяя захват начала сессии.
def read(self): # Возвращает несколько готовых записей одним блоком, как реальный конвейер USB.
if self.queue: result = b''.join(self.queue); self.queue.clear(); return result # Сохраняет порядок ACK и первого RX в одном чтении.
if self.tx: worker.requestInterruption() # Завершает тест после успешной пользовательской передачи, не оставляя бесконечный loop.
return b'' # Пустое чтение соответствует штатному ограниченному таймауту транспорта.
def close(self): self.closed = True # Фиксирует обязательное закрытие после STOP независимо от данных сессии.
worker.usb_factory = FakeUsb; worker.commands.put(payload); statuses = []; worker.status.connect(statuses.append) # Ставит пользовательский TX до запуска worker без взаимодействия с GUI потоком.
worker.start(); assert worker.wait(3000) # Проверяет настоящий QThread и его штатный requestInterruption с ограниченным сроком завершения.
assert worker.usb.closed and worker.usb.tx == [payload] and worker.usb.attempts == 2 # BUSY вызывает повтор ровно один раз и не дублирует байты USART.
assert worker.usb.commands[:4] == [(3, 0), (1, 1), (1, 2), (2, 0)] # Сборка с двумя входами не настраивает несуществующие каналы 3 и 4.
assert worker.usb.commands[-1] == (3, 0) # Штатное отключение завершается командой STOP до закрытия Windows handle.
assert list(tmp_path.glob('*/rx1.bin'))[0].read_bytes() == rx # Бинарный журнал сохраняет исходные байты без UTF-8 перекодирования и USB заголовка.
assert worker.totals == [len(rx), 0, 0, 0] # Общий счётчик хоста соответствует всем реально полученным данным.
assert not any('Нет подтверждения' in status for status in statuses) # Нормальный BUSY не маскируется таймаутом команды.
def test_panel_preview_and_rx_only(native): # Проверяет реальную панель без открытия USB и без аппаратного оборудования.
application = QApplication.instance() or QApplication([]) # Создаёт один Qt event dispatcher для виджетов теста.
panel = UartUsbTerminal(); panel.resize(1000, 650) # Проверяет компоновку четырёх каналов в обычном размере окна.
assert not panel.send.isEnabled() # TX недоступен до подтверждённого открытия и START.
panel.started(2); assert panel.send.isEnabled() and not panel.views[2].isEnabled() # Возможности прошивки отключают экраны отсутствующих третьего и четвёртого входов.
panel.received(1, b'x' * 20000, 20000); panel.statistics(1, 7, 3) # Имитирует большой непрерывный поток и отдельные аппаратные счётчики.
assert len(panel.buffers[0]) == 8192 and panel.counts[0] == 20000 # Предпросмотр ограничен, но суммарное число байтов не обрезается.
assert 'потери 7' in panel.counters[0].text() and 'ошибки 3' in panel.counters[0].text() # GUI показывает явные сообщения о перегрузке прошивки.
panel.hex_view.setChecked(True); assert panel.views[0].toPlainText().startswith('78 78') # HEX меняет только отображение принятого пользовательского потока.
panel.close(); application.processEvents() # Завершает тест без фонового QThread и открытых системных ресурсов.
+55
View File
@@ -0,0 +1,55 @@
"""Эталонные байты и потоковые проверки единственного C-кодека USART USB.""" # Тест использует настоящую DLL, а не повторяет кодек на Python.
import ctypes as ct # Передаёт эталонные фрагменты непосредственно C-функциям.
import os # Получает путь собранной DLL через окружение тестового запуска.
import random # Создаёт воспроизводимые произвольные разрывы входного потока.
import pytest # Параметризует границы каналов и длины USB-записей.
from set_devices.uart_usb import Native, Frame, Parser, CEvent # Использует штатные ABI структуры production порта.
@pytest.fixture # Каждая проверка получает независимое состояние C parser.
def native(): # Загружает только DLL, явно подготовленную внешней командой сборки.
result = Native(os.environ['UART_USB_LIBRARY']) # Исключает случайную проверку старой установленной библиотеки.
result.lib.ub_encode.argtypes = [ct.c_uint8, ct.c_uint8, ct.POINTER(ct.c_uint8), ct.c_uint16, ct.POINTER(ct.c_uint8)] # Описывает общий builder для эталонных ответов fake устройства.
result.lib.ub_encode.restype = ct.c_uint16 # Принимает точную длину построенной записи.
return result # Возвращает реальный C-кодек и Windows-порт с общим ABI.
def encoded(native, kind, channel, data): # Строит тестовый ответ общим C builder, сохраняя literal-векторы в проверках ниже.
source, out = (ct.c_uint8 * len(data)).from_buffer_copy(data), (ct.c_uint8 * 64)() # Размещает входной payload и независимый выходной буфер.
size = native.lib.ub_encode(kind, channel, source, len(data), out) # Вызывает production кодек без реализации заголовка в тестовом helper.
return bytes(out[:size]) # Возвращает ровно столько байтов, сколько разрешило C-ядро.
def test_literal_commands(native): # Фиксирует endian и единственный TX канал независимо от будущих изменений builder.
assert native.make('config', 1, 3000000) == bytes.fromhex('a7 11 04 00 c0 c6 2d 00') # Скорость 3000000 бит/с кодируется little-endian, канал 1 находится в младшей тетраде.
assert native.make('start') == bytes.fromhex('a7 20 00 00') # Общая команда START не содержит payload и номера физического входа.
assert native.make('stop') == bytes.fromhex('a7 30 00 00') # Общая команда STOP отличается только типом.
assert native.make('tx', data=b'\0\xa7\xff') == bytes.fromhex('a7 41 03 00 00 a7 ff') # Служебный байт внутри данных передаётся без экранирования и изменения.
@pytest.mark.parametrize('cut', range(65)) # Проверяет каждый возможный разрыв максимального USB-пакета.
def test_every_split(native, cut): # Гарантирует восстановление записи между произвольными вызовами чтения.
payload = bytes([0xA7, 0, 255] * 20) # Заполняет все 60 байт двоичными значениями, включая синхронизацию.
packet = encoded(native, 9, 4, payload) # Готовит максимальный RX ответ канала 4.
events = native.feed(packet[:cut]) + native.feed(packet[cut:]) # Разделяет заголовок и данные в каждой возможной позиции.
assert len(events) == 1 and events[0].channel == 4 and events[0].data == payload # Ни разрыв, ни служебный байт внутри payload не создают ложный канал.
def test_noise_and_invalid_header(native): # Проверяет восстановление после шума, неизвестного типа и превышения длины.
stream = bytes.fromhex('00 ff a7 f1 00 00 a7 91 ff ff a7 95 01 00') + encoded(native, 9, 2, b'ok') # Добавляет неправильные тип, длину и канал перед валидной записью.
events = native.feed(stream) # Передаёт повреждённый поток реальному C parser.
assert [(item.channel, item.data) for item in events] == [(2, b'ok')] # Ошибочные заголовки не меняют полезные данные следующего канала.
def test_many_records_random_chunks(native): # Проверяет последовательность множества каналов при разных границах системного чтения.
rng, expected, stream = random.Random(474), [], bytearray() # Фиксированный seed делает проверку повторяемой.
for index in range(1000): # Создаёт достаточно длинный поток для многократного использования внутреннего буфера parser.
channel, payload = index % 4 + 1, bytes(rng.randrange(256) for _ in range(rng.randrange(1, 61))) # Перемешивает размеры и бинарные значения четырёх физических входов.
expected.append((channel, payload)); stream.extend(encoded(native, 9, channel, payload)) # Сохраняет ожидаемую модель до произвольной нарезки.
actual, offset = [], 0 # Собирает восстановленные события в исходном порядке.
while offset < len(stream): # Имитация WinUSB отдаёт блоки разной длины без границ записей.
count = rng.randrange(1, 300); actual.extend((item.channel, item.data) for item in native.feed(stream[offset:offset + count])); offset += count # Делегирует весь разбор общего заголовка C-ядру.
assert actual == expected # Проверяет отсутствие потерь, перестановки каналов и повреждения payload.
def test_ack_and_stats(native): # Фиксирует смысловые поля ответов без локального декодирования wire-байтов.
ack = native.feed(bytes.fromhex('a7 80 04 00 02 00 04 01'))[0] # Эталон подтверждает START, четыре RX и TX только канала 1.
assert (ack.kind, ack.command, ack.status, ack.channels, ack.tx_channel) == (2, 2, 0, 4, 1) # C API возвращает уже разобранные свойства устройства.
stats = native.feed(bytes.fromhex('a7 a3 08 00 78 56 34 12 ff ff ff ff'))[0] # Эталон содержит статистику канала 3 и максимальный беззнаковый счётчик.
assert (stats.kind, stats.channel, stats.lost, stats.errors) == (3, 3, 0x12345678, 0xFFFFFFFF) # Значения endian и диапазоны счётчиков одинаковы в MCU и Python.
@pytest.mark.parametrize('payload', [b'', b'\x02\x00\x04', b'\x02\x00\x05\x01', b'\x02\x00\x04\x02']) # Покрывает ошибочные длины и несовместимые возможности прошивки.
def test_bad_ack_is_not_event(native, payload): # Ошибочный ACK не разрешает передачу либо запуск панели.
assert native.feed(encoded(native, 8, 0, payload)) == [] # Семантическая проверка выполняется в C ub_describe.
def test_builder_rejects_bounds(native): # Границы публичного builder не зависят от ограничений UI.
assert encoded(native, 9, 5, b'x') == b'' # Номер канала 5 не существует в минимальном протоколе.
assert encoded(native, 9, 1, b'x' * 61) == b'' # Длина 61 превысила бы максимальный USB-пакет 64 байта.
with pytest.raises(ValueError): native.make('tx', data=b'') # Пустая отправка не создаёт неоднозначную команду TX.
def test_describe_checks_abi_bounds(native): # Прямой пользователь C ABI также защищён от выхода за размер payload.
frame, event = Frame(), CEvent(); frame.type = 9; frame.channel = 1; frame.length = 61 # Имитирует неверную структуру, созданную в обход потокового parser.
assert native.lib.ub_describe(ct.byref(frame), ct.byref(event)) == 0 # Проверка выполняется до memcpy и защищает память выходной модели.
+64
View File
@@ -0,0 +1,64 @@
#include "uart_usb.h" /* Подключает общий формат, размеры буферов и публичный ABI. */
#include <string.h> /* Использует стандартное копирование памяти без зависимости от MCU или ОС. */
static int valid_type(uint8_t type) { /* Ограничивает типы реальными командами и ответами версии 1. */
return (type >= UB_CONFIG && type <= UB_TX) || (type >= UB_ACK && type <= UB_STATS); /* Отвергает свободные значения тега, чтобы раньше восстановить границу. */
} /* Завершает проверку допустимых типов. */
uint16_t ub_encode(uint8_t type, uint8_t channel, const uint8_t *data, uint16_t length, uint8_t *out) { /* Формирует единственный wire-формат для прошивки и GUI. */
if (!out || !valid_type(type) || channel > 4U || length > UB_PAYLOAD || (length && !data)) return 0U; /* Проверяет указатели и границы до обращения к памяти. */
out[0] = UB_MAGIC; /* Отмечает начало записи выбранным байтом синхронизации 0xA7. */
out[1] = (uint8_t)((type << 4U) | channel); /* Упаковывает тип и номер канала в старшую и младшую тетрады. */
out[2] = (uint8_t)length; /* Записывает младший байт длины данных в байтах. */
out[3] = 0U; /* Старший байт длины равен нулю при ограничении payload до 60 байт. */
if (length && data != out + 4U) memcpy(out + 4U, data, length); /* Сохраняет бинарные значения и допускает уже заполненную полезную область выходного буфера. */
return (uint16_t)(length + 4U); /* Возвращает длину USB-записи вместе с заголовком. */
} /* Завершает построение записи без CRC, поскольку целостность обеспечивает USB. */
uint16_t ub_feed(ub_parser *parser, const uint8_t *data, uint16_t length, ub_frame *frame) { /* Разбирает фрагменты потока и выдаёт не более одной записи за вызов. */
uint16_t offset = 0U; /* Начинает счёт потреблённых байтов нового входного фрагмента. */
frame->type = 0U; /* Явно обозначает отсутствие полного результата до накопления всей записи. */
while (offset < length) { /* Ограничивает чтение фактической длиной входного USB-пакета. */
uint8_t byte = data[offset++]; /* Потребляет очередной байт ровно один раз. */
if (!parser->used && byte != UB_MAGIC) continue; /* Пропускает шум до начала следующей записи. */
parser->bytes[parser->used++] = byte; /* Сохраняет очередной байт в ограниченном буфере записи. */
while (parser->used >= 4U && (!valid_type(parser->bytes[1] >> 4U) || (parser->bytes[1] & 15U) > 4U || parser->bytes[2] > UB_PAYLOAD || parser->bytes[3])) { /* Отбрасывает заголовки с неизвестными типами, каналами и длинами. */
memmove(parser->bytes, parser->bytes + 1U, --parser->used); /* Сдвигает окно на байт, сохраняя возможное начало корректного заголовка. */
while (parser->used && parser->bytes[0] != UB_MAGIC) { /* Ищет синхронизацию только среди уже полученных байтов. */
memmove(parser->bytes, parser->bytes + 1U, --parser->used); /* Удаляет префикс шума без потери следующего служебного байта. */
} /* Завершает повторную синхронизацию внутри ошибочного заголовка. */
} /* Завершает проверку накопленного заголовка. */
if (parser->used >= 4U && parser->used == (uint16_t)(4U + parser->bytes[2])) { /* Выдаёт запись только после получения всех заявленных данных. */
frame->type = parser->bytes[1] >> 4U; /* Извлекает тип из старшей тетрады тега. */
frame->channel = parser->bytes[1] & 15U; /* Извлекает логический номер канала из младшей тетрады. */
frame->length = parser->bytes[2]; /* Возвращает проверенную длину не более 60 байт. */
memcpy(frame->data, parser->bytes + 4U, frame->length); /* Копирует данные, чтобы следующий USB-пакет не изменил результат. */
parser->used = 0U; /* Готовит parser к следующей записи в том же входном фрагменте. */
break; /* Позволяет вызывающему обработать результат и затем передать остаток потока. */
} /* Завершает выдачу одного полного сообщения. */
} /* Завершает обработку доступного фрагмента. */
return offset; /* Позволяет без потерь продолжить разбор оставшихся байтов входного буфера. */
} /* Завершает потоковый parser без heap и системных вызовов. */
uint32_t ub_get_u32(const uint8_t *data) { /* Читает значение без невыровненных обращений к uint32_t. */
return (uint32_t)data[0] | ((uint32_t)data[1] << 8U) | ((uint32_t)data[2] << 16U) | ((uint32_t)data[3] << 24U); /* Собирает little-endian значение из четырёх байтов. */
} /* Завершает чтение скорости или счётчика. */
void ub_put_u32(uint8_t *data, uint32_t value) { /* Записывает числовые поля в общий wire-формат. */
for (uint8_t i = 0U; i < 4U; ++i) data[i] = (uint8_t)(value >> (8U * i)); /* Выделяет четыре последовательных байта от младшего к старшему. */
} /* Завершает переносимое преобразование endian. */
uint16_t ub_make_config(uint8_t channel, uint32_t baud, uint8_t *out) { /* Строит целую команду настройки одним общим вызовом C. */
uint8_t data[4]; ub_put_u32(data, baud); /* Представляет скорость в четырёх little-endian байтах. */
return ub_encode(UB_CONFIG, channel, data, sizeof(data), out); /* Передаёт проверку границ канала и построение заголовка единственному кодеку. */
} /* Завершает создание конфигурационной команды для настольного клиента. */
uint16_t ub_make_start(uint8_t *out) { return ub_encode(UB_START, 0U, 0, 0U, out); } /* Общий канал 0 и пустой payload однозначно запускают все входы. */
uint16_t ub_make_stop(uint8_t *out) { return ub_encode(UB_STOP, 0U, 0, 0U, out); } /* Общий канал 0 и пустой payload однозначно останавливают все входы. */
uint16_t ub_make_tx(const uint8_t *data, uint16_t length, uint8_t *out) { return length ? ub_encode(UB_TX, 1U, data, length, out) : 0U; } /* Не допускает пустую передачу и всегда выбирает только канал 1. */
int ub_describe(const ub_frame *frame, ub_event *event) { /* Декодирует смысл служебных payload в общем C вместо отдельных реализаций GUI. */
if (!frame || !event || frame->channel > 4U || frame->length > UB_PAYLOAD) return 0; /* Проверяет публичные ABI аргументы даже при прямом вызове без потокового parser. */
memset(event, 0, sizeof(*event)); /* Не оставляет поля предыдущего события при коротком или ошибочном ответе. */
event->channel = frame->channel; /* Передаёт уже проверенный parser логический номер канала. */
if (frame->type == UB_RX && frame->channel && frame->length) { /* RX допускает только существующий номер и непустые бинарные данные. */
event->kind = 1U; event->length = frame->length; memcpy(event->data, frame->data, frame->length); /* ABI событие 1 содержит только полученные байты без служебного заголовка. */
} else if (frame->type == UB_ACK && frame->length == 4U && frame->data[0] >= UB_CONFIG && frame->data[0] <= UB_TX && frame->data[1] <= UB_BUSY && frame->data[2] >= 2U && frame->data[2] <= 4U && frame->data[3] == 1U) { /* Проверяет длину, исходную команду, статус и объявленные возможности G474. */
event->kind = 2U; event->command = frame->data[0]; event->status = frame->data[1]; event->channels = frame->data[2]; event->tx_channel = frame->data[3]; /* ABI событие 2 передаёт поля подтверждения без знания смещений в Python. */
} else if (frame->type == UB_STATS && frame->channel && frame->length == 8U) { /* Статистика содержит ровно два 32-битных счётчика отдельного канала. */
event->kind = 3U; event->lost = ub_get_u32(frame->data); event->errors = ub_get_u32(frame->data + 4U); /* ABI событие 3 возвращает готовые числовые значения. */
} /* Другие записи не являются корректными ответами USB терминалу. */
return event->kind != 0U; /* Отрицательный семантический результат не маскируется под пустой RX. */
} /* Завершает единый разбор служебных полей протокола. */
+44
View File
@@ -0,0 +1,44 @@
#ifndef UART_USB_H /* Защищает общий ABI протокола от повторного включения. */
#define UART_USB_H /* Обозначает подключённый заголовок переносимого C99-ядра. */
#include <stdint.h> /* Задаёт одинаковые размеры полей MCU и настольного клиента. */
#if defined(_WIN32) /* Экспортирует кодек в отдельную DLL для ctypes на Windows. */
#define UB_API __declspec(dllexport) /* Делает публичные функции доступными без второго кодека в Python. */
#else /* Остальные платформы используют обычную видимость функций C. */
#define UB_API /* Оставляет интерфейс пригодным для статической линковки прошивки. */
#endif /* Завершает выбор способа экспорта ABI. */
#define UB_MAGIC 0xA7U /* Служебный байт выбран для восстановления границы записи в потоке USB. */
#define UB_PAYLOAD 60U /* Вместе с четырьмя байтами заголовка заполняет пакет USB FS длиной 64 байта. */
#define UB_CONFIG 1U /* Команда задаёт скорость одного выключенного приёмника в битах в секунду. */
#define UB_START 2U /* Команда запускает все включённые каналы захвата. */
#define UB_STOP 3U /* Команда останавливает DMA и освобождает USART после завершения TX. */
#define UB_TX 4U /* Команда передаёт необработанные байты только через логический канал 1. */
#define UB_ACK 8U /* Ответ содержит исходную команду, результат и число аппаратных каналов. */
#define UB_RX 9U /* Запись переносит принятые байты одного USART без текстового преобразования. */
#define UB_STATS 10U /* Запись сообщает накопленные потери и аппаратные ошибки одного канала. */
#define UB_OK 0U /* Нулевой статус подтверждает выполнение команды. */
#define UB_INVALID 1U /* Некорректные канал, длина или скорость не меняют состояние устройства. */
#define UB_BUSY 2U /* Занятый передатчик или работающий захват требуют повторения команды. */
typedef struct { /* Представляет разобранную запись без упаковки структур в wire-формат. */
uint8_t type; /* Хранит старшие четыре бита тега как отдельный тип сообщения. */
uint8_t channel; /* Хранит логический номер 1…4; номер 0 относится ко всему устройству. */
uint16_t length; /* Показывает фактическое количество байтов в payload, не более 60. */
uint8_t data[UB_PAYLOAD]; /* Передаёт бинарные данные без указателя на временную USB-память. */
} ub_frame; /* Сохраняет стабильное естественное выравнивание структуры для ctypes. */
typedef struct { /* Сохраняет состояние разбора между произвольно разделёнными USB-пакетами. */
uint8_t bytes[64]; /* Вмещает максимальную запись: заголовок 4 байта и данные 60 байт. */
uint16_t used; /* Показывает число уже накопленных байтов текущей записи. */
} ub_parser; /* Вся память принадлежит вызывающему; глобальное состояние отсутствует. */
typedef struct { /* Передаёт разобранный смысл ответа GUI через стабильный ABI без знания смещений payload. */
uint32_t kind, channel, length, command, status, channels, tx_channel, lost, errors; /* Хранит тип события и уже проверенные числовые поля ACK или статистики. */
uint8_t data[UB_PAYLOAD]; /* Содержит исключительно полезные байты RX для вывода и двоичного журнала. */
} ub_event; /* Размеры uint32 исключают разное представление enum и bool в языковых FFI. */
UB_API uint16_t ub_make_config(uint8_t channel, uint32_t baud, uint8_t *out); /* Формирует настройку скорости без сборки wire-полей в Python. */
UB_API uint16_t ub_make_start(uint8_t *out); /* Формирует общую команду запуска захвата. */
UB_API uint16_t ub_make_stop(uint8_t *out); /* Формирует общую команду остановки захвата. */
UB_API uint16_t ub_make_tx(const uint8_t *data, uint16_t length, uint8_t *out); /* Формирует передачу через единственный разрешённый канал 1. */
UB_API int ub_describe(const ub_frame *frame, ub_event *event); /* Проверяет семантику ответа и возвращает готовые поля либо 0 при ошибке. */
UB_API uint16_t ub_encode(uint8_t type, uint8_t channel, const uint8_t *data, uint16_t length, uint8_t *out); /* Записывает максимум 64 байта в буфер вызывающего и возвращает длину либо 0. */
UB_API uint16_t ub_feed(ub_parser *parser, const uint8_t *data, uint16_t length, ub_frame *frame); /* Возвращает число потреблённых байтов; type=0 означает незавершённую запись. */
UB_API uint32_t ub_get_u32(const uint8_t *data); /* Читает четыре байта little-endian независимо от архитектуры хоста. */
UB_API void ub_put_u32(uint8_t *data, uint32_t value); /* Записывает скорость или счётчик как четыре байта little-endian. */
#endif /* Завершает описание единственного общего кодека. */
@@ -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