Compare commits
8
Commits
device-tools
..
main
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
e627d088e0 | ||
|
|
34d9016118 | ||
|
|
28fe22439c | ||
|
|
a197437985 | ||
|
|
ae018a1347 | ||
|
|
80d8fe1794 | ||
|
|
d057df7698 | ||
|
|
f9d369d032 |
@@ -4,3 +4,8 @@
|
|||||||
|
|
||||||
*.pdf binary
|
*.pdf binary
|
||||||
*.png binary
|
*.png binary
|
||||||
|
|
||||||
|
# CMD.exe требует CRLF в BAT, иначе после переноса Git часть команд разбирается неверно.
|
||||||
|
*.bat text eol=crlf
|
||||||
|
# Командные файлы CMD выполняются тем же интерпретатором Windows и требуют CRLF.
|
||||||
|
*.cmd text eol=crlf
|
||||||
|
|||||||
@@ -38,6 +38,8 @@ templates/
|
|||||||
|
|
||||||
### C
|
### C
|
||||||
|
|
||||||
|
USART STM32G474 → USB и терминал четырёх каналов: [`c/uart-usb`](c/uart-usb/README.md).
|
||||||
|
|
||||||
| Библиотека | Что делает | Зависимости | Что нужно от платформы |
|
| Библиотека | Что делает | Зависимости | Что нужно от платформы |
|
||||||
|---|---|---|---|
|
|---|---|---|---|
|
||||||
| [`c/st7789`](c/st7789) | TFT ST7789V по SPI, RGB565, текст без кадрового буфера | `stdint.h` | SPI-запись, линия DC, задержка |
|
| [`c/st7789`](c/st7789) | TFT ST7789V по SPI, RGB565, текст без кадрового буфера | `stdint.h` | SPI-запись, линия DC, задержка |
|
||||||
|
|||||||
@@ -0,0 +1,45 @@
|
|||||||
|
# Загрузчик F28335 по RS для periph_28335
|
||||||
|
|
||||||
|
Постоянный загрузчик принимает `INITLOAD` (58), `LOAD` (51) и `TFLASH` (55),
|
||||||
|
совместимые с Flash RS в терминале `periph_28335` SETGUI. Ядро не зависит от
|
||||||
|
UART, GPIO, ОС и Qt. Оно использует существующий валидатор и writer
|
||||||
|
`c/protocan-boot/ports/tms320f28335`, сохраняя единый формат SCI8/FAB1.
|
||||||
|
|
||||||
|
Слои: клиент periph_28335 → автомат RS → проверка SCI8/FAB1 → callbacks платы
|
||||||
|
→ TI Flash API. Передаются октеты; адреса CPU считаются 16-битными словами.
|
||||||
|
|
||||||
|
| Файл | Назначение и зависимости |
|
||||||
|
|---|---|
|
||||||
|
| `include/f28335_rs_boot.h`, `src/f28335_rs_boot.c` | Переносимый автомат, зависит от protocan-boot |
|
||||||
|
| `ports/tms320f28335/flash_api.c` | Официальный TI API v2.10, заголовки устройства, частота F28335_RS_CPU_HZ |
|
||||||
|
| `ports/tms320f28335/boot.cmd` | Постоянный сектор A, отдельные RAMAPI, RAMFUNCS и стек |
|
||||||
|
| `tools/build.py` | Сборка boot и выпуск проверенных Flash OUT/SCI8 с manifest/SHA-256 |
|
||||||
|
| `tests/test_boot.py` | Настоящий автомат и writer в модели RAM/Flash без оборудования |
|
||||||
|
|
||||||
|
Приложение занимает `[0x300000,0x338000)`, первые 16 слов содержат FAB1.
|
||||||
|
Сектор A и переход `0x33FFF6` принадлежат постоянному загрузчику.
|
||||||
|
`INITLOAD` разрешает только staging `0x200000`, чётный размер 24..130560
|
||||||
|
октетов. Ошибочные CRC, таймаут и ошибка UART отзывают подтверждение LOAD.
|
||||||
|
Перед erase повторно проверяются RAM, CRC32, все адреса, entry и FAB1.
|
||||||
|
Общий writer пишет FAB1 последним и проверяет физическую Flash.
|
||||||
|
Ошибка не удаляет recovery; перезапуск разрешён после успешного ACK.
|
||||||
|
|
||||||
|
Контракт callbacks: `stage_write(user, offset, octet)` и `stage.read(user,
|
||||||
|
offset, buffer, size)` обслуживают RAM относительно начала файла;
|
||||||
|
`transmit(user, data, size)` возвращает true после физического окончания TX;
|
||||||
|
`program(user, image)` вызывает общий Flash writer; `reboot(user)` сбрасывает
|
||||||
|
контроллер. Все чтения/записи должны завершиться полностью либо вернуть false.
|
||||||
|
Прерывания в постоянном загрузчике запрещены, watchdog выключен на время
|
||||||
|
стирания. Межбайтовый таймаут аппаратный порт передаёт в `f28335_rs_abort`.
|
||||||
|
|
||||||
|
Быстрый старт: выделить `f28335_rs_boot_t` в RAM, заполнить пять callbacks,
|
||||||
|
вызвать `f28335_rs_init(&boot, &port, 16)` и передавать каждый октет SCI
|
||||||
|
через `f28335_rs_feed(&boot, octet)`. До запуска приложения вызвать
|
||||||
|
`f28335_flash_app_validate`, после успеха перейти на возвращённый entry.
|
||||||
|
Аппаратные таймауты, выключение силовых выходов и выбор скорости задаёт плата.
|
||||||
|
|
||||||
|
Подключено в `prolitarski_ups`: SCI-A/RS-422, 115200 8N1, адрес 16;
|
||||||
|
Monitor №93=1 в остановленном состоянии запрашивает boot через watchdog.
|
||||||
|
Первичная установка требует записи двух OUT через JTAG с сохранением
|
||||||
|
сектора A при загрузке приложения. Все последующие RS-обновления меняют B–H.
|
||||||
|
Повреждённое приложение оставляет устройство в RS recovery после сброса.
|
||||||
@@ -0,0 +1,23 @@
|
|||||||
|
#ifndef F28335_RS_BOOT_H /* Один контракт обслуживает постоянный загрузчик и его модель на ПК. */
|
||||||
|
#define F28335_RS_BOOT_H /* Исключает повторные объявления при подключении аппаратного порта. */
|
||||||
|
#include "../../protocan-boot/ports/tms320f28335/f28335_flash_update.h" /* Повторно использует проверку SCI8/FAB1 и запись с защитой сектора A. */
|
||||||
|
#define F28335_RS_STAGE 0x200000UL /* Адрес слова внешней RAM совпадает с INITLOAD в periph_28335. */
|
||||||
|
#define F28335_RS_LIMIT F28335_AB_SLOT_BYTES /* Проверяемый SCI8 ограничен 130560 октетами общего валидатора F28335. */
|
||||||
|
typedef struct { /* Аппаратная плата владеет памятью и UART; ядро владеет только состоянием протокола. */
|
||||||
|
bool (*stage_write)(void *, uint32_t, unsigned int); /* Записывает один октет по относительному смещению staging RAM. */
|
||||||
|
f28335_boot_io_t stage; /* Читает октеты staging для повторной CRC32 и проверки всех адресов перед erase. */
|
||||||
|
bool (*transmit)(void *, const unsigned int *, unsigned int); /* Передаёт полный ответ и дожидается последнего стопового бита. */
|
||||||
|
unsigned int (*program)(void *, f28335_flash_update_t *); /* Возвращает 0 после записи и проверки, код TI либо 1004/1006 при защите или ошибке проверки; управление остаётся в секторе A. */
|
||||||
|
void (*reboot)(void *); /* Выполняет reset только после успешного ответа о завершении записи. */
|
||||||
|
void *user; /* Независимый контекст UART, Flash и модели испытаний. */
|
||||||
|
} f28335_rs_port_t; /* Аппаратный порт не собирает кадры и не дублирует алгоритм проверки образа. */
|
||||||
|
typedef struct { /* Экземпляр допускает работу без heap и без прерываний. */
|
||||||
|
f28335_rs_port_t port; /* Сохраняет callbacks на весь сеанс обновления. */
|
||||||
|
f28335_flash_update_t image; /* Ограниченный индекс адресных секций и страничный кеш общего валидатора. */
|
||||||
|
uint32_t length, position, expected, received, crc32; /* Длины и позиции считаются октетами, независимо от sizeof(char) C28x. */
|
||||||
|
unsigned int address, command, crc16, wire_crc, loaded, fault, header[16]; /* Заголовок вмещает максимальный фиксированный запрос TFLASH на 16 октетов. */
|
||||||
|
} f28335_rs_boot_t; /* Загруженный блок никогда не исполняется как произвольный код RAM. */
|
||||||
|
void f28335_rs_init(f28335_rs_boot_t *s, const f28335_rs_port_t *port, unsigned int address); /* Настраивает адрес 1..255 и сбрасывает разрешение программирования. */
|
||||||
|
void f28335_rs_abort(f28335_rs_boot_t *s); /* Сбрасывает неполный кадр и подтверждение LOAD при таймауте или аппаратной ошибке SCI. */
|
||||||
|
void f28335_rs_feed(f28335_rs_boot_t *s, unsigned int value); /* Принимает один восьмибитный октет совместимых INITLOAD/LOAD/TFLASH. */
|
||||||
|
#endif /* Завершает публичный интерфейс общего RS-загрузчика. */
|
||||||
@@ -0,0 +1,28 @@
|
|||||||
|
MEMORY /* Все адреса и размеры относятся к 16-битным словам CPU C28x. */
|
||||||
|
{ /* Постоянный загрузчик использует только сектор A и внутреннюю RAM. */
|
||||||
|
PAGE 0: /* Исполняемый код и адреса загрузки из Flash. */
|
||||||
|
FLASHA : origin = 0x338000, length = 0x007F80 /* Область постоянного boot заканчивается до служебной области CSM. */
|
||||||
|
BEGIN : origin = 0x33FFF6, length = 0x000002 /* Два слова аппаратного перехода Boot ROM в режиме Flash. */
|
||||||
|
RAMAPI : origin = 0x008000, length = 0x001800 /* 6144 слова предназначены для копии официального TI Flash API. */
|
||||||
|
RAMFUNCS : origin = 0x00F800, length = 0x000800 /* InitFlash выполняется из RAM, не затрагивая код самого API. */
|
||||||
|
RESET : origin = 0x3FFFC0, length = 0x000002 /* Вектор reset находится в ROM и не программируется. */
|
||||||
|
PAGE 1: /* Данные загрузчика не зависят от размещения будущего приложения. */
|
||||||
|
RAMM0 : origin = 0x000058, length = 0x0003A8 /* Слова 50..57 сохранены для запроса boot через watchdog reset. */
|
||||||
|
RAMM1 : origin = 0x000400, length = 0x000400 /* Стек на 1024 слова вмещает буфер writer и контекст runtime. */
|
||||||
|
RAMDATA : origin = 0x00E000, length = 0x001800 /* Индекс SCI8, состояния протокола и аппаратные данные находятся в RAM. */
|
||||||
|
} /* Внешняя RAM используется через callbacks и не содержит исполняемого кода. */
|
||||||
|
SECTIONS /* C runtime загрузчика, в отличие от приложения, целиком сохраняется в A. */
|
||||||
|
{ /* Размещение API указано до общей .text, чтобы извлечь все его код и константы. */
|
||||||
|
codestart : > BEGIN, PAGE = 0 /* Штатный TI startup запрещает watchdog и вызывает _c_int00 загрузчика. */
|
||||||
|
flash_api : { -lFlash28335_API_V210.lib(.text) -lFlash28335_API_V210.lib(.econst) } LOAD = FLASHA, RUN = RAMAPI, LOAD_START(_FlashApiLoadStart), LOAD_END(_FlashApiLoadEnd), RUN_START(_FlashApiRunStart), PAGE = 0 /* Ни одна функция TI API не исполняется из занятого банка Flash. */
|
||||||
|
.text : > FLASHA, PAGE = 0 /* Протокол, валидатор и собственный runtime загрузчика остаются после обновления приложения. */
|
||||||
|
.cinit : > FLASHA, PAGE = 0 /* Инициализация данных не зависит от целостности B–H. */
|
||||||
|
.pinit : > FLASHA, PAGE = 0 /* Поддерживает стандартную секцию инициализации COFF. */
|
||||||
|
.econst : > FLASHA, PAGE = 0 /* Таблицы и константы загрузчика также защищены от erase B–H. */
|
||||||
|
.switch : > FLASHA, PAGE = 0 /* Таблицы переходов автомата не находятся в заменяемом приложении. */
|
||||||
|
ramfuncs : LOAD = FLASHA, RUN = RAMFUNCS, LOAD_START(_RamfuncsLoadStart), LOAD_END(_RamfuncsLoadEnd), RUN_START(_RamfuncsRunStart), PAGE = 0 /* InitFlash переносится до изменения Flash wait states. */
|
||||||
|
.stack : > RAMM1, PAGE = 1 /* Стек отделён от handoff и буфера внешней RAM. */
|
||||||
|
.ebss : > RAMDATA, PAGE = 1 /* Нулевая инициализация касается только состояния boot. */
|
||||||
|
.esysmem : > RAMDATA, PAGE = 1 /* Оставляет корректную секцию runtime без использования heap в алгоритме. */
|
||||||
|
.reset : > RESET, PAGE = 0, TYPE = DSECT /* ROM-вектор не попадает в программируемый OUT. */
|
||||||
|
} /* Пароли CSM, OTP и сектора приложения не создаются в образе загрузчика. */
|
||||||
@@ -0,0 +1,33 @@
|
|||||||
|
#include "DSP2833x_Device.h" /* Использует официальные описания регистров выбранной платы F28335. */
|
||||||
|
#include "../../include/f28335_rs_boot.h" /* Получает общий writer с повторной проверкой staging перед erase. */
|
||||||
|
#include "Flash2833x_API_Library.h" /* Официальный TI API v2.10 выполняет физические операции внутренней Flash. */
|
||||||
|
#include <string.h> /* Копирует код и таблицы TI API в RAM до изменения общего банка Flash. */
|
||||||
|
extern Uint16 FlashApiLoadStart, FlashApiLoadEnd, FlashApiRunStart; /* LOAD/RUN-символы создаёт linker постоянного загрузчика. */
|
||||||
|
static FLASH_ST api_status; /* Диагностика TI хранится в RAM и доступна во время занятости Flash. */
|
||||||
|
static unsigned int api_error; /* Код последней операции TI передаётся клиенту без подмены успехом. */
|
||||||
|
static bool erase(void *user) /* Стирает исключительно семь секторов приложения B–H. */
|
||||||
|
{ /* Сам API исполняется из RAM; вызывающий код продолжит работу из сохранённого сектора A. */
|
||||||
|
(void)user; api_error = Flash_Erase(0x00FEU, &api_status); return api_error == STATUS_SUCCESS; /* В TI v2.10 бит 0 выбирает A, маска FE исключает его и сохраняет recovery; результат сохраняет диагностику API. */
|
||||||
|
} /* Ненулевой результат запрещает программирование данных. */
|
||||||
|
static bool program(void *user, uint32_t address, uint16_t *data, unsigned int words) /* Записывает и немедленно проверяет одну ограниченную порцию. */
|
||||||
|
{ /* Дополнительная аппаратная проверка диапазона защищает boot независимо от wire-парсера. */
|
||||||
|
Uint16 result; (void)user; /* Результат официального API не подменяется успешным кодом протокола. */
|
||||||
|
if (!words || address < F28335_FLASH_APP_START || address >= F28335_FLASH_APP_STOP || words > F28335_FLASH_APP_STOP - address) return false; /* Исключает сектор A, CSM, OTP и переполнение верхней границы. */
|
||||||
|
result = Flash_Program((Uint16 *)address, data, words, &api_status); /* Данные и рабочий буфер находятся в RAM. */
|
||||||
|
if (!result) result = Flash_Verify((Uint16 *)address, data, words, &api_status); /* Подтверждает физическую запись до перехода к следующей порции. */
|
||||||
|
api_error = result; return result == STATUS_SUCCESS; /* Ошибка оставляет FAB1 неопубликованным, сохраняет код TI и RS recovery. */
|
||||||
|
} /* Все прерывания остаются запрещёнными на протяжении жизни постоянного загрузчика. */
|
||||||
|
uint16_t F28335Rs_ReadFlash(void *user, uint32_t address) /* Читает физическое слово для общей проверки приложения перед запуском. */
|
||||||
|
{ /* Общий валидатор ограничивает адреса диапазоном B–H. */
|
||||||
|
(void)user; return *(volatile Uint16 *)address; /* Чтение применяется только вне активной операции Flash API. */
|
||||||
|
} /* Стёртые промежутки проверяются вместе с загруженными секциями. */
|
||||||
|
unsigned int F28335Rs_Program(void *user, f28335_flash_update_t *image) /* Callback работает из сектора A и возвращает полный статус, совместимый с Flash RS periph_28335. */
|
||||||
|
{ /* Проект задаёт реальный SYSCLK в герцах через F28335_RS_CPU_HZ при компиляции. */
|
||||||
|
f28335_flash_ops_t ops; (void)user; /* Таблица операций не содержит обращений к приложению из B–H. */
|
||||||
|
if (CsmRegs.CSMSCR.bit.SECURE) return 0x1004U; /* Не начинает стирание защищённого CSM устройства и передаёт клиенту стандартный статус защиты. */
|
||||||
|
memcpy(&FlashApiRunStart, &FlashApiLoadStart, &FlashApiLoadEnd - &FlashApiLoadStart); /* Все .text и .econst TI API копируются во внутреннюю RAM. */
|
||||||
|
Flash_CPUScaleFactor = (Uint32)(1048576.0L * 200.0L * F28335_RS_CPU_HZ / 1000000000.0L); /* Формула IQ20 из TI v2.10 учитывает фактическую частоту CPU, единицы — Гц. */
|
||||||
|
Flash_CallbackPtr = 0; ops.erase = erase; ops.program = program; ops.read = F28335Rs_ReadFlash; ops.user = 0; /* Callback во Flash во время erase/program запрещён. */
|
||||||
|
api_error = 0U; if (f28335_flash_update_program(image, &ops)) return 0U; /* Повторная CRC staging, запись FAB1 последним и CRC физической Flash находятся в общем writer; ноль означает подтверждённый успех. */
|
||||||
|
return api_error ? api_error : 0x1006U; /* Ошибка TI сохраняет свой код, отказ структуры/readback без ошибки API получает отдельный ненулевой статус. */
|
||||||
|
} /* После отказа управление остаётся в постоянном загрузчике и допускает новый LOAD. */
|
||||||
@@ -0,0 +1,79 @@
|
|||||||
|
#include "../include/f28335_rs_boot.h" /* Единственная реализация автомата используется платой и host-тестами. */
|
||||||
|
#include <string.h> /* Сбрасывает состояние без динамического выделения памяти. */
|
||||||
|
static unsigned int crc16(unsigned int crc, unsigned int value) /* CRC16 Modbus защищает запросы и ответы существующего periph_28335. */
|
||||||
|
{ /* Все операции явно ограничены 16 битами и подходят для 16-битного int C28x. */
|
||||||
|
unsigned int bit; /* Каждый принятый октет содержит ровно восемь значащих битов. */
|
||||||
|
crc ^= value & 255U; /* Старшие биты аппаратного регистра SCI не являются данными протокола. */
|
||||||
|
for (bit = 0U; bit < 8U; ++bit) crc = (crc & 1U) ? ((crc >> 1) ^ 0xA001U) : (crc >> 1); /* Отражённый полином A001 соответствует CRC16 Modbus. */
|
||||||
|
return crc & 65535U; /* На ПК unsigned int шире C28x, поэтому маска сохраняет одинаковый результат. */
|
||||||
|
} /* Завершает переносимый шаг CRC. */
|
||||||
|
static uint32_t get32(const unsigned int *p) /* Поля BIOS передаются младшим октетом вперёд, в отличие от адреса внутри SCI8. */
|
||||||
|
{ /* Приведение перед сдвигом исключает потерю старших битов на 16-битном int. */
|
||||||
|
return (uint32_t)p[0] | ((uint32_t)p[1] << 8) | ((uint32_t)p[2] << 16) | ((uint32_t)p[3] << 24); /* Возвращает адрес слова либо длину октетов по назначению поля. */
|
||||||
|
} /* Формат запроса совпадает с periph28335_firmware.request. */
|
||||||
|
static bool reply(f28335_rs_boot_t *s, unsigned int command, unsigned int status) /* TFLASH сообщает конкретный статус, остальные успешные команды — короткий ACK. */
|
||||||
|
{ /* Ответ не содержит хвостового паддинга, который клиент periph_28335 считает необязательным. */
|
||||||
|
unsigned int frame[6], crc = 0xFFFFU, i, size = command == 55U ? 4U : 2U; /* CMD_TFLASH=55 включает два октета результата; ACK INITLOAD/LOAD содержит адрес и команду. */
|
||||||
|
frame[0] = s->address; frame[1] = command; frame[2] = status & 255U; frame[3] = status >> 8; /* Сохраняет принятый адрес и little-endian статус. */
|
||||||
|
for (i = 0U; i < size; ++i) crc = crc16(crc, frame[i]); /* Контрольная сумма защищает все значащие поля ответа. */
|
||||||
|
frame[size] = crc & 255U; frame[size + 1U] = crc >> 8; /* CRC16 передаётся младшим октетом вперёд. */
|
||||||
|
return s->port.transmit(s->port.user, frame, size + 2U); /* Reset разрешается только после фактического завершения передачи. */
|
||||||
|
} /* Ошибка UART никогда не превращается в разрешение перезапуска. */
|
||||||
|
void f28335_rs_abort(f28335_rs_boot_t *s) /* Инвалидирует частичный кадр и прежнее подтверждение образа. */
|
||||||
|
{ /* Порт вызывает эту функцию при межбайтовом таймауте, переполнении либо RXERROR. */
|
||||||
|
s->position = 0UL; s->loaded = 0U; s->length = 0UL; s->image.valid = false; /* Новый TFLASH после сбоя требует полного нового INITLOAD/LOAD. */
|
||||||
|
} /* Прерывание сеанса не изменяет действующую Flash. */
|
||||||
|
void f28335_rs_init(f28335_rs_boot_t *s, const f28335_rs_port_t *port, unsigned int address) /* Создаёт независимый экземпляр без скрытых глобальных переменных. */
|
||||||
|
{ /* Конфигурация платы должна передать все обязательные callbacks. */
|
||||||
|
memset(s, 0, sizeof(*s)); s->port = *port; s->address = address; /* Обнуляет кеш, счётчики и разрешение LOAD до первого принятого кадра. */
|
||||||
|
} /* Аппаратная инициализация SCI и GPIO остаётся в проекте платы. */
|
||||||
|
static void execute(f28335_rs_boot_t *s) /* Выполняет только полностью принятый запрос с подтверждённой CRC16. */
|
||||||
|
{ /* Транспортные поля никогда не разыменовываются как произвольные CPU-адреса. */
|
||||||
|
uint32_t source, destination, length; unsigned int status = 0U; pcan_boot_manifest_t manifest; /* Manifest общего валидатора используется только для размера и транспортной CRC32. */
|
||||||
|
if (s->command == 58U) { /* CMD_INITLOAD=58 резервирует фиксированный безопасный staging вместо произвольной записи памяти. */
|
||||||
|
source = get32(s->header + 2); length = get32(s->header + 6); s->loaded = 0U; s->length = 0UL; /* Новая подготовка всегда отзывает подтверждение прежнего блока. */
|
||||||
|
if (source == F28335_RS_STAGE && length >= 24UL && length <= F28335_RS_LIMIT && !(length & 1UL)) { s->length = length; reply(s, 58U, 0U); } /* Чётный SCI8 должен поместиться в предел общего проверяемого формата. */
|
||||||
|
} else if (s->command == 51U) { /* CMD_LOAD=51 уже принял поток в staging, но до этой точки не разрешал запись Flash. */
|
||||||
|
if (!s->fault && s->length) { s->loaded = 1U; reply(s, 51U, 0U); } /* Подтверждает блок только после полного приёма, успешной записи RAM и CRC16. */
|
||||||
|
} else if (s->command == 55U) { /* CMD_TFLASH=55 совместим с шестибайтовым статусом periph_28335. */
|
||||||
|
destination = get32(s->header + 2); source = get32(s->header + 6); length = get32(s->header + 10); /* Назначение, источник и размер сохраняют порядок полей существующего GUI. */
|
||||||
|
if (destination || source || length) { /* Нулевая тройка служит безопасной пробой поддержки без стирания и запуска. */
|
||||||
|
if (!s->loaded || destination != F28335_FLASH_APP_START || source != F28335_RS_STAGE || length != s->length) status = 0x1003U; /* Требует ровно тот блок, который подтвердил завершённый LOAD. */
|
||||||
|
else { /* Общий валидатор повторно читает RAM и сравнивает CRC32, записанную при приёме. */
|
||||||
|
memset(&manifest, 0, sizeof(manifest)); manifest.image_size = length; manifest.image_crc32 = s->crc32; /* Не доверяет CRC из непроверенного пользовательского manifest. */
|
||||||
|
if (!f28335_flash_update_validate(&s->image, &s->port.stage, 0UL, &manifest)) status = 0x1002U; /* Отвергает сектор A, CSM, OTP, перекрытия, неверный FAB1 и повреждённые данные до erase. */
|
||||||
|
else status = s->port.program(s->port.user, &s->image); /* Сохраняет конкретный код TI, защиту CSM 1004 и ошибку readback 1006; отказ оставляет RS recovery доступным. */
|
||||||
|
} /* Завершает проверку и аппаратную запись текущего образа. */
|
||||||
|
s->loaded = 0U; /* Повторная команда записи требует нового подтверждённого LOAD независимо от результата. */
|
||||||
|
} /* Безопасная проба не потребляет подтверждённый блок RAM. */
|
||||||
|
if (reply(s, 55U, status) && !status && length) s->port.reboot(s->port.user); /* Успешный reset следует только после записи, проверки физической Flash и отправки ACK. */
|
||||||
|
} /* Остальные команды не поддерживаются и не меняют память. */
|
||||||
|
} /* EEPROM параметров не входит ни в один callback загрузчика. */
|
||||||
|
void f28335_rs_feed(f28335_rs_boot_t *s, unsigned int value) /* Разбирает запросы последовательно без большого приёмного массива. */
|
||||||
|
{ /* Один вызов обрабатывает ровно один октет; время межбайтового ожидания контролирует порт. */
|
||||||
|
uint32_t position = s->position; pcan_boot_byte_t octet = value & 255U; /* Маска исключает флаги SCI и старшие биты широкого char. */
|
||||||
|
if (!position) { /* Новый кадр начинается только с адреса этого устройства. */
|
||||||
|
if (octet != s->address || !s->address || s->address > 255U) return; /* Чужой адрес не получает ACK и не запускает запись RAM. */
|
||||||
|
s->crc16 = 0xFFFFU; s->wire_crc = 0U; s->fault = 0U; /* CRC16 каждого запроса начинается со значения FFFF протокола Modbus. */
|
||||||
|
} /* После первого октета автомат ожидает номер команды. */
|
||||||
|
if (position == 1UL) { /* Второй октет задаёт фиксированную либо потоковую длину кадра. */
|
||||||
|
s->command = octet; /* Сохраняет неизменный номер BIOS-команды. */
|
||||||
|
if (octet == 58U) s->expected = 12UL; /* INITLOAD содержит адрес/команду, два u32 и CRC16: 12 октетов. */
|
||||||
|
else if (octet == 55U) s->expected = 16UL; /* TFLASH содержит три u32 и занимает 16 октетов с CRC16. */
|
||||||
|
else if (octet == 51U && s->length) { s->expected = s->length + 4UL; s->loaded = 0U; s->crc32 = 0UL; } /* LOAD состоит из адреса/команды, точного SCI8 и CRC16. */
|
||||||
|
else { f28335_rs_abort(s); return; } /* Неизвестная команда не позволяет использовать оставшиеся байты как адрес CPU. */
|
||||||
|
} /* Только распознанный заголовок разрешает приём полезных данных. */
|
||||||
|
if (position < 2UL || s->command != 51U) { if (position < 16UL) s->header[position] = octet; } /* Фиксированные запросы сохраняются в ограниченном заголовке. */
|
||||||
|
else if (position < s->expected - 2UL) { /* Поток LOAD записывается в RAM, пока завершающая CRC16 ещё не подтверждена. */
|
||||||
|
if (!s->port.stage_write(s->port.user, position - 2UL, octet)) s->fault = 1U; /* Ошибка RAM запрещает подтверждение и последующий erase. */
|
||||||
|
s->crc32 = pcan_boot_crc32_update(s->crc32, &octet, 1U); /* Независимая CRC32 позволяет обнаружить изменение staging после LOAD. */
|
||||||
|
} /* Два завершающих октета CRC не попадают в staging образа. */
|
||||||
|
if (position < 2UL || position < s->expected - 2UL) s->crc16 = crc16(s->crc16, octet); /* CRC16 включает адрес, команду и всю полезную нагрузку. */
|
||||||
|
else if (position == s->expected - 2UL) s->wire_crc = octet; /* Первый октет контрольной суммы является младшим. */
|
||||||
|
else s->wire_crc |= (unsigned int)octet << 8; /* Второй октет завершает 16-битную CRC принятого кадра. */
|
||||||
|
s->position = position + 1UL; /* Продвигает курсор только после обработки текущего октета. */
|
||||||
|
if (position >= 1UL && s->position == s->expected) { /* Запрос исполняется ровно один раз после получения последнего октета. */
|
||||||
|
s->position = 0UL; /* Следующий адрес начнёт независимый кадр даже при ошибочной CRC текущего. */
|
||||||
|
if (s->wire_crc == s->crc16) execute(s); else f28335_rs_abort(s); /* Повреждённый кадр отзывает прежний LOAD и никогда не вызывает program. */
|
||||||
|
} /* Частичный кадр остаётся в ожидании следующего октета либо внешнего timeout. */
|
||||||
|
} /* Автомат не использует системные часы, регистры MCU или динамическую память. */
|
||||||
File diff suppressed because one or more lines are too long
@@ -0,0 +1,88 @@
|
|||||||
|
"""Проверяет production-автомат RS и общий writer на модели сбоев без платы.""" # Не вызывает JTAG, COM и TI Flash API.
|
||||||
|
import ctypes # Передаёт октеты настоящему скомпилированному C-автомату.
|
||||||
|
import importlib.util # Использует общий подписыватель FAB1 для корректных тестовых образов.
|
||||||
|
import os # Добавляет runtime GCC только в окружение тестового процесса.
|
||||||
|
from pathlib import Path # Разрешает пути относительно установленной библиотеки templates.
|
||||||
|
import struct # Формирует стандартные поля запросов и адресные секции SCI8.
|
||||||
|
import subprocess # Собирает C-модель с production-исходниками GCC.
|
||||||
|
import tempfile # Удаляет только собственные временные DLL проверки.
|
||||||
|
import unittest # Каждый отказ выполняется независимо и получает отдельный результат.
|
||||||
|
LIBRARY = Path(__file__).resolve().parents[1]; TEMPLATES = LIBRARY.parents[1]; PORT = TEMPLATES / "c/protocan-boot/ports/tms320f28335" # Тест использует те же валидатор и writer, которые компилируются для платы.
|
||||||
|
spec = importlib.util.spec_from_file_location("boot_test_contract", TEMPLATES / "python/protocan/f28335_flash.py"); contract = importlib.util.module_from_spec(spec); spec.loader.exec_module(contract) # Эталон FAB1 берётся из действующей общей библиотеки.
|
||||||
|
|
||||||
|
def section(address, words): # Создаёт адресный блок TI без дополнительных правил обновления.
|
||||||
|
return struct.pack("<HHH", len(words), address >> 16, address & 65535) + struct.pack("<" + "H" * len(words), *words) # Длина считается словами, каждое слово little endian, адрес — старшим словом вперёд.
|
||||||
|
|
||||||
|
def image(): # Минимальный правильный образ содержит разрыв для проверки CRC стёртых промежутков.
|
||||||
|
entry = contract.APP_DATA; loaded = {entry: 0x1234, entry + 1: 0x5678, entry + 12: 0xAABB, entry + 13: 0xCCDD} # Промежуток между двумя секциями должен остаться FFFF после erase.
|
||||||
|
return b"\xaa\x08" + bytes(16) + struct.pack("<HH", entry >> 16, entry & 65535) + section(contract.APP_START, struct.unpack("<16H", contract.descriptor(entry, loaded))) + section(entry, [0x1234, 0x5678]) + section(entry + 12, [0xAABB, 0xCCDD]) + bytes(2) # Заголовок FAB1 передаётся первым, но writer обязан опубликовать его последним.
|
||||||
|
|
||||||
|
class BootTests(unittest.TestCase): # Проверяет наблюдаемое поведение полного обмена, а не отдельные строки реализации.
|
||||||
|
@classmethod # DLL компилируется один раз для всех сценариев отказа.
|
||||||
|
def setUpClass(cls): # Изолирует бинарный результат и зависимости GCC.
|
||||||
|
gcc = Path(os.environ.get("CC", "C:/msys64/mingw64/bin/gcc.exe")); os.environ["PATH"] = str(gcc.parent) + os.pathsep + os.environ["PATH"] # CC позволяет выбрать другой совместимый GCC без изменения теста.
|
||||||
|
cls.temporary = tempfile.TemporaryDirectory(prefix="f28335-rs-tests-"); dll = Path(cls.temporary.name) / "model.dll" # Все артефакты испытания находятся вне прошивки пользователя.
|
||||||
|
subprocess.run([str(gcc), "-shared", "-std=c99", "-Wall", "-Wextra", "-Werror", str(LIBRARY / "tests/model.c"), str(PORT / "f28335_flash_app.c"), str(PORT / "f28335_flash_update.c"), str(TEMPLATES / "c/protocan-boot/src/pcan_boot.c"), "-o", str(dll)], check=True) # Компилирует production parser, CRC, validator и writer без извлечения копий функций.
|
||||||
|
cls.native = ctypes.CDLL(str(dll)); cls.native.model_crc.argtypes = [ctypes.c_char_p, ctypes.c_uint]; cls.native.model_crc.restype = ctypes.c_uint; cls.native.model_value.restype = ctypes.c_uint # ABI содержит только явно заданные целые числа и октеты.
|
||||||
|
|
||||||
|
@classmethod # Windows требует освободить библиотеку до удаления DLL.
|
||||||
|
def tearDownClass(cls): # Закрывает только дескриптор, созданный этим тестом.
|
||||||
|
if os.name == "nt": # На Windows открытая DLL удерживает файл от удаления.
|
||||||
|
release = ctypes.WinDLL("kernel32").FreeLibrary; release.argtypes = [ctypes.c_void_p]; release.restype = ctypes.c_int; release(cls.native._handle) # Освобождает единственную тестовую DLL с полным размером указателя.
|
||||||
|
cls.temporary.cleanup() # Временные файлы не остаются в библиотеке или проекте ИБП.
|
||||||
|
|
||||||
|
def setUp(self): self.native.model_reset() # Стирает модель между тестами, сохраняя независимость сценариев.
|
||||||
|
|
||||||
|
def frame(self, command, payload=b"", address=16): # Формирует запросы совместимого BIOS для управления production-автоматом.
|
||||||
|
body = bytes((address, command)) + payload; return body + struct.pack("<H", self.native.model_crc(body, len(body))) # Повреждение CRC тестируется отдельно, а фиксированный probe-вектор проверяет численное значение.
|
||||||
|
|
||||||
|
def send(self, data): # Аппаратные границы чтений могут разделить кадр после любого октета.
|
||||||
|
for octet in data: self.native.model_feed(octet) # Никакая модель не собирает кадр за production-автомат.
|
||||||
|
return bytes(self.native.model_value(10 + i) for i in range(self.native.model_value(0))) # Получает фактический ACK/status, отправленный callback transmit.
|
||||||
|
|
||||||
|
def load(self, payload): # Выполняет стандартный INITLOAD/LOAD без TFLASH.
|
||||||
|
self.assertEqual(len(self.send(self.frame(58, struct.pack("<II", 0x200000, len(payload))))), 4) # Подготовка RAM требует точного короткого ACK.
|
||||||
|
self.assertEqual(len(self.send(self.frame(51, payload))), 4) # Правильный LOAD подтверждается только после полной CRC16.
|
||||||
|
|
||||||
|
def program(self, payload): return self.send(self.frame(55, struct.pack("<III", 0x300000, 0x200000, len(payload)))) # Адреса и порядок полей совпадают с program_request periph_28335.
|
||||||
|
|
||||||
|
def assert_protected(self): self.assertEqual(self.native.model_value(5), 0xA55A) # Постоянный сектор A должен сохраняться даже после отказа на любой стадии записи.
|
||||||
|
|
||||||
|
def test_probe_and_success(self): # Полный успешный обмен должен подтвердить физическую Flash до reset.
|
||||||
|
probe = self.frame(55, bytes(12)); self.assertEqual(probe.hex(), "1037000000000000000000000000f066") # Вектор независимо подтверждён setprotocol.dll через protocan.periph28335.with_crc и обнаруживает изменение wire-формата.
|
||||||
|
response = self.send(probe); self.assertEqual(response[:4], bytes((16, 55, 0, 0))); self.assertEqual(self.native.model_value(1), 0) # Probe ничего не стирает и не останавливает действующую программу.
|
||||||
|
payload = image(); self.load(payload); response = self.program(payload); self.assertEqual(response[:4], bytes((16, 55, 0, 0))) # Успешный TFLASH сообщает нулевой статус.
|
||||||
|
self.assertEqual(self.native.model_value(4), 1); self.assertEqual(self.native.model_value(3), 1); self.assert_protected() # Реальный валидатор принимает физическую Flash, и только затем запрошен reset.
|
||||||
|
|
||||||
|
def test_wrong_address_crc_and_timeout(self): # Чужие либо оборванные запросы не должны разрешать запись.
|
||||||
|
payload = image(); self.assertEqual(self.send(self.frame(58, struct.pack("<II", 0x200000, len(payload)), address=17)), b"") # Чужой адрес не получает подтверждения INITLOAD.
|
||||||
|
self.load(payload); self.send(self.frame(58, struct.pack("<II", 0x200000, len(payload)))[:5]); self.native.model_abort() # Таймаут отбрасывает недопринятый запрос и старое подтверждение LOAD.
|
||||||
|
self.assertEqual(self.program(payload)[2:4], b"\x03\x10"); self.assertEqual(self.native.model_value(1), 0) # Без нового LOAD статус 1003 возникает до erase.
|
||||||
|
self.load(payload); damaged = bytearray(self.frame(55, struct.pack("<III", 0x300000, 0x200000, len(payload)))); damaged[-1] ^= 1; self.assertEqual(self.send(damaged), b"") # Неверная CRC TFLASH не вызывает никакого ответа об успехе.
|
||||||
|
self.assertEqual(self.native.model_value(1), 0); self.assert_protected() # Ни timeout, ни повреждение запроса не затронули Flash.
|
||||||
|
|
||||||
|
def test_changed_ram_and_read_failure(self): # CRC32 staging повторно проверяется после успешного LOAD.
|
||||||
|
payload = image(); self.load(payload); self.native.model_corrupt(60); self.assertEqual(self.program(payload)[2:4], b"\x02\x10") # Изменение RAM не скрывается первоначальным успешным ACK LOAD.
|
||||||
|
self.assertEqual(self.native.model_value(1), 0); self.load(payload); self.native.model_fault(0, 0, 1); self.assertEqual(self.program(payload)[2:4], b"\x02\x10") # Ошибка чтения staging также запрещает первый erase.
|
||||||
|
self.assertEqual(self.native.model_value(1), 0); self.assert_protected() # Память приложения и boot остались прежними.
|
||||||
|
|
||||||
|
def test_forbidden_addresses_and_bad_image(self): # Проверяет все опасные границы Flash и неполную таблицу.
|
||||||
|
for address in (0x2FFFFF, 0x338000, 0x33FFF6, 0x33FFF8, 0x380400): # Включает RAM/границу приложения, boot, CSM и OTP.
|
||||||
|
with self.subTest(address=hex(address)): # Ошибка конкретного диапазона видна отдельно в отчёте.
|
||||||
|
self.native.model_reset(); payload = image()[:-2] + section(address, [1, 2]) + bytes(2); self.load(payload); self.assertEqual(self.program(payload)[2:4], b"\x02\x10") # Правильная CRC16 не разрешает опасный LOAD-адрес внутри SCI8.
|
||||||
|
self.assertEqual(self.native.model_value(1), 0); self.assert_protected() # Неверная структура отвергается раньше физического стирания.
|
||||||
|
for payload in (image()[:-2], image() + bytes(2), image()[:-2] + section(contract.APP_DATA, [1]) + bytes(2)): # Проверяет отсутствующий терминатор, хвост и перекрытие секций.
|
||||||
|
self.native.model_reset(); self.load(payload); self.assertEqual(self.program(payload)[2:4], b"\x02\x10"); self.assertEqual(self.native.model_value(1), 0) # Любое нарушение структуры запрещает erase.
|
||||||
|
|
||||||
|
def test_failure_at_each_write_and_retry(self): # Имитирует обрыв каждого этапа программирования и последующее восстановление.
|
||||||
|
for operation in (100, 1, 2, 3): # 100 обозначает erase; три program-порции — две секции данных и последний FAB1.
|
||||||
|
with self.subTest(operation=operation): # Все стадии проверяются независимо на свежей модели Flash.
|
||||||
|
self.native.model_reset(); payload = image(); self.load(payload); self.native.model_fault(operation, 0, 0); self.assertEqual(self.program(payload)[2:4], b"\x16\x00") # Отказ writer передаёт статус ошибки TI вместо успешного ACK.
|
||||||
|
self.assertEqual(self.native.model_value(4), 0); self.assertEqual(self.native.model_value(3), 0); self.assert_protected() # Частичный образ не запускается, reset не запрошен, постоянный boot сохранён.
|
||||||
|
self.native.model_fault(0, 0, 0); self.load(payload); self.assertEqual(self.program(payload)[2:4], bytes(2)); self.assertEqual(self.native.model_value(4), 1) # Новый полный LOAD восстанавливает приложение через тот же оставшийся boot.
|
||||||
|
|
||||||
|
def test_failed_ack_prevents_reset(self): # Потеря передачи результата не должна перезапускать контроллер неожиданно для клиента.
|
||||||
|
payload = image(); self.load(payload); self.native.model_fault(0, 1, 0); self.program(payload) # Запись проходит успешно, но transmit возвращает ошибку.
|
||||||
|
self.assertEqual(self.native.model_value(4), 1); self.assertEqual(self.native.model_value(3), 0); self.assert_protected() # Физическая Flash готова, однако boot остаётся в recovery до явного последующего reset.
|
||||||
|
|
||||||
|
if __name__ == "__main__": unittest.main(verbosity=2) # Самостоятельный запуск выводит результаты модели без утверждений о проверке платы.
|
||||||
@@ -0,0 +1,105 @@
|
|||||||
|
"""Собирает постоянный RS boot и выпускает проверенное Flash-приложение CCS.""" # Все аппаратные пути и исходники передаются проектом платы.
|
||||||
|
import argparse # Разбирает режим полной сборки либо postbuild уже собранного приложения.
|
||||||
|
from datetime import datetime # Восстанавливает двенадцать слов встроенного паспорта текущего prebuild.
|
||||||
|
import importlib.util # Подключает существующие инструменты firmware-info и FAB1 без копирования алгоритмов.
|
||||||
|
import json # Читает проектные настройки и сохраняет отдельные manifest приложения и boot.
|
||||||
|
from pathlib import Path # Разрешает пути независимо от текущего каталога CCS.
|
||||||
|
import re # Разбирает стандартные относительные ссылки PARENT-N-PROJECT_LOC в Eclipse.
|
||||||
|
import shutil # Переносит только проверенный комплект из временного каталога.
|
||||||
|
import struct # Сопоставляет двенадцать 16-битных слов паспорта точным октетам COFF.
|
||||||
|
import subprocess # Запускает TI compiler/OFD/hex2000 без shell и без доступа к программатору.
|
||||||
|
import tempfile # Изолирует объекты и неполные выпуски текущей попытки.
|
||||||
|
import xml.etree.ElementTree as ET # Читает реальные linked resources и include paths выбранной конфигурации CCS.
|
||||||
|
TEMPLATES = Path(__file__).resolve().parents[3] # Каталог tools расположен в templates/c/f28335-rs-boot/tools.
|
||||||
|
LIBRARY = Path(__file__).resolve().parents[1] # Общие исходники и linker boot берутся из того же checkout templates.
|
||||||
|
FLASH = TEMPLATES / "c/protocan-boot/ports/tms320f28335" # Использует единые валидатор FAB1 и writer SCI8.
|
||||||
|
|
||||||
|
def module(name, path): # Загружает существующий инструмент по конкретному пути выбранной библиотеки.
|
||||||
|
spec = importlib.util.spec_from_file_location(name, path) # Избегает случайного импорта другого установленного protocan.
|
||||||
|
result = importlib.util.module_from_spec(spec); spec.loader.exec_module(result); return result # Ошибка общей зависимости останавливает выпуск.
|
||||||
|
|
||||||
|
identity = module("rs_boot_identity", TEMPLATES / "c/firmware-info/tools/identity.py") # Сохраняет общие manifest, SHA-256 и имена архивов.
|
||||||
|
contract = module("rs_boot_contract", TEMPLATES / "python/protocan/f28335_flash.py") # Сохраняет единый формат подписания и проверки FAB1.
|
||||||
|
|
||||||
|
def project_paths(args): # Получает фактические C/ASM и include paths из настроек проекта.
|
||||||
|
project = args.project.resolve(); sources = [] # Проектный каталог содержит .project/.cproject и generated отдельной конфигурации.
|
||||||
|
for link in ET.parse(project / ".project").findall(".//linkedResources/link"): # Заголовки, OBJ и старые linker-файлы не компилируются как исходники.
|
||||||
|
uri = link.findtext("locationURI", ""); prefix, separator, relative = uri.partition("/") # Eclipse хранит корень ссылки отдельно от относительного пути.
|
||||||
|
match = re.fullmatch(r"PARENT-(\d+)-PROJECT_LOC", prefix) # Поддерживает переносимые ссылки любого уровня, не зашивая репозиторий платы.
|
||||||
|
root = project.parents[int(match[1]) - 1] if match else project # PARENT-1 указывает непосредственно на родителя CCS-проекта.
|
||||||
|
if separator and (match or prefix == "PROJECT_LOC") and Path(relative).suffix.lower() in (".c", ".asm"): sources.append((root / relative).resolve()) # Сохраняет только реальные C/ASM linked resources.
|
||||||
|
sources.extend((project / "setgui_firmware_identity").glob("*.c")) # Подключённый ранее паспорт SETGUI остаётся частью приложения.
|
||||||
|
config = next(item for item in ET.parse(project / ".cproject").findall(".//configuration") if item.get("name") == args.configuration) # Выбирает именно Debug либо Release, запрошенный CCS.
|
||||||
|
option = next(item for item in config.findall(".//tool/option") if "compilerID.INCLUDE_PATH" in item.get("superClass", "")) # Сохраняет порядок поиска действующих заголовков платы.
|
||||||
|
includes = []; macros = {"${PROJECT_ROOT}": project, "${PROJECT_LOC}": project, "${CG_TOOL_ROOT}": args.compiler.resolve(), "${BuildDirectory}": args.build_dir.resolve()} # Разрешает только ожидаемые файловые макросы CCS.
|
||||||
|
for item in option.findall("listOptionValue"): # Каждая include-настройка применяется без shell expansion.
|
||||||
|
value = item.get("value", "") # Пустой путь не должен означать случайный текущий каталог.
|
||||||
|
for macro, replacement in macros.items(): value = value.replace(macro, str(replacement)) # Подставляет фактические абсолютные пути текущей конфигурации.
|
||||||
|
if not value or "${" in value: raise ValueError("Не разрешён include path CCS: " + value) # Отсутствующую зависимость требуется исправить до компиляции.
|
||||||
|
includes.append(Path(value)) # Сохраняет приоритет dev_sup перед дополнительными TI-заголовками.
|
||||||
|
return list(dict.fromkeys(sources)), includes # Не компилирует повторную ссылку на один исходник дважды.
|
||||||
|
|
||||||
|
def compile_image(args, sources, includes, linker, output, optimize=False, api=False): # Создаёт самостоятельный COFF с собственным runtime.
|
||||||
|
compiler = args.compiler.resolve(); support = args.support.resolve(); objects = [] # Объекты boot не смешиваются с объектами приложения.
|
||||||
|
with tempfile.TemporaryDirectory(prefix="objects-", dir=output.parent) as directory: # Не использует старые OBJ из Debug либо другой версии исходников.
|
||||||
|
for index, source in enumerate(sources): # Уникальный индекс исключает коллизии одинаковых имён модулей из разных каталогов.
|
||||||
|
obj = Path(directory) / (str(index) + "_" + source.stem + ".obj") # Каждый результат принадлежит только этой попытке сборки.
|
||||||
|
command = [str(compiler / "bin/cl2000.exe"), "-v28", "-ml", "-mt", "--float_support=fpu32", "--abi=coffabi", "--gen_func_subsections=on", "--define=F28335_RS_CPU_HZ=150000000UL"] # Архитектура и частота соответствуют F28335 платы ИБП; частота используется формулой TI Flash API.
|
||||||
|
if source.suffix.lower() == ".c": command.append("--c99") # C99 требуется общим bool/stdint, но не передаётся как режим ассемблера.
|
||||||
|
if optimize: command.append("-O2") # Оптимизация boot уменьшает постоянный сектор A; алгоритмы управления приложения сохраняют штатный режим без оптимизации.
|
||||||
|
command.extend("--include_path=" + str(path) for path in includes) # Пути передаются отдельными аргументами, включая пробелы Windows.
|
||||||
|
subprocess.run(command + ["--compile_only", "--output_file=" + str(obj), str(source)], check=True); objects.append(obj) # Ненулевой код TI останавливает сборку до линковки.
|
||||||
|
command = [str(compiler / "bin/cl2000.exe"), "-v28", "--float_support=fpu32", "--abi=coffabi", "-z", "--rom_model", "--heap_size=0", "--stack_size=0x400", "--warn_sections", "--search_path=" + str(compiler / "lib"), "--search_path=" + str(support / "source")] # Отдельный runtime сохраняет boot работоспособным при пустом приложении.
|
||||||
|
if api: command.append("--search_path=" + str(args.flash_api.resolve() / "lib")) # Библиотека TI берётся из локальной установки и не копируется в templates.
|
||||||
|
command.extend(str(path) for path in objects) # Линкер получает только свежие объекты этой попытки.
|
||||||
|
command.extend([str(linker), str(support / "source/DSP2833x_Headers_nonBIOS.cmd"), "-lrts2800_fpu32.lib", "--map_file=" + str(output.with_suffix(".map")), "--output_file=" + str(output)]) # Общие регистры и runtime согласованы с COFF/FPU32 действующего проекта.
|
||||||
|
if not api: command.append(str(support / "source/rts2800_fpu32_fast_supplement.lib")) # Приложение сохраняет ускоренные sincos/sqrt/div/atan2 в прежней ramfuncs.
|
||||||
|
subprocess.run(command, check=True) # Отсутствие Flash API или переполнение RAM/Flash запрещает выпуск.
|
||||||
|
|
||||||
|
def build_boot(args, output): # Компилирует постоянный сектор A с независимыми исходниками платы.
|
||||||
|
support = args.support.resolve(); port = LIBRARY / "ports/tms320f28335" # Общий аппаратный порт не содержит GPIO конкретного изделия.
|
||||||
|
sources = [args.board.resolve(), LIBRARY / "src/f28335_rs_boot.c", port / "flash_api.c", FLASH / "f28335_flash_app.c", FLASH / "f28335_flash_update.c", TEMPLATES / "c/protocan-boot/src/pcan_boot.c", support / "source/DSP2833x_GlobalVariableDefs.c", support / "source/init28335_func.c", support / "source/DSP2833x_CodeStartBranch.asm"] # UART/GPIO принадлежат только board.c; формат и writer повторно используются из templates.
|
||||||
|
includes = [support / "include", LIBRARY / "include", args.flash_api.resolve() / "include", args.compiler.resolve() / "include"] # Все зависимости TI должны существовать до компиляции.
|
||||||
|
compile_image(args, sources, includes, port / "boot.cmd", output, optimize=True, api=True) # Boot использует только FLASHA и выделенные RAMAPI/RAMFUNCS.
|
||||||
|
document = ET.fromstring(subprocess.check_output([str(args.compiler / "bin/ofd2000.exe"), "-x", str(output)])) # Проверяет фактические LOAD-секции, а не только текст linker-команды.
|
||||||
|
for section in document.findall(".//ti_coff/section"): # Учитывает также Flash LOAD копируемого в RAM кода API.
|
||||||
|
if section.findtext("raw_data") is None or section.findtext("copy") == "true": continue # Незагружаемые секции отладки не программируются.
|
||||||
|
start = int(section.findtext("virtual_addr", "0"), 0); size = int(section.findtext("raw_data_size", "0"), 0) // 2 # OFD хранит LOAD как virtual_addr, размер raw_data измеряет октетами.
|
||||||
|
if not (0x338000 <= start < start + size <= 0x33FF80 or start == 0x33FFF6 and size == 2): raise ValueError("Boot OUT содержит LOAD вне постоянного сектора A") # Запрещает приложение, RAM LOAD, CSM и OTP в установочном образе boot.
|
||||||
|
|
||||||
|
def publish(args): # Проверяет оба независимых OUT перед переносом нового выпуска в постоянный каталог.
|
||||||
|
project = args.project.resolve(); build = args.build_dir.resolve(); metadata_path = build / "generated/firmware_identity.json" # Каждый Debug/Release использует собственный паспорт prebuild.
|
||||||
|
metadata = json.loads(metadata_path.read_text(encoding="utf-8")); settings = json.loads((project / "firmware_identity.json").read_text(encoding="utf-8-sig")) # Не резервирует дополнительную версию после компиляции.
|
||||||
|
if any(metadata.get(field) != settings.get(field) for field in ("product", "target", "version", "flashing")): raise ValueError("Настройки изменились: повторите prebuild и сборку") # Не связывает старый OUT с новым продуктом, номером либо маршрутом прошивки.
|
||||||
|
output = build / "firmware"; output.mkdir(parents=True, exist_ok=True) # Все временные и постоянные результаты принадлежат выбранной конфигурации CCS.
|
||||||
|
with tempfile.TemporaryDirectory(prefix=".rs-release-", dir=build) as directory: # Частичная сборка никогда не заменяет предыдущий выпуск.
|
||||||
|
stage = Path(directory); app = stage / "flash" / (args.artifact + ".out"); app.parent.mkdir() # Flash OUT приложения хранится отдельно от boot.
|
||||||
|
shutil.copy2(build / (args.artifact + ".out"), app); contract.seal_coff(app, args.compiler / "bin/ofd2000.exe") # Заполняет только заранее выделенный FAB1 после проверки всех LOAD-адресов приложения.
|
||||||
|
document = ET.fromstring(subprocess.check_output([str(args.compiler / "bin/ofd2000.exe"), "-x", str(app)])); entry, loaded, sections = contract.coff_sections(document) # Содержимое извлекается официальным TI OFD из реального COFF.
|
||||||
|
built = datetime.fromisoformat(metadata["built_at_utc"]); build_id = metadata["build_id"].encode("ascii"); expected = (1, *metadata["version"], built.year, built.month << 8 | built.day, built.hour << 8 | built.minute, built.second, *(build_id[i] << 8 | build_id[i + 1] for i in range(0, 8, 2))) # Двенадцать слов повторяют публичный firmware_info_static контракт паспорта без изменения версии.
|
||||||
|
if sum(tuple(loaded.get(address + i) for i in range(12)) == expected for address in loaded) != 1: raise ValueError("OUT не содержит единственный паспорт текущего prebuild") # Старый объект, чужая версия либо дублированный паспорт не выпускаются.
|
||||||
|
serial = stage / "rs" / (args.artifact + "_flash_rs.bin"); serial.parent.mkdir() # RS-клиент выбирает только SCI8 приложения, исключая постоянный boot.
|
||||||
|
subprocess.run([str(args.compiler / "bin/hex2000.exe"), str(app), "-boot", "-sci8", "-b", "-o", str(serial), "-map", str(serial.with_suffix(".bin.map"))], check=True) # Официальный конвертор сохраняет адресные секции TI SCI8.
|
||||||
|
contract.parse_sci8(serial.read_bytes()); boot = stage / "boot" / (args.artifact + "_boot.out"); boot.parent.mkdir(); build_boot(args, boot) # Проверяет BIN независимо от OUT и создаёт отдельный проверенный установочный boot.
|
||||||
|
shutil.copy2(build / (args.artifact + ".map"), app.with_suffix(".map")) # Карта соответствует неизменным адресам приложения до заполнения заголовка.
|
||||||
|
for image, kind in ((app, "COFF-FLASH"), (serial, "SCI8-FLASH"), (boot, "COFF-RS-BOOT")): # Каждый тип получает собственный manifest и SHA-256 точных байтов.
|
||||||
|
specific = dict(metadata, execution="BOOTLOADER" if image == boot else "FLASH", image_format=kind, boot_contract="f28335-universal-v1", boot_protected=True) # Явно разделяет установку постоянного boot и обновление приложения.
|
||||||
|
if image == boot: specific["flashing"] = {"default_loader": "f28335-jtag", "profiles": {"f28335-jtag": {}}} # Постоянный загрузчик устанавливается через JTAG и никогда не выбирается для RS TFLASH.
|
||||||
|
current = stage / "manifest-source.json"; current.write_text(json.dumps(specific, ensure_ascii=False, indent=2), encoding="utf-8"); identity.seal(image, current); identity.verify(image, image.with_suffix(image.suffix + ".manifest.json")) # Все стороны используют существующие проверенные средства firmware-info.
|
||||||
|
(stage / "manifest-source.json").unlink(); shutil.copy2(metadata_path, stage / "firmware_identity.json") # В архив попадает один исходный паспорт текущей компиляции.
|
||||||
|
destination = output / identity.build_folder_name(metadata); shutil.copytree(stage, destination, dirs_exist_ok=True) # Сохраняет предыдущие архивы и переносит только полностью проверенный выпуск.
|
||||||
|
shutil.copy2(app, build / app.name) # Основной OUT CCS получает тот же FAB1, что опубликованные RS BIN и Flash OUT.
|
||||||
|
if settings.get("copy_to") and not args.no_export: identity.export_build(destination, (project / settings["copy_to"]).resolve(), "rs/" + serial.name) # Установленный проектный export проверяет BIN в папке rs и применяется после всех локальных проверок.
|
||||||
|
print("[firmware-build] RS boot package: " + str(destination)); return destination # Показывает точный постоянный каталог для JTAG и последующего RS-обновления.
|
||||||
|
|
||||||
|
def main(): # Одна точка входа используется проектной обёрткой и проверкой воспроизводимости.
|
||||||
|
parser = argparse.ArgumentParser(description=__doc__); parser.add_argument("command", choices=("build", "postbuild")) # build компилирует приложение; postbuild использует OUT, уже собранный CCS.
|
||||||
|
for name in ("project", "compiler", "build-dir", "support", "board", "app-linker", "flash-api"): parser.add_argument("--" + name, type=Path, required=True) # Все аппаратные исходники и установки выбирает проект-потребитель.
|
||||||
|
parser.add_argument("--artifact", required=True); parser.add_argument("--configuration", default="Debug", choices=("Debug", "Release")); parser.add_argument("--no-export", action="store_true") # Локальная проверка может отключить дополнительное копирование в GUI.
|
||||||
|
args = parser.parse_args(); args.compiler = args.compiler.resolve(); args.build_dir = args.build_dir.resolve(); args.build_dir.mkdir(parents=True, exist_ok=True) # Нормализует только ожидаемые пути без shell expansion.
|
||||||
|
if Path(args.artifact).name != args.artifact or any(char in args.artifact for char in '\\/:*?"<>|'): parser.error("artifact должен быть именем OUT без расширения") # Имя файла не может выйти за выбранный каталог выпуска.
|
||||||
|
if args.command == "build": # Ручной полный build полезен для проверки проекта вне запущенной IDE.
|
||||||
|
sources, includes = project_paths(args); compile_image(args, sources, includes, args.app_linker.resolve(), args.build_dir / (args.artifact + ".out")) # Использует действующие linked resources без ручного списка копий исходников.
|
||||||
|
publish(args) # Ненулевые коды компиляции, конверсии и проверки распространяются в CCS.
|
||||||
|
|
||||||
|
if __name__ == "__main__": main() # Импорт тестами не запускает компилятор и не изменяет рабочую версию.
|
||||||
File diff suppressed because one or more lines are too long
@@ -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 порт напрямую своим проектом.
|
||||||
@@ -0,0 +1,122 @@
|
|||||||
|
# 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 через Microsoft OS 1.0. USART использует отдельный GUID
|
||||||
|
`{8a650f40-8fb3-49b5-a067-5b2494740001}`, чтобы CAN-клиенты gs_usb не считали
|
||||||
|
новый интерфейс ещё одним CAN-адаптером. Ревизия USB bcdDevice=0x0001 обновляет
|
||||||
|
кэш состава интерфейсов Windows после прошивки; переподключите кабель USB.
|
||||||
|
|
||||||
|
Запись: `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` без служебных заголовков и перекодирования.
|
||||||
|
На неподключённой плате измерение реальной скорости и проверка проводов
|
||||||
|
не выполняются; это отдельная аппаратная проверка.
|
||||||
@@ -0,0 +1,139 @@
|
|||||||
|
#include "uart_usb_g474.h" /* Подключает контракт единственного аппаратного порта этой версии. */
|
||||||
|
#include "uart_usb.h" /* Использует общие статусы протокола и максимальную длину TX. */
|
||||||
|
#include "stm32g4xx.h" /* Получает проверенные адреса и маски регистров из CMSIS производителя. */
|
||||||
|
#include <string.h> /* Копирует DMA-данные в буфер USB и собственный буфер передатчика. */
|
||||||
|
#define RX_SIZE 4096U /* Выделяет 4 КиБ SRAM на канал, то есть около 41 мс при 1 Мбит/с 8N1. */
|
||||||
|
static USART_TypeDef *const uart[4] = {USART2, USART3, UART4, UART5}; /* Отделяет захват от USART1, занятого действующим загрузчиком. */
|
||||||
|
static DMA_Channel_TypeDef *const dma[4] = {DMA1_Channel1, DMA1_Channel2, DMA1_Channel3, DMA1_Channel4}; /* Назначает отдельное кольцо DMA каждому приёмнику. */
|
||||||
|
static DMAMUX_Channel_TypeDef *const mux[4] = {DMAMUX1_Channel0, DMAMUX1_Channel1, DMAMUX1_Channel2, DMAMUX1_Channel3}; /* Связывает каналы DMA1 с соответствующими входами DMAMUX1. */
|
||||||
|
static const uint8_t requests[4] = {26U, 28U, 30U, 32U}; /* Номера USART2_RX, USART3_RX, UART4_RX, UART5_RX взяты из таблицы DMAMUX RM0440. */
|
||||||
|
static const IRQn_Type irqs[4] = {DMA1_Channel1_IRQn, DMA1_Channel2_IRQn, DMA1_Channel3_IRQn, DMA1_Channel4_IRQn}; /* Включает IRQ завершения оборота для точного учёта перезаписи. */
|
||||||
|
static uint8_t rx[UART_USB_CHANNELS][RX_SIZE]; /* Размещает входные кольца в SRAM1, доступной DMA, без динамического выделения. */
|
||||||
|
static volatile uint32_t rounds[UART_USB_CHANNELS]; /* IRQ увеличивает число полностью завершённых оборотов кольца. */
|
||||||
|
static uint32_t consumed[UART_USB_CHANNELS], lost_bytes[UART_USB_CHANNELS], error_count[UART_USB_CHANNELS]; /* Хранит курсор чтения и явную диагностику перегрузки USB. */
|
||||||
|
static uint32_t rates[UART_USB_CHANNELS]; /* Сохраняет индивидуальные скорости в битах в секунду. */
|
||||||
|
static uint8_t tx[UB_PAYLOAD]; /* Сохраняет пакет до завершения DMA USART2_TX независимо от USB OUT. */
|
||||||
|
static uint8_t running; /* Разрешает чтение только после явной команды START от терминала. */
|
||||||
|
static void pin(GPIO_TypeDef *gpio, uint32_t number, uint32_t af) { /* Настраивает один вывод без изменения соседних CAN, USB и BOOT. */
|
||||||
|
uint32_t shift = number * 2U; /* Каждый вывод занимает два бита MODER, PUPDR и OSPEEDR. */
|
||||||
|
gpio->MODER = (gpio->MODER & ~(3UL << shift)) | (2UL << shift); /* Режим 10 выбирает альтернативную функцию периферии. */
|
||||||
|
gpio->PUPDR = (gpio->PUPDR & ~(3UL << shift)) | (1UL << shift); /* Подтяжка вверх удерживает отключённый UART RX в состоянии покоя. */
|
||||||
|
gpio->OTYPER &= ~(1UL << number); /* Двухтактный выход обеспечивает фронты единственного TX при высокой скорости. */
|
||||||
|
gpio->OSPEEDR |= 3UL << shift; /* Максимальная скорость GPIO уменьшает искажения фронтов TX. */
|
||||||
|
shift = (number & 7U) * 4U; /* Каждый регистр AFR содержит восемь полей по четыре бита. */
|
||||||
|
gpio->AFR[number / 8U] = (gpio->AFR[number / 8U] & ~(15UL << shift)) | (af << shift); /* Выбирает AF из таблицы выводов STM32G474xE. */
|
||||||
|
} /* Завершает настройку одного физического контакта. */
|
||||||
|
void ub_g474_init(void) { /* Подготавливает только аппаратные ресурсы USART-моста. */
|
||||||
|
RCC->AHB1ENR |= RCC_AHB1ENR_DMA1EN | RCC_AHB1ENR_DMAMUX1EN; /* Включает DMA1 и маршрутизатор запросов периферии. */
|
||||||
|
RCC->AHB2ENR |= RCC_AHB2ENR_GPIOAEN | RCC_AHB2ENR_GPIOBEN | RCC_AHB2ENR_GPIOCEN | RCC_AHB2ENR_GPIODEN; /* Разрешает доступ к портам выбранных RX и единственного TX. */
|
||||||
|
RCC->APB1ENR1 |= RCC_APB1ENR1_USART2EN | RCC_APB1ENR1_USART3EN | RCC_APB1ENR1_UART4EN | RCC_APB1ENR1_UART5EN; /* Включает четыре доступных UART блока, не меняя USART1. */
|
||||||
|
RCC->CCIPR &= ~(RCC_CCIPR_USART2SEL | RCC_CCIPR_USART3SEL | RCC_CCIPR_UART4SEL | RCC_CCIPR_UART5SEL); /* Значение 00 выбирает PCLK1, равный 144 МГц в текущем профиле платы. */
|
||||||
|
(void)RCC->APB1ENR1; /* Завершает запись тактирования до первого обращения к USART. */
|
||||||
|
pin(GPIOA, 2U, 7U); /* PA2/AF7 — USART2_TX, логический передатчик канала 1. */
|
||||||
|
pin(GPIOA, 3U, 7U); /* PA3/AF7 — USART2_RX, логический приёмник канала 1. */
|
||||||
|
pin(GPIOB, 11U, 7U); /* PB11/AF7 — USART3_RX, логический приёмник канала 2. */
|
||||||
|
if (UART_USB_CHANNELS >= 3U) pin(GPIOC, 11U, 5U); /* PC11/AF5 — UART4_RX, логический приёмник канала 3. */
|
||||||
|
if (UART_USB_CHANNELS >= 4U) pin(GPIOD, 2U, 5U); /* PD2/AF5 — UART5_RX, логический приёмник канала 4. */
|
||||||
|
for (uint8_t i = 0U; i < UART_USB_CHANNELS; ++i) { /* Инициализирует только включённые сборкой каналы. */
|
||||||
|
rates[i] = 1000000UL; /* Начальная скорость 1 Мбит/с даёт суммарно 400 Кбайт/с для четырёх каналов 8N1. */
|
||||||
|
NVIC_SetPriority(irqs[i], 1U); /* IRQ оборота DMA имеет приоритет выше USB, чтобы не терять учёт кольца. */
|
||||||
|
NVIC_EnableIRQ(irqs[i]); /* Разрешает обработку завершённых оборотов входного DMA. */
|
||||||
|
} /* Завершает настройку аппаратных каналов. */
|
||||||
|
} /* До START приёмники выключены и данные не захватываются. */
|
||||||
|
uint8_t ub_g474_config(uint8_t channel, uint32_t baud) { /* Проверяет скорость до изменения аппаратных регистров. */
|
||||||
|
if (!channel || channel > UART_USB_CHANNELS || baud < 1200U || baud > 6000000UL) return UB_INVALID; /* Ограничивает скорости диапазоном 1200…6000000 бит/с при PCLK1=144 МГц. */
|
||||||
|
if (running) return UB_BUSY; /* Не обрывает непрерывный захват ради скрытой перенастройки канала. */
|
||||||
|
uint32_t divisor = (SystemCoreClock + baud / 2U) / baud; /* Округляет делитель BRR для oversampling 16 при PCLK1=SYSCLK. */
|
||||||
|
uint32_t actual = SystemCoreClock / divisor; /* Рассчитывает достижимую аппаратурой скорость в битах в секунду. */
|
||||||
|
uint32_t delta = actual > baud ? actual - baud : baud - actual; /* Находит абсолютную погрешность выбранного делителя. */
|
||||||
|
if (delta > baud / 50U) return UB_INVALID; /* Не допускает отклонение скорости более 2 процентов. */
|
||||||
|
rates[channel - 1U] = baud; /* Применяет новую скорость при следующем START. */
|
||||||
|
return UB_OK; /* Подтверждает, что конфигурация сохранена. */
|
||||||
|
} /* Завершает индивидуальную настройку канала. */
|
||||||
|
uint8_t ub_g474_start(void) { /* Перезапускает захват только из остановленного состояния. */
|
||||||
|
if (running) return UB_BUSY; /* Повторный START не сбрасывает уже полученные данные. */
|
||||||
|
for (uint8_t i = 0U; i < UART_USB_CHANNELS; ++i) { /* Подготавливает отдельный DMA для каждого входа. */
|
||||||
|
uart[i]->CR1 = 0U; /* Выключает USART перед записью формата и делителя. */
|
||||||
|
uart[i]->BRR = (SystemCoreClock + rates[i] / 2U) / rates[i]; /* Задаёт скорость 8N1, oversampling 16, в единицах тактов PCLK1. */
|
||||||
|
uart[i]->CR2 = 0U; /* Выбирает один стоповый бит и обычную полярность сигнала. */
|
||||||
|
uart[i]->CR3 = USART_CR3_DMAR | (i == 0U ? USART_CR3_DMAT : 0U); /* Разрешает RX DMA всем каналам, TX DMA только USART2. */
|
||||||
|
uart[i]->ICR = USART_ICR_ORECF | USART_ICR_FECF | USART_ICR_NECF | USART_ICR_PECF; /* Снимает аппаратные ошибки предыдущей сессии. */
|
||||||
|
uart[i]->RQR = USART_RQR_RXFRQ; /* Удаляет остаточный байт RDR перед началом новой сессии. */
|
||||||
|
dma[i]->CCR = 0U; /* Останавливает канал DMA перед изменением его адресов. */
|
||||||
|
DMA1->IFCR = 15UL << (i * 4U); /* Сбрасывает четыре флага GIF/TCIF/HTIF/TEIF выбранного DMA-канала. */
|
||||||
|
mux[i]->CCR = requests[i]; /* Направляет запрос соответствующего USART_RX в канал DMA1. */
|
||||||
|
dma[i]->CPAR = (uint32_t)&uart[i]->RDR; /* Источник DMA — байтовый регистр данных выбранного USART. */
|
||||||
|
dma[i]->CMAR = (uint32_t)rx[i]; /* Приёмник DMA — собственное кольцо канала в SRAM1. */
|
||||||
|
dma[i]->CNDTR = RX_SIZE; /* Счётчик DMA задаётся в байтах, поскольку PSIZE/MSIZE оставлены 8-битными. */
|
||||||
|
rounds[i] = consumed[i] = lost_bytes[i] = error_count[i] = 0U; /* Сбрасывает курсоры и диагностику новой явно запущенной сессии. */
|
||||||
|
dma[i]->CCR = DMA_CCR_MINC | DMA_CCR_CIRC | DMA_CCR_TCIE | DMA_CCR_TEIE | DMA_CCR_PL_1 | DMA_CCR_EN; /* Включает кольцо с инкрементом памяти и высоким приоритетом, без IRQ на каждый байт. */
|
||||||
|
uart[i]->CR1 = USART_CR1_RE | USART_CR1_UE | (i == 0U ? USART_CR1_TE : 0U); /* Включает приём на всех входах и передатчик только канала 1. */
|
||||||
|
} /* Все каналы работают независимо, без HAL IRQ на каждый байт. */
|
||||||
|
running = 1U; /* Разрешает перенос накопленных данных в USB. */
|
||||||
|
return UB_OK; /* Подтверждает успешный запуск всех сконфигурированных каналов. */
|
||||||
|
} /* Завершает запуск кольцевого захвата. */
|
||||||
|
void ub_g474_abort(void) { /* Освобождает аппаратные ресурсы при потере USB-сессии. */
|
||||||
|
DMA1_Channel5->CCR = 0U; /* Немедленно прерывает TX, поскольку хост уже отключён. */
|
||||||
|
for (uint8_t i = 0U; i < UART_USB_CHANNELS; ++i) { /* Последовательно выключает только каналы моста. */
|
||||||
|
dma[i]->CCR = 0U; /* Прекращает запись в кольцевой буфер SRAM. */
|
||||||
|
uart[i]->CR1 = 0U; /* Останавливает RX/TX выбранного USART, сохраняя USART1 загрузчика. */
|
||||||
|
} /* Завершает остановку аппаратуры без ожидания внешних событий. */
|
||||||
|
running = 0U; /* Не выдаёт накопленные данные в следующую USB-сессию. */
|
||||||
|
} /* Завершает аварийное закрытие транспорта. */
|
||||||
|
uint8_t ub_g474_stop(void) { /* Не обрывает последний стоповый бит обычной командой STOP. */
|
||||||
|
if (running && !(USART2->ISR & USART_ISR_TC)) return UB_BUSY; /* Хост повторяет STOP после завершения текущей передачи USART2. */
|
||||||
|
ub_g474_abort(); /* Выключает приёмники и DMA после освобождения передатчика. */
|
||||||
|
return UB_OK; /* Подтверждает остановку аппаратного захвата. */
|
||||||
|
} /* Завершает штатную остановку сессии. */
|
||||||
|
uint8_t ub_g474_tx(const uint8_t *data, uint16_t length) { /* Запускает одну неблокирующую передачу через канал 1. */
|
||||||
|
if (!running || !length || length > UB_PAYLOAD) return UB_INVALID; /* Требует активную сессию и пакет размером 1…60 байт. */
|
||||||
|
if ((DMA1_Channel5->CCR & DMA_CCR_EN) && DMA1_Channel5->CNDTR) return UB_BUSY; /* Не перезаписывает буфер, пока DMA ещё читает предыдущие данные. */
|
||||||
|
DMA1_Channel5->CCR = 0U; /* Отключает завершённый DMA перед повторной настройкой. */
|
||||||
|
memcpy(tx, data, length); /* Сохраняет USB-команду в памяти с временем жизни всей DMA-передачи. */
|
||||||
|
DMAMUX1_Channel4->CCR = 27U; /* USART2_TX имеет номер запроса 27 в таблице DMAMUX RM0440. */
|
||||||
|
DMA1_Channel5->CPAR = (uint32_t)&USART2->TDR; /* Направляет передаваемые байты в аппаратный USART2_TX. */
|
||||||
|
DMA1_Channel5->CMAR = (uint32_t)tx; /* Указывает стабильный буфер данных единственного передатчика. */
|
||||||
|
DMA1_Channel5->CNDTR = length; /* Ограничивает передачу точным количеством полученных байтов. */
|
||||||
|
DMA1->IFCR = 15UL << 16U; /* Снимает четыре флага DMA1 Channel5, расположенные в битах 16…19. */
|
||||||
|
DMA1_Channel5->CCR = DMA_CCR_MINC | DMA_CCR_DIR | DMA_CCR_EN; /* Запускает память→периферия с байтовыми элементами без блокирования CPU. */
|
||||||
|
return UB_OK; /* ACK означает постановку данных в DMA, а не физическое окончание стопового бита. */
|
||||||
|
} /* Завершает запуск аппаратной передачи. */
|
||||||
|
static void dma_irq(uint8_t i) { /* Учитывает обороты кольца и ошибки DMA в коротком обработчике. */
|
||||||
|
uint32_t flags = (DMA1->ISR >> (i * 4U)) & 15U; /* Выделяет четыре аппаратных флага соответствующего канала. */
|
||||||
|
DMA1->IFCR = flags << (i * 4U); /* Снимает только фактически установленные флаги выбранного канала. */
|
||||||
|
if (i >= UART_USB_CHANNELS) return; /* Защищает массивы при выключенном третьем или четвёртом канале. */
|
||||||
|
if (flags & 2U) ++rounds[i]; /* TCIF в позиции 1 означает запись очередных 4096 байт. */
|
||||||
|
if (flags & 8U) { ++error_count[i]; dma[i]->CCR &= ~DMA_CCR_EN; } /* TEIF в позиции 3 фиксирует отказ DMA и прекращает повреждённый захват. */
|
||||||
|
} /* Завершает обслуживание DMA без копирования полезных данных. */
|
||||||
|
void DMA1_Channel1_IRQHandler(void) { dma_irq(0U); } /* Обслуживает оборот кольца USART2_RX, логического канала 1. */
|
||||||
|
void DMA1_Channel2_IRQHandler(void) { dma_irq(1U); } /* Обслуживает оборот кольца USART3_RX, логического канала 2. */
|
||||||
|
void DMA1_Channel3_IRQHandler(void) { dma_irq(2U); } /* Обслуживает оборот кольца UART4_RX, логического канала 3. */
|
||||||
|
void DMA1_Channel4_IRQHandler(void) { dma_irq(3U); } /* Обслуживает оборот кольца UART5_RX, логического канала 4. */
|
||||||
|
uint16_t ub_g474_read(uint8_t channel, uint8_t *data, uint16_t capacity) { /* Переносит данные одного кольца с явным обнаружением переполнения. */
|
||||||
|
uint8_t i = channel - 1U; /* Переводит внешний номер 1…N во внутренний индекс массива. */
|
||||||
|
if (!running || !channel || channel > UART_USB_CHANNELS || !(dma[i]->CCR & DMA_CCR_EN)) return 0U; /* Не читает несуществующий, остановленный или аварийный DMA. */
|
||||||
|
uint32_t mask = __get_PRIMASK(); /* Сохраняет исходное разрешение IRQ для атомарного снимка курсора DMA. */
|
||||||
|
__disable_irq(); /* Исключает изменение счётчика rounds обработчиком между чтениями. */
|
||||||
|
if (DMA1->ISR & (DMA_ISR_TCIF1 << (i * 4U))) dma_irq(i); /* Учитывает оборот, IRQ которого ещё не успел выполниться. */
|
||||||
|
uint32_t remaining = dma[i]->CNDTR; /* Читает остаток DMA однократно, без ожидания аппаратной перезагрузки кольца. */
|
||||||
|
if (!remaining) { __set_PRIMASK(mask); return 0U; } /* Краткий ноль между оборотами обслуживается следующим проходом, исключая удвоение оборота и блокирование main. */
|
||||||
|
if (DMA1->ISR & (DMA_ISR_TCIF1 << (i * 4U))) { dma_irq(i); remaining = dma[i]->CNDTR; } /* Повторяет снимок, если оборот произошёл непосредственно при чтении остатка DMA. */
|
||||||
|
if (!remaining) { __set_PRIMASK(mask); return 0U; } /* Не ожидает зависшую либо ещё перезагружаемую аппаратуру при повторном снимке. */
|
||||||
|
uint32_t position = RX_SIZE - remaining; /* Получает курсор внутри кольца после согласования счётчика оборотов с флагом TC. */
|
||||||
|
uint32_t produced = rounds[i] * RX_SIZE + position; /* Получает монотонный 32-битный счётчик реально принятых байтов с модульной арифметикой. */
|
||||||
|
__set_PRIMASK(mask); /* Восстанавливает прежнее состояние IRQ, не включая их внутри чужой критической секции. */
|
||||||
|
uint32_t errors = uart[i]->ISR & (USART_ISR_ORE | USART_ISR_FE | USART_ISR_NE | USART_ISR_PE); /* Проверяет переполнение USART и ошибки линии независимо от содержимого данных. */
|
||||||
|
if (errors) { ++error_count[i]; uart[i]->ICR = errors; } /* Фиксирует событие и снимает соответствующие флаги ICR с теми же битовыми позициями. */
|
||||||
|
uint32_t available = produced - consumed[i]; /* Вычитание без знака сохраняет корректность после переполнения счётчика 32 бит. */
|
||||||
|
if (available > RX_SIZE / 2U) { lost_bytes[i] += available - RX_SIZE / 2U; consumed[i] = produced - RX_SIZE / 2U; available = RX_SIZE / 2U; } /* Сохраняет новейшую половину кольца и запас от DMA, явно считая отброшенные байты. */
|
||||||
|
uint32_t offset = consumed[i] % RX_SIZE; /* Находит начало непрочитанной области внутри физического кольца. */
|
||||||
|
uint32_t count = available < capacity ? available : capacity; /* Ограничивает копирование вместимостью полезной части USB-пакета. */
|
||||||
|
if (count > RX_SIZE - offset) count = RX_SIZE - offset; /* Не пересекает конец кольца за одно копирование; остаток уйдёт следующим пакетом. */
|
||||||
|
memcpy(data, rx[i] + offset, count); /* Забирает неизменяемую DMA область с запасом не менее половины кольца. */
|
||||||
|
consumed[i] += count; /* Отмечает данные переданными во владение стабильного USB IN буфера. */
|
||||||
|
return (uint16_t)count; /* Возвращает число бинарных байтов выбранного канала. */
|
||||||
|
} /* Завершает неблокирующее чтение с честным учётом перегрузки. */
|
||||||
|
void ub_g474_stats(uint8_t channel, uint32_t *lost, uint32_t *errors) { /* Даёт терминалу накопленные счётчики текущей сессии. */
|
||||||
|
*lost = lost_bytes[channel - 1U]; /* Возвращает точное число программно отброшенных байтов при переполнении кольца. */
|
||||||
|
*errors = error_count[channel - 1U]; /* Возвращает количество замеченных аппаратных событий USART и DMA. */
|
||||||
|
} /* Завершает чтение диагностики существующего канала. */
|
||||||
@@ -0,0 +1,16 @@
|
|||||||
|
#pragma once /* Защищает аппаратный интерфейс STM32G474 от повторного объявления. */
|
||||||
|
#include <stdint.h> /* Фиксирует размеры счётчиков и длины буферов порта. */
|
||||||
|
#ifndef UART_USB_CHANNELS /* Позволяет сборке выбрать от двух до четырёх физических входов. */
|
||||||
|
#define UART_USB_CHANNELS 4U /* По умолчанию включает USART2, USART3, UART4 и UART5. */
|
||||||
|
#endif /* Сохраняет явно заданное сборкой количество каналов. */
|
||||||
|
#if UART_USB_CHANNELS < 2 || UART_USB_CHANNELS > 4 /* Ограничивает конфигурации реально предусмотренными каналами. */
|
||||||
|
#error UART_USB_CHANNELS_must_be_2_to_4 /* Прерывает сборку при ошибке аппаратной конфигурации. */
|
||||||
|
#endif /* Завершает проверку количества каналов. */
|
||||||
|
void ub_g474_init(void); /* Готовит тактирование и выводы, оставляя захват выключенным. */
|
||||||
|
uint8_t ub_g474_config(uint8_t channel, uint32_t baud); /* Настраивает выключенный канал 1…N; возвращает UB_OK, UB_BUSY либо UB_INVALID. */
|
||||||
|
uint8_t ub_g474_start(void); /* Запускает кольцевой DMA всех выбранных каналов с чистыми счётчиками. */
|
||||||
|
uint8_t ub_g474_stop(void); /* Останавливает захват после завершения единственного аппаратного TX. */
|
||||||
|
uint8_t ub_g474_tx(const uint8_t *data, uint16_t length); /* Копирует до 60 байт и запускает DMA USART2_TX без ожидания. */
|
||||||
|
uint16_t ub_g474_read(uint8_t channel, uint8_t *data, uint16_t capacity); /* Забирает очередную непрерывную часть кольца и учитывает перезапись. */
|
||||||
|
void ub_g474_stats(uint8_t channel, uint32_t *lost, uint32_t *errors); /* Возвращает накопленные потери и число аппаратных ошибок канала. */
|
||||||
|
void ub_g474_abort(void); /* Немедленно выключает мост при USB reset, suspend или отключении. */
|
||||||
@@ -0,0 +1,96 @@
|
|||||||
|
#define WIN32_LEAN_AND_MEAN /* Исключает лишние Windows API из переносимого по разрядности host-порта. */
|
||||||
|
#include <windows.h> /* Предоставляет handles, события и overlapped I/O для высокоскоростного USB. */
|
||||||
|
#include <setupapi.h> /* Перечисляет интерфейсы устройства по опубликованному прошивкой GUID. */
|
||||||
|
#include <winusb.h> /* Использует штатный драйвер WinUSB без установки Python USB-пакетов. */
|
||||||
|
#include <stdlib.h> /* Выделяет память только в настольном порте; MCU-ядро остаётся без heap. */
|
||||||
|
#include <string.h> /* Копирует завершённые USB-пакеты в буфер Python-клиента. */
|
||||||
|
#include "uart_usb.h" /* Экспортирует Windows транспорт рядом с единственным C-кодеком протокола. */
|
||||||
|
#define USB_READS 16U /* Держит шестнадцать запросов IN одновременно, исключая паузы между вызовами Python. */
|
||||||
|
static const GUID interface_guid = {0x8a650f40, 0x8fb3, 0x49b5, {0xa0, 0x67, 0x5b, 0x24, 0x94, 0x74, 0x00, 0x01}}; /* Собственный UUID USART совпадает с интерфейсом 2 прошивки и исключает перечисление моста CAN-клиентами gs_usb. */
|
||||||
|
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 с двойным завершающим нулём. */
|
||||||
|
if (!out || capacity < 2U) return -1; /* Проверяет выходной буфер до выделения системного SetupDi списка, исключая утечку handle. */
|
||||||
|
HDEVINFO devices = SetupDiGetClassDevsW(&interface_guid, NULL, NULL, DIGCF_PRESENT | DIGCF_DEVICEINTERFACE); /* Перечисляет только подключённые WinUSB интерфейсы данного семейства. */
|
||||||
|
uint32_t used = 0U; /* Считает записанные wchar_t, а не байты, для совместимости x86/x64. */
|
||||||
|
if (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); /* Запрашивает размер без фиксированного ограничения длины системного пути. */
|
||||||
|
if (needed < sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_W)) continue; /* Устройство могло отключиться между перечислением и запросом размера; не пишет cbSize в нулевой malloc. */
|
||||||
|
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)) { /* Собственный GUID уже выделяет USART; номер интерфейса дополнительно проверяется при open независимо от регистра DevicePath. */
|
||||||
|
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-ядре. */
|
||||||
@@ -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 и открытых системных ресурсов.
|
||||||
@@ -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 и защищает память выходной модели.
|
||||||
@@ -0,0 +1,64 @@
|
|||||||
|
#include "uart_usb.h" /* Подключает общий формат, размеры буферов и публичный ABI. */
|
||||||
|
#include <string.h> /* Использует стандартное копирование памяти без зависимости от MCU или ОС. */
|
||||||
|
static int valid_type(uint8_t type) { /* Ограничивает типы реальными командами и ответами версии 1. */
|
||||||
|
return (type >= UB_CONFIG && type <= UB_TX) || (type >= UB_ACK && type <= UB_STATS); /* Отвергает свободные значения тега, чтобы раньше восстановить границу. */
|
||||||
|
} /* Завершает проверку допустимых типов. */
|
||||||
|
uint16_t ub_encode(uint8_t type, uint8_t channel, const uint8_t *data, uint16_t length, uint8_t *out) { /* Формирует единственный wire-формат для прошивки и GUI. */
|
||||||
|
if (!out || !valid_type(type) || channel > 4U || length > UB_PAYLOAD || (length && !data)) return 0U; /* Проверяет указатели и границы до обращения к памяти. */
|
||||||
|
out[0] = UB_MAGIC; /* Отмечает начало записи выбранным байтом синхронизации 0xA7. */
|
||||||
|
out[1] = (uint8_t)((type << 4U) | channel); /* Упаковывает тип и номер канала в старшую и младшую тетрады. */
|
||||||
|
out[2] = (uint8_t)length; /* Записывает младший байт длины данных в байтах. */
|
||||||
|
out[3] = 0U; /* Старший байт длины равен нулю при ограничении payload до 60 байт. */
|
||||||
|
if (length && data != out + 4U) memcpy(out + 4U, data, length); /* Сохраняет бинарные значения и допускает уже заполненную полезную область выходного буфера. */
|
||||||
|
return (uint16_t)(length + 4U); /* Возвращает длину USB-записи вместе с заголовком. */
|
||||||
|
} /* Завершает построение записи без CRC, поскольку целостность обеспечивает USB. */
|
||||||
|
uint16_t ub_feed(ub_parser *parser, const uint8_t *data, uint16_t length, ub_frame *frame) { /* Разбирает фрагменты потока и выдаёт не более одной записи за вызов. */
|
||||||
|
uint16_t offset = 0U; /* Начинает счёт потреблённых байтов нового входного фрагмента. */
|
||||||
|
frame->type = 0U; /* Явно обозначает отсутствие полного результата до накопления всей записи. */
|
||||||
|
while (offset < length) { /* Ограничивает чтение фактической длиной входного USB-пакета. */
|
||||||
|
uint8_t byte = data[offset++]; /* Потребляет очередной байт ровно один раз. */
|
||||||
|
if (!parser->used && byte != UB_MAGIC) continue; /* Пропускает шум до начала следующей записи. */
|
||||||
|
parser->bytes[parser->used++] = byte; /* Сохраняет очередной байт в ограниченном буфере записи. */
|
||||||
|
while (parser->used >= 4U && (!valid_type(parser->bytes[1] >> 4U) || (parser->bytes[1] & 15U) > 4U || parser->bytes[2] > UB_PAYLOAD || parser->bytes[3])) { /* Отбрасывает заголовки с неизвестными типами, каналами и длинами. */
|
||||||
|
memmove(parser->bytes, parser->bytes + 1U, --parser->used); /* Сдвигает окно на байт, сохраняя возможное начало корректного заголовка. */
|
||||||
|
while (parser->used && parser->bytes[0] != UB_MAGIC) { /* Ищет синхронизацию только среди уже полученных байтов. */
|
||||||
|
memmove(parser->bytes, parser->bytes + 1U, --parser->used); /* Удаляет префикс шума без потери следующего служебного байта. */
|
||||||
|
} /* Завершает повторную синхронизацию внутри ошибочного заголовка. */
|
||||||
|
} /* Завершает проверку накопленного заголовка. */
|
||||||
|
if (parser->used >= 4U && parser->used == (uint16_t)(4U + parser->bytes[2])) { /* Выдаёт запись только после получения всех заявленных данных. */
|
||||||
|
frame->type = parser->bytes[1] >> 4U; /* Извлекает тип из старшей тетрады тега. */
|
||||||
|
frame->channel = parser->bytes[1] & 15U; /* Извлекает логический номер канала из младшей тетрады. */
|
||||||
|
frame->length = parser->bytes[2]; /* Возвращает проверенную длину не более 60 байт. */
|
||||||
|
memcpy(frame->data, parser->bytes + 4U, frame->length); /* Копирует данные, чтобы следующий USB-пакет не изменил результат. */
|
||||||
|
parser->used = 0U; /* Готовит parser к следующей записи в том же входном фрагменте. */
|
||||||
|
break; /* Позволяет вызывающему обработать результат и затем передать остаток потока. */
|
||||||
|
} /* Завершает выдачу одного полного сообщения. */
|
||||||
|
} /* Завершает обработку доступного фрагмента. */
|
||||||
|
return offset; /* Позволяет без потерь продолжить разбор оставшихся байтов входного буфера. */
|
||||||
|
} /* Завершает потоковый parser без heap и системных вызовов. */
|
||||||
|
uint32_t ub_get_u32(const uint8_t *data) { /* Читает значение без невыровненных обращений к uint32_t. */
|
||||||
|
return (uint32_t)data[0] | ((uint32_t)data[1] << 8U) | ((uint32_t)data[2] << 16U) | ((uint32_t)data[3] << 24U); /* Собирает little-endian значение из четырёх байтов. */
|
||||||
|
} /* Завершает чтение скорости или счётчика. */
|
||||||
|
void ub_put_u32(uint8_t *data, uint32_t value) { /* Записывает числовые поля в общий wire-формат. */
|
||||||
|
for (uint8_t i = 0U; i < 4U; ++i) data[i] = (uint8_t)(value >> (8U * i)); /* Выделяет четыре последовательных байта от младшего к старшему. */
|
||||||
|
} /* Завершает переносимое преобразование endian. */
|
||||||
|
uint16_t ub_make_config(uint8_t channel, uint32_t baud, uint8_t *out) { /* Строит целую команду настройки одним общим вызовом C. */
|
||||||
|
uint8_t data[4]; ub_put_u32(data, baud); /* Представляет скорость в четырёх little-endian байтах. */
|
||||||
|
return ub_encode(UB_CONFIG, channel, data, sizeof(data), out); /* Передаёт проверку границ канала и построение заголовка единственному кодеку. */
|
||||||
|
} /* Завершает создание конфигурационной команды для настольного клиента. */
|
||||||
|
uint16_t ub_make_start(uint8_t *out) { return ub_encode(UB_START, 0U, 0, 0U, out); } /* Общий канал 0 и пустой payload однозначно запускают все входы. */
|
||||||
|
uint16_t ub_make_stop(uint8_t *out) { return ub_encode(UB_STOP, 0U, 0, 0U, out); } /* Общий канал 0 и пустой payload однозначно останавливают все входы. */
|
||||||
|
uint16_t ub_make_tx(const uint8_t *data, uint16_t length, uint8_t *out) { return length ? ub_encode(UB_TX, 1U, data, length, out) : 0U; } /* Не допускает пустую передачу и всегда выбирает только канал 1. */
|
||||||
|
int ub_describe(const ub_frame *frame, ub_event *event) { /* Декодирует смысл служебных payload в общем C вместо отдельных реализаций GUI. */
|
||||||
|
if (!frame || !event || frame->channel > 4U || frame->length > UB_PAYLOAD) return 0; /* Проверяет публичные ABI аргументы даже при прямом вызове без потокового parser. */
|
||||||
|
memset(event, 0, sizeof(*event)); /* Не оставляет поля предыдущего события при коротком или ошибочном ответе. */
|
||||||
|
event->channel = frame->channel; /* Передаёт уже проверенный parser логический номер канала. */
|
||||||
|
if (frame->type == UB_RX && frame->channel && frame->length) { /* RX допускает только существующий номер и непустые бинарные данные. */
|
||||||
|
event->kind = 1U; event->length = frame->length; memcpy(event->data, frame->data, frame->length); /* ABI событие 1 содержит только полученные байты без служебного заголовка. */
|
||||||
|
} else if (frame->type == UB_ACK && frame->length == 4U && frame->data[0] >= UB_CONFIG && frame->data[0] <= UB_TX && frame->data[1] <= UB_BUSY && frame->data[2] >= 2U && frame->data[2] <= 4U && frame->data[3] == 1U) { /* Проверяет длину, исходную команду, статус и объявленные возможности G474. */
|
||||||
|
event->kind = 2U; event->command = frame->data[0]; event->status = frame->data[1]; event->channels = frame->data[2]; event->tx_channel = frame->data[3]; /* ABI событие 2 передаёт поля подтверждения без знания смещений в Python. */
|
||||||
|
} else if (frame->type == UB_STATS && frame->channel && frame->length == 8U) { /* Статистика содержит ровно два 32-битных счётчика отдельного канала. */
|
||||||
|
event->kind = 3U; event->lost = ub_get_u32(frame->data); event->errors = ub_get_u32(frame->data + 4U); /* ABI событие 3 возвращает готовые числовые значения. */
|
||||||
|
} /* Другие записи не являются корректными ответами USB терминалу. */
|
||||||
|
return event->kind != 0U; /* Отрицательный семантический результат не маскируется под пустой RX. */
|
||||||
|
} /* Завершает единый разбор служебных полей протокола. */
|
||||||
@@ -0,0 +1,44 @@
|
|||||||
|
#ifndef UART_USB_H /* Защищает общий ABI протокола от повторного включения. */
|
||||||
|
#define UART_USB_H /* Обозначает подключённый заголовок переносимого C99-ядра. */
|
||||||
|
#include <stdint.h> /* Задаёт одинаковые размеры полей MCU и настольного клиента. */
|
||||||
|
#if defined(_WIN32) /* Экспортирует кодек в отдельную DLL для ctypes на Windows. */
|
||||||
|
#define UB_API __declspec(dllexport) /* Делает публичные функции доступными без второго кодека в Python. */
|
||||||
|
#else /* Остальные платформы используют обычную видимость функций C. */
|
||||||
|
#define UB_API /* Оставляет интерфейс пригодным для статической линковки прошивки. */
|
||||||
|
#endif /* Завершает выбор способа экспорта ABI. */
|
||||||
|
#define UB_MAGIC 0xA7U /* Служебный байт выбран для восстановления границы записи в потоке USB. */
|
||||||
|
#define UB_PAYLOAD 60U /* Вместе с четырьмя байтами заголовка заполняет пакет USB FS длиной 64 байта. */
|
||||||
|
#define UB_CONFIG 1U /* Команда задаёт скорость одного выключенного приёмника в битах в секунду. */
|
||||||
|
#define UB_START 2U /* Команда запускает все включённые каналы захвата. */
|
||||||
|
#define UB_STOP 3U /* Команда останавливает DMA и освобождает USART после завершения TX. */
|
||||||
|
#define UB_TX 4U /* Команда передаёт необработанные байты только через логический канал 1. */
|
||||||
|
#define UB_ACK 8U /* Ответ содержит исходную команду, результат и число аппаратных каналов. */
|
||||||
|
#define UB_RX 9U /* Запись переносит принятые байты одного USART без текстового преобразования. */
|
||||||
|
#define UB_STATS 10U /* Запись сообщает накопленные потери и аппаратные ошибки одного канала. */
|
||||||
|
#define UB_OK 0U /* Нулевой статус подтверждает выполнение команды. */
|
||||||
|
#define UB_INVALID 1U /* Некорректные канал, длина или скорость не меняют состояние устройства. */
|
||||||
|
#define UB_BUSY 2U /* Занятый передатчик или работающий захват требуют повторения команды. */
|
||||||
|
typedef struct { /* Представляет разобранную запись без упаковки структур в wire-формат. */
|
||||||
|
uint8_t type; /* Хранит старшие четыре бита тега как отдельный тип сообщения. */
|
||||||
|
uint8_t channel; /* Хранит логический номер 1…4; номер 0 относится ко всему устройству. */
|
||||||
|
uint16_t length; /* Показывает фактическое количество байтов в payload, не более 60. */
|
||||||
|
uint8_t data[UB_PAYLOAD]; /* Передаёт бинарные данные без указателя на временную USB-память. */
|
||||||
|
} ub_frame; /* Сохраняет стабильное естественное выравнивание структуры для ctypes. */
|
||||||
|
typedef struct { /* Сохраняет состояние разбора между произвольно разделёнными USB-пакетами. */
|
||||||
|
uint8_t bytes[64]; /* Вмещает максимальную запись: заголовок 4 байта и данные 60 байт. */
|
||||||
|
uint16_t used; /* Показывает число уже накопленных байтов текущей записи. */
|
||||||
|
} ub_parser; /* Вся память принадлежит вызывающему; глобальное состояние отсутствует. */
|
||||||
|
typedef struct { /* Передаёт разобранный смысл ответа GUI через стабильный ABI без знания смещений payload. */
|
||||||
|
uint32_t kind, channel, length, command, status, channels, tx_channel, lost, errors; /* Хранит тип события и уже проверенные числовые поля ACK или статистики. */
|
||||||
|
uint8_t data[UB_PAYLOAD]; /* Содержит исключительно полезные байты RX для вывода и двоичного журнала. */
|
||||||
|
} ub_event; /* Размеры uint32 исключают разное представление enum и bool в языковых FFI. */
|
||||||
|
UB_API uint16_t ub_make_config(uint8_t channel, uint32_t baud, uint8_t *out); /* Формирует настройку скорости без сборки wire-полей в Python. */
|
||||||
|
UB_API uint16_t ub_make_start(uint8_t *out); /* Формирует общую команду запуска захвата. */
|
||||||
|
UB_API uint16_t ub_make_stop(uint8_t *out); /* Формирует общую команду остановки захвата. */
|
||||||
|
UB_API uint16_t ub_make_tx(const uint8_t *data, uint16_t length, uint8_t *out); /* Формирует передачу через единственный разрешённый канал 1. */
|
||||||
|
UB_API int ub_describe(const ub_frame *frame, ub_event *event); /* Проверяет семантику ответа и возвращает готовые поля либо 0 при ошибке. */
|
||||||
|
UB_API uint16_t ub_encode(uint8_t type, uint8_t channel, const uint8_t *data, uint16_t length, uint8_t *out); /* Записывает максимум 64 байта в буфер вызывающего и возвращает длину либо 0. */
|
||||||
|
UB_API uint16_t ub_feed(ub_parser *parser, const uint8_t *data, uint16_t length, ub_frame *frame); /* Возвращает число потреблённых байтов; type=0 означает незавершённую запись. */
|
||||||
|
UB_API uint32_t ub_get_u32(const uint8_t *data); /* Читает четыре байта little-endian независимо от архитектуры хоста. */
|
||||||
|
UB_API void ub_put_u32(uint8_t *data, uint32_t value); /* Записывает скорость или счётчик как четыре байта little-endian. */
|
||||||
|
#endif /* Завершает описание единственного общего кодека. */
|
||||||
@@ -0,0 +1,163 @@
|
|||||||
|
"""Четырёхканальный терминал USB USART для страницы STM32G474VET6.""" # Общая панель используется SETGUI через тонкую интеграцию страницы MCU.
|
||||||
|
import queue # Ограничивает очередь команд GUI, чтобы ввод не вытеснял приём данных.
|
||||||
|
import time # Использует монотонные сроки подтверждений и обновления экрана.
|
||||||
|
from pathlib import Path # Создаёт раздельные бинарные журналы в выбранном пользователем каталоге.
|
||||||
|
from ..uart_usb import Native, Usb # Получает команды и проверенные события исключительно через C-ядро templates.
|
||||||
|
try: # Поддерживает штатную сборку SETGUI на современном Qt.
|
||||||
|
from PySide6.QtCore import QThread, Signal # Передаёт данные между USB worker и GUI очередью Qt.
|
||||||
|
from PySide6.QtWidgets import QWidget, QVBoxLayout, QHBoxLayout, QGridLayout, QLabel, QComboBox, QPushButton, QPlainTextEdit, QLineEdit, QFileDialog, QMessageBox, QCheckBox # Создаёт компактный терминал без отдельного главного окна.
|
||||||
|
except ImportError: # Сохраняет совместимость той же панели со сборкой Qt5 для Windows 7.
|
||||||
|
from PySide2.QtCore import QThread, Signal # Использует тот же контракт потока и сигналов на Qt5.
|
||||||
|
from PySide2.QtWidgets import QWidget, QVBoxLayout, QHBoxLayout, QGridLayout, QLabel, QComboBox, QPushButton, QPlainTextEdit, QLineEdit, QFileDialog, QMessageBox, QCheckBox # Подключает эквивалентные виджеты без второго UI.
|
||||||
|
class UsbWorker(QThread): # Выполняет все блокирующие WinUSB операции вне GUI потока.
|
||||||
|
data_ready = Signal(int, bytes, object) # Передаёт канал, ограниченный хвост данных и точное суммарное число принятых байтов.
|
||||||
|
stats_ready = Signal(int, object, object) # Передаёт 32-битные счётчики потерь и аппаратных ошибок без знакового ограничения Qt int.
|
||||||
|
status = Signal(str) # Показывает пользователю запуск, результат отправки либо причину отключения.
|
||||||
|
active = Signal(int) # Сообщает фактическое количество каналов из ACK прошивки после запуска.
|
||||||
|
def __init__(self, path, rates, directory=None, parent=None, native_factory=Native, usb_factory=Usb): # Позволяет проверять worker имитацией транспорта без подключённой платы.
|
||||||
|
super().__init__(parent) # Связывает жизненный цикл worker с панелью Qt.
|
||||||
|
self.path, self.rates, self.directory = path, rates, directory # Фиксирует параметры сессии до запуска фонового потока.
|
||||||
|
self.native_factory, self.usb_factory = native_factory, usb_factory # Обычная работа использует C DLL, тест может подставить ограниченный fake USB.
|
||||||
|
self.commands = queue.Queue(maxsize=4) # Не принимает бесконечное количество запросов передачи при медленном USART.
|
||||||
|
self.pending = [bytearray() for _ in range(4)] # Отделяет ограниченные хвосты предпросмотра каждого RX-канала.
|
||||||
|
self.totals, self.files = [0] * 4, [] # Считает все байты независимо от усечения экранного предпросмотра.
|
||||||
|
self.flush_at = time.monotonic() # Ограничивает частоту сигналов GUI, сохраняя непрерывное USB чтение.
|
||||||
|
def _read(self): # Принимает пакетную выдачу Windows-конвейера и классифицирует уже разобранные C события.
|
||||||
|
acknowledgements = [] # Собирает ACK отдельно от непрерывных RX и диагностических сообщений.
|
||||||
|
for event in self.native.feed(self.usb.read()): # Все длины, каналы и служебные поля проверены C parser и ub_describe.
|
||||||
|
if event.kind == 1: # Готовое ABI событие RX содержит только полезные байты одного канала.
|
||||||
|
index = event.channel - 1 # Переводит логический номер канала в индекс четырёх экранов и файлов.
|
||||||
|
self.totals[index] += len(event.data) # Учитывает каждый полученный байт до усечения предпросмотра.
|
||||||
|
self.pending[index].extend(event.data); del self.pending[index][:-8192] # Ограничивает накопление для GUI последними 8 КиБ на канал.
|
||||||
|
if self.files: self.files[index].write(event.data) # Записывает все бинарные байты без перекодирования, заголовков и усечения.
|
||||||
|
elif event.kind == 2: acknowledgements.append(event) # Передаёт ACK автомату ожидаемой команды без повторного разбора payload.
|
||||||
|
elif event.kind == 3: self.stats_ready.emit(event.channel, event.lost, event.errors) # Независимо обновляет счётчики потерь и ошибок прошивки.
|
||||||
|
self._flush() # Отправляет накопленный экранный хвост не чаще одного раза за 50 мс.
|
||||||
|
return acknowledgements # Возвращает только подтверждения для текущего синхронного шага worker.
|
||||||
|
def _flush(self, force=False): # Отделяет частоту отображения от скорости аппаратного потока.
|
||||||
|
if not force and time.monotonic() < self.flush_at: return # Уменьшает число queued signals при непрерывном потоке USB.
|
||||||
|
self.flush_at = time.monotonic() + 0.05 # Ограничивает обновление четырёх экранов частотой до 20 Гц.
|
||||||
|
for index, data in enumerate(self.pending): # Выдаёт независимые хвосты только изменившихся каналов.
|
||||||
|
if data: self.data_ready.emit(index + 1, bytes(data), self.totals[index]); data.clear() # Сохраняет точный общий счётчик даже при ограниченном предпросмотре.
|
||||||
|
def _exchange(self, name, channel=0, baud=0, data=b'', closing=False): # Отправляет ровно одну команду и ждёт её подтверждения, продолжая принимать RX.
|
||||||
|
deadline, command = time.monotonic() + 1.5, {'config': 1, 'start': 2, 'stop': 3, 'tx': 4}[name] # Связывает имена API с идентификаторами ACK, ограничивая шаг полутора секундами.
|
||||||
|
packet = self.native.make(name, channel, baud, data) # Передаёт построение всех wire-полей общему C-кодеку.
|
||||||
|
while time.monotonic() < deadline: # Повторяет только явно отвергнутые со статусом BUSY команды.
|
||||||
|
if self.isInterruptionRequested() and not closing: raise InterruptedError() # Даёт кнопке отключения прервать настройку либо длинную отправку.
|
||||||
|
self.usb.write(packet) # Передаёт один неизменяемый пакет без повторения после потери ACK.
|
||||||
|
while time.monotonic() < deadline: # Принимает USART во время ожидания соответствующего подтверждения.
|
||||||
|
for event in self._read(): # Чтение имеет системное ожидание не более 50 мс при пустой линии.
|
||||||
|
if event.command != command or event.channel != channel: continue # Не принимает подтверждение другой команды за завершение текущей.
|
||||||
|
if event.status == 0: return event # Сохраняет возможности прошивки из успешного ACK.
|
||||||
|
if event.status != 2: raise RuntimeError('Команда ' + name + ' отклонена: канал или скорость не поддерживаются') # Показывает явный отказ вместо скрытой работы с другой скоростью.
|
||||||
|
break # BUSY разрешает повтор, поскольку прошивка гарантирует отсутствие побочного действия отклонённой команды.
|
||||||
|
else: continue # Обычные RX пакеты не прерывают ожидание подтверждения.
|
||||||
|
break # Возвращает управление внешнему циклу для повтора команды после BUSY.
|
||||||
|
else: break # Не повторяет потенциально выполненную команду после таймаута потерянного ACK.
|
||||||
|
raise RuntimeError('Нет подтверждения USB USART: ' + name) # Завершает сессию при нарушении последовательного обмена.
|
||||||
|
def run(self): # Владеет USB, кодеком и файлами исключительно в одном фоновом потоке.
|
||||||
|
self.usb = None # Позволяет корректно очистить ресурсы при ошибке загрузки DLL.
|
||||||
|
try: # Любая аппаратная ошибка завершает сессию и возвращается видимым статусом GUI.
|
||||||
|
self.native = self.native_factory(); self.usb = self.usb_factory(self.native, self.path) # Открывает только выбранный интерфейс USART, сохраняя CAN-соединения.
|
||||||
|
info = self._exchange('stop', closing=True) # Получает число каналов и приводит ранее открытую прошивку к остановленному состоянию.
|
||||||
|
for channel in range(1, info.channels + 1): self._exchange('config', channel, self.rates[channel - 1]) # Настраивает только реально включённые в сборке приёмники.
|
||||||
|
if self.directory: # Создаёт двоичные журналы до START, чтобы не потерять начало захвата.
|
||||||
|
folder = Path(self.directory) / time.strftime('usart-%Y%m%d-%H%M%S') # Выделяет отдельную папку сессии внутри выбранного пользователем каталога.
|
||||||
|
folder.mkdir(parents=True, exist_ok=False) # Не перезаписывает ранее записанные пользовательские данные.
|
||||||
|
for channel in range(1, 5): self.files.append((folder / ('rx' + str(channel) + '.bin')).open('wb', buffering=65536)) # Сохраняет каналы раздельно с дисковым буфером 64 КиБ.
|
||||||
|
self.status.emit('Журнал: ' + str(folder)) # Показывает точное место записи до начала непрерывного потока.
|
||||||
|
self._exchange('start'); self.active.emit(info.channels) # Разрешает TX и сообщает реальное количество работающих RX только после ACK START.
|
||||||
|
while not self.isInterruptionRequested(): # Обслуживает приём до явного отключения или закрытия приложения.
|
||||||
|
try: data = self.commands.get_nowait() # Проверяет ограниченную очередь отправки без ожидания GUI.
|
||||||
|
except queue.Empty: data = None # При отсутствии TX непрерывно обслуживает USB IN.
|
||||||
|
if data is not None: # Одна пользовательская отправка разбивается на атомарные команды TX.
|
||||||
|
for offset in range(0, len(data), 60): self._exchange('tx', 1, data=data[offset:offset + 60]) # Общий C builder кодирует каждый пакет, а ACK BUSY обеспечивает обратное давление USART2.
|
||||||
|
self.status.emit('Передано в USART2: ' + str(len(data)) + ' байт') # Подтверждает приём данных аппаратным DMA передатчика.
|
||||||
|
self._read() # Обрабатывает RX и статистику между пользовательскими запросами TX.
|
||||||
|
except InterruptedError: pass # Явное отключение пользователем является штатным окончанием сессии.
|
||||||
|
except Exception as error: self.status.emit(str(error)) # Показывает ошибку DLL, USB, ACK либо записи файла без фонового traceback.
|
||||||
|
finally: # Освобождает аппаратуру и журналы при любом способе завершения потока.
|
||||||
|
if self.usb: # STOP возможен только после успешного открытия Windows handle.
|
||||||
|
try: self._exchange('stop', closing=True) # Останавливает захват, продолжая читать данные до подтверждения команды.
|
||||||
|
except Exception: pass # Физическое отключение уже остановило прошивку через USB lifecycle; закрытие handle остаётся обязательным.
|
||||||
|
self.usb.close() # Отменяет и дожидается всех шестнадцати pending USB чтений до освобождения памяти.
|
||||||
|
for file in self.files: file.close() # Сбрасывает дисковые буферы каждого бинарного журнала.
|
||||||
|
self._flush(force=True) # Передаёт последний ограниченный хвост предпросмотра перед сигналом finished.
|
||||||
|
class UartUsbTerminal(QWidget): # Встраивается непосредственно в страницу STM32G474VET6 главного приложения.
|
||||||
|
def __init__(self, parent=None): # Не загружает DLL и не открывает оборудование при создании вкладки.
|
||||||
|
super().__init__(parent); self.worker = None; self.directory = None # Начинает с отключённой сессии и выключенной записи на диск.
|
||||||
|
self.buffers = [bytearray() for _ in range(4)]; self.rates = []; self.views = []; self.counters = [] # Разделяет отображение и скорости всех четырёх физических входов.
|
||||||
|
layout = QVBoxLayout(self) # Позволяет панели растягиваться внутри существующей MCU страницы.
|
||||||
|
layout.addWidget(QLabel('USART → USB · RX1 PA3 / RX2 PB11 / RX3 PC11 / RX4 PD2 · TX1 PA2 · 8N1')) # Показывает проверенную разводку до подключения проводов.
|
||||||
|
controls = QHBoxLayout(); self.devices = QComboBox(); self.devices.setMinimumContentsLength(35) # Делает выбор нескольких USB адаптеров читаемым в обычном окне.
|
||||||
|
self.refresh = QPushButton('Обновить USB'); self.connect = QPushButton('Запустить'); self.record = QPushButton('Запись RX…') # Разделяет поиск, начало захвата и выбор места бинарных журналов.
|
||||||
|
for widget in (self.devices, self.refresh, self.connect, self.record): controls.addWidget(widget) # Сохраняет основные действия в одной строке над потоками.
|
||||||
|
layout.addLayout(controls); grid = QGridLayout(); layout.addLayout(grid) # Показывает четыре RX-экрана одновременно в сетке 2×2.
|
||||||
|
for index, peripheral in enumerate(('USART2', 'USART3', 'UART4', 'UART5')): # Имена соответствуют единственному аппаратному порту G474 из templates.
|
||||||
|
container = QWidget(); column = QVBoxLayout(container); row = QHBoxLayout(); rate = QComboBox(); rate.setEditable(True) # Каждому входу назначает независимый редактор скорости.
|
||||||
|
rate.addItems(['115200', '512000', '1000000', '2000000', '3000000', '6000000']); rate.setCurrentText('1000000') # Начальная скорость совпадает с прошивкой: 1 Мбит/с, формат 8N1.
|
||||||
|
row.addWidget(QLabel('RX' + str(index + 1) + ' · ' + peripheral)); row.addWidget(rate); column.addLayout(row) # Размещает скорость рядом с однозначным номером канала.
|
||||||
|
view = QPlainTextEdit(); view.setReadOnly(True); view.setMinimumHeight(110) # Не позволяет случайному вводу в RX экран отправлять байты устройству.
|
||||||
|
counter = QLabel('0 байт · потери 0 · ошибки 0'); column.addWidget(counter); column.addWidget(view) # Сохраняет диагностику отдельно от текста необработанной линии.
|
||||||
|
grid.addWidget(container, index // 2, index % 2); self.rates.append(rate); self.views.append(view); self.counters.append(counter) # Сохраняет управление каналами без дублирования четырёх обработчиков.
|
||||||
|
sending = QHBoxLayout(); self.input = QLineEdit(); self.hex = QCheckBox('HEX'); self.send = QPushButton('Передать TX1 / PA2'); self.send.setEnabled(False) # Передача доступна только после подтверждённого START и только на первом канале.
|
||||||
|
for widget in (self.input, self.hex, self.send): sending.addWidget(widget) # Формат HEX применяется к пользовательским байтам, а не к служебному USB заголовку.
|
||||||
|
layout.addLayout(sending); self.hex_view = QCheckBox('Показывать RX в HEX'); layout.addWidget(self.hex_view) # Позволяет читать двоичный поток без потери исходных байтов журнала.
|
||||||
|
self.message = QLabel('Отключено. Для непрерывного потока выберите запись RX; экран показывает последние 8 КиБ каждого канала.'); self.message.setWordWrap(True); layout.addWidget(self.message) # Объясняет ограничение предпросмотра до начала длительного захвата.
|
||||||
|
self.counts = [0] * 4; self.lost = [0] * 4; self.errors = [0] * 4 # Разделяет счётчики хоста и сообщённые прошивкой потери.
|
||||||
|
self.refresh.clicked.connect(self.refresh_devices); self.connect.clicked.connect(self.toggle); self.record.clicked.connect(self.choose_directory); self.send.clicked.connect(self.transmit); self.input.returnPressed.connect(self.transmit) # Связывает действия с общими обработчиками без открытия транспорта при создании UI.
|
||||||
|
self.hex_view.toggled.connect(self.render_all) # Меняет только представление уже принятых байтов.
|
||||||
|
def refresh_devices(self): # Поиск выполняется только по явной кнопке пользователя.
|
||||||
|
try: # Ошибка установки DLL должна быть видна на этой же странице.
|
||||||
|
paths = Native().paths(); self.devices.clear() # Сканирует только USART интерфейс 2, сохраняя отдельный CAN интерфейс свободным.
|
||||||
|
for index, path in enumerate(paths): self.devices.addItem('G474 USB USART ' + str(index + 1) + ' · ' + path.split('#')[2], path) # Хранит полный Windows путь в userData, а не восстанавливает его из подписи.
|
||||||
|
self.message.setText('Найдено USART-интерфейсов: ' + str(len(paths))) # Пустой список корректно сообщает об отсутствии новой прошивки либо WinUSB.
|
||||||
|
except Exception as error: self.message.setText(str(error)) # Не подменяет отсутствующую DLL альтернативным протоколом Python.
|
||||||
|
def choose_directory(self): # Выбирает существующую пользовательскую папку до начала сессии.
|
||||||
|
if self.directory: self.directory = None; self.record.setText('Запись RX…'); return # Повторное нажатие явно выключает запись до следующего START.
|
||||||
|
directory = QFileDialog.getExistingDirectory(self, 'Каталог бинарных журналов RX') # Пользователь явно определяет место длительной записи.
|
||||||
|
if directory: self.directory = directory; self.record.setText('Запись RX: включена') # Отдельная подпапка и четыре bin файла создаются worker при START.
|
||||||
|
def toggle(self): # Кнопка запуска меняет состояние только существующей сессии этой панели.
|
||||||
|
if self.worker and self.worker.isRunning(): self.worker.requestInterruption(); self.connect.setEnabled(False); return # Просит worker штатно завершить TX, STOP и закрытие файлов без блокирования GUI.
|
||||||
|
if not self.devices.currentData(): self.refresh_devices() # Первый запуск помогает обнаружить устройство без дополнительного шага пользователя.
|
||||||
|
if not self.devices.currentData(): return # Не создаёт worker с пустым либо выдуманным USB путём.
|
||||||
|
try: rates = [int(rate.currentText()) for rate in self.rates] # Читает независимые скорости в битах в секунду перед фиксацией сессии.
|
||||||
|
except ValueError: self.message.setText('Скорость должна быть целым числом бит/с'); return # Оставляет соединение выключенным при незавершённом вводе.
|
||||||
|
if any(rate < 1200 or rate > 6000000 for rate in rates): self.message.setText('Допустимые скорости: 1200…6000000 бит/с'); return # Не посылает заведомо неподдерживаемую скорость; точную погрешность проверяет MCU.
|
||||||
|
self.buffers = [bytearray() for _ in range(4)]; self.counts = [0] * 4; self.lost = [0] * 4; self.errors = [0] * 4; self.render_all() # Начинает новую экранную сессию без счётчиков предыдущего захвата.
|
||||||
|
self.worker = UsbWorker(self.devices.currentData(), rates, self.directory, self) # Передаёт потоку неизменяемые параметры выбранного оборудования.
|
||||||
|
self.worker.data_ready.connect(self.received); self.worker.stats_ready.connect(self.statistics); self.worker.status.connect(self.message.setText); self.worker.active.connect(self.started); self.worker.finished.connect(self.finished) # Все изменения виджетов выполняются через queued Qt сигналы GUI потока.
|
||||||
|
for widget in [self.devices, self.refresh, self.record] + self.rates: widget.setEnabled(False) # Исключает изменение параметров уже открытого USB-сеанса.
|
||||||
|
self.connect.setText('Отключить'); self.message.setText('Подключение и настройка USART…'); self.worker.start() # Запускает ограниченные ожидания USB в фоне.
|
||||||
|
def started(self, channels): # Показывает возможности, которые реально подтвердила прошивка.
|
||||||
|
self.send.setEnabled(True); self.message.setText('Захват активен: RX ' + str(channels) + ', TX только канал 1 / PA2') # Не разрешает TX до ACK команды START.
|
||||||
|
for index, view in enumerate(self.views): view.setEnabled(index < channels) # Отражает сборки с двумя и тремя входами без ложного ожидания четырёх потоков.
|
||||||
|
def finished(self): # Возвращает элементы управления только после закрытия USB и файлов worker.
|
||||||
|
self.send.setEnabled(False); self.connect.setEnabled(True); self.connect.setText('Запустить') # Завершённая сессия больше не принимает данные передатчика.
|
||||||
|
for widget in [self.devices, self.refresh, self.record] + self.rates: widget.setEnabled(True) # Разрешает выбор следующего устройства и независимых скоростей.
|
||||||
|
self.worker.deleteLater(); self.worker = None # Освобождает завершённый QThread после обработки его последнего queued сигнала.
|
||||||
|
def transmit(self): # Отправляет пользовательские данные только через единственный доступный TX.
|
||||||
|
if not self.worker or not self.worker.isRunning() or not self.send.isEnabled(): return # Не ставит команды в закрытую либо ещё настраиваемую сессию.
|
||||||
|
try: data = bytes.fromhex(self.input.text()) if self.hex.isChecked() else self.input.text().encode('utf-8') # HEX ввод задаёт двоичные байты, текст использует явно выбранную кодировку UTF-8.
|
||||||
|
except ValueError: self.message.setText('HEX: введите пары шестнадцатеричных цифр'); return # Не меняет пользовательский ввод при ошибочном двоичном формате.
|
||||||
|
if not data or len(data) > 65536: self.message.setText('Одна отправка: 1…65536 байт'); return # Ограничивает память и время обслуживания одной GUI-команды.
|
||||||
|
try: self.worker.commands.put_nowait(data) # Передаёт неизменяемые байты worker без ожидания подтверждения в GUI.
|
||||||
|
except queue.Full: self.message.setText('Очередь TX занята, дождитесь передачи'); return # Явно сообщает обратное давление вместо роста памяти.
|
||||||
|
self.input.clear() # Удаляет ввод только после успешной постановки всей отправки в очередь.
|
||||||
|
def received(self, channel, data, total): # Обновляет только экран конкретного входа, сохраняя полный журнал в worker.
|
||||||
|
index = channel - 1; self.buffers[index].extend(data); del self.buffers[index][:-8192]; self.counts[index] = total # Держит ограниченный хвост и точный монотонный счётчик байтов хоста.
|
||||||
|
self.render(index) # Перерисовывает лишь изменившийся RX экран.
|
||||||
|
def statistics(self, channel, lost, errors): # Принимает готовые счётчики из C-модели, не разбирая пакет самостоятельно.
|
||||||
|
index = channel - 1; self.lost[index] = lost; self.errors[index] = errors; self.render(index) # Не смешивает потери микроконтроллера с усечением экранного предпросмотра.
|
||||||
|
def render(self, index): # Выполняет только визуальное преобразование пользовательских байтов.
|
||||||
|
data = bytes(self.buffers[index]); text = ' '.join(format(byte, '02X') for byte in data) if self.hex_view.isChecked() else data.decode('utf-8', errors='replace') # Бинарный журнал остаётся точным независимо от режима отображения.
|
||||||
|
self.views[index].setPlainText(text); bar = self.views[index].verticalScrollBar(); bar.setValue(bar.maximum()) # Показывает последние данные в ограниченном по памяти документе.
|
||||||
|
self.counters[index].setText(str(self.counts[index]) + ' байт · потери ' + str(self.lost[index]) + ' · ошибки ' + str(self.errors[index])) # Явно отображает переполнение USB и аппаратные нарушения линии.
|
||||||
|
def render_all(self, checked=False): # Перерисовывает сохранённые хвосты после смены формата либо новой сессии.
|
||||||
|
for index in range(4): self.render(index) # Четыре одинаковых представления используют одну функцию форматирования.
|
||||||
|
def shutdown(self): # Главный SETGUI вызывает этот метод перед уничтожением панели.
|
||||||
|
if self.worker and self.worker.isRunning(): self.worker.requestInterruption(); return self.worker.wait(4000) # Даёт ограниченный срок STOP и отмене pending WinUSB I/O до удаления QThread.
|
||||||
|
return True # Закрытая сессия не задерживает завершение приложения.
|
||||||
|
def closeEvent(self, event): # Самостоятельная панель также корректно останавливает захват при закрытии окна.
|
||||||
|
if self.shutdown(): event.accept() # Закрывает виджет только после освобождения USB ресурсов worker.
|
||||||
|
else: event.ignore() # Не уничтожает память ещё работающего потока при редком системном зависании I/O.
|
||||||
File diff suppressed because one or more lines are too long
@@ -15,6 +15,132 @@ User → Stop on Exit Code** для команд **Before Build/Rebuild** и
|
|||||||
для ручной правки XML сначала закройте проект в Keil и сохраните резервную копию.
|
для ручной правки XML сначала закройте проект в Keil и сохраните резервную копию.
|
||||||
Обновление templates не меняет уже сохранённые условия в файле проекта.
|
Обновление templates не меняет уже сохранённые условия в файле проекта.
|
||||||
|
|
||||||
|
## Параметры прошивки CAN и RS из JSON
|
||||||
|
|
||||||
|
Настройка CCS/Keil в SETGUI теперь проверяет Python до изменения проекта.
|
||||||
|
Общие BAT вызывают `python-runtime.ps1`: он находит Python 3.7+ в установленном
|
||||||
|
окружении либо готовит проверенный переносимый runtime в
|
||||||
|
`%LOCALAPPDATA%/SET/FirmwareBuild`. Ручная настройка PATH не требуется.
|
||||||
|
Для Windows 10/11 x64 используется закреплённый Python 3.13.12, для Windows 7
|
||||||
|
и x86 — Python 3.8.10. ZIP загружается с python.org с проверкой SHA-256;
|
||||||
|
повторные сборки используют готовую локальную копию. При отсутствии доступа
|
||||||
|
к сети можно заранее установить Python либо задать полный путь `FIRMWARE_PYTHON`.
|
||||||
|
|
||||||
|
Для **штатного SCI-загрузчика UlitCo / C2Prog** выберите в настройке проекта
|
||||||
|
маршрут `f28335-sci`. Он автоматически подключает общую реализацию из
|
||||||
|
`c/firmware-info/tools/c2000_sci_build.py`; отдельный проектный `build_flash.py`
|
||||||
|
не требуется. Пример блока:
|
||||||
|
|
||||||
|
```json
|
||||||
|
"flashing": {
|
||||||
|
"default_loader": "f28335-sci",
|
||||||
|
"profiles": {
|
||||||
|
"f28335-sci": {
|
||||||
|
"baudrate": 115200,
|
||||||
|
"oscillator_hz": 30000000,
|
||||||
|
"enter_monitor": false,
|
||||||
|
"timeout_ms": 3000
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
```
|
||||||
|
|
||||||
|
Укажите фактическую частоту кварца: поддержаны 20, 25 и 30 МГц. Она определяет
|
||||||
|
времена Flash API и сохраняется вместе с RAM-ядром. Установленный C2000Ware с
|
||||||
|
`device_support/f2833x/examples/f28335_flash_kernel` определяется автоматически
|
||||||
|
в `C:/ti` либо по `C2000WARE_ROOT`. Эта зависимость проверяется при применении
|
||||||
|
настройки проекта. TI compiler берётся из `${CG_TOOL_ROOT}` текущей CCS.
|
||||||
|
|
||||||
|
Postbuild проверяет Flash LOAD-секции исходного OUT и выпускает
|
||||||
|
`*_flash_rs.bin`, `*_flash.out`, `f28335_sci_kernel.bin`, manifest, SHA-256
|
||||||
|
и уведомление о лицензии TI. Ядро собирается из штатных исходников SDK под
|
||||||
|
частоту платы и маску секторов именно текущего приложения. Основной manifest
|
||||||
|
в `latest_build.json` указывает сразу на Flash SCI BIN; папка `eeprom` для
|
||||||
|
этого маршрута не создаётся.
|
||||||
|
|
||||||
|
В SETGUI маршрут работает внутри общей вкладки прошивки: первичный загрузчик
|
||||||
|
принимает RAM-ядро TI с побайтовым эхом, затем Kernel A стирает выбранные сектора
|
||||||
|
и принимает порции Flash с подтверждением checksum после Flash API. Внешний
|
||||||
|
C2Prog не запускается. Тайм-аут, несовпадение эха/суммы и отмена завершают
|
||||||
|
операцию; readback-проверка памяти этим протоколом Kernel A не заявляется.
|
||||||
|
Ядро автоматически выбирается из manifest и проверяется по SHA-256.
|
||||||
|
|
||||||
|
`enter_monitor=true` включает штатную команду UlitCo: запись `1` в параметр
|
||||||
|
Monitor №93 перед autobaud. Действующая прошивка разрешает такой переход только
|
||||||
|
в остановленном состоянии. При `false` предварительно переведите плату в
|
||||||
|
первичный SCI-загрузчик обычным способом. Это отдельный маршрут относительно
|
||||||
|
`f28335-flash-rs`, который использует BIOS ПМ35 и защищённое приложение FAB1.
|
||||||
|
|
||||||
|
В проектном `firmware_identity.json` можно хранить блок `flashing` вместе с
|
||||||
|
версией. Keil и CCS проверяют его до увеличения номера сборки и переносят в
|
||||||
|
`generated/firmware_identity.json`, каждый `*.manifest.json` и архив выпуска.
|
||||||
|
Параметры описывают **загрузку образа**; скорость работающей программы на MCU
|
||||||
|
по-прежнему задаётся её исходниками и настройками аппаратуры.
|
||||||
|
|
||||||
|
```json
|
||||||
|
"flashing": {
|
||||||
|
"default_loader": "set-can",
|
||||||
|
"profiles": {
|
||||||
|
"set-can": {"bitrate": 250000, "node_id": 13},
|
||||||
|
"set-rs485": {"baudrate": 115200}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
```
|
||||||
|
|
||||||
|
`default_loader` — конкретный загрузчик, выбираемый при импорте сборки или
|
||||||
|
локального образа; его ключ должен присутствовать в `profiles`. Каждая запись
|
||||||
|
`profiles` задаёт независимые параметры соответствующего загрузчика. Значения
|
||||||
|
примеров нужно заменить параметрами своей платы. JSON не допускает комментарии;
|
||||||
|
назначение полей приведено ниже.
|
||||||
|
|
||||||
|
| Загрузчик | Поддерживаемые параметры |
|
||||||
|
|---|---|
|
||||||
|
| `set-can` | `bitrate`, `node_id`, `product_type`, `hardware_min`, `hardware_max`, `base_address` |
|
||||||
|
| `protocan-can` | Поля `set-can`, кроме `base_address`; дополнительно `device_type`, `session_id`, `memory` |
|
||||||
|
| `set-rs485`, `stm32-uart` | `baudrate`, `base_address` |
|
||||||
|
| `f28335-eeprom`, `f28335-flash-rs` | `baudrate`, `controller`, `timeout_ms` |
|
||||||
|
| `stm32-usb` | `base_address` |
|
||||||
|
| `manual`, `f28335-jtag` | Пустой объект `{}` |
|
||||||
|
|
||||||
|
| Поле | Единицы и ограничения |
|
||||||
|
|---|---|
|
||||||
|
| `bitrate` | Целое число бит/с, `1..1000000`; верхняя граница Classic CAN. Например, `250000` — 250 кбит/с. Адаптер также должен поддерживать выбранную скорость. |
|
||||||
|
| `baudrate` | Целое число бод, `1..2147483647`; фактическую поддержку проверяет COM-драйвер. Например, `115200`. |
|
||||||
|
| `node_id` | Адрес SETP `0..255`; для ProtoCAN — поле Device `0..15`. |
|
||||||
|
| `device_type`, `session_id` | Поля существующего ProtoCAN-загрузчика: Type `0..7`, Session ID `1..255`. |
|
||||||
|
| `product_type` | Код совместимости `0..65535`; например, `358` соответствует `0x0166`, а `10291` — `0x2833`. |
|
||||||
|
| `hardware_min`, `hardware_max` | Включительный диапазон аппаратных ревизий `0..255`; min не больше max. |
|
||||||
|
| `base_address` | Целочисленный адрес приложения в **байтах**, `0..4294967295`. Например, `134230016` соответствует `0x08003000`; это адрес примера, а не общий адрес всех STM32. Для HEX должен совпадать с адресом самого образа. |
|
||||||
|
| `controller` | Независимый адрес контроллера RS-протокола ПМ35, `0..255`. |
|
||||||
|
| `timeout_ms` | Дополнительный тайм-аут RS-панели ПМ35 в миллисекундах, `50..10000`. |
|
||||||
|
| `memory` | Выбор назначения ProtoCAN: `eeprom`, `flash` или `stm32`. |
|
||||||
|
|
||||||
|
Формат UART определяется протоколом: SET RS использует 8N1, STM32 ROM Boot —
|
||||||
|
8E1. COM-порт, экземпляр CAN-адаптера и его соединение выбираются на компьютере
|
||||||
|
оператора, поскольку они не являются свойствами образа прошивки.
|
||||||
|
|
||||||
|
Обновлённый SETGUI выбирает загрузчик и заполняет форму из manifest при импорте
|
||||||
|
postbuild и выборе опубликованного комплекта. Общая вкладка прошивки также
|
||||||
|
подхватывает настройки при обычном выборе локального BIN/HEX, если рядом лежит
|
||||||
|
соответствующий `имя.bin.manifest.json` или `имя.hex.manifest.json`; перед
|
||||||
|
применением проверяются имя, размер и SHA-256 файла. Маршрут выбранной записи
|
||||||
|
каталога использует свой профиль, даже если `default_loader` задаёт другой.
|
||||||
|
При переключении общей формы между CAN и RS применяется профиль нового режима.
|
||||||
|
Локальный выбор BIN в панели F28335 подхватывает профиль выбранного RS-загрузчика
|
||||||
|
после штатной проверки образа; JTAG сохраняет отдельное подключение.
|
||||||
|
Скорость уже открытого канала применяется после его отключения. Запись платы
|
||||||
|
запускается отдельной штатной кнопкой.
|
||||||
|
|
||||||
|
Для отдельных CAN BIN и Flash RS BIN C2000 назначение из паспорта артефакта
|
||||||
|
имеет приоритет над `default_loader` основного EEPROM-образа. Профили при этом
|
||||||
|
остаются общими для комплекта. Старые конфигурации без `flashing` сохраняют
|
||||||
|
прежнее поведение; существующие проектные JSON автоматически не заменяются.
|
||||||
|
|
||||||
|
Полные примеры: [Keil](keil/firmware_identity.example.json) и
|
||||||
|
[CCS](ccs/firmware_identity.example.json). Поддержка чтения профилей должна быть
|
||||||
|
включена в сборку SETGUI вместе с обновлённым модулем
|
||||||
|
`set_devices.firmware_flashing` из templates.
|
||||||
|
|
||||||
Для проектов ПЛИС используйте [шаблон Xilinx ISE, Vivado и Altera/Intel Quartus](fpga/README.md):
|
Для проектов ПЛИС используйте [шаблон Xilinx ISE, Vivado и Altera/Intel Quartus](fpga/README.md):
|
||||||
общий сохраняемый итератор, паспорт на Verilog/VHDL, полная сборка `.bit`/`.sof`,
|
общий сохраняемый итератор, паспорт на Verilog/VHDL, полная сборка `.bit`/`.sof`,
|
||||||
manifest, SHA-256 и архив выпуска.
|
manifest, SHA-256 и архив выпуска.
|
||||||
|
|||||||
Reference in New Issue
Block a user