From 34d90161182432e357fe798ea0b1c0e57f361955 Mon Sep 17 00:00:00 2001 From: Andrey Date: Mon, 16 Nov 2026 18:15:48 +0300 Subject: [PATCH] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=B8=D1=82?= =?UTF-8?q?=D1=8C=20USART=20USB=20=D0=BC=D0=BE=D1=81=D1=82=20G474=20=D0=B8?= =?UTF-8?q?=20=D0=BE=D0=B1=D1=89=D0=B8=D0=B9=20=D1=87=D0=B5=D1=82=D1=8B?= =?UTF-8?q?=D1=80=D1=91=D1=85=D0=BA=D0=B0=D0=BD=D0=B0=D0=BB=D1=8C=D0=BD?= =?UTF-8?q?=D1=8B=D0=B9=20=D1=82=D0=B5=D1=80=D0=BC=D0=B8=D0=BD=D0=B0=D0=BB?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- c/uart-usb/CMakeLists.txt | 9 + c/uart-usb/README.md | 119 +++++++++++++ c/uart-usb/ports/stm32g474/uart_usb_g474.c | 139 +++++++++++++++ c/uart-usb/ports/stm32g474/uart_usb_g474.h | 16 ++ c/uart-usb/ports/windows/uart_usb_winusb.c | 94 ++++++++++ c/uart-usb/tests/test_terminal.py | 45 +++++ c/uart-usb/tests/test_uart_usb.py | 55 ++++++ c/uart-usb/uart_usb.c | 64 +++++++ c/uart-usb/uart_usb.h | 44 +++++ .../set_devices/qt_ports/uart_usb_terminal.py | 163 ++++++++++++++++++ python/set_devices/uart_usb.py | 79 +++++++++ 11 files changed, 827 insertions(+) create mode 100644 c/uart-usb/CMakeLists.txt create mode 100644 c/uart-usb/README.md create mode 100644 c/uart-usb/ports/stm32g474/uart_usb_g474.c create mode 100644 c/uart-usb/ports/stm32g474/uart_usb_g474.h create mode 100644 c/uart-usb/ports/windows/uart_usb_winusb.c create mode 100644 c/uart-usb/tests/test_terminal.py create mode 100644 c/uart-usb/tests/test_uart_usb.py create mode 100644 c/uart-usb/uart_usb.c create mode 100644 c/uart-usb/uart_usb.h create mode 100644 python/set_devices/qt_ports/uart_usb_terminal.py create mode 100644 python/set_devices/uart_usb.py diff --git a/c/uart-usb/CMakeLists.txt b/c/uart-usb/CMakeLists.txt new file mode 100644 index 0000000..5da37a7 --- /dev/null +++ b/c/uart-usb/CMakeLists.txt @@ -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 порт напрямую своим проектом. diff --git a/c/uart-usb/README.md b/c/uart-usb/README.md new file mode 100644 index 0000000..0e0283c --- /dev/null +++ b/c/uart-usb/README.md @@ -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` без служебных заголовков и перекодирования. +На неподключённой плате измерение реальной скорости и проверка проводов +не выполняются; это отдельная аппаратная проверка. diff --git a/c/uart-usb/ports/stm32g474/uart_usb_g474.c b/c/uart-usb/ports/stm32g474/uart_usb_g474.c new file mode 100644 index 0000000..e293dcf --- /dev/null +++ b/c/uart-usb/ports/stm32g474/uart_usb_g474.c @@ -0,0 +1,139 @@ +#include "uart_usb_g474.h" /* Подключает контракт единственного аппаратного порта этой версии. */ +#include "uart_usb.h" /* Использует общие статусы протокола и максимальную длину TX. */ +#include "stm32g4xx.h" /* Получает проверенные адреса и маски регистров из CMSIS производителя. */ +#include /* Копирует 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. */ +} /* Завершает чтение диагностики существующего канала. */ diff --git a/c/uart-usb/ports/stm32g474/uart_usb_g474.h b/c/uart-usb/ports/stm32g474/uart_usb_g474.h new file mode 100644 index 0000000..610e528 --- /dev/null +++ b/c/uart-usb/ports/stm32g474/uart_usb_g474.h @@ -0,0 +1,16 @@ +#pragma once /* Защищает аппаратный интерфейс STM32G474 от повторного объявления. */ +#include /* Фиксирует размеры счётчиков и длины буферов порта. */ +#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 или отключении. */ diff --git a/c/uart-usb/ports/windows/uart_usb_winusb.c b/c/uart-usb/ports/windows/uart_usb_winusb.c new file mode 100644 index 0000000..ee952ac --- /dev/null +++ b/c/uart-usb/ports/windows/uart_usb_winusb.c @@ -0,0 +1,94 @@ +#define WIN32_LEAN_AND_MEAN /* Исключает лишние Windows API из переносимого по разрядности host-порта. */ +#include /* Предоставляет handles, события и overlapped I/O для высокоскоростного USB. */ +#include /* Перечисляет интерфейсы устройства по опубликованному прошивкой GUID. */ +#include /* Использует штатный драйвер WinUSB без установки Python USB-пакетов. */ +#include /* Выделяет память только в настольном порте; MCU-ядро остаётся без heap. */ +#include /* Копирует завершённые 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-ядре. */ diff --git a/c/uart-usb/tests/test_terminal.py b/c/uart-usb/tests/test_terminal.py new file mode 100644 index 0000000..652b7ba --- /dev/null +++ b/c/uart-usb/tests/test_terminal.py @@ -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 и открытых системных ресурсов. diff --git a/c/uart-usb/tests/test_uart_usb.py b/c/uart-usb/tests/test_uart_usb.py new file mode 100644 index 0000000..3c5d89a --- /dev/null +++ b/c/uart-usb/tests/test_uart_usb.py @@ -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 и защищает память выходной модели. diff --git a/c/uart-usb/uart_usb.c b/c/uart-usb/uart_usb.c new file mode 100644 index 0000000..5be0464 --- /dev/null +++ b/c/uart-usb/uart_usb.c @@ -0,0 +1,64 @@ +#include "uart_usb.h" /* Подключает общий формат, размеры буферов и публичный ABI. */ +#include /* Использует стандартное копирование памяти без зависимости от 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. */ +} /* Завершает единый разбор служебных полей протокола. */ diff --git a/c/uart-usb/uart_usb.h b/c/uart-usb/uart_usb.h new file mode 100644 index 0000000..20373b1 --- /dev/null +++ b/c/uart-usb/uart_usb.h @@ -0,0 +1,44 @@ +#ifndef UART_USB_H /* Защищает общий ABI протокола от повторного включения. */ +#define UART_USB_H /* Обозначает подключённый заголовок переносимого C99-ядра. */ +#include /* Задаёт одинаковые размеры полей 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 /* Завершает описание единственного общего кодека. */ diff --git a/python/set_devices/qt_ports/uart_usb_terminal.py b/python/set_devices/qt_ports/uart_usb_terminal.py new file mode 100644 index 0000000..aae738d --- /dev/null +++ b/python/set_devices/qt_ports/uart_usb_terminal.py @@ -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. diff --git a/python/set_devices/uart_usb.py b/python/set_devices/uart_usb.py new file mode 100644 index 0000000..8138c07 --- /dev/null +++ b/python/set_devices/uart_usb.py @@ -0,0 +1,79 @@ +"""Тонкий ctypes-порт общего C-кодека и конвейера WinUSB для USART G474.""" # Хранит протокол исключительно в c/uart-usb, без алгоритмического fallback. +import ctypes as ct # Связывает Python с единым стабильным ABI C99. +import importlib.util # Находит каталог установленного SETGUI без создания его главного окна. +import os # Читает явно заданный путь UART_USB_LIBRARY для исходников и тестов. +from pathlib import Path # Одинаково разрешает пути исходного и установленного приложения. +from dataclasses import dataclass # Передаёт UI готовые смысловые поля вместо wire-структуры. +class Frame(ct.Structure): # Повторяет только ABI структуры C, а не алгоритм разбора USB. + _fields_ = [('type', ct.c_uint8), ('channel', ct.c_uint8), ('length', ct.c_uint16), ('data', ct.c_uint8 * 60)] # Размер payload и естественное выравнивание совпадают с uart_usb.h. +class Parser(ct.Structure): # Владеет памятью состояния общего потокового parser. + _fields_ = [('bytes', ct.c_uint8 * 64), ('used', ct.c_uint16)] # C хранит до одной записи, включая незавершённый заголовок. +class CEvent(ct.Structure): # Описывает смысловой ABI ответа без packed-полей или платформенных enum. + _fields_ = [(name, ct.c_uint32) for name in ('kind', 'channel', 'length', 'command', 'status', 'channels', 'tx_channel', 'lost', 'errors')] + [('data', ct.c_uint8 * 60)] # Все числовые поля C имеют фиксированные 32 бита. +@dataclass(frozen=True) # Делает событие неизменяемым при передаче из worker в GUI. +class Event: # Содержит только проверенные C-ядром значения протокола. + kind: int # Значения ABI: 1 — RX, 2 — ACK, 3 — статистика. + channel: int # Указывает логический канал 1…4 либо общий канал 0. + data: bytes # Содержит полезные бинарные байты RX без служебных полей. + command: int # Идентифицирует команду, к которой относится ACK. + status: int # Возвращает результат: 0 — успех, 1 — неверные параметры, 2 — занято. + channels: int # Объявляет фактическое количество включённых приёмников прошивки. + tx_channel: int # Показывает единственный разрешённый канал передачи. + lost: int # Считает отброшенные прошивкой байты при перегрузке USB. + errors: int # Считает замеченные аппаратные события USART и DMA. +class Native: # Предоставляет высокоуровневые команды и события поверх одного C-кодека. + def __init__(self, library=None): # Позволяет тесту явно выбрать проверяемую DLL без изменения окружения приложения. + candidates = [Path(library)] if library else [] # Предпочитает явно выбранную библиотеку нужной архитектуры. + if not library and os.environ.get('UART_USB_LIBRARY'): candidates.append(Path(os.environ['UART_USB_LIBRARY'])) # Поддерживает отдельный путь исходной сборки. + candidates.append(Path(__file__).with_suffix('.dll')) # Поддерживает самостоятельную установку библиотеки set_devices. + spec = importlib.util.find_spec('gui_desktop') # Находит штатный пакет GUI без импорта его Qt-панелей. + if spec and spec.origin: candidates.append(Path(spec.origin).parent / 'native' / 'uart_usb.dll') # Использует стандартный каталог нативных библиотек SETGUI. + path = next((item for item in candidates if item.is_file()), None) # Не загружает случайную DLL из текущего каталога процесса. + if path is None: raise RuntimeError('Не найдена uart_usb.dll. Соберите c/uart-usb/ports/windows и установите DLL в gui_desktop/native.') # Ошибка установки не подменяет C-кодек реализацией Python. + self.lib = ct.CDLL(str(path)) # Загружает C ABI cdecl, одинаково объявленный для x86 и x64. + ptr = ct.POINTER(ct.c_uint8) # Задаёт тип указателя на бинарные массивы общего API. + signatures = {'ub_feed': ([ct.POINTER(Parser), ptr, ct.c_uint16, ct.POINTER(Frame)], ct.c_uint16), 'ub_describe': ([ct.POINTER(Frame), ct.POINTER(CEvent)], ct.c_int), 'ub_make_config': ([ct.c_uint8, ct.c_uint32, ptr], ct.c_uint16), 'ub_make_start': ([ptr], ct.c_uint16), 'ub_make_stop': ([ptr], ct.c_uint16), 'ub_make_tx': ([ptr, ct.c_uint16, ptr], ct.c_uint16), 'ub_usb_paths': ([ct.c_wchar_p, ct.c_uint32], ct.c_int), 'ub_usb_open': ([ct.c_wchar_p], ct.c_void_p), 'ub_usb_close': ([ct.c_void_p], None), 'ub_usb_read': ([ct.c_void_p, ptr, ct.c_uint32], ct.c_int), 'ub_usb_write': ([ct.c_void_p, ptr, ct.c_uint32], ct.c_int)} # Описывает только типы ABI, оставляя все wire-операции в C. + for name, (args, result) in signatures.items(): # Явные сигнатуры предотвращают обрезание 64-битных handles ctypes. + function = getattr(self.lib, name); function.argtypes = args; function.restype = result # Проверяет наличие всех экспортов при открытии терминала. + self.parser = Parser() # Каждое подключение получает независимое состояние разбора USB-потока. + def make(self, name, channel=0, baud=0, data=b''): # Создаёт целую команду общим C builder без знания её байтового заголовка. + if name == 'tx' and not 1 <= len(data) <= 60: raise ValueError('Один пакет TX должен содержать 1…60 байт') # Проверяет границу ABI до преобразования Python длины в uint16. + out = (ct.c_uint8 * 64)() # Выделяет максимальный выходной буфер публичного ABI. + if name == 'config': size = self.lib.ub_make_config(channel, baud, out) # Передаёт выбранную скорость в битах в секунду C-кодеку. + elif name == 'start': size = self.lib.ub_make_start(out) # Вызывает общий builder запуска всех каналов. + elif name == 'stop': size = self.lib.ub_make_stop(out) # Вызывает общий builder остановки всех каналов. + elif name == 'tx': size = self.lib.ub_make_tx((ct.c_uint8 * len(data)).from_buffer_copy(data), len(data), out) # Передаёт полезные байты, а выбор единственного TX выполняет C. + else: raise ValueError('Неизвестная команда USART-моста') # Не допускает скрытого построения произвольного wire-пакета в GUI. + if not size: raise ValueError('Неверные параметры команды USART-моста') # Не отправляет отвергнутую C builder команду. + return bytes(out[:size]) # Возвращает точное готовое представление для WinUSB WritePipe. + def feed(self, data): # Передаёт произвольные фрагменты USB в общее C-состояние parser. + result, offset = [], 0 # Накапливает несколько записей одного блока конвейера WinUSB. + while offset < len(data): # Продолжает разбор до потребления всех байтов драйвера. + fragment = data[offset:offset + 65535] # Ограничивает длину одним uint16, как требует публичный ABI C. + buffer = (ct.c_uint8 * len(fragment)).from_buffer_copy(fragment) # Даёт C непрерывную память входного фрагмента. + frame, event = Frame(), CEvent() # Выделяет независимые структуры результата для одного сообщения. + consumed = self.lib.ub_feed(ct.byref(self.parser), buffer, len(fragment), ct.byref(frame)) # Все границы, синхронизацию и длины проверяет общий C parser. + if not consumed: raise RuntimeError('C parser не потребил входные данные') # Не допускает бесконечный цикл при несовместимой DLL. + offset += consumed # Продолжает с остатка, который C ещё не прочитал. + if frame.type and self.lib.ub_describe(ct.byref(frame), ct.byref(event)): # Получает только семантически корректные ответы прошивки. + result.append(Event(event.kind, event.channel, bytes(event.data[:event.length]), event.command, event.status, event.channels, event.tx_channel, event.lost, event.errors)) # Преобразует готовую C-модель без чтения смещений wire-payload. + return result # Возвращает события для журнала, отображения и автомата подтверждения команд. + def paths(self): # Перечисляет отдельные USB USART-интерфейсы G474 без открытия CAN. + out = ct.create_unicode_buffer(32768) # Вмещает несколько полных системных путей устройств Windows. + size = self.lib.ub_usb_paths(out, len(out)) # Передаёт системное перечисление нативному Windows-порту. + if size < 0: raise RuntimeError('Не удалось перечислить WinUSB USART-интерфейсы') # Отличает системную ошибку от корректного пустого списка. + return [item for item in out[:size].split('\0') if item] # Преобразует системный MULTI_SZ, который не является wire-протоколом устройства. +class Usb: # Владеет одним непрозрачным WinUSB handle в рабочем потоке. + def __init__(self, native, path): # Открывает выбранный интерфейс после явного действия пользователя. + self.native, self.handle = native, native.lib.ub_usb_open(path) # C проверяет bInterfaceNumber, подкласс и версию до обмена. + if not self.handle: raise RuntimeError('Не удалось открыть USART USB. Проверьте прошивку G474, WinUSB и доступ к интерфейсу 2.') # Объясняет отличие старой CAN-прошивки от нового моста. + def write(self, data): # Передаёт уже готовую C-команду без изменения её байтов. + buffer = (ct.c_uint8 * len(data)).from_buffer_copy(data) # Сохраняет буфер до завершения синхронного ограниченного OUT. + if self.native.lib.ub_usb_write(self.handle, buffer, len(data)) != len(data): raise RuntimeError('Ошибка записи USB USART') # Неполная запись никогда не считается подтверждённой командой. + def read(self): # Получает сразу несколько готовых пакетов без задержки очереди аппаратных RX. + buffer = (ct.c_uint8 * 4096)() # Снижает число переходов ctypes, собирая до 4 КиБ готовых USB-пакетов. + size = self.native.lib.ub_usb_read(self.handle, buffer, len(buffer)) # В C постоянно ожидают шестнадцать независимых запросов IN. + if size < 0: raise RuntimeError('USB USART отключён или чтение завершилось ошибкой: ' + str(size)) # Прекращает worker при физическом отключении устройства. + return bytes(buffer[:size]) # Пустой блок означает таймаут 50 мс и позволяет обработать STOP либо TX. + def close(self): # Останавливает все pending I/O до уничтожения Python объекта. + if self.handle: self.native.lib.ub_usb_close(self.handle); self.handle = None # Повторное закрытие безопасно и не освобождает чужой CAN handle.