11 Commits
Author SHA1 Message Date
Andrey 824fe55fe9 Вынести редактор настроек CAN в общую библиотеку 2026-11-18 16:58:34 +03:00
Andrey afdf62cfa4 Добавить проверку Flash SCI, системные диалоги и векторизацию PDF
Расширить протокол SCI проверкой содержимого Flash и комплектом RAM-ядер.
Добавить утилиту векторизации PDF с OCR, общие диалоги DSView и проверки.
2026-11-18 16:03:53 +03:00
Andrey 4825465583 Добавить общее ядро автомобильной диагностики и порт SETGUI
Вынести ISO-TP, OBD-II, UDS, профили, сервисный автомат, журнал и симулятор программирования в переносимый модуль C11.

Добавить единый ABI и тонкий Python-порт, переносимые тесты и независимую сборку CMake. Оставить неподтверждённые фирменные команды и реальную запись ECU отключёнными.
2026-11-17 17:31:28 +03:00
Andrey e627d088e0 Разделить USB идентичность USART и CAN адаптеров 2026-11-16 18:20:19 +03:00
Andrey 34d9016118 Добавить USART USB мост G474 и общий четырёхканальный терминал 2026-11-16 18:15:48 +03:00
Andrey 28fe22439c Объединить инструменты устройств и загрузчик F28335 в основной ветке 2026-11-13 19:32:52 +03:00
Andrey a197437985 Исправить ядро SCI UlitCo и отображение хода прошивки
Загружать RAM-ядро через переход по адресу 0 в _InitBoot,
повторно использовать поток Qt и передавать сигналы в GUI.
Показывать точный этап ошибки, изменения процентов и время сеанса.

Проверено: реальная сборка ядра TI и аппаратная передача ИБП
на скоростях 57600 и 115200 бод.
2026-11-13 19:23:40 +03:00
Andrey ae018a1347 Исправить окончания строк командных файлов Windows
Выдавать BAT и CMD с CRLF при получении из Git. Общий LF приводил к пропуску команд postbuild и экспорта SCI-комплекта после переноса на другой ПК.
2026-11-13 17:06:56 +03:00
Andrey 80d8fe1794 Исправить вход UlitCo в SCI через Monitor
Передавать контрольную сумму команды перехода в загрузчик.
Отправлять Monitor на 468750 бод и затем включать скорость SCI из JSON.
Обновить эталонные проверки входа в загрузчик.
2026-11-13 17:06:39 +03:00
Andrey d057df7698 Добавить прошивку F28335 через SCI и подготовку Python
Подключить сборку Flash BIN и RAM-ядра TI через templates.
Передавать настройки CAN и RS из JSON и проверять окружение CCS/Keil.
Добавить общий C99-протокол и проверки обмена SCI.
2026-11-13 17:02:33 +03:00
Andrey f9d369d032 feat(f28335-rs-boot): добавьте постоянный загрузчик по RS
Принимайте INITLOAD, LOAD и TFLASH общим автоматом с повторной
проверкой SCI8/FAB1 до стирания и сохранением сектора A.

Сохраняйте параметры прошивки в паспорте prebuild, выпускайте
независимые образы загрузчика и приложения с manifest и SHA-256.

Проверено: шесть испытаний модели, включая обрывы записи и восстановление.
2026-11-13 15:07:55 +03:00
105 changed files with 5575 additions and 45 deletions
+5
View File
@@ -4,3 +4,8 @@
*.pdf binary
*.png binary
# CMD.exe требует CRLF в BAT, иначе после переноса Git часть команд разбирается неверно.
*.bat text eol=crlf
# Командные файлы CMD выполняются тем же интерпретатором Windows и требуют CRLF.
*.cmd text eol=crlf
+2
View File
@@ -7,6 +7,8 @@ cmake-build-*/
*.a
*.elf
*.bin
# Встроенные ядра F28335 являются ресурсами поставки, а не промежуточными результатами пользовательской сборки.
!python/set_devices/sci_kernels/*.bin
*.hex
*.map
*.lst
+2
View File
@@ -38,6 +38,8 @@ templates/
### C
USART STM32G474 → USB и терминал четырёх каналов: [`c/uart-usb`](c/uart-usb/README.md).
| Библиотека | Что делает | Зависимости | Что нужно от платформы |
|---|---|---|---|
| [`c/st7789`](c/st7789) | TFT ST7789V по SPI, RGB565, текст без кадрового буфера | `stdint.h` | SPI-запись, линия DC, задержка |
+23
View File
@@ -0,0 +1,23 @@
cmake_minimum_required(VERSION 3.20) # Современный CMake поддерживает одинаковое описание C11 для Windows и Linux.
project(automotive LANGUAGES C) # Общее ядро не требует C++, Qt, HAL или аппаратного SDK.
set(CMAKE_C_STANDARD 11) # Размеры структур и алгоритмы проверяются в языке C11.
set(CMAKE_C_STANDARD_REQUIRED ON) # Компилятор без поддержки C11 не принимается молча.
set(CMAKE_C_EXTENSIONS OFF) # Переносимое ядро не зависит от GNU расширений языка.
set(AUTOMOTIVE_SOURCES src/isotp.c src/obd2_pid.c src/obd2_dtc.c src/uds.c src/diag_engine.c src/diag_abi.c src/vehicle_manager.c src/landrover_suspension.c src/service_manager.c src/ecu_programmer.c src/cli.c src/can_logger.c ../set-protocol/src/pcan_ring.c ../set-protocol/src/gui_frame.c) # CRC32 и кольца повторно используются из существующего templates.
add_library(automotive SHARED ${AUTOMOTIVE_SOURCES}) # DLL или SO предоставляет тот же C ABI, которым пользуется Python-порт.
set_target_properties(automotive PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS ON) # Прямой MCU API также доступен тестам DLL на Windows, помимо явно экспортированного ABI.
if(MINGW) # MinGW отключает автоматический экспорт при наличии хотя бы одного declspec(dllexport) в ABI.
target_link_options(automotive PRIVATE -Wl,--export-all-symbols) # Явный экспорт прямого API позволяет связать независимые C-тесты с этой же DLL.
endif() # Для MSVC экспорт настраивается штатным свойством CMake выше.
target_include_directories(automotive PUBLIC include ../set-protocol/include) # Публичные заголовки не включают STM32 HAL.
if(CMAKE_C_COMPILER_ID MATCHES "GNU|Clang") # Строгие предупреждения включаются только для совместимых компиляторов.
target_compile_options(automotive PRIVATE -Wall -Wextra -Werror -Wconversion -Wshadow -pedantic) # Ошибки знака, ширины и скрытые объявления останавливают сборку общего ядра.
endif() # MSVC сохраняет собственный синтаксис предупреждений.
include(CTest) # Переносимые тесты запускаются отдельно от аппаратных проверок OBD.
if(BUILD_TESTING) # Потребитель библиотеки может явно исключить тестовые исполняемые файлы.
foreach(suite protocols managers logger) # Каждый набор проверяет самостоятельный слой архитектуры.
add_executable(test_${suite} tests/test_${suite}.c) # Эталоны используют общий исходник теста без дублирования в прошивке.
target_link_libraries(test_${suite} PRIVATE automotive) # Проверяется действительно собранная библиотека.
add_test(NAME ${suite} COMMAND test_${suite}) # CTest учитывает фактический код завершения процесса.
endforeach() # Все переносимые наборы имеют одинаковые правила регистрации.
endif() # Аппаратный HAL и физическая CAN-шина для этих тестов не требуются.
+29
View File
@@ -0,0 +1,29 @@
# Общее ядро автомобильной диагностики
C11 без HAL и heap: ISO-TP Classic CAN, стандартный OBD, ограниченный UDS,
события диагностики, каталог PID, DTC, профили, FSM сервисных операций,
симулятор программирования в RAM, CLI и пассивный CAN logger.
Порты STM32 и SETGUI передают кадры в один и тот же движок.
`include/diag_engine.h` — прямой статический API для MCU;
`include/diag_abi.h` — версионируемый ABI для DLL/SO;
`../../python/automotive` — тонкая ctypes-оболочка без копии протоколов.
Часы в миллисекундах и физический CAN принадлежат порту.
`DIAG_OK` передачи означает принятие ограниченной очередью, а не ACK ECU.
Порт обязан сообщать физические ошибки через `auto_transport_error`.
Начальное состояние пассивное. `auto_enable(false)` отменяет текущую
транзакцию и отложенные кадры. Обнаружение использует только стандартные
0x7DF / 0x7E8..0x7EF; нормальная адресация ISO-TP поддерживает 11/29-битный ID.
Extended/mixed addressing, CAN FD и KWP не реализованы.
Реальные UDS-записи, исполнительные команды и перепрограммирование ECU
не подключены. Фирменные Ford/JLR ID, DID и Routine ID не выдумываются:
профили имеют статус UNVERIFIED до появления проверенной документации.
Mode 04 требует отдельного одноразового подтверждения.
Сборка и тесты: `cmake -S . -B build`, `cmake --build build`,
`ctest --test-dir build --output-on-failure`.
Общие зависимости `pcan_ring` и `gui_frame` берутся из соседнего `c/set-protocol`.
Полные сведения о плате HOPE, CLI, проверках и границах поддержки —
в документации проекта OBD.
+12
View File
@@ -0,0 +1,12 @@
#ifndef CAN_FRAME_H /* Отделяет переносимый формат кадра от STM32 HAL. */
#define CAN_FRAME_H /* Используется одновременно аппаратным драйвером и host-тестами протоколов. */
#include <stdbool.h> /* Тип признака extended не зависит от представления HAL. */
#include <stdint.h> /* CAN ID и миллисекундное время имеют фиксированную разрядность. */
typedef struct { /* Структура описывает только классический CAN, без аппаратного кода DLC. */
uint32_t id; /* Нормальный 11-битный CAN ID; поле допускает дальнейшее расширение до 29 бит. */
uint32_t timestamp_ms; /* Время приёма кадра позволяет отклонять устаревшие ответы. */
uint8_t data[8]; /* Максимум восемь байтов данных Classic CAN по ISO 11898. */
uint8_t length; /* Фактическое число значимых байтов CAN от нуля до восьми. */
bool extended; /* Истина резервируется для будущего расширения 29-битной адресации. */
} can_frame_t; /* Копия структуры не зависит от срока жизни аппаратного FIFO. */
#endif /* Завершает переносимое представление CAN-кадра. */
+14
View File
@@ -0,0 +1,14 @@
#ifndef CAN_LOGGER_H /* Защищает интерфейс форматирования и пассивного декодирования CAN-журнала. */
#define CAN_LOGGER_H /* Модуль не имеет физического передающего callback и не способен посылать FC на автомобиль. */
#include "diag_engine.h" /* Использует одно представление кадра, направления и ISO-TP контекста. */
typedef struct { uint32_t first_id, last_id; bool enabled; } can_log_filter_t; /* Фильтр журнала не меняет адреса активной диагностики. */
bool can_log_matches(const can_log_filter_t *filter, const can_frame_t *frame); /* Проверяет включённый диапазон до вывода или экспорта кадра. */
diag_status_t can_log_format(const auto_log_t *entry, bool csv, char *text, size_t capacity); /* Формирует только фактический DLC, временную метку и тип ID, с контролем выходной ёмкости. */
typedef void (*can_trace_notify_t)(uint32_t id, const uint8_t *payload, size_t length, void *user); /* Наблюдатель получает полный ISO-TP payload для анализа SID/NRC без второго транспортного алгоритма. */
struct can_trace_decoder; /* Обратная ссылка не требует глобального состояния наблюдателя. */
typedef struct { isotp_link_t tp; struct can_trace_decoder *owner; } can_trace_link_t; /* Каждый канал хранит собственный неизменяемый указатель на владельца. */
typedef struct can_trace_decoder { can_trace_link_t link[16]; can_trace_notify_t notify; void *user; uint32_t completed, malformed; } can_trace_decoder_t; /* Шестнадцать независимых направлений покрывают восемь стандартных OBD пар. */
void can_trace_init(can_trace_decoder_t *ctx, can_trace_notify_t notify, void *user); /* Создаёт исключительно пассивные виртуальные порты ISO-TP. */
void can_trace_feed(can_trace_decoder_t *ctx, const can_frame_t *frame, uint32_t now); /* Декодирует записанные SF/FF/CF, не создавая физического Flow Control. */
void can_trace_poll(can_trace_decoder_t *ctx, uint32_t now); /* Отмечает незавершённые последовательности по конечному N_Cr даже после окончания входящего потока. */
#endif /* Завершает интерфейс функционального CAN-журнала. */
+13
View File
@@ -0,0 +1,13 @@
#ifndef CLI_H /* Защищает интерфейс построчного парсера команд. */
#define CLI_H /* Парсер не зависит от HAL, UART и диагностического транспорта. */
#ifndef APP_CLI_LINE_CAPACITY /* Порт может переопределить ёмкость до подключения переносимого парсера. */
#define APP_CLI_LINE_CAPACITY 80U /* Восемьдесят байтов включают завершающий ноль и ограничивают память команды без зависимости от HAL. */
#endif /* Проектная конфигурация сохраняет приоритет над переносимым значением по умолчанию. */
#include <stdbool.h> /* Признак discard запрещает выполнение усечённых команд. */
#include <stdint.h> /* Входные байты UART имеют явную разрядность. */
typedef void (*cli_command_t)(const char *line, void *user); /* Исполнитель получает проверенную ограниченную строку только после перевода строки. */
typedef struct { char line[APP_CLI_LINE_CAPACITY]; uint32_t length; bool discard; cli_command_t execute; void *user; } cli_t; /* Единственный экземпляр не требует heap и безопасен для тестов на ПК. */
void cli_init(cli_t *ctx, cli_command_t execute, void *user); /* Устанавливает обработчик и очищает незавершённую команду. */
void cli_feed(cli_t *ctx, uint8_t byte); /* Принимает один символ, CRLF, backspace и отбрасывает слишком длинную строку целиком. */
void cli_reset_line(cli_t *ctx); /* После транспортной потери запрещает исполнение до следующего перевода строки. */
#endif /* Завершает интерфейс проверяемого отдельно парсера. */
+27
View File
@@ -0,0 +1,27 @@
#ifndef DIAG_ABI_H /* Защищает стабильный плоский ABI автомобильной диагностики. */
#define DIAG_ABI_H /* Порт Python вызывает только это C-ядро и не дублирует wire-правила. */
#include "diag_engine.h" /* Определяет тип события с фиксированными числовыми полями и текстом UTF-8. */
#if defined(_WIN32) /* Экспорт нужен только native DLL Windows, MCU компилирует обычные C-функции. */
#define AUTO_API __declspec(dllexport) /* Явно публикует символы независимо от настроек линкера. */
#else /* ELF и прошивка не требуют атрибута экспорта Windows. */
#define AUTO_API /* Сохраняет один заголовок для всех целевых платформ. */
#endif /* Завершает выбор атрибута ABI. */
AUTO_API uint32_t diagnostic_abi_version(void); /* Версия один закрепляет размеры и смысл аргументов этого интерфейса. */
AUTO_API uint32_t diagnostic_context_size(void); /* Host выделяет непрозрачный контекст без копирования внутренней структуры C. */
AUTO_API int diagnostic_init(void *memory, uint32_t size); /* Проверяет размер и выравнивание памяти до создания пассивного контекста. */
AUTO_API void diagnostic_enable(void *memory, int enabled); /* Отключение немедленно отменяет отложенный диагностический TX. */
AUTO_API int diagnostic_request(void *memory, uint32_t service, uint32_t parameter, uint32_t target, int confirmed, uint32_t now); /* Проверяет диапазоны до сужения целых аргументов ABI. */
AUTO_API int diagnostic_scan(void *memory, uint32_t now); /* Запускает стандартный OBD discovery без перебора всей CAN-шины. */
AUTO_API int diagnostic_uds(void *memory, uint32_t target, uint32_t service, uint32_t parameter, uint32_t now); /* Разрешения определяет C-менеджер UDS, а не GUI. */
AUTO_API void diagnostic_feed(void *memory, uint32_t id, const uint8_t *data, uint32_t length, int extended, uint32_t now); /* Получает только транспортные поля, сами протоколы разбираются внутри C. */
AUTO_API void diagnostic_poll(void *memory, uint32_t now); /* Продвигает все таймауты внешним монотонным временем. */
AUTO_API int diagnostic_tx(void *memory, uint32_t *id, uint8_t *data, uint32_t *length, uint32_t *extended); /* Выдаёт один готовый кадр без дополнительной упаковки протокола в Python. */
AUTO_API int diagnostic_event(void *memory, auto_event_t *event); /* Возвращает декодированные события общей очереди. */
AUTO_API int diagnostic_busy(void *memory); /* Истина означает текущую транзакцию либо продолжающееся сканирование карт PID. */
AUTO_API int diagnostic_supported(void *memory, uint32_t target, uint32_t pid); /* Карта возможностей принадлежит выбранному ECU в C-контексте. */
AUTO_API uint32_t diagnostic_pid_count(void); /* Каталог GUI формируется по реально реализованным формулам. */
AUTO_API uint32_t diagnostic_pid_code(uint32_t index); /* Некорректный индекс возвращает значение 256 за пределами однобайтового PID. */
AUTO_API const char *diagnostic_pid_name(uint32_t index); /* Возвращает неизменяемое имя UTF-8. */
AUTO_API const char *diagnostic_pid_unit(uint32_t index); /* Единица физического параметра приходит из того же C-каталога. */
AUTO_API void diagnostic_error(void *memory, uint32_t error); /* Отказ физического адаптера останавливает C-контекст и будущие CF/FC. */
#endif /* Завершает общий native ABI. */
+32
View File
@@ -0,0 +1,32 @@
#ifndef AUTO_DIAG_ENGINE_H /* Защищает общий интерфейс диагностики для MCU, DLL и симулятора. */
#define AUTO_DIAG_ENGINE_H /* Ни один протокольный алгоритм не требует Qt, ОС или HAL. */
#include "isotp.h" /* Все физические ECU используют один проверяемый транспортный автомат. */
#include "uds.h" /* UDS имеет независимые сессионные таймеры и ограничения сервисов. */
#include "obd2_pid.h" /* GUI получает каталог параметров из того же C-ядра, что прошивка. */
#define AUTO_ECU_COUNT 8U /* Стандартный диапазон OBD 0x7E8..0x7EF содержит восемь ответных адресов. */
#define AUTO_QUEUE_SIZE 16U /* Ограничивает память исходящих кадров и событий; одна позиция кольца резервируется. */
#define AUTO_EVENT_SIZE 128U /* Отдельная очередь вмещает 64 DTC одного ECU вместе со служебными событиями без потери кодов. */
typedef enum { AUTO_ECU = 1, AUTO_VALUE, AUTO_VIN, AUTO_DTC, AUTO_NRC, AUTO_DONE, AUTO_ERROR, AUTO_RAW, AUTO_UDS } auto_event_kind_t; /* Тип события определяет смысл числового значения и текста. */
typedef struct { uint32_t kind, ecu, service, parameter, code; int32_t value; char text[96]; } auto_event_t; /* Стабильные числовые поля и фиксированный текст упрощают безопасный C ABI. */
typedef struct { can_frame_t frame; uint32_t direction; } auto_log_t; /* direction=0 — RX, direction=1 — TX; timestamp хранится в кадре. */
struct auto_engine; /* Обратная ссылка канала не вводит зависимость протокола от аппаратуры. */
typedef struct { isotp_link_t tp; uds_t uds; struct auto_engine *owner; uint32_t maps[4]; uint8_t map_valid, map_attempted, slot; bool present; } auto_ecu_t; /* Собственные PID-карты и ISO-TP контексты исключают смешение ECU. */
typedef struct auto_engine { /* Контекст можно статически разместить в RAM микроконтроллера. */
auto_ecu_t ecu[AUTO_ECU_COUNT]; can_frame_t tx[AUTO_QUEUE_SIZE]; auto_event_t events[AUTO_EVENT_SIZE]; /* RX-события имеют отдельную ёмкость для полного списка DTC. */
auto_log_t log[128]; uint32_t log_head, log_tail, log_dropped, queue_dropped; /* Ограниченный журнал не исчерпывает память при длительном мониторинге. */
uint32_t tx_head, tx_tail, event_head, event_tail, now, started, last_request, interval_ms, replies, reply_mask, negative_mask; /* Маски исключают повторный вывод одного ответа ECU в текущей транзакции. */
uint16_t parameter; uint8_t service, target; bool enabled, active, ever_requested, scanning; /* Запуск по умолчанию полностью пассивен. */
} auto_engine_t; /* MCU использует прямой контекст, host может получить его размер через sizeof. */
void auto_init(auto_engine_t *ctx); /* Создаёт стандартные пары OBD ID без инициирования передачи. */
void auto_enable(auto_engine_t *ctx, bool enabled); /* Отключение отменяет транзакцию, сканирование и все отложенные TX. */
diag_status_t auto_request(auto_engine_t *ctx, uint8_t service, uint16_t parameter, uint8_t target, bool confirmed, uint32_t now); /* target=0..7 выбирает физический ECU; 255 означает стандартный функциональный запрос. */
diag_status_t auto_scan(auto_engine_t *ctx, uint32_t now); /* Ищет только стандартные ECU и последовательно получает объявленные карты PID00/20/40/60. */
diag_status_t auto_uds_request(auto_engine_t *ctx, uint8_t target, uint8_t service, uint16_t parameter, uint32_t now); /* Передаёт только запросы, разрешённые независимым менеджером UDS. */
void auto_feed(auto_engine_t *ctx, const can_frame_t *frame, uint32_t now); /* Регистрирует RX и передаёт кадр соответствующему активному ISO-TP соединению. */
void auto_poll(auto_engine_t *ctx, uint32_t now); /* Обслуживает ISO-TP, UDS и дальнейшие шаги сканирования без ожиданий. */
diag_status_t auto_take_tx(auto_engine_t *ctx, can_frame_t *frame); /* Порт обязан сообщить ошибку фактической передачи через auto_transport_error. */
diag_status_t auto_take_event(auto_engine_t *ctx, auto_event_t *event); /* GUI/CLI получают декодированные результаты без повторения протокольных формул. */
diag_status_t auto_take_log(auto_engine_t *ctx, auto_log_t *entry); /* Позволяет выгрузить журнал без динамического выделения памяти. */
void auto_transport_error(auto_engine_t *ctx, diag_status_t error); /* Отмена на bus-off, разрыве USB/COM и отказе отправки запрещает дальнейшие диагностические TX. */
int auto_pid_supported(const auto_engine_t *ctx, uint8_t target, uint8_t pid); /* Возвращает 1/0 для известной карты либо -1, если карта конкретного ECU ещё неизвестна. */
#endif /* Завершает общий диагностический движок, одинаковый для STM32 и SETGUI. */
+20
View File
@@ -0,0 +1,20 @@
#ifndef DIAG_STATUS_H /* Исключает повторное объявление общих результатов операций. */
#define DIAG_STATUS_H /* Объединяет аппаратные и протокольные ошибки одним интерфейсом. */
#include <stdint.h> /* Задаёт одинаковую разрядность времени на ПК и Cortex-M4. */
typedef enum { /* Каждый отказ возвращается вызывающему без бесконечного ожидания. */
DIAG_OK = 0, /* Операция завершена либо неблокирующий запрос принят в очередь. */
DIAG_EMPTY, /* В очереди пока нет данных; это штатное состояние опроса. */
DIAG_BUSY, /* Предыдущая операция ещё не завершена или действует ограничитель частоты. */
DIAG_INVALID, /* Аргумент, длина или формат сообщения нарушают контракт интерфейса. */
DIAG_OVERFLOW, /* Статический буфер заполнен; новые данные не перезаписывают старые. */
DIAG_TIMEOUT, /* Истёк программный предел ожидания в миллисекундах. */
DIAG_IO, /* HAL сообщил аппаратную ошибку или незавершённую передачу. */
DIAG_PASSIVE, /* Передача запрещена режимом прослушивания. */
DIAG_UNSUPPORTED, /* Возможность отсутствует в текущем этапе реализации. */
DIAG_BUS_OFF /* Контроллер отключён от CAN после накопления ошибок. */
} diag_status_t; /* Публичные функции не скрывают отказ под успешным результатом. */
static inline uint32_t diag_elapsed(uint32_t now, uint32_t since) /* Принимает значения одного миллисекундного счётчика HAL. */
{ /* Вычитание без знака сохраняет интервалы при переполнении HAL_GetTick. */
return now - since; /* Таймауты проекта существенно меньше половины диапазона uint32_t. */
} /* Завершает переносимый расчёт прошедшего времени. */
#endif /* Завершает интерфейс общих кодов ошибок. */
+16
View File
@@ -0,0 +1,16 @@
#ifndef ECU_PROGRAMMER_H /* Защищает исключительно симуляционную подсистему проверки обновления ECU. */
#define ECU_PROGRAMMER_H /* Здесь принципиально отсутствует выходной CAN callback для записи реального автомобиля. */
#include "diag_status.h" /* Проверки целостности, питания и последовательности возвращают явный отказ. */
#include <stdbool.h> /* Признаки подписи и питания не заменяются неявными значениями по умолчанию. */
#include <stddef.h> /* Ёмкости образа и блоков проверяются до копирования. */
typedef enum { PROGRAM_IDLE, PROGRAM_CHECK, PROGRAM_SESSION, PROGRAM_DOWNLOAD, PROGRAM_TRANSFER, PROGRAM_VERIFY, PROGRAM_COMPLETE, PROGRAM_FAILED, PROGRAM_CANCELLED } programmer_state_t; /* Реальный процесс разбит на наблюдаемые конечные шаги. */
typedef bool (*programmer_signature_t)(const uint8_t *image, size_t length, void *user); /* Легитимная проверка подписи подключается отдельно; отсутствие проверяющего не считается успешной подписью. */
typedef struct { uint32_t ecu_id, hardware, software, length, crc32; bool signed_image; programmer_signature_t verify_signature; void *signature_user; } programmer_manifest_t; /* Данные совместимости относятся только к описанному тестовому ECU. */
typedef struct { uint32_t ecu_id, hardware, software; uint8_t flash[1024]; size_t expected_length, received; uint8_t expected_sequence; bool download_open, power_good; } programming_simulator_t; /* Изолированная тестовая Flash — массив RAM, не периферия автомобиля. */
typedef struct { programmer_state_t state; programming_simulator_t *sim; programmer_manifest_t manifest; const uint8_t *image; uint32_t started, maximum_ms; size_t offset; uint8_t sequence, trace[64]; size_t trace_count; diag_status_t error; } ecu_programmer_t; /* Журнал содержит SID локальных этапов 0x10/0x34/0x36/0x37. */
void programming_simulator_init(programming_simulator_t *sim, uint32_t ecu_id, uint32_t hardware, uint32_t software); /* Создаёт явный виртуальный ECU без обращения к аппаратуре. */
diag_status_t programming_simulator_block(programming_simulator_t *sim, uint8_t sequence, const uint8_t *data, size_t length); /* Проверяет питание, открытый download, ожидаемый номер блока и границы RAM-образа. */
diag_status_t ecu_programmer_begin_simulation(ecu_programmer_t *ctx, programming_simulator_t *sim, const programmer_manifest_t *manifest, const uint8_t *image, size_t length, uint32_t now); /* Нет API запуска реального программирования без профиля, допускающего запись. */
void ecu_programmer_poll(ecu_programmer_t *ctx, uint32_t now); /* Передаёт максимум один локальный блок 32 байта за шаг и проверяет итоговый CRC. */
void ecu_programmer_cancel(ecu_programmer_t *ctx); /* Отменяет только виртуальный download без отправки ECU Reset или стирания автомобиля. */
#endif /* Любой будущий реальный backend требует отдельной спецификации ECU, подписи и политики разрешения. */
+27
View File
@@ -0,0 +1,27 @@
#ifndef ISOTP_H /* Защищает независимый от HAL транспортный интерфейс. */
#define ISOTP_H /* Общий автомат реализует SF, FF, CF и FC классического CAN с нормальной адресацией. */
#include <stddef.h> /* Размеры буферов передаются явно для контроля границ. */
#include <stdint.h> /* Кодек работает с байтами одинаково на ПК и MCU. */
#include "diag_status.h" /* Ошибки длины, последовательности и времени передаются порту едиными кодами. */
diag_status_t isotp_sf_encode(const uint8_t *payload, size_t length, uint8_t frame[8]); /* Кодирует от одного до семи байтов и дополняет кадр значением 0x55. */
diag_status_t isotp_sf_decode(const uint8_t *frame, size_t dlc, const uint8_t **payload, size_t *length); /* Проверяет PCI и длину; возвращённый срез живёт не дольше входного кадра. */
#include "can_frame.h" /* Формат CAN ID отделён от нормальной адресации ISO-TP. */
#define ISOTP_MAX_PAYLOAD 512U /* Статический предел сообщения ограничивает SRAM нескольких независимых ECU-соединений. */
typedef diag_status_t (*isotp_send_t)(const can_frame_t *frame, void *user); /* DIAG_BUSY означает временно занятый транспорт; DIAG_OK подтверждает принятие в ограниченную очередь CAN. */
typedef void (*isotp_receive_t)(const uint8_t *payload, size_t length, void *user); /* Полное сообщение передаётся синхронно в главном цикле до повторного использования RX-буфера. */
typedef struct { /* По одному экземпляру требуется для каждой пары физических CAN ID. */
uint32_t tx_id, rx_id, now, tx_since, rx_since, pending_since, last_cf; /* Время в миллисекундах приходит извне; системные часы и HAL не используются. */
uint32_t n_as, n_ar, n_bs, n_br, n_cs, n_cr; /* Пределы принятия TX/FC транспортом, ожидания FC, подготовки FC/CF и ожидания CF. */
uint8_t tx[ISOTP_MAX_PAYLOAD], rx[ISOTP_MAX_PAYLOAD]; /* Независимые буферы допускают одновременный приём и передачу. */
uint16_t tx_length, tx_offset, rx_length, rx_offset; /* Двенадцатибитная FF-длина дополнительно ограничивается ISOTP_MAX_PAYLOAD. */
uint8_t tx_state, rx_state, tx_sn, rx_sn, tx_bs, tx_count, rx_count, waits, stmin_ms, block_size, receive_stmin; /* Состояния и счётчики кадров не зависят от модели ECU. */
bool extended; /* Выбирает 11/29-битный CAN ID, сохраняя нормальную ISO-TP адресацию без дополнительного адресного байта. */
diag_status_t error; /* Последняя ошибка последовательности, таймаута либо транспорта наблюдаема приложением. */
isotp_send_t send; isotp_receive_t receive; void *user; /* Порты предоставляют только кадры и события, без копирования алгоритма ISO-TP. */
} isotp_link_t; /* Буферы и состояние целиком принадлежат вызывающему контексту. */
void isotp_init(isotp_link_t *link, uint32_t tx_id, uint32_t rx_id, bool extended, isotp_send_t send, isotp_receive_t receive, void *user); /* Устанавливает конечные таймауты и параметры FC по умолчанию. */
diag_status_t isotp_transmit(isotp_link_t *link, const uint8_t *payload, size_t length, uint32_t now); /* Запускает SF либо многокадровый TX, не ожидая FC в цикле. */
void isotp_on_frame(isotp_link_t *link, const can_frame_t *frame, uint32_t now); /* Разбирает SF/FF/CF/FC только своей пары ID и проверяет все границы. */
void isotp_poll(isotp_link_t *link, uint32_t now); /* Обслуживает ожидающие FC/CF и шесть классов протокольных таймаутов. */
void isotp_abort(isotp_link_t *link); /* Останавливает только программный обмен; физическую очередь отменяет владелец CAN-порта. */
#endif /* Завершает интерфейс ISO-TP Classic CAN с нормальной адресацией. */
@@ -0,0 +1,7 @@
#ifndef LANDROVER_SUSPENSION_H /* Защищает таблицу доступности процедур пневмоподвески. */
#define LANDROVER_SUSPENSION_H /* Список операций не является набором неподтверждённых CAN-команд. */
#include "vehicle_manager.h" /* Сохраняет независимый статус источника каждой операции. */
typedef struct { const char *name; profile_evidence_t evidence; uint16_t did, routine; uint8_t service; const char *source; } suspension_operation_t; /* Неизвестные идентификаторы явно нулевые и заблокированы статусом UNVERIFIED. */
const suspension_operation_t *landrover_suspension_operation(size_t index); /* Возвращает метаданные либо NULL при выходе за таблицу. */
size_t landrover_suspension_count(void); /* Позволяет UI перечислять неподтверждённые возможности с честным статусом. */
#endif /* Ни один клапан или компрессор не управляется по догадке. */
+8
View File
@@ -0,0 +1,8 @@
#ifndef OBD2_DTC_H /* Защищает интерфейс стандартных двухбайтовых DTC. */
#define OBD2_DTC_H /* Производительские расшифровки не выводятся из одного лишь номера кода. */
#include "diag_status.h" /* Некорректные длины возвращают общий код ошибки. */
#include <stddef.h> /* Количество кодов и ёмкость массива передаются отдельно. */
void obd2_dtc_format(uint16_t raw, char text[6]); /* Формирует пять символов P/C/B/U + четыре цифры и завершающий ноль. */
const char *obd2_dtc_description(uint16_t raw); /* Возвращает проверенное описание небольшого общего каталога либо явный текст об отсутствии расшифровки. */
diag_status_t obd2_dtc_decode(const uint8_t *payload, size_t length, uint16_t *codes, size_t capacity, size_t *count); /* Разбирает CAN-ответ Mode03/07/0A с байтом числа DTC после положительного SID. */
#endif /* Завершает общий API DTC. */
+11
View File
@@ -0,0 +1,11 @@
#ifndef OBD2_PID_H /* Защищает интерфейс формул стандартных PID. */
#define OBD2_PID_H /* Физические величины представлены без потери четвертей оборота. */
#include <stddef.h> /* Декодер проверяет фактическую длину ответа. */
#include <stdint.h> /* Сырой PID 0C занимает ровно шестнадцать бит. */
#include "diag_status.h" /* Ошибка формата не превращается в нулевые обороты. */
diag_status_t obd2_pid_rpm(const uint8_t *payload, size_t length, uint16_t *rpm_quarters); /* Возвращает RPM*4 для ответа 41 0C A B; формула RPM=(256*A+B)/4. */
typedef struct { uint8_t pid, bytes; const char *name, *unit; int32_t minimum_milli, maximum_milli; } obd_pid_info_t; /* Единый каталог используется прошивкой и GUI через C ABI без копирования формул. */
size_t obd2_pid_count(void); /* Возвращает число реализованных числовых PID в каталоге. */
const obd_pid_info_t *obd2_pid_info(size_t index); /* Возвращает неизменяемую запись либо NULL при выходе за таблицу. */
diag_status_t obd2_pid_decode(uint8_t pid, const uint8_t *data, size_t length, int32_t *milli); /* data содержит только байты параметра; milli задаёт тысячные доли единицы из каталога. */
#endif /* Завершает единый интерфейс каталога и формул PID. */
+15
View File
@@ -0,0 +1,15 @@
#ifndef SERVICE_MANAGER_H /* Защищает интерфейс конечного автомата сервисной процедуры. */
#define SERVICE_MANAGER_H /* Неизвестные ECU-команды отсутствуют; исполнение требует проверенного профиля. */
#include "uds.h" /* Категории READ_ONLY, ACTUATOR_CONTROL и другие общие для UDS и сервисных операций. */
#include "vehicle_manager.h" /* Статус доказательств проверяется независимо от наличия callback. */
typedef enum { SERVICE_IDLE, SERVICE_CHECK_PRECONDITIONS, SERVICE_SESSION_START, SERVICE_AUTHORIZATION, SERVICE_EXECUTE, SERVICE_WAIT_RESPONSE, SERVICE_VERIFY, SERVICE_COMPLETE, SERVICE_FAILED, SERVICE_CANCELLED, SERVICE_RECOVERY } service_state_t; /* Все состояния ТЗ представлены отдельными наблюдаемыми этапами. */
typedef diag_status_t (*service_step_t)(void *user, uint32_t now); /* Каждый callback выполняет один ограниченный шаг и возвращает DIAG_BUSY до завершения. */
typedef struct { uint32_t id, maximum_ms, recovery_ms; const char *name, *vehicle, *ecu, *source; uds_category_t category; profile_evidence_t evidence; bool needs_session, needs_authorization; service_step_t preconditions, independent_check, session, authorize, execute, verify, recover; } service_profile_t; /* Производительская последовательность хранится в проверяемом профиле и не выдумывается менеджером. */
typedef struct { const service_profile_t *profile; void *user; service_state_t state, final_state; uint32_t started, recovery_started; diag_status_t error; bool cancel_requested, touched_ecu, recovery_incomplete, first_check_done, state_changes_enabled; } service_manager_t; /* Защищённый режим изменения состояния по умолчанию выключен независимо от подтверждения отдельной операции. */
void service_manager_init(service_manager_t *ctx); /* Начинает в IDLE без сетевых действий. */
diag_status_t service_protected_mode(service_manager_t *ctx, bool enabled); /* Может менять разрешение воздействий только между процедурами; штатный CLI не включает этот режим. */
diag_status_t service_start(service_manager_t *ctx, const service_profile_t *profile, void *user, bool operator_confirmed, uint32_t now); /* Изменение состояния требует подтверждения, независимой проверки и процедуры безопасного завершения. */
void service_poll(service_manager_t *ctx, uint32_t now); /* Выполняет максимум один callback процедуры за шаг. */
void service_cancel(service_manager_t *ctx); /* После начала воздействия переводит процедуру в RECOVERY, а не предполагает выключение оборудования. */
void service_link_error(service_manager_t *ctx, diag_status_t error, uint32_t now); /* Отказ связи требует документированного безопасного завершения с отдельным конечным сроком. */
#endif /* Завершает проверяемый менеджер процедур. */
+14
View File
@@ -0,0 +1,14 @@
#ifndef UDS_H /* Защищает независимый от HAL менеджер UDS. */
#define UDS_H /* Операции изменения состояния выключены до подтверждённого профиля ECU. */
#include "diag_status.h" /* Общие результаты различают отрицательный ответ, ожидание и ошибку длины. */
#include <stdbool.h> /* Флаг разрешения сессии по умолчанию сброшен. */
#include <stddef.h> /* Длины запросов и ответов проверяются до чтения полей. */
typedef enum { UDS_READ_ONLY, UDS_SESSION_CONTROL, UDS_ACTUATOR_CONTROL, UDS_CALIBRATION, UDS_CONFIGURATION_WRITE, UDS_ECU_PROGRAMMING, UDS_DANGEROUS_OPERATION } uds_category_t; /* Категории не зависят от названия автомобиля. */
typedef struct { uint32_t started, phase_started, p2_ms, p2_star_ms, overall_ms; uint16_t did; uint8_t service, subfunction, nrc; bool active, pending, session_enabled; } uds_t; /* Контекст одной физической сессии не смешивается с остальными ECU. */
void uds_init(uds_t *ctx); /* Начинает с P2=1000 мс, P2*=5000 мс и полного запрета изменения состояния. */
uds_category_t uds_category(uint8_t service); /* Классифицирует сервис до формирования какого-либо CAN-кадра. */
diag_status_t uds_request(uds_t *ctx, uint8_t service, uint16_t parameter, uint32_t now, uint8_t *payload, size_t capacity, size_t *length); /* Реально формирует только 0x19, 0x22 и явно разрешённые 0x10/0x3E. */
diag_status_t uds_response(uds_t *ctx, const uint8_t *payload, size_t length, uint32_t now); /* Проверяет SID, эхо DID/подфункции, NRC и ResponsePending 0x78. */
diag_status_t uds_poll(uds_t *ctx, uint32_t now); /* Ограничивает P2, P2* и суммарное продление ожидания. */
const char *uds_nrc_name(uint8_t nrc); /* Возвращает стандартное обозначение NRC без производительских догадок. */
#endif /* Завершает интерфейс безопасного UDS. */
+16
View File
@@ -0,0 +1,16 @@
#ifndef VEHICLE_MANAGER_H /* Защищает реестр проверяемых автомобильных профилей. */
#define VEHICLE_MANAGER_H /* База данных и алгоритмы диагностического обмена разделены. */
#include "diag_status.h" /* Неподтверждённая конфигурация возвращает явный отказ. */
#include <stdbool.h> /* Проверенность источника хранится отдельно от наличия числового адреса. */
#include <stddef.h> /* Таблицы ECU имеют явное число элементов. */
typedef enum { PROFILE_SUPPORTED, PROFILE_DOCUMENTED_NOT_IMPLEMENTED, PROFILE_UNVERIFIED, PROFILE_UNSUPPORTED } profile_evidence_t; /* Статусы не позволяют принять найденный в сети ID за проверенную команду. */
typedef enum { VEHICLE_HS_CAN, VEHICLE_MS_CAN, VEHICLE_OTHER_CAN } vehicle_bus_t; /* Битрейт не подменяет электрический тип CAN-шины. */
typedef enum { VEHICLE_OBD_CAN, VEHICLE_UDS_CAN, VEHICLE_KWP_UNIMPLEMENTED } vehicle_protocol_t; /* KWP явно не выдаётся за реализованный CAN-протокол. */
typedef struct { const char *name; uint32_t request_id, response_id, bitrate, services; vehicle_bus_t bus; vehicle_protocol_t protocol; profile_evidence_t evidence; bool extended; const char *source; } vehicle_ecu_t; /* Адреса, сеть, протокол и источник проверяются вместе. */
typedef struct { const char *maker, *model, *generation; uint16_t first_year, last_year; const vehicle_ecu_t *ecu; size_t ecu_count; profile_evidence_t evidence; const char *limitations; } vehicle_profile_t; /* Нулевые годы означают отсутствие проверенных данных конкретного рынка. */
typedef struct { const vehicle_profile_t *profiles[16]; size_t count, selected; } vehicle_manager_t; /* Статический реестр допускает добавление пользовательских профилей без правки ядра. */
void vehicle_manager_init(vehicle_manager_t *ctx); /* Регистрирует Generic OBD, Focus Mk2/3/4, Discovery 3/4/5 и Range Rover/Sport. */
diag_status_t vehicle_register(vehicle_manager_t *ctx, const vehicle_profile_t *profile); /* Профиль живёт дольше менеджера; переполнение реестра возвращается явно. */
diag_status_t vehicle_select(vehicle_manager_t *ctx, size_t index); /* Выбор профиля сам по себе не включает диагностическую передачу. */
bool vehicle_ecu_verified(const vehicle_ecu_t *ecu); /* Разрешает активный маршрут лишь при статусе SUPPORTED и непустом источнике адресов. */
#endif /* Завершает безопасный реестр автомобильных данных. */
+36
View File
@@ -0,0 +1,36 @@
#include "can_logger.h" /* Пассивный анализатор повторно использует действующий ISO-TP автомат. */
#include <stdio.h> /* Ограниченный snprintf обеспечивает безопасный текстовый и CSV экспорт. */
#include <string.h> /* Контексты наблюдения выделяются вызывающим статически. */
bool can_log_matches(const can_log_filter_t *filter, const can_frame_t *frame) /* Нулевой фильтр означает отсутствие программного ограничения журнала. */
{ return frame != NULL && (filter == NULL || !filter->enabled || (frame->id >= filter->first_id && frame->id <= filter->last_id)); } /* Диапазон не зависит от численного совпадения standard и extended ID. */
diag_status_t can_log_format(const auto_log_t *entry, bool csv, char *text, size_t capacity) /* Входной frame.length определяет реальное число выводимых байтов. */
{ /* Ошибка длины не должна превратиться в чтение за восьмибайтовым массивом. */
if (entry == NULL || text == NULL || capacity == 0U || entry->frame.length > 8U) { return DIAG_INVALID; } /* Проверяет контракт до формирования любого поля. */
int written = snprintf(text, capacity, csv ? "%lu,%s,%lX,%u,%u," : "%lu %s %lX ext=%u [%u] ", (unsigned long)entry->frame.timestamp_ms, entry->direction == 0U ? "RX" : "TX", (unsigned long)entry->frame.id, (unsigned)entry->frame.extended, (unsigned)entry->frame.length); /* Миллисекунды, IDE и DLC сохраняются явно и не выводятся из ширины строки ID. */
if (written < 0 || (size_t)written >= capacity) { return DIAG_OVERFLOW; } size_t offset = (size_t)written; /* Отрицательный результат не приводится к большому беззнаковому смещению. */
for (uint8_t i = 0U; i < entry->frame.length; ++i) { written = snprintf(&text[offset], capacity - offset, i == 0U ? "%02X" : " %02X", entry->frame.data[i]); if (written < 0 || (size_t)written >= capacity - offset) { return DIAG_OVERFLOW; } offset += (size_t)written; } /* Padding за фактическим DLC не добавляется в экспорт как вымышленные байты. */
if (capacity - offset < 3U) { return DIAG_OVERFLOW; } memcpy(&text[offset], "\r\n", 3U); return DIAG_OK; /* Место резервируется также для CRLF и завершающего нулевого байта. */
} /* Завершает ограниченное форматирование одной записи. */
static diag_status_t passive_sink(const can_frame_t *frame, void *user) /* Виртуальный FC нужен только внутреннему состоянию анализатора записи. */
{ (void)frame; (void)user; return DIAG_OK; } /* Функция не имеет доступа к аппаратному порту и намеренно не передаёт кадр наружу. */
static void trace_payload(const uint8_t *payload, size_t length, void *user) /* Полное сообщение поступает из общего автомата ISO-TP. */
{ /* Контекст текущего канала передаётся наблюдателю только на время callback. */
can_trace_link_t *channel = user; can_trace_decoder_t *ctx = channel->owner; ctx->completed++; if (ctx->notify != NULL) { ctx->notify(channel->tp.rx_id, payload, length, ctx->user); } /* Канал и владелец связаны явно, поэтому несколько декодеров могут работать независимо. */
} /* Завершает публикацию полной пассивно собранной диагностической нагрузки. */
void can_trace_init(can_trace_decoder_t *ctx, can_trace_notify_t notify, void *user) /* Анализатор наблюдает оба направления стандартных физических OBD пар. */
{ /* Внешний передатчик не принимается интерфейсом и не сохраняется в контексте. */
if (ctx == NULL) { return; } memset(ctx, 0, sizeof(*ctx)); ctx->notify = notify; ctx->user = user; /* Новый файл журнала не наследует незавершённые сообщения прежнего файла. */
for (uint8_t i = 0U; i < 16U; ++i) { uint32_t receive = i < 8U ? 0x7E8U + i : 0x7E0U + i - 8U; uint32_t transmit = i < 8U ? receive - 8U : receive + 8U; ctx->link[i].owner = ctx; isotp_init(&ctx->link[i].tp, transmit, receive, false, passive_sink, trace_payload, &ctx->link[i]); ctx->link[i].tp.block_size = 0U; } /* Пассивная сборка не требует физического FC между блоками наблюдаемого трафика. */
} /* Завершает безопасное создание наблюдателя. */
void can_trace_feed(can_trace_decoder_t *ctx, const can_frame_t *frame, uint32_t now) /* Принимает как живые пассивные, так и сохранённые кадры в порядке времени. */
{ /* Функциональные OBD запросы всегда Single Frame и обрабатываются отдельно. */
if (ctx == NULL || frame == NULL || frame->extended || frame->length == 0U || frame->length > 8U) { return; } /* Не выдаёт неизвестную 29-битную топологию за стандартные пары ECU. */
if (frame->id == 0x7DFU) { const uint8_t *payload; size_t length; if (isotp_sf_decode(frame->data, frame->length, &payload, &length) == DIAG_OK) { ctx->completed++; if (ctx->notify != NULL) { ctx->notify(frame->id, payload, length, ctx->user); } } else { ctx->malformed++; } return; } /* Разбор функционального запроса не генерирует ответа на шину. */
if ((frame->data[0] >> 4U) == 3U) { return; } /* Наблюдаемый FC является управляющим кадром и не относится к собираемому диагностическому payload. */
for (uint8_t i = 0U; i < 16U; ++i) { isotp_link_t *link = &ctx->link[i].tp; if (link->rx_id != frame->id) { continue; } if ((frame->data[0] >> 4U) < 2U) { isotp_abort(link); } /* Новый SF/FF синхронизирует запись после возможной потери предыдущего сообщения. */
isotp_on_frame(link, frame, now); isotp_poll(link, now); /* Общий транспортный автомат собирает сообщение, виртуальный sink поглощает любой FC. */
if (link->error != DIAG_OK) { ctx->malformed++; link->error = DIAG_OK; } return; /* Наблюдатель не содержит физического порта даже при неполном или неверном сообщении. */
} /* Неизвестные ID остаются сырыми записями журнала без догадки о диагностической адресации. */
} /* Завершает пассивный анализ одного кадра. */
void can_trace_poll(can_trace_decoder_t *ctx, uint32_t now) /* Вызывается при чтении файла также после его последнего кадра. */
{ if (ctx != NULL) { for (uint8_t i = 0U; i < 16U; ++i) { isotp_poll(&ctx->link[i].tp, now); if (ctx->link[i].tp.error != DIAG_OK) { ctx->malformed++; ctx->link[i].tp.error = DIAG_OK; } } } } /* Таймаут незавершённой сборки не становится фиктивным успешным UDS-ответом. */
+19
View File
@@ -0,0 +1,19 @@
#include "cli.h" /* Подключает независимый от аппаратуры конечный автомат строки. */
#include <string.h> /* Обнуление контекста не выделяет динамическую память. */
void cli_init(cli_t *ctx, cli_command_t execute, void *user) /* Вызывается один раз до чтения UART. */
{ if (ctx != NULL) { memset(ctx, 0, sizeof(*ctx)); ctx->execute = execute; ctx->user = user; } } /* Сохраняет обработчик и гарантирует пустую, завершаемую нулём строку. */
void cli_reset_line(cli_t *ctx) /* Предупреждение о потере байтов приходит от UART-транспорта. */
{ if (ctx != NULL) { ctx->length = 0U; ctx->discard = true; } } /* Ни один фрагмент повреждённой команды не попадает в исполнитель. */
void cli_feed(cli_t *ctx, uint8_t byte) /* Обработка одного символа всегда ограничена константным временем. */
{ /* Команда исполняется исключительно после CR либо LF, никогда по заполнению буфера. */
if (ctx == NULL) { return; } /* Позволяет безопасно отклонить ошибочный контекст. */
if (byte == '\r' || byte == '\n') { /* Пара CRLF приводит к одной непустой команде и одной игнорируемой пустой строке. */
if (!ctx->discard && ctx->length != 0U && ctx->execute != NULL) { ctx->line[ctx->length] = '\0'; ctx->execute(ctx->line, ctx->user); } /* Передаёт только полную строку с проверенным терминатором. */
ctx->length = 0U; ctx->discard = false; return; /* Восстанавливает синхронизацию после переполнения или некорректного символа. */
} /* Завершает обработку границы команды. */
if (ctx->discard) { return; } /* Превышенную строку нельзя сделать исполнимой последующим backspace. */
if (byte == 8U || byte == 127U) { if (ctx->length != 0U) { ctx->length--; } return; } /* Поддерживает BS/DEL без выхода за начало массива. */
if ((byte < 32U && byte != '\t') || byte > 126U) { cli_reset_line(ctx); return; } /* Команды ASCII не принимают управляющие или многобайтовые символы как аргументы. */
if (ctx->length + 1U >= APP_CLI_LINE_CAPACITY) { cli_reset_line(ctx); return; } /* Всегда резервирует место под завершающий нулевой байт. */
ctx->line[ctx->length++] = (char)byte; /* Записывает символ только после полной проверки ёмкости. */
} /* Завершает неблокирующий шаг построчного парсера. */
+25
View File
@@ -0,0 +1,25 @@
#include "diag_abi.h" /* Плоские функции служат только адаптером типов, без второго диагностического автомата. */
#include <string.h> /* Входные байты копируются только после проверки длины. */
uint32_t diagnostic_abi_version(void) { return 1U; } /* Повышается при несовместимом изменении публичного ABI. */
uint32_t diagnostic_context_size(void) { return (uint32_t)sizeof(auto_engine_t); } /* Python не хранит собственной копии внутренней геометрии контекста. */
int diagnostic_init(void *memory, uint32_t size) /* Буфер принадлежит вызывающему и должен жить дольше сеанса. */
{ if (memory == NULL || size < sizeof(auto_engine_t) || (uintptr_t)memory % _Alignof(auto_engine_t) != 0U) { return DIAG_INVALID; } auto_init(memory); return DIAG_OK; } /* Проверяет ёмкость и выравнивание до первого обращения к C-структуре. */
void diagnostic_enable(void *memory, int enabled) { auto_enable(memory, enabled != 0); } /* Флаг ABI нормализуется в логическое значение C. */
int diagnostic_request(void *memory, uint32_t service, uint32_t parameter, uint32_t target, int confirmed, uint32_t now) /* Диапазоны проверяются до приведения к uint8_t и uint16_t. */
{ if (service > 255U || parameter > 65535U || (target >= AUTO_ECU_COUNT && target != 255U)) { return DIAG_INVALID; } return auto_request(memory, (uint8_t)service, (uint16_t)parameter, (uint8_t)target, confirmed != 0, now); } /* Нельзя обойти ограничения SID или ECU переполнением аргумента из GUI. */
int diagnostic_scan(void *memory, uint32_t now) { return auto_scan(memory, now); } /* Поиск целиком выполняется в общей C-реализации. */
int diagnostic_uds(void *memory, uint32_t target, uint32_t service, uint32_t parameter, uint32_t now) /* Аргументы физического UDS проверяются на границах ABI. */
{ if (target >= AUTO_ECU_COUNT || service > 255U || parameter > 65535U) { return DIAG_INVALID; } return auto_uds_request(memory, (uint8_t)target, (uint8_t)service, (uint16_t)parameter, now); } /* Даже произвольный вызов DLL не обходит политику запрещённых сервисов. */
void diagnostic_feed(void *memory, uint32_t id, const uint8_t *data, uint32_t length, int extended, uint32_t now) /* Длина ограничивается Classic CAN до копирования из Python-буфера. */
{ if (memory == NULL || data == NULL || length > 8U) { return; } can_frame_t frame = {0}; frame.id = id; frame.length = (uint8_t)length; frame.extended = extended != 0; frame.timestamp_ms = now; memcpy(frame.data, data, length); auto_feed(memory, &frame, now); } /* Флаг IDE задаёт только ширину CAN ID, не extended addressing ISO-TP. */
void diagnostic_poll(void *memory, uint32_t now) { auto_poll(memory, now); } /* Время передаётся явно и одинаково тестируется на MCU и ПК. */
int diagnostic_tx(void *memory, uint32_t *id, uint8_t *data, uint32_t *length, uint32_t *extended) /* Получатель предоставляет восьмибайтовый выходной буфер CAN. */
{ if (id == NULL || data == NULL || length == NULL || extended == NULL) { return DIAG_INVALID; } can_frame_t frame; diag_status_t result = auto_take_tx(memory, &frame); if (result == DIAG_OK) { *id = frame.id; *length = frame.length; *extended = frame.extended ? 1U : 0U; memcpy(data, frame.data, frame.length); } return result; } /* Поля изменяются только при наличии целого готового кадра. */
int diagnostic_event(void *memory, auto_event_t *entry) { return auto_take_event(memory, entry); } /* Текст и физические значения уже проверены C-ядром. */
int diagnostic_busy(void *memory) { auto_engine_t *ctx = memory; return ctx != NULL && (ctx->active || ctx->scanning); } /* Планировщик GUI не должен перекрывать незавершённую транзакцию. */
int diagnostic_supported(void *memory, uint32_t target, uint32_t pid) { return target < AUTO_ECU_COUNT && pid <= 255U ? auto_pid_supported(memory, (uint8_t)target, (uint8_t)pid) : -1; } /* Неполученная карта сохраняет состояние неизвестности. */
uint32_t diagnostic_pid_count(void) { return (uint32_t)obd2_pid_count(); } /* Количество строк таблицы берётся из реального каталога C. */
uint32_t diagnostic_pid_code(uint32_t index) { const obd_pid_info_t *info = obd2_pid_info(index); return info == NULL ? 256U : info->pid; } /* Зарезервированное значение исключает ошибочный PID00 при выходе за таблицу. */
const char *diagnostic_pid_name(uint32_t index) { const obd_pid_info_t *info = obd2_pid_info(index); return info == NULL ? "" : info->name; } /* UTF-8 строка принадлежит статическому каталогу. */
const char *diagnostic_pid_unit(uint32_t index) { const obd_pid_info_t *info = obd2_pid_info(index); return info == NULL ? "" : info->unit; } /* Порт GUI не содержит собственной таблицы физических единиц. */
void diagnostic_error(void *memory, uint32_t error) { auto_transport_error(memory, error <= DIAG_BUS_OFF ? (diag_status_t)error : DIAG_IO); } /* Некорректный внешний код нормализуется в явную аппаратную ошибку. */
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
+116
View File
@@ -0,0 +1,116 @@
#include "isotp.h" /* Подключает единственный публичный контракт кодека Single Frame. */
#include <string.h> /* Ограниченные memcpy и memset не требуют динамической памяти. */
diag_status_t isotp_sf_encode(const uint8_t *payload, size_t length, uint8_t frame[8]) /* Принимает полезную нагрузку нормальной 11-битной адресации. */
{ /* Один PCI-байт оставляет семь из восьми байтов классического CAN для данных. */
if (payload == NULL || frame == NULL || length == 0U || length > 7U) { return DIAG_INVALID; } /* Нулевая длина относится к неподдерживаемому escape-формату CAN FD. */
memset(frame, 0x55, 8U); /* Заполнитель 0x55 соответствует опубликованному примеру OBD-II и не входит в SF_DL. */
frame[0] = (uint8_t)length; /* Старшая тетрада PCI равна нулю, младшая содержит длину ISO-TP данных. */
memcpy(&frame[1], payload, length); /* Копирование безопасно после ограничения length семью байтами. */
return DIAG_OK; /* Выход содержит ровно восемь байтов классического CAN. */
} /* Завершает построение Single Frame без аппаратных зависимостей. */
diag_status_t isotp_sf_decode(const uint8_t *frame, size_t dlc, const uint8_t **payload, size_t *length) /* Разбирает только фактически полученные байты. */
{ /* Любая проверка PCI выполняется до доступа к полезной нагрузке. */
if (frame == NULL || payload == NULL || length == NULL || dlc < 2U || dlc > 8U) { return DIAG_INVALID; } /* Исключает пустые кадры, CAN FD и нулевые выходные указатели. */
if ((frame[0] & 0xF0U) != 0U) { return DIAG_UNSUPPORTED; } /* PCI типов 1/2/3 требует будущего автомата FF/CF/FC. */
*length = frame[0] & 0x0FU; /* SF_DL занимает четыре младших бита по ISO 15765-2. */
if (*length == 0U || *length > 7U || *length + 1U > dlc) { return DIAG_INVALID; } /* Не принимает усечённые данные и escape-последовательность CAN FD. */
*payload = &frame[1]; /* Передаёт срез без копирования после проверки его полного размещения в кадре. */
return DIAG_OK; /* Байты дополнения за SF_DL намеренно не трактуются как данные OBD-II. */
} /* Завершает проверенный разбор Single Frame. */
enum { TP_IDLE, TP_FIRST, TP_WAIT_FC, TP_CF, TP_SINGLE }; /* Внутренние состояния TX не смешиваются с типом CAN ID. */
enum { RX_IDLE, RX_FLOW, RX_CF, RX_OVERFLOW }; /* FC отправляется из poll и не требует протокольной работы в IRQ. */
static void tp_error(isotp_link_t *link, diag_status_t error) /* Общий отказ закрывает незавершённые сообщения без выдачи частичного payload. */
{ link->tx_state = TP_IDLE; link->rx_state = RX_IDLE; link->error = error; } /* Повторный обмен возможен только новым вызовом isotp_transmit. */
void isotp_abort(isotp_link_t *link) /* Смена скорости или отключение адаптера отменяет оба направления связи. */
{ if (link != NULL) { tp_error(link, DIAG_OK); } } /* Не генерирует CAN-команд и не предполагает отключение исполнительного механизма. */
void isotp_init(isotp_link_t *link, uint32_t tx_id, uint32_t rx_id, bool extended, isotp_send_t send, isotp_receive_t receive, void *user) /* Принимает независимо настраиваемые физические адреса. */
{ /* Таймеры конечны и могут быть уточнены документированным профилем ECU после init. */
if (link == NULL) { return; } /* Нулевой контекст не разыменовывается. */
memset(link, 0, sizeof(*link)); link->tx_id = tx_id; link->rx_id = rx_id; link->extended = extended; /* Канал не наследует старые данные и последовательности. */
link->send = send; link->receive = receive; link->user = user; /* Обработчики исполняются только в контексте вызывающего цикла. */
link->n_as = 100U; link->n_ar = 100U; link->n_bs = 1000U; link->n_br = 100U; link->n_cs = 100U; link->n_cr = 1000U; /* Значения в миллисекундах задают консервативные пределы программного порта, а не сертификацию ISO. */
link->block_size = 8U; link->receive_stmin = 5U; /* FC разрешает восемь CF за блок с интервалом пять миллисекунд. */
} /* Инициализация не отправляет сообщения. */
diag_status_t isotp_transmit(isotp_link_t *link, const uint8_t *payload, size_t length, uint32_t now) /* Передача полностью асинхронна относительно внешнего CAN. */
{ /* Максимум 512 байтов исключает переполнение статического хранилища. */
if (link == NULL || payload == NULL || link->send == NULL || length == 0U || length > ISOTP_MAX_PAYLOAD || link->tx_id > (link->extended ? 0x1FFFFFFFU : 0x7FFU)) { return DIAG_INVALID; } /* Не путает ширину CAN ID с режимом адресации ISO-TP. */
if (link->tx_state != TP_IDLE) { return DIAG_BUSY; } /* Новый payload не перезаписывает незавершённый TX. */
memcpy(link->tx, payload, length); link->tx_length = (uint16_t)length; link->tx_offset = 0U; link->tx_sn = 1U; /* Копия данных живёт до окончания всего многокадрового TX. */
link->tx_state = length <= 7U ? TP_SINGLE : TP_FIRST; link->pending_since = now; link->tx_since = now; link->waits = 0U; link->error = DIAG_OK; /* Первый кадр отправляется следующим poll с контролем N_As. */
return DIAG_OK; /* Принятый запрос ещё не означает, что удалённый ECU получил сообщение. */
} /* Завершает запуск SF либо FF без ожидания FC. */
static diag_status_t tp_send(isotp_link_t *link, can_frame_t *frame) /* Подготавливает общие поля всех четырёх типов кадра. */
{ frame->id = link->tx_id; frame->extended = link->extended; frame->length = 8U; frame->timestamp_ms = link->now; return link->send(frame, link->user); } /* Порт возвращает явный отказ либо принятие в ограниченную очередь. */
void isotp_on_frame(isotp_link_t *link, const can_frame_t *frame, uint32_t now) /* Принимает только кадры своего физического собеседника. */
{ /* Нормальная адресация использует первый байт данных под PCI при обоих форматах CAN ID. */
uint8_t type; size_t length; const uint8_t *payload; /* Доступ к данным начинается после проверки DLC. */
if (link == NULL || frame == NULL || frame->id != link->rx_id || frame->extended != link->extended) { return; } /* Другие ECU обрабатываются другими контекстами. */
link->now = now; /* Внешний монотонный tick используется без зависимости от HAL. */
if (frame->length == 0U || frame->length > 8U) { tp_error(link, DIAG_INVALID); return; } /* Исключает выход за массив и неявный CAN FD. */
if (link->rx_state == RX_CF && diag_elapsed(now, link->rx_since) >= link->n_cr) { tp_error(link, DIAG_TIMEOUT); return; } /* Просроченный CF не восстанавливает уже потерянную последовательность. */
type = frame->data[0] >> 4U; /* Старшая тетрада PCI задаёт SF=0, FF=1, CF=2, FC=3. */
if (type == 0U) { /* Single Frame не должен маскировать незавершённый многокадровый приём. */
if (link->rx_state != RX_IDLE || isotp_sf_decode(frame->data, frame->length, &payload, &length) != DIAG_OK) { tp_error(link, DIAG_INVALID); return; } /* Проверяет SF_DL до передачи среза клиенту. */
if (link->receive != NULL) { link->receive(payload, length, link->user); } return; /* Полный payload передаётся без промежуточного состояния. */
} /* Завершает приём одиночного кадра. */
if (type == 1U) { /* First Frame содержит двенадцатибитную общую длину и первые шесть байтов данных. */
if (frame->length != 8U || link->rx_state != RX_IDLE) { tp_error(link, DIAG_INVALID); return; } /* FF Classic CAN должен заполнять восьмибайтовый кадр. */
length = ((size_t)(frame->data[0] & 0x0FU) << 8U) | frame->data[1]; /* Escape-длины CAN FD и нулевая длина не поддерживаются. */
if (length <= 7U) { tp_error(link, DIAG_INVALID); return; } /* Малое сообщение обязано использовать Single Frame. */
link->rx_since = now; link->rx_length = (uint16_t)length; link->rx_offset = 6U; link->rx_sn = 1U; link->rx_count = 0U; /* Подготавливает независимую последовательность RX. */
if (length > ISOTP_MAX_PAYLOAD) { link->rx_state = RX_OVERFLOW; link->error = DIAG_OVERFLOW; return; } /* Сначала планирует FC Overflow, не копируя данные за границы массива. */
memcpy(link->rx, &frame->data[2], 6U); link->rx_state = RX_FLOW; return; /* CTS будет отправлен ближайшим poll до приёма CF. */
} /* Завершает проверку First Frame. */
if (type == 2U) { /* Consecutive Frame должен продолжать только подтверждённую CTS последовательность. */
if (link->rx_state != RX_CF || frame->length < 2U || (frame->data[0] & 0x0FU) != link->rx_sn) { tp_error(link, DIAG_INVALID); return; } /* SN проверяется до изменения данных и смещения. */
length = link->rx_length - link->rx_offset; if (length > 7U) { length = 7U; } /* Последний CF может содержать меньше семи полезных байтов. */
if (frame->length < length + 1U) { tp_error(link, DIAG_INVALID); return; } /* Усечённый CF не выдаётся за полное сообщение. */
memcpy(&link->rx[link->rx_offset], &frame->data[1], length); link->rx_offset += (uint16_t)length; /* Общая длина уже ограничена размером RX-буфера на FF. */
link->rx_sn = (uint8_t)((link->rx_sn + 1U) & 0x0FU); link->rx_since = now; link->rx_count++; /* SN циклически переходит с пятнадцати на ноль по ISO 15765-2. */
if (link->rx_offset == link->rx_length) { link->rx_state = RX_IDLE; if (link->receive != NULL) { link->receive(link->rx, link->rx_length, link->user); } } /* Клиент получает только полностью собранный payload. */
else if (link->block_size != 0U && link->rx_count >= link->block_size) { link->rx_state = RX_FLOW; link->rx_count = 0U; } /* После заданного блока CF требуется новый Flow Control. */
return; /* Padding последнего CF не входит в payload. */
} /* Завершает приём Consecutive Frame. */
if (type == 3U) { /* Flow Control относится только к текущему многокадровому TX. */
if (link->tx_state != TP_WAIT_FC || frame->length < 3U || diag_elapsed(now, link->tx_since) >= link->n_bs) { tp_error(link, DIAG_INVALID); return; } /* Чужой или усечённый FC не меняет скорость и последовательность TX. */
uint8_t flow = frame->data[0] & 0x0FU; /* Flow Status различает CTS=0, WAIT=1, Overflow=2. */
if (flow == 1U) { if (++link->waits > 3U) { tp_error(link, DIAG_TIMEOUT); } else { link->tx_since = now; } return; } /* Максимум три WAIT не допускают бесконечного продления N_Bs. */
if (flow != 0U) { tp_error(link, flow == 2U ? DIAG_OVERFLOW : DIAG_INVALID); return; } /* Overflow и зарезервированные значения немедленно прекращают TX. */
uint8_t stmin = frame->data[2]; /* STmin 0..127 задаётся в мс, 0xF1..0xF9 — в сотнях микросекунд. */
if (stmin > 0x7FU && (stmin < 0xF1U || stmin > 0xF9U)) { tp_error(link, DIAG_INVALID); return; } /* Не принимает зарезервированный STmin как нулевую задержку. */
link->stmin_ms = stmin <= 0x7FU ? stmin : 1U; link->tx_bs = frame->data[1]; link->tx_count = 0U; /* Субмиллисекундный STmin консервативно округляется вверх до одного миллисекундного тика. */
link->last_cf = now; link->pending_since = now; link->tx_state = TP_CF; return; /* Первый CF также соблюдает полученный интервал после CTS. */
} /* Завершает обработку Flow Control. */
tp_error(link, DIAG_INVALID); /* Зарезервированные PCI не попадают в диагностический декодер. */
} /* Завершает один конечный шаг приёма ISO-TP. */
void isotp_poll(isotp_link_t *link, uint32_t now) /* Вызывается независимо для каждой диагностической пары ID. */
{ /* За вызов отправляется максимум один FC и один кадр данных; нет циклов ожидания ответа. */
can_frame_t frame = {0}; diag_status_t result; size_t count; /* Локальный кадр копируется CAN-портом до возврата send. */
if (link == NULL || link->send == NULL) { return; } link->now = now; /* Без выходного порта автомат не обращается к аппаратуре. */
if (link->rx_state == RX_CF && diag_elapsed(now, link->rx_since) >= link->n_cr) { tp_error(link, DIAG_TIMEOUT); return; } /* N_Cr ограничивает ожидание каждого следующего CF. */
if (link->rx_state == RX_FLOW || link->rx_state == RX_OVERFLOW) { /* Подготовка FC не выполняется в обработчике CAN IRQ. */
if (diag_elapsed(now, link->rx_since) >= link->n_br || diag_elapsed(now, link->rx_since) >= link->n_ar) { tp_error(link, DIAG_TIMEOUT); return; } /* N_Br и N_Ar ограничивают задержку программной подготовки и принятия FC транспортом. */
memset(frame.data, 0x55, 8U); frame.data[0] = link->rx_state == RX_OVERFLOW ? 0x32U : 0x30U; /* FC Overflow не разрешает отправителю продолжить слишком длинное сообщение. */
frame.data[1] = link->block_size; frame.data[2] = link->receive_stmin; result = tp_send(link, &frame); /* CTS сообщает реальный размер блока и требуемую паузу. */
if (result == DIAG_OK) { link->rx_state = link->rx_state == RX_OVERFLOW ? RX_IDLE : RX_CF; link->rx_since = now; } /* N_Cr начинается только после принятия FC транспортом. */
else if (result != DIAG_BUSY) { tp_error(link, result); return; } /* Временная занятость допускается только до конечного N_Ar. */
} /* Завершает один шаг Flow Control. */
if (link->tx_state == TP_IDLE) { return; } /* Пассивный контекст не создаёт периодических сообщений. */
if (link->tx_state == TP_WAIT_FC) { if (diag_elapsed(now, link->tx_since) >= link->n_bs) { tp_error(link, DIAG_TIMEOUT); } return; } /* N_Bs ограничивает ожидание CTS/WAIT после FF либо блока CF. */
if (link->tx_state == TP_CF && diag_elapsed(now, link->last_cf) < link->stmin_ms) { return; } /* Не отправляет CF раньше разрешённого интервала STmin. */
uint32_t elapsed = diag_elapsed(now, link->pending_since); /* Отсчитывает подготовку нового TX с момента, когда он стал допустим. */
uint32_t allowance = link->tx_state == TP_CF ? (uint32_t)link->stmin_ms + link->n_cs : link->n_as; /* N_Cs не включает обязательный запрет раннего CF по STmin. */
if (elapsed >= allowance) { tp_error(link, DIAG_TIMEOUT); return; } /* Занятый CAN-порт не удерживает сообщение бесконечно. */
memset(frame.data, 0x55, 8U); count = 0U; /* Каждый кадр имеет детерминированный padding вне полезных данных. */
if (link->tx_state == TP_SINGLE) { result = isotp_sf_encode(link->tx, link->tx_length, frame.data); if (result != DIAG_OK) { tp_error(link, result); return; } } /* SF использует тот же проверенный кодек, что OBD и тесты. */
else if (link->tx_state == TP_FIRST) { frame.data[0] = (uint8_t)(0x10U | (link->tx_length >> 8U)); frame.data[1] = (uint8_t)link->tx_length; memcpy(&frame.data[2], link->tx, 6U); count = 6U; } /* FF передаёт длину и первые шесть байтов без escape-расширения. */
else { count = link->tx_length - link->tx_offset; if (count > 7U) { count = 7U; } frame.data[0] = (uint8_t)(0x20U | link->tx_sn); memcpy(&frame.data[1], &link->tx[link->tx_offset], count); } /* CF переносит до семи оставшихся байтов с текущим SN. */
result = tp_send(link, &frame); /* Одна попытка постановки кадра в CAN за шаг автомата. */
if (result == DIAG_BUSY) { return; } if (result != DIAG_OK) { tp_error(link, result); return; } /* Не сдвигает смещение, пока транспорт действительно не принял кадр. */
if (link->tx_state == TP_SINGLE) { link->tx_state = TP_IDLE; return; } /* Однокадровая передача завершает программную сегментацию. */
link->tx_offset += (uint16_t)count; link->tx_since = now; link->pending_since = now; /* Смещение продвигается только по успешно принятому транспортом кадру. */
if (link->tx_state == TP_FIRST) { link->tx_state = TP_WAIT_FC; return; } /* CF запрещён до первого CTS. */
link->last_cf = now; link->tx_sn = (uint8_t)((link->tx_sn + 1U) & 0x0FU); link->tx_count++; /* Каждый следующий CF получает следующий SN с переходом через ноль. */
if (link->tx_offset == link->tx_length) { link->tx_state = TP_IDLE; } /* Последний принятый транспортом CF завершает TX. */
else if (link->tx_bs != 0U && link->tx_count >= link->tx_bs) { link->tx_state = TP_WAIT_FC; } /* Нулевой BS разрешает все CF, ненулевой требует нового CTS после блока. */
} /* Завершает ограниченный шаг передачи и контроля таймаутов. */
+12
View File
@@ -0,0 +1,12 @@
#include "landrover_suspension.h" /* Модуль хранит только проверяемую доступность процедур конкретной системы JLR. */
static const suspension_operation_t operations[] = { /* Все источники пока отсутствуют, поэтому активный маршрут для этих записей не создаётся. */
{"Ошибки подвески", PROFILE_UNVERIFIED, 0U, 0U, 0U, "Нужен подтверждённый адрес и протокол ECU"}, /* Стандартные OBD DTC двигателя не подменяют ошибки подвески. */
{"Высота и датчики каждого колеса", PROFILE_UNVERIFIED, 0U, 0U, 0U, "Нужны DID и масштабы по конкретному ECU"}, /* Четыре высоты нельзя достоверно вывести без фирменных формул. */
{"Давление, компрессор и клапаны", PROFILE_UNVERIFIED, 0U, 0U, 0U, "Нужны проверенные параметры состояния"}, /* Состояние оборудования не предполагается по одному CAN ID. */
{"Проверка компрессора и клапанов", PROFILE_UNVERIFIED, 0U, 0U, 0U, "Нужны условия, команда и подтверждённое безопасное завершение"}, /* Прекращение сообщений не считается командой выключения. */
{"Диагностика утечек", PROFILE_UNVERIFIED, 0U, 0U, 0U, "Нужна официальная процедура ECU"}, /* Время и давление процедуры не выбираются произвольно. */
{"Калибровка высоты", PROFILE_UNVERIFIED, 0U, 0U, 0U, "Нужны Routine ID, допуски и легитимная авторизация"}, /* Запись калибровки отключена до подтверждённого профиля. */
{"Вход и выход из сервисного режима", PROFILE_UNVERIFIED, 0U, 0U, 0U, "Нужна документированная последовательность для VIN"} /* Сервисный режим не считается универсальным для всех JLR поколений. */
}; /* Здесь намеренно нет исполняемых вымышленных DID или Routine ID. */
size_t landrover_suspension_count(void) { return sizeof(operations) / sizeof(operations[0]); } /* Размер вычисляется по фактической таблице. */
const suspension_operation_t *landrover_suspension_operation(size_t index) { return index < landrover_suspension_count() ? &operations[index] : NULL; } /* Границы проверяются до чтения записи. */
+29
View File
@@ -0,0 +1,29 @@
#include "obd2_dtc.h" /* Подключает единый кодек DTC, применяемый прошивкой и GUI. */
void obd2_dtc_format(uint16_t raw, char text[6]) /* Битовая упаковка соответствует стандартному пятисимвольному OBD коду. */
{ /* Первый символ задаётся двумя старшими битами, последующие четыре — остальными четырнадцатью битами. */
static const char groups[] = "PCBU", hex[] = "0123456789ABCDEF"; /* Порядок P/C/B/U соответствует битам класса 00/01/10/11. */
if (text == NULL) { return; } /* Отсутствующий выходной буфер не разыменовывается. */
text[0] = groups[(raw >> 14U) & 3U]; text[1] = hex[(raw >> 12U) & 3U]; /* Вторая цифра ограничена двумя битами и принимает значения 0..3. */
text[2] = hex[(raw >> 8U) & 15U]; text[3] = hex[(raw >> 4U) & 15U]; text[4] = hex[raw & 15U]; text[5] = '\0'; /* Маски извлекают три шестнадцатеричных разряда и завершают строку. */
} /* Завершает форматирование без sprintf и heap. */
const char *obd2_dtc_description(uint16_t raw) /* Ограниченный каталог не объявляется полной базой SAE либо Ford/JLR. */
{ /* Неизвестный код сохраняет числовое представление для поиска в документации ECU. */
switch (raw) { /* Стандартные общеупотребительные коды приведены для проверки базового декодирования. */
case 0x0100U: return "Цепь датчика массового расхода воздуха"; /* P0100 относится к цепи MAF. */
case 0x0115U: return "Цепь датчика температуры охлаждающей жидкости"; /* P0115 относится к цепи ECT. */
case 0x0133U: return "Медленный отклик кислородного датчика B1S1"; /* P0133 используется в опубликованном примере ELM327. */
case 0x0300U: return "Случайные или множественные пропуски воспламенения"; /* P0300 не указывает на конкретный цилиндр. */
case 0x0301U: return "Пропуски воспламенения в цилиндре 1"; /* P0301 задаёт конкретный первый цилиндр. */
case 0x0420U: return "Эффективность катализатора ниже порога, банк 1"; /* P0420 не должен трактоваться как указание на второй банк. */
default: return "Расшифровка отсутствует; нужна документация ECU"; /* Производительский код не получает выдуманного описания. */
} /* Завершает ограниченный проверяемый каталог. */
} /* Возвращённая неизменяемая строка живёт всё время работы программы. */
diag_status_t obd2_dtc_decode(const uint8_t *payload, size_t length, uint16_t *codes, size_t capacity, size_t *count) /* На CAN число DTC располагается сразу после SID по примеру ELM Electronics. */
{ /* Проверка длины предшествует чтению любой пары DTC. */
if (payload == NULL || count == NULL || codes == NULL || length < 2U || (payload[0] != 0x43U && payload[0] != 0x47U && payload[0] != 0x4AU)) { return DIAG_INVALID; } /* Разрешает только ответы сохранённых, pending и permanent DTC. */
size_t declared = payload[1]; /* Число кодов берётся из payload, а не из MIL другого ECU. */
if (declared > (length - 2U) / 2U || length != 2U + declared * 2U) { return DIAG_INVALID; } /* ISO-TP длина не включает CAN padding и должна точно совпадать с числом двухбайтовых записей. */
if (declared > capacity) { return DIAG_OVERFLOW; } /* Не возвращает усечённый список как полный результат. */
for (size_t i = 0U; i < declared; ++i) { codes[i] = (uint16_t)(((uint16_t)payload[2U + i * 2U] << 8U) | payload[3U + i * 2U]); } /* Старший байт каждого кода расположен первым. */
*count = declared; return DIAG_OK; /* Нулевое число DTC является корректным положительным результатом. */
} /* Завершает декодер без зависимости от транспорта. */
+44
View File
@@ -0,0 +1,44 @@
#include "obd2_pid.h" /* Использует проверяемую независимо от транспорта формулу RPM. */
diag_status_t obd2_pid_rpm(const uint8_t *payload, size_t length, uint16_t *rpm_quarters) /* Ожидает ISO-TP payload без PCI и CAN padding. */
{ /* SID и PID проверяются вместе с длиной, чтобы не принять чужой ответ за обороты. */
if (payload == NULL || rpm_quarters == NULL || length != 4U || payload[0] != 0x41U || payload[1] != 0x0CU) { return DIAG_INVALID; } /* Положительный ответ Mode 01 имеет SID 0x01+0x40 и ровно два байта RPM. */
*rpm_quarters = (uint16_t)(((uint16_t)payload[2] << 8U) | payload[3]); /* A — старший байт; сохранение значения до деления исключает потерю шагов 0,25 об/мин. */
return DIAG_OK; /* Представление допускает диапазон 0..16383,75 об/мин по SAE J1979 PID 0C. */
} /* Завершает целочисленный декодер без требований к printf float. */
static const obd_pid_info_t catalog[] = { /* Стандартные PID Mode01 по SAE J1979; производительские значения здесь не размещаются. */
{0x04U, 1U, "Расчётная нагрузка", "%", 0, 100000}, /* Нагрузка A*100/255 процентов, полный диапазон одного байта. */
{0x05U, 1U, "Температура ОЖ", "degC", -40000, 215000}, /* Температура A-40 градусов Цельсия. */
{0x06U, 1U, "Краткосрочная коррекция B1", "%", -100000, 99219}, /* Коррекция топлива (A-128)*100/128 процентов. */
{0x07U, 1U, "Долгосрочная коррекция B1", "%", -100000, 99219}, /* Сохраняемая коррекция первого банка, та же стандартная формула. */
{0x08U, 1U, "Краткосрочная коррекция B2", "%", -100000, 99219}, /* Второй банк поддерживается только при объявлении PID соответствующим ECU. */
{0x09U, 1U, "Долгосрочная коррекция B2", "%", -100000, 99219}, /* Неподдерживаемый банк не получает выдуманного нулевого значения. */
{0x0BU, 1U, "Давление во впуске", "kPa", 0, 255000}, /* Абсолютное давление равно A кПа. */
{0x0CU, 2U, "Обороты двигателя", "rpm", 0, 16383750}, /* RPM=(256*A+B)/4 с разрешением четверть оборота в минуту. */
{0x0DU, 1U, "Скорость автомобиля", "km/h", 0, 255000}, /* Скорость равна A км/ч. */
{0x0FU, 1U, "Температура воздуха", "degC", -40000, 215000}, /* Температура впускного воздуха равна A-40 градусов Цельсия. */
{0x10U, 2U, "Массовый расход воздуха", "g/s", 0, 655350}, /* MAF=(256*A+B)/100 граммов в секунду. */
{0x11U, 1U, "Положение дросселя", "%", 0, 100000}, /* Положение A*100/255 процентов. */
{0x1CU, 1U, "Стандарт OBD", "code", 0, 255000}, /* Числовой код соответствия OBD, без выдуманной расшифровки зарезервированных значений. */
{0x1FU, 2U, "Время работы двигателя", "s", 0, 65535000}, /* Время (256*A+B) секунд после запуска. */
{0x42U, 2U, "Напряжение ECU", "V", 0, 65535} /* Напряжение (256*A+B)/1000 вольт, только при поддержке PID42 данным ECU. */
}; /* Список возможностей GUI формируется из этой таблицы C. */
size_t obd2_pid_count(void) { return sizeof(catalog) / sizeof(catalog[0]); } /* Размер вычисляется компилятором и не расходится с фактическим каталогом. */
const obd_pid_info_t *obd2_pid_info(size_t index) { return index < obd2_pid_count() ? &catalog[index] : NULL; } /* Проверка индекса предшествует обращению к массиву. */
diag_status_t obd2_pid_decode(uint8_t pid, const uint8_t *data, size_t length, int32_t *milli) /* Нормализует числовые PID для MCU и ПК одним алгоритмом. */
{ /* Все вычисления помещаются в int32_t при диапазонах каталога. */
const obd_pid_info_t *info = NULL; int32_t raw; /* Информация выбирается только из реализованного каталога. */
if (data == NULL || milli == NULL) { return DIAG_INVALID; } /* Выходной результат не изменяется при неправильных указателях. */
for (size_t i = 0U; i < obd2_pid_count(); ++i) { if (catalog[i].pid == pid) { info = &catalog[i]; break; } } /* Малый фиксированный каталог не требует heap либо хеш-таблицы. */
if (info == NULL) { return DIAG_UNSUPPORTED; } if (length != info->bytes) { return DIAG_INVALID; } /* Неподдерживаемый PID отличается от усечённого ответа. */
raw = data[0]; if (length == 2U) { raw = raw * 256 + data[1]; } /* Двухбайтовые PID используют старший байт A по SAE J1979. */
switch (pid) { /* Формулы находятся только здесь и не повторяются в Python или Qt. */
case 0x04U: case 0x11U: *milli = (raw * 100000 + 127) / 255; break; /* Проценты округляются до тысячной доли после масштабирования A/255. */
case 0x05U: case 0x0FU: *milli = (raw - 40) * 1000; break; /* Температурное смещение применяется до перевода в тысячные градуса. */
case 0x06U: case 0x07U: case 0x08U: case 0x09U: *milli = (raw - 128) * 100000 / 128; break; /* Коррекция топлива допускает отрицательный результат до минус ста процентов. */
case 0x0CU: *milli = raw * 250; break; /* Тысячная RPM равна четверти исходного целого, умноженной на тысячу. */
case 0x10U: *milli = raw * 10; break; /* Сотые грамма в секунду переводятся в тысячные умножением на десять. */
case 0x42U: *milli = raw; break; /* Сырой PID уже выражен в милливольтах. */
default: *milli = raw * 1000; break; /* Оставшиеся каталогизированные PID имеют единичный масштаб A либо AB. */
} /* Завершает выбор стандартной формулы. */
return DIAG_OK; /* Значение сохраняет физическую единицу из неизменяемого каталога. */
} /* Завершает общий декодер физических величин без float. */
+38
View File
@@ -0,0 +1,38 @@
#include "service_manager.h" /* Менеджер исполняет только явно переданную проверенную процедуру. */
#include <string.h> /* Контекст не требует динамической памяти. */
void service_manager_init(service_manager_t *ctx) { if (ctx != NULL) { memset(ctx, 0, sizeof(*ctx)); } } /* Нулевое состояние соответствует SERVICE_IDLE и не запускает операции. */
static bool running(service_state_t state) { return state != SERVICE_IDLE && state != SERVICE_COMPLETE && state != SERVICE_FAILED && state != SERVICE_CANCELLED; } /* Терминальные состояния никогда не повторяют execute автоматически. */
static bool changes(const service_profile_t *profile) { return profile->category != UDS_READ_ONLY || profile->needs_session || profile->needs_authorization; } /* Даже чтение через изменение сессии требует защищённого режима и безопасного завершения. */
diag_status_t service_protected_mode(service_manager_t *ctx, bool enabled) { if (ctx == NULL) { return DIAG_INVALID; } if (running(ctx->state)) { return DIAG_BUSY; } ctx->state_changes_enabled = enabled; return DIAG_OK; } /* Штатный запуск остаётся READ_ONLY; приложение не содержит команды снятия этой блокировки. */
diag_status_t service_start(service_manager_t *ctx, const service_profile_t *profile, void *user, bool operator_confirmed, uint32_t now) /* Проверяет доступность и безопасность до первого callback. */
{ /* Одного подтверждения недостаточно для неподтверждённого профиля. */
if (ctx == NULL || profile == NULL || profile->maximum_ms == 0U || profile->maximum_ms >= 0x80000000U) { return DIAG_INVALID; } if (running(ctx->state)) { return DIAG_BUSY; } /* Длительность конечна и однозначна через переполнение tick. */
if (profile->evidence != PROFILE_SUPPORTED || profile->source == NULL || profile->source[0] == '\0' || profile->execute == NULL || profile->verify == NULL || profile->preconditions == NULL) { return DIAG_UNSUPPORTED; } /* Пустые функции и неизвестные последовательности не выдаются за доступную процедуру. */
if (changes(profile) && (!ctx->state_changes_enabled || !operator_confirmed || profile->independent_check == NULL || profile->recover == NULL || profile->recovery_ms == 0U || profile->recovery_ms >= 0x80000000U)) { return DIAG_PASSIVE; } /* Нужны защищённый режим, отдельное подтверждение, независимая проверка и документированное завершение. */
if ((profile->needs_session && profile->session == NULL) || (profile->needs_authorization && profile->authorize == NULL)) { return DIAG_UNSUPPORTED; } /* Авторизация подключается только легитимным провайдером; seed/key обхода нет. */
bool protected_mode = ctx->state_changes_enabled; service_manager_init(ctx); ctx->state_changes_enabled = protected_mode; ctx->profile = profile; ctx->user = user; ctx->started = now; ctx->state = SERVICE_CHECK_PRECONDITIONS; return DIAG_OK; /* Сохраняет явно выбранную политику между операциями, не включая её автоматически. */
} /* Завершает подготовку процедуры. */
static void stop_operation(service_manager_t *ctx, service_state_t final_state, diag_status_t error, uint32_t now) /* Общий путь отказа, отмены и истечения срока. */
{ ctx->error = error; ctx->final_state = final_state; if (ctx->touched_ecu && changes(ctx->profile)) { ctx->state = SERVICE_RECOVERY; ctx->recovery_started = now; } else { ctx->state = final_state; } } /* Сессия и авторизация также требуют документированного восстановления, если могли изменить ECU. */
void service_cancel(service_manager_t *ctx) { if (ctx != NULL && running(ctx->state)) { ctx->cancel_requested = true; } } /* Реальное завершение происходит конечным recovery-автоматом в главном цикле. */
void service_link_error(service_manager_t *ctx, diag_status_t error, uint32_t now) { if (ctx != NULL && running(ctx->state) && ctx->state != SERVICE_RECOVERY) { stop_operation(ctx, SERVICE_FAILED, error, now); } } /* Не перезапускает recovery при каждой повторной ошибке линии. */
void service_poll(service_manager_t *ctx, uint32_t now) /* Один шаг никогда не ожидает завершения удалённого ECU в цикле. */
{ /* Любой callback обязан сам оставаться неблокирующим и не использовать произвольные CAN-команды. */
if (ctx == NULL || !running(ctx->state)) { return; } const service_profile_t *profile = ctx->profile; diag_status_t result = DIAG_OK; /* Терминальные состояния не имеют побочных эффектов. */
if (ctx->state == SERVICE_RECOVERY) { /* Безопасное завершение имеет собственный независимый конечный срок. */
if (diag_elapsed(now, ctx->recovery_started) >= profile->recovery_ms) { ctx->recovery_incomplete = true; ctx->state = SERVICE_FAILED; ctx->error = DIAG_TIMEOUT; return; } /* Нельзя сообщить «оборудование выключено», если recovery не подтверждён. */
result = profile->recover(ctx->user, now); if (result == DIAG_OK) { ctx->state = ctx->final_state; } else if (result != DIAG_BUSY) { ctx->recovery_incomplete = true; ctx->state = SERVICE_FAILED; ctx->error = result; } return; /* Только подтверждённый callback завершает recovery успешно. */
} /* Завершает отдельный шаг безопасного восстановления. */
if (ctx->cancel_requested) { stop_operation(ctx, SERVICE_CANCELLED, DIAG_OK, now); return; } /* Отмена до первого воздействия не требует выдуманной команды выключения. */
if (diag_elapsed(now, ctx->started) >= profile->maximum_ms) { stop_operation(ctx, SERVICE_FAILED, DIAG_TIMEOUT, now); return; } /* Общий срок ограничивает также длительность исполнительного воздействия. */
switch (ctx->state) { /* Переходы определены независимо от конкретного автомобиля. */
case SERVICE_CHECK_PRECONDITIONS: result = ctx->first_check_done ? profile->independent_check(ctx->user, now) : profile->preconditions(ctx->user, now); if (result == DIAG_OK && changes(profile) && !ctx->first_check_done) { ctx->first_check_done = true; } else if (result == DIAG_OK) { ctx->state = SERVICE_SESSION_START; } break; /* Независимая проверка обязательна также для read-профилей со сменой сессии. */
case SERVICE_AUTHORIZATION: if (profile->needs_authorization) { ctx->touched_ecu = true; result = profile->authorize(ctx->user, now); } if (result == DIAG_OK) { ctx->state = SERVICE_EXECUTE; } break; /* Легитимный провайдер авторизации вызывается отдельно от исполнительной команды. */
case SERVICE_SESSION_START: if (profile->needs_session) { ctx->touched_ecu = true; result = profile->session(ctx->user, now); } if (result == DIAG_OK) { ctx->state = SERVICE_AUTHORIZATION; } break; /* Смена сессии также считается возможным изменением состояния ECU. */
case SERVICE_EXECUTE: ctx->touched_ecu = true; result = profile->execute(ctx->user, now); if (result == DIAG_OK) { ctx->state = SERVICE_WAIT_RESPONSE; } break; /* DIAG_BUSY оставляет шаг execute активным до завершения его собственного неблокирующего автомата. */
case SERVICE_WAIT_RESPONSE: result = profile->verify(ctx->user, now); if (result == DIAG_OK) { ctx->state = SERVICE_VERIFY; } break; /* Верификация ждёт документированный критерий, а не только завершение CAN TX. */
case SERVICE_VERIFY: if (changes(profile)) { stop_operation(ctx, SERVICE_COMPLETE, DIAG_OK, now); } else { ctx->state = SERVICE_COMPLETE; } break; /* После воздействия или смены сессии даже успех проходит безопасное завершение. */
default: result = DIAG_INVALID; break; /* Непредусмотренное состояние не выполняет произвольный callback. */
} /* Завершает один ограниченный переход. */
if (result != DIAG_OK && result != DIAG_BUSY) { stop_operation(ctx, SERVICE_FAILED, result, now); } /* Финальный отказ переводит изменённый ECU в документированное recovery. */
} /* Завершает шаг менеджера сервисных функций. */
+65
View File
@@ -0,0 +1,65 @@
#include "uds.h" /* Предоставляет безопасные построители и конечный автомат ожидания ответа. */
#include <string.h> /* Контекст инициализируется без heap. */
void uds_init(uds_t *ctx) /* Каждый ECU получает собственный контекст. */
{ if (ctx != NULL) { memset(ctx, 0, sizeof(*ctx)); ctx->p2_ms = 1000U; ctx->p2_star_ms = 5000U; ctx->overall_ms = 30000U; } } /* Суммарный предел 30 секунд исключает бесконечные ResponsePending. */
uds_category_t uds_category(uint8_t service) /* Определяет политику до построения запроса. */
{ /* Неизвестный сервис получает наиболее ограничительную категорию. */
switch (service) { /* Перечень соответствует сервисам ISO 14229 из технического задания. */
case 0x19U: case 0x22U: return UDS_READ_ONLY; /* Поддерживаемые запросы читают DTC и DID. */
case 0x10U: case 0x3EU: case 0x27U: return UDS_SESSION_CONTROL; /* Сессия, TesterPresent и авторизация могут изменить режим ECU. */
case 0x2FU: return UDS_ACTUATOR_CONTROL; /* InputOutputControl управляет оборудованием и штатно запрещён. */
case 0x31U: return UDS_CALIBRATION; /* RoutineControl требует отдельного проверенного профиля конкретной процедуры. */
case 0x2EU: case 0x14U: case 0x85U: return UDS_CONFIGURATION_WRITE; /* Запись DID и изменение DTC-информации не относятся к безопасному чтению. */
case 0x34U: case 0x35U: case 0x36U: case 0x37U: return UDS_ECU_PROGRAMMING; /* Программирование подключается только к симулятору отдельной подсистемой. */
default: return UDS_DANGEROUS_OPERATION; /* Reset, память, CommunicationControl и неизвестные сервисы требуют подтверждённой спецификации. */
} /* Завершает классификацию сервисов. */
} /* Категория сама по себе не разрешает исполнение. */
diag_status_t uds_request(uds_t *ctx, uint8_t service, uint16_t parameter, uint32_t now, uint8_t *payload, size_t capacity, size_t *length) /* Формирует запрос лишь после проверки политики и параметров. */
{ /* Реальный транспорт остаётся у вызывающего ISO-TP канала. */
if (ctx == NULL || payload == NULL || length == NULL || capacity < 3U) { return DIAG_INVALID; } /* Минимальная ёмкость покрывает самый длинный поддержанный запрос. */
if (ctx->active) { return DIAG_BUSY; } /* Не перезаписывает ожидаемое эхо предыдущего запроса. */
if (service != 0x19U && service != 0x22U && !(ctx->session_enabled && (service == 0x10U || service == 0x3EU))) { return DIAG_UNSUPPORTED; } /* Нет произвольного пути к памяти, SecurityAccess или записи ECU. */
payload[0] = service; *length = 3U; ctx->did = parameter; ctx->subfunction = 0U; /* SID задаётся только после проверки разрешённого набора. */
if (service == 0x22U) { payload[1] = (uint8_t)(parameter >> 8U); payload[2] = (uint8_t)parameter; } /* ReadDataByIdentifier содержит один проверяемый 16-битный DID. */
else if (service == 0x19U) { if (parameter > 255U) { return DIAG_INVALID; } payload[1] = 0x02U; payload[2] = (uint8_t)parameter; ctx->subfunction = 0x02U; } /* Подфункция reportDTCByStatusMask использует восьмибитную маску статуса. */
else { if ((service == 0x10U && (parameter < 1U || parameter > 3U)) || (service == 0x3EU && parameter != 0U)) { return DIAG_INVALID; } payload[1] = (uint8_t)parameter; ctx->subfunction = (uint8_t)parameter; *length = 2U; } /* Подавление положительного ответа и нестандартные сессии не включаются неявно. */
ctx->service = service; ctx->started = now; ctx->phase_started = now; ctx->active = true; ctx->pending = false; ctx->nrc = 0U; /* Таймаут начинается при принятии запроса владельцем транспорта. */
return DIAG_OK; /* Вызывающий ставит payload в ISO-TP лишь после этого результата. */
} /* Завершает безопасное построение UDS-запроса. */
diag_status_t uds_poll(uds_t *ctx, uint32_t now) /* Проверяется независимо от наличия входящих CAN-кадров. */
{ /* Нельзя бесконечно удерживать сессию серией NRC 0x78. */
if (ctx == NULL) { return DIAG_INVALID; } if (!ctx->active) { return DIAG_EMPTY; } /* Неактивная сессия не создаёт запросов TesterPresent. */
if (diag_elapsed(now, ctx->started) >= ctx->overall_ms || diag_elapsed(now, ctx->phase_started) >= (ctx->pending ? ctx->p2_star_ms : ctx->p2_ms)) { ctx->active = false; return DIAG_TIMEOUT; } /* P2/P2* и общий срок работают через переполнение tick. */
return DIAG_BUSY; /* Сессия ожидает ответ, но не блокирует главный цикл. */
} /* Завершает контроль конечных временных пределов. */
diag_status_t uds_response(uds_t *ctx, const uint8_t *payload, size_t length, uint32_t now) /* Принимает полный ISO-TP payload одного ECU. */
{ /* Отрицательный и положительный ответы проверяются до выдачи результата приложению. */
if (ctx == NULL || payload == NULL || length == 0U || !ctx->active) { return DIAG_INVALID; } /* Нет активного запроса — нет допустимого положительного ответа. */
if (uds_poll(ctx, now) == DIAG_TIMEOUT) { return DIAG_TIMEOUT; } /* Поздний ответ не продлевает уже истёкший срок. */
if (payload[0] == 0x7FU) { /* Отрицательный ответ обязан содержать исходный SID и NRC. */
if (length != 3U || payload[1] != ctx->service) { return DIAG_INVALID; } /* Отрицательный ответ чужого сервиса не закрывает текущую транзакцию. */
ctx->nrc = payload[2]; if (ctx->nrc == 0x78U) { ctx->pending = true; ctx->phase_started = now; return DIAG_BUSY; } /* ResponsePending переключает ожидание на P2*, сохраняя общий предел. */
ctx->active = false; return DIAG_IO; /* Финальный NRC передаётся отдельно в ctx->nrc и не трактуется как успех. */
} /* Завершает проверку NRC. */
if (payload[0] != (uint8_t)(ctx->service + 0x40U)) { return DIAG_INVALID; } /* Положительный SID должен соответствовать именно отправленному сервису. */
if (ctx->service == 0x22U && (length < 4U || payload[1] != (uint8_t)(ctx->did >> 8U) || payload[2] != (uint8_t)ctx->did)) { return DIAG_INVALID; } /* Проверяет эхо DID и наличие хотя бы одного байта данных. */
if (ctx->service == 0x19U && (length < 3U || payload[1] != ctx->subfunction || (length - 3U) % 4U != 0U)) { return DIAG_INVALID; } /* Ответ 59 02 содержит availability mask и записи DTC24+status по четыре байта. */
if (ctx->service == 0x3EU && (length != 2U || payload[1] != 0U)) { return DIAG_INVALID; } /* TesterPresent с ожидаемым ответом имеет строго два байта. */
if (ctx->service == 0x10U) { /* Ответ на смену сессии передаёт стандартные серверные P2/P2*. */
if (length != 6U || payload[1] != ctx->subfunction) { return DIAG_INVALID; } /* Не принимает усечённый параметр времени сессии. */
uint32_t p2 = ((uint32_t)payload[2] << 8U) | payload[3]; uint32_t star = (((uint32_t)payload[4] << 8U) | payload[5]) * 10U; /* P2 выражен в миллисекундах, P2* — в единицах десять миллисекунд по ISO 14229. */
if (p2 == 0U || star == 0U || p2 > ctx->overall_ms || star > ctx->overall_ms) { return DIAG_INVALID; } /* Сервер не может отключить конечный общий предел ожидания. */
ctx->p2_ms = p2; ctx->p2_star_ms = star; /* Новые интервалы применяются только после полностью проверенного ответа. */
} /* Завершает разбор разрешённой смены сессии. */
ctx->active = false; return DIAG_OK; /* Успех означает проверенный ответ конкретного ECU, а не только принятие запроса транспортом. */
} /* Завершает конечный автомат UDS одного соединения. */
const char *uds_nrc_name(uint8_t nrc) /* Краткие стандартные обозначения пригодны для CLI и GUI. */
{ /* Неизвестный NRC сохраняется числом в событии, текст не подменяет исходное значение. */
switch (nrc) { /* Значения взяты из стандартного набора NRC ISO 14229. */
case 0x10U: return "generalReject"; case 0x11U: return "serviceNotSupported"; /* Общий отказ либо отсутствие сервиса в ECU. */
case 0x12U: return "subFunctionNotSupported"; case 0x13U: return "incorrectMessageLengthOrInvalidFormat"; /* Отказ подфункции и формата запроса различаются. */
case 0x21U: return "busyRepeatRequest"; case 0x22U: return "conditionsNotCorrect"; /* Автомат не повторяет запрос по busy без команды оператора. */
case 0x31U: return "requestOutOfRange"; case 0x33U: return "securityAccessDenied"; /* Отказ доступа никогда не запускает подбор seed/key. */
case 0x78U: return "responsePending"; default: return "unknownNRC"; /* Pending обрабатывается таймером P2*, неизвестный код остаётся явным. */
} /* Завершает каталог стандартных отрицательных ответов. */
} /* Возвращённые строки неизменяемы и не требуют освобождения. */
+33
View File
@@ -0,0 +1,33 @@
#include "vehicle_manager.h" /* Проверяет данные профиля до их использования аппаратным или диагностическим портом. */
#include <string.h> /* Реестр полностью инициализируется без динамической памяти. */
static const vehicle_ecu_t generic[] = { /* Универсальная запись отражает стандартный OBD-диапазон, а не конкретный Ford/JLR блок. */
{"OBD ECU 0", 0x7E0U, 0x7E8U, 500000U, 0x000006DEU, VEHICLE_HS_CAN, VEHICLE_OBD_CAN, PROFILE_SUPPORTED, false, "ISO 15765-4, SAE J1979; фактическая поддержка сервисов проверяется ответом ECU"} /* Установлены биты 1, 2, 3, 4, 6, 7, 9 и 10: маска реализации сканера не обещает эти сервисы автомобиля. */
}; /* Остальные стандартные ECU обнаруживаются функциональным запросом, без догадки о названии PCM. */
static const vehicle_ecu_t ford[] = { /* Ни один неизвестный Ford ID не используется для активного управления. */
{"PCM", 0U, 0U, 0U, 0U, VEHICLE_HS_CAN, VEHICLE_UDS_CAN, PROFILE_UNVERIFIED, false, "Требуется документация ECU конкретного автомобиля"}, /* Нули являются явными неизвестными полями, а не адресом для передачи. */
{"ABS", 0U, 0U, 0U, 0U, VEHICLE_HS_CAN, VEHICLE_UDS_CAN, PROFILE_UNVERIFIED, false, "Требуется документация ECU конкретного автомобиля"}, /* Поколения Focus могут иметь различные диагностические сети. */
{"BCM", 0U, 0U, 0U, 0U, VEHICLE_MS_CAN, VEHICLE_UDS_CAN, PROFILE_UNVERIFIED, false, "Шина и протокол требуют проверки для VIN"}, /* Возможный MS-CAN не считается электрически совместимым с HS-трансивером по одному битрейту. */
{"IPC", 0U, 0U, 0U, 0U, VEHICLE_OTHER_CAN, VEHICLE_KWP_UNIMPLEMENTED, PROFILE_UNVERIFIED, false, "Протокол и адреса не подтверждены"} /* Обозначение KWP здесь не включает фиктивную реализацию сервиса. */
}; /* Имена модулей позволяют заполнить профиль после получения проверенных адресов. */
static const vehicle_ecu_t jlr[] = { /* Специфические параметры подвески и других JLR систем не выводятся из названия модели. */
{"Подвеска", 0U, 0U, 0U, 0U, VEHICLE_OTHER_CAN, VEHICLE_UDS_CAN, PROFILE_UNVERIFIED, false, "Нужна официальная спецификация ECU подвески по VIN"} /* DID, Routine ID и исполнительные операции отсутствуют до проверки. */
}; /* Универсальная диагностика выбросов доступна отдельно от этого неподтверждённого маршрута. */
static const vehicle_profile_t profiles[] = { /* Нулевые интервалы выпуска исключают ложную точность без рынка и VIN. */
{"Generic", "OBD-II", "ISO 15765-4 11-bit", 0U, 0U, generic, 1U, PROFILE_SUPPORTED, "Только доступные сервисы OBD конкретного ECU; скорость задаёт оператор"}, /* Это стандартная основа диагностики, не фирменная база. */
{"Ford", "Focus", "Mk2", 0U, 0U, ford, 4U, PROFILE_UNVERIFIED, "Проверить CAN/KWP, шины и адреса по конкретному автомобилю"}, /* Mk2 не наследует автоматически архитектуру Mk3. */
{"Ford", "Focus", "Mk3", 0U, 0U, ford, 4U, PROFILE_UNVERIFIED, "Нужны проверенные адреса, DID и сеть ECU"}, /* Общие имена ECU не доказывают одинаковую адресацию. */
{"Ford", "Focus", "Mk4", 0U, 0U, ford, 4U, PROFILE_UNVERIFIED, "CAN FD и фирменные сервисы не включаются по названию поколения"}, /* Стандартный Classic OBD остаётся отдельной проверяемой возможностью. */
{"Land Rover", "Discovery", "3", 0U, 0U, jlr, 1U, PROFILE_UNVERIFIED, "Нужны документация ECU и безопасные условия сервисных процедур"}, /* Нет неподтверждённых команд клапанов. */
{"Land Rover", "Discovery", "4", 0U, 0U, jlr, 1U, PROFILE_UNVERIFIED, "Не наследует последовательности Discovery 3"}, /* Сервисные данные различных поколений разделяются. */
{"Land Rover", "Discovery", "5", 0U, 0U, jlr, 1U, PROFILE_UNVERIFIED, "Протоколы и сети проверить по VIN"}, /* Не предполагает наличие или отсутствие gateway. */
{"Land Rover", "Range Rover", "Требуется уточнение поколения", 0U, 0U, jlr, 1U, PROFILE_UNVERIFIED, "Нужны VIN, ECU и источник сервисных данных"}, /* Одного коммерческого названия недостаточно для активных операций. */
{"Land Rover", "Range Rover Sport", "Требуется уточнение поколения", 0U, 0U, jlr, 1U, PROFILE_UNVERIFIED, "Фирменные параметры и процедуры не подтверждены"} /* Не подставляет вымышленные DID и Routine ID. */
}; /* Таблица хранит данные; программная реализация протоколов находится отдельно. */
void vehicle_manager_init(vehicle_manager_t *ctx) /* Подготавливает статический реестр без сетевых действий. */
{ if (ctx != NULL) { memset(ctx, 0, sizeof(*ctx)); for (size_t i = 0U; i < sizeof(profiles) / sizeof(profiles[0]); ++i) { ctx->profiles[ctx->count++] = &profiles[i]; } } } /* По умолчанию выбран универсальный OBD, а не неподтверждённый производительский маршрут. */
diag_status_t vehicle_register(vehicle_manager_t *ctx, const vehicle_profile_t *profile) /* Позволяет добавить документированный профиль без изменения ядра. */
{ if (ctx == NULL || profile == NULL || profile->model == NULL || (profile->ecu_count != 0U && profile->ecu == NULL)) { return DIAG_INVALID; } if (ctx->count >= 16U) { return DIAG_OVERFLOW; } ctx->profiles[ctx->count++] = profile; return DIAG_OK; } /* Память профиля принадлежит вызывающему и должна быть постоянной. */
diag_status_t vehicle_select(vehicle_manager_t *ctx, size_t index) /* Выбор изменяет только метаданные текущего автомобиля. */
{ if (ctx == NULL || index >= ctx->count) { return DIAG_INVALID; } ctx->selected = index; return DIAG_OK; } /* Применение CAN-параметров требует отдельного проверенного аппаратного шага. */
bool vehicle_ecu_verified(const vehicle_ecu_t *ecu) /* Проверенность является обязательным условием любого фирменного активного маршрута. */
{ return ecu != NULL && ecu->evidence == PROFILE_SUPPORTED && ecu->source != NULL && ecu->source[0] != '\0' && ecu->bitrate != 0U && ecu->request_id <= (ecu->extended ? 0x1FFFFFFFU : 0x7FFU) && ecu->response_id <= (ecu->extended ? 0x1FFFFFFFU : 0x7FFU); } /* Само наличие числа или описания без SUPPORTED не разрешает передачу. */
+18
View File
@@ -0,0 +1,18 @@
#include "can_logger.h" /* Проверяет формат журнала и пассивную сборку тем же ISO-TP кодом. */
#include <assert.h> /* Ошибка теста завершает процесс до отчёта об успехе. */
#include <stdio.h> /* Итог содержит только фактически исполненные условия. */
#include <string.h> /* Сравнивает точные CSV-байты и полный собранный payload. */
static unsigned checks, messages; static uint8_t captured[32]; static size_t captured_length; /* Счётчик наблюдения не имеет физического CAN-порта. */
#define CHECK(value) do { checks++; assert(value); } while (0) /* Каждая гарантия выводится в итоговое число проверок. */
static void observed(uint32_t id, const uint8_t *payload, size_t length, void *user) { (void)user; CHECK(id == 0x7E8U || id == 0x7DFU); CHECK(length <= sizeof(captured)); memcpy(captured, payload, length); captured_length = length; messages++; } /* Callback получает только анализируемый полный payload, не исходящие кадры. */
int main(void) /* Проверка не открывает автомобильную шину или USB/COM. */
{ /* Весь вход является синтетической записью, а не командами реальному автомобилю. */
auto_log_t entry = {0}; entry.frame.id = 0x7E8U; entry.frame.timestamp_ms = 12U; entry.frame.length = 2U; entry.frame.data[0] = 0xAAU; entry.frame.data[1] = 0xBBU; entry.frame.data[2] = 0xCCU; char text[96]; /* Третий байт намеренно отличен от нуля, но не входит в DLC. */
CHECK(can_log_format(&entry, true, text, sizeof(text)) == DIAG_OK && strcmp(text, "12,RX,7E8,0,2,AA BB\r\n") == 0); CHECK(can_log_format(&entry, true, text, 5U) == DIAG_OVERFLOW); /* Экспорт не добавляет скрытые байты и проверяет ёмкость назначения. */
can_log_filter_t filter = {0x7E8U, 0x7EFU, true}; CHECK(can_log_matches(&filter, &entry.frame)); entry.frame.id = 0x100U; CHECK(!can_log_matches(&filter, &entry.frame)); /* Программный фильтр не принимает посторонний ID. */
static can_trace_decoder_t decoder; can_trace_init(&decoder, observed, NULL); can_frame_t frame = {0}; frame.id = 0x7E8U; frame.length = 8U; frame.data[0] = 0x10U; frame.data[1] = 20U; uint8_t payload[20]; for (uint8_t i = 0U; i < 20U; ++i) { payload[i] = i; } memcpy(&frame.data[2], payload, 6U); can_trace_feed(&decoder, &frame, 0U); CHECK(messages == 0U); /* First Frame сам по себе не является полным диагностическим сообщением. */
frame.data[0] = 0x21U; memcpy(&frame.data[1], &payload[6], 7U); can_trace_feed(&decoder, &frame, 5U); frame.data[0] = 0x22U; memcpy(&frame.data[1], &payload[13], 7U); can_trace_feed(&decoder, &frame, 10U); CHECK(messages == 1U && captured_length == 20U && memcmp(captured, payload, 20U) == 0); /* Полная последовательность собирается без физической передачи FC. */
frame.id = 0x7DFU; frame.data[0] = 2U; frame.data[1] = 1U; frame.data[2] = 0x0CU; can_trace_feed(&decoder, &frame, 20U); CHECK(messages == 2U && captured_length == 2U && captured[1] == 0x0CU); /* Стандартный функциональный запрос также декодируется пассивно. */
frame.id = 0x7E8U; frame.data[0] = 0x10U; frame.data[1] = 20U; can_trace_feed(&decoder, &frame, 30U); can_trace_poll(&decoder, 1030U); CHECK(decoder.malformed == 1U && messages == 2U); /* Неполный журнал после N_Cr не выдаёт частичный UDS/VIN как успешное сообщение. */
printf("PASS: %u logger checks\n", checks); return 0; /* Успех подтверждает реальный запуск форматтера и пассивного ISO-TP наблюдателя. */
} /* Завершает изолированную проверку журнала. */
File diff suppressed because one or more lines are too long
+98
View File
@@ -0,0 +1,98 @@
#include "diag_engine.h" /* Испытывает тот же движок, который компилируется в STM32 и native DLL SETGUI. */
#include "obd2_dtc.h" /* Проверяет стандартные DTC независимо от CAN и GUI. */
#include "cli.h" /* Парсер терминала тестируется без USART. */
#include "pcan_ring.h" /* Проверяет используемое общее кольцо templates на переполнение и заворот. */
#include <assert.h> /* Любое нарушение эталонных байтов завершает тест с ненулевым кодом. */
#include <stdio.h> /* Выводит только итог фактически выполненных проверок. */
#include <string.h> /* Сравнивает wire-байты и полные собранные сообщения. */
static unsigned assertions; /* Считает реально выполненные условия, а не число объявленных тестов. */
#define CHECK(expression) do { assertions++; assert(expression); } while (0) /* Даже успешная проверка учитывается счётчиком; NDEBUG при тестовой сборке запрещён. */
static can_frame_t sent[128]; static size_t sent_count; static uint8_t received[512]; static size_t received_length; static diag_status_t port_status; /* Фиксированный симулятор транспорта не использует STM32 HAL. */
static diag_status_t send_frame(const can_frame_t *frame, void *user) /* Подменяет только физический порт, а не алгоритм ISO-TP. */
{ (void)user; if (port_status != DIAG_OK) { return port_status; } CHECK(sent_count < 128U); sent[sent_count++] = *frame; return DIAG_OK; } /* Сохраняет точные байты принятого транспортом кадра для эталонного сравнения. */
static void receive_payload(const uint8_t *payload, size_t length, void *user) /* Получает только полностью собранное сообщение через публичный callback. */
{ (void)user; CHECK(length <= sizeof(received)); memcpy(received, payload, length); received_length = length; } /* Любой выход за статический буфер немедленно проваливает тест. */
static void reset_port(void) /* Каждая независимая проверка начинает с пустого транспорта. */
{ sent_count = 0U; received_length = 0U; port_status = DIAG_OK; memset(sent, 0, sizeof(sent)); } /* Состояние одного кейса не маскирует результат другого. */
static can_frame_t frame(uint8_t pci) /* Создаёт восьмибайтовый ответ стандартного тестового ECU. */
{ can_frame_t value = {0}; value.id = 0x7E8U; value.length = 8U; value.data[0] = pci; return value; } /* Используются документированные OBD ID, а не Ford/JLR-specific адреса. */
static void test_sf_pid_dtc(void) /* Проверяет транспортные границы и физические формулы стандартных параметров. */
{ /* Формулы проверяются эталонами, включая дробные RPM и отрицательную температуру. */
uint8_t output[8], data[] = {0x01U, 0x0CU}; const uint8_t *payload; size_t length; int32_t value; uint16_t quarters; /* Размеры и результаты проверяются независимо. */
CHECK(isotp_sf_encode(data, 2U, output) == DIAG_OK); CHECK(output[0] == 2U && output[1] == 1U && output[2] == 0x0CU && output[7] == 0x55U); /* Запрос RPM должен иметь точный SF_DL и padding. */
CHECK(isotp_sf_decode(output, 8U, &payload, &length) == DIAG_OK && length == 2U && payload[1] == 0x0CU); /* Эталонный encode/decode дополнен отдельными wire-проверками выше. */
CHECK(isotp_sf_encode(data, 0U, output) == DIAG_INVALID); CHECK(isotp_sf_encode(data, 8U, output) == DIAG_INVALID); /* Нулевой escape SF и превышение семи байтов запрещены. */
output[0] = 7U; CHECK(isotp_sf_decode(output, 3U, &payload, &length) == DIAG_INVALID); output[0] = 0x10U; CHECK(isotp_sf_decode(output, 8U, &payload, &length) == DIAG_UNSUPPORTED); /* Усечённый SF и FF не принимаются одиночным кодеком. */
uint8_t rpm[] = {0x41U, 0x0CU, 0x1AU, 0xFBU}; CHECK(obd2_pid_rpm(rpm, sizeof(rpm), &quarters) == DIAG_OK && quarters == 6907U); /* 0x1AFB соответствует 1726,75 об/мин, поэтому целочисленное деление недопустимо. */
CHECK(obd2_pid_decode(0x0CU, &rpm[2], 2U, &value) == DIAG_OK && value == 1726750); /* Универсальный каталог должен сохранить тот же результат в тысячных RPM. */
uint8_t temp[] = {0U}; CHECK(obd2_pid_decode(0x05U, temp, 1U, &value) == DIAG_OK && value == -40000); /* Нижняя граница PID05 равна минус сорока градусам. */
temp[0] = 255U; CHECK(obd2_pid_decode(0x11U, temp, 1U, &value) == DIAG_OK && value == 100000); /* Полный TPS не должен округляться выше ста процентов. */
temp[0] = 128U; CHECK(obd2_pid_decode(0x06U, temp, 1U, &value) == DIAG_OK && value == 0); CHECK(obd2_pid_decode(0x0CU, temp, 1U, &value) == DIAG_INVALID); /* Нулевой trim и усечённый RPM имеют разные результаты. */
uint8_t volts[] = {0x38U, 0x40U}; CHECK(obd2_pid_decode(0x42U, volts, 2U, &value) == DIAG_OK && value == 14400); /* PID42 0x3840 означает 14,4 В, не 14400 В. */
char text[6]; obd2_dtc_format(0x0133U, text); CHECK(strcmp(text, "P0133") == 0); obd2_dtc_format(0xC123U, text); CHECK(strcmp(text, "U0123") == 0); /* Проверяет стандартный и сетевой классы DTC. */
uint8_t dtc[] = {0x43U, 2U, 0x01U, 0x33U, 0x03U, 0x00U}; uint16_t codes[2]; size_t count; /* CAN-ответ имеет отдельный байт количества кодов. */
CHECK(obd2_dtc_decode(dtc, sizeof(dtc), codes, 2U, &count) == DIAG_OK && count == 2U && codes[1] == 0x0300U); /* Число DTC не берётся из MIL или деления всей длины на два. */
CHECK(obd2_dtc_decode(dtc, sizeof(dtc) - 1U, codes, 2U, &count) == DIAG_INVALID); CHECK(obd2_dtc_decode(dtc, sizeof(dtc), codes, 1U, &count) == DIAG_OVERFLOW); /* Усечение и недостаточная выходная ёмкость не выдаются за полный список. */
} /* Завершает базовые кодеки OBD. */
static void test_isotp_rx(void) /* Проверяет сборку, границы, SN, block size и независимость контекстов. */
{ /* Пакет из двадцати байтов проходит FF и два CF. */
isotp_link_t link; reset_port(); isotp_init(&link, 0x7E0U, 0x7E8U, false, send_frame, receive_payload, NULL); /* Использует настоящий транспортный автомат с тестовым физическим портом. */
can_frame_t first = frame(0x10U); first.data[1] = 20U; for (uint8_t i = 0U; i < 6U; ++i) { first.data[2U + i] = i; } /* FF содержит длину 20 и первые шесть эталонных байтов. */
isotp_on_frame(&link, &first, 0U); CHECK(received_length == 0U); isotp_poll(&link, 0U); CHECK(sent_count == 1U && sent[0].id == 0x7E0U && sent[0].data[0] == 0x30U && sent[0].data[1] == 8U); /* До полного сообщения клиент не получает payload, а FC направляется на физический request ID. */
can_frame_t cf = frame(0x21U); for (uint8_t i = 0U; i < 7U; ++i) { cf.data[i + 1U] = (uint8_t)(6U + i); } isotp_on_frame(&link, &cf, 5U); /* Первый CF переносит байты 6..12 с SN=1. */
cf.data[0] = 0x22U; for (uint8_t i = 0U; i < 7U; ++i) { cf.data[i + 1U] = (uint8_t)(13U + i); } isotp_on_frame(&link, &cf, 10U); CHECK(received_length == 20U); /* Второй CF завершает последовательность без выдачи padding. */
for (uint8_t i = 0U; i < 20U; ++i) { CHECK(received[i] == i); } /* Независимый эталон проверяет порядок каждого байта, а не только длину. */
isotp_on_frame(&link, &first, 20U); isotp_poll(&link, 20U); cf.data[0] = 0x22U; isotp_on_frame(&link, &cf, 25U); CHECK(link.error == DIAG_INVALID); /* Неверный первый SN=2 немедленно прекращает сборку. */
isotp_init(&link, 0x7E0U, 0x7E8U, false, send_frame, receive_payload, NULL); isotp_on_frame(&link, &first, UINT32_MAX - 9U); isotp_poll(&link, UINT32_MAX - 9U); isotp_poll(&link, 990U); CHECK(link.error == DIAG_TIMEOUT); /* N_Cr сохраняет конечный предел через переполнение миллисекундного tick. */
isotp_init(&link, 0x7E0U, 0x7E8U, false, send_frame, receive_payload, NULL); first.data[0] = 0x12U; first.data[1] = 1U; isotp_on_frame(&link, &first, 0U); isotp_poll(&link, 0U); CHECK(sent[sent_count - 1U].data[0] == 0x32U && link.error == DIAG_OVERFLOW); /* FF длиной 513 превышает фиксированную ёмкость и требует FC Overflow. */
isotp_link_t other; isotp_init(&other, 0x7E1U, 0x7E9U, false, send_frame, receive_payload, NULL); size_t before = received_length; isotp_on_frame(&other, &cf, 0U); CHECK(other.error == DIAG_OK && received_length == before); /* Чужой ECU не изменяет независимый контекст. */
} /* Завершает проверки многокадрового приёма. */
static void test_isotp_tx(void) /* Проверяет сегментацию, паузы, BS, WAIT и таймаут выходного порта. */
{ /* Успех send означает принятие кадра ограниченным транспортом, а не подмену ISO-TP алгоритма. */
isotp_link_t link; uint8_t payload[130]; for (uint16_t i = 0U; i < 130U; ++i) { payload[i] = (uint8_t)i; } reset_port(); isotp_init(&link, 0x7E0U, 0x7E8U, false, send_frame, receive_payload, NULL); /* Длина 130 позволяет проверить переход SN через ноль. */
CHECK(isotp_transmit(&link, payload, 20U, 0U) == DIAG_OK); isotp_poll(&link, 0U); CHECK(sent_count == 1U && sent[0].data[0] == 0x10U && sent[0].data[1] == 20U); /* FF не должен отправлять CF до получения CTS. */
isotp_poll(&link, 10U); CHECK(sent_count == 1U); can_frame_t fc = frame(0x30U); fc.data[1] = 1U; fc.data[2] = 5U; isotp_on_frame(&link, &fc, 10U); /* BS=1 требует Flow Control после каждого CF, STmin=5 мс ограничивает частоту. */
isotp_poll(&link, 14U); CHECK(sent_count == 1U); isotp_poll(&link, 15U); CHECK(sent_count == 2U && sent[1].data[0] == 0x21U && sent[1].data[1] == 6U); /* CF появляется ровно после минимального интервала. */
isotp_poll(&link, 20U); CHECK(sent_count == 2U); fc.data[1] = 0U; fc.data[2] = 0xF1U; isotp_on_frame(&link, &fc, 20U); isotp_poll(&link, 20U); CHECK(sent_count == 2U); isotp_poll(&link, 21U); CHECK(sent_count == 3U && sent[2].data[0] == 0x22U); /* Субмиллисекундный STmin округлён вверх и не превращается в отсутствие паузы. */
reset_port(); isotp_init(&link, 0x7E0U, 0x7E8U, false, send_frame, receive_payload, NULL); CHECK(isotp_transmit(&link, payload, 130U, 0U) == DIAG_OK); isotp_poll(&link, 0U); fc.data[1] = 0U; fc.data[2] = 0U; isotp_on_frame(&link, &fc, 0U); for (uint32_t t = 1U; t < 25U; ++t) { isotp_poll(&link, t); } CHECK(sent[16].data[0] == 0x20U && sent_count == 19U); /* Сегментация 130 байтов требует 18 CF и корректного SN=0 после пятнадцати. */
reset_port(); isotp_init(&link, 0x7E0U, 0x7E8U, false, send_frame, receive_payload, NULL); CHECK(isotp_transmit(&link, payload, 20U, 0U) == DIAG_OK); isotp_poll(&link, 0U); fc.data[0] = 0x31U; for (uint32_t t = 1U; t < 5U; ++t) { isotp_on_frame(&link, &fc, t); } CHECK(link.error == DIAG_TIMEOUT); /* Четвёртый WAIT запрещён и не продлевает ожидание бесконечно. */
reset_port(); isotp_init(&link, 0x7E0U, 0x7E8U, false, send_frame, receive_payload, NULL); port_status = DIAG_BUSY; CHECK(isotp_transmit(&link, payload, 2U, 0U) == DIAG_OK); isotp_poll(&link, 0U); isotp_poll(&link, 100U); CHECK(link.error == DIAG_TIMEOUT && sent_count == 0U); /* Постоянно занятый порт ограничивается N_As. */
} /* Завершает проверки многокадрового TX и Flow Control. */
static void test_uds(void) /* Проверяет стандартную политику, эхо DID, NRC и P2/P2*. */
{ /* Никакой кейс не взаимодействует с реальным ECU. */
uds_t session; uint8_t request[8]; size_t length; uds_init(&session); CHECK(uds_request(&session, 0x2EU, 0x1234U, 0U, request, 8U, &length) == DIAG_UNSUPPORTED); CHECK(uds_request(&session, 0x10U, 3U, 0U, request, 8U, &length) == DIAG_UNSUPPORTED); /* Запись и даже смена сессии запрещены по умолчанию. */
CHECK(uds_request(&session, 0x22U, 0xF190U, UINT32_MAX - 499U, request, 8U, &length) == DIAG_OK && length == 3U && request[2] == 0x90U); /* F190 используется только стандартным тестовым вектором чтения VIN DID. */
uint8_t wrong[] = {0x62U, 0xF1U, 0x91U, 0U}; CHECK(uds_response(&session, wrong, 4U, 0U) == DIAG_INVALID && session.active); /* Чужой DID не считается ответом на отправленный запрос. */
uint8_t pending[] = {0x7FU, 0x22U, 0x78U}; CHECK(uds_response(&session, pending, 3U, 0U) == DIAG_BUSY); CHECK(uds_poll(&session, 4999U) == DIAG_BUSY); CHECK(uds_poll(&session, 5000U) == DIAG_TIMEOUT); /* P2* проверяется на границе и через wrap. */
uds_init(&session); CHECK(uds_request(&session, 0x22U, 0xF190U, 0U, request, 8U, &length) == DIAG_OK); uint8_t denial[] = {0x7FU, 0x22U, 0x33U}; CHECK(uds_response(&session, denial, 3U, 1U) == DIAG_IO && session.nrc == 0x33U && !session.active); /* Отказ SecurityAccess не запускает авторизацию или подбор ключей. */
uds_init(&session); CHECK(uds_request(&session, 0x22U, 0xF190U, 0U, request, 8U, &length) == DIAG_OK); uint8_t positive[] = {0x62U, 0xF1U, 0x90U, 'A'}; CHECK(uds_response(&session, positive, 4U, 1U) == DIAG_OK && !session.active); /* Проверяет успешный SID и точное эхо DID. */
} /* Завершает проверки менеджера UDS. */
static void test_feed(auto_engine_t *engine, can_frame_t *answer, uint32_t now) /* Порт CAN передаёт реальную метку приёма кадра из того же миллисекундного счётчика. */
{ answer->timestamp_ms = now; auto_feed(engine, answer, now); } /* Тестовые ответы не должны случайно выглядеть старыми кадрами предыдущего запроса. */
static void test_engine(void) /* Проверяет путь запроса и нескольких ECU до готовых событий. */
{ /* Контекст размещён статически, как на STM32, без malloc. */
static auto_engine_t engine; auto_init(&engine); can_frame_t output; auto_event_t entry; CHECK(auto_take_tx(&engine, &output) == DIAG_EMPTY); CHECK(auto_scan(&engine, 0U) == DIAG_PASSIVE); /* Запуск и пассивный контекст не имеют скрытого TX. */
auto_enable(&engine, true); CHECK(auto_scan(&engine, 0U) == DIAG_OK); CHECK(auto_take_tx(&engine, &output) == DIAG_OK && output.id == 0x7DFU && output.data[1] == 1U && output.data[2] == 0U); /* Обнаружение отправляет единственный документированный функциональный запрос. */
can_frame_t answer = frame(6U); uint8_t map[] = {0x41U, 0U, 0U, 0x10U, 0U, 0U}; memcpy(&answer.data[1], map, 6U); test_feed(&engine, &answer, 10U); answer.id = 0x7E9U; answer.data[4] = 0U; test_feed(&engine, &answer, 11U); /* Первый ECU объявляет PID0C, второй — нет. */
CHECK(auto_pid_supported(&engine, 0U, 0x0CU) == 1 && auto_pid_supported(&engine, 1U, 0x0CU) == 0); CHECK(auto_pid_supported(&engine, 2U, 0x0CU) == -1); auto_poll(&engine, 1000U); /* Карты поддержанных PID не распространяются между ECU. */
CHECK(auto_request(&engine, 1U, 0x0CU, 1U, false, 1100U) == DIAG_UNSUPPORTED); CHECK(auto_request(&engine, 1U, 0x0CU, 0U, false, 1100U) == DIAG_OK); auto_poll(&engine, 1100U); CHECK(auto_take_tx(&engine, &output) == DIAG_OK && output.id == 0x7E0U); /* Физический запрос использует request ID выбранного ECU. */
answer = frame(4U); uint8_t rpm[] = {0x41U, 0x0CU, 0x1AU, 0xF8U}; memcpy(&answer.data[1], rpm, 4U); test_feed(&engine, &answer, 1110U); bool found = false; while (auto_take_event(&engine, &entry) == DIAG_OK) { if (entry.kind == AUTO_VALUE) { found = entry.value == 1726000 && entry.ecu == 0x7E8U; } } CHECK(found && !engine.active); /* Итоговые обороты и ECU проверяются после полного маршрута через ISO-TP. */
CHECK(auto_request(&engine, 4U, 0U, 0U, false, 1200U) == DIAG_PASSIVE); CHECK(auto_take_tx(&engine, &output) == DIAG_EMPTY); /* Отсутствие подтверждения Mode04 гарантирует отсутствие кадра сброса. */
CHECK(auto_request(&engine, 9U, 2U, 0U, false, 1200U) == DIAG_OK); auto_poll(&engine, 1200U); CHECK(auto_take_tx(&engine, &output) == DIAG_OK); uint8_t vin[] = {0x49U, 0x02U, 0x01U, 'W','F','0','A','B','C','D','E','1','2','3','4','5','6','7','8','9'}; /* Синтетический VIN не описывает реальный автомобиль. */
answer = frame(0x10U); answer.data[1] = 20U; memcpy(&answer.data[2], vin, 6U); test_feed(&engine, &answer, 1210U); auto_poll(&engine, 1210U); CHECK(auto_take_tx(&engine, &output) == DIAG_OK && output.data[0] == 0x30U); /* Многокадровый VIN получает FC на физический адрес ECU. */
answer = frame(0x21U); memcpy(&answer.data[1], &vin[6], 7U); test_feed(&engine, &answer, 1215U); answer.data[0] = 0x22U; memcpy(&answer.data[1], &vin[13], 7U); test_feed(&engine, &answer, 1220U); found = false; while (auto_take_event(&engine, &entry) == DIAG_OK) { if (entry.kind == AUTO_VIN) { found = strcmp(entry.text, "WF0ABCDE123456789") == 0; } } CHECK(found); /* VIN появляется только после полной сборки семнадцати символов. */
auto_transport_error(&engine, DIAG_BUS_OFF); CHECK(!engine.enabled && !engine.active && auto_take_tx(&engine, &output) == DIAG_EMPTY); /* Bus-off отменяет будущие CF, FC и диагностические запросы. */
} /* Завершает интеграционные проверки OBD/ISO-TP/событий. */
static unsigned commands; static char last_command[80]; /* Фиксированный приёмник CLI используется для проверки границ команд. */
static void execute(const char *line, void *user) { (void)user; commands++; (void)snprintf(last_command, sizeof(last_command), "%s", line); } /* Записывает только реально вызванные парсером команды. */
static void test_buffers_cli(void) /* Проверяет кольца и невозможность выполнения усечённой команды. */
{ /* Кольцо является исходным кодом submodule templates, а не тестовой копией алгоритма. */
pcan_ring_t ring; uint8_t storage[8], byte; CHECK(!pcan_ring_init(&ring, storage, 7U)); CHECK(pcan_ring_init(&ring, storage, 8U)); /* Размер кольца должен быть степенью двойки. */
for (uint8_t i = 0U; i < 7U; ++i) { CHECK(pcan_ring_put(&ring, i)); } CHECK(!pcan_ring_put(&ring, 99U) && ring.dropped == 1U); /* Полная очередь не перезаписывает старые байты. */
for (uint8_t i = 0U; i < 7U; ++i) { CHECK(pcan_ring_get(&ring, &byte) && byte == i); } CHECK(!pcan_ring_get(&ring, &byte)); /* Проверяет порядок и корректное пустое состояние. */
uint8_t block[] = {1U, 2U, 3U}; CHECK(pcan_ring_write(&ring, block, 3U)); CHECK(pcan_ring_write(&ring, block, 3U)); CHECK(!pcan_ring_write(&ring, block, 3U) && pcan_ring_count(&ring) == 6U); /* Блочная запись должна выполняться целиком либо не менять содержимое. */
cli_t parser; cli_init(&parser, execute, NULL); const char *line = "obd pid 0C\r\n"; for (size_t i = 0U; i < strlen(line); ++i) { cli_feed(&parser, (uint8_t)line[i]); } CHECK(commands == 1U && strcmp(last_command, "obd pid 0C") == 0); /* CRLF не выполняет одну команду дважды. */
for (unsigned i = 0U; i < 100U; ++i) { cli_feed(&parser, 'A'); } cli_feed(&parser, '\n'); CHECK(commands == 1U); cli_feed(&parser, 'x'); cli_reset_line(&parser); cli_feed(&parser, '\n'); CHECK(commands == 1U); /* Переполнение строки и транспортная потеря запрещают выполнение всего фрагмента. */
} /* Завершает тесты буферизации и терминального парсера. */
int main(void) /* Host-тест исполняется обычным процессом Windows без STM32. */
{ test_sf_pid_dtc(); test_isotp_rx(); test_isotp_tx(); test_uds(); test_engine(); test_buffers_cli(); printf("PASS: %u checks\n", assertions); return 0; } /* Успех сообщается только после реального прохождения всех проверок. */
+45
View File
@@ -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 после сброса.
+23
View File
@@ -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. */
+79
View File
@@ -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
+88
View File
@@ -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) # Самостоятельный запуск выводит результаты модели без утверждений о проверке платы.
+105
View File
@@ -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() # Импорт тестами не запускает компилятор и не изменяет рабочую версию.
@@ -20,6 +20,7 @@ class SciKernelBuildTests(unittest.TestCase): # Фиксирует несовм
image = sci.build_kernel(compiler, Path(temporary) / 'f28335_sci_kernel.bin', 30000000, 0x0080, ware) # Плата использует кварц 30 МГц; маска 0x80 выбирает сектор H из комплекта, вызвавшего ошибку.
data = image.read_bytes() # Проверяет конечный транспортный BIN после настоящего hex2000.
self.assertEqual(data[:2], b'\xAA\x08') # Действующий приёмник ожидает ключ SCI8 0x08AA в порядке младшего байта вперёд.
self.assertEqual(data[2:6], b'VR\x01\x00') # Реально собранное ядро объявляет VR1 в резерве SCI8; entry и адреса блоков остаются на штатных смещениях.
self.assertEqual(struct.unpack_from('<HH', data, 18), (0, 0), 'primary_bootloader.obj отклоняет ненулевой адрес входа') # Восемь резервных слов после ключа оставляют entry на смещении 18 октетов.
self.assertEqual(struct.unpack_from('<HHH', data, 22), (2, 0, 0)) # Первый блок должен загрузить двухсловный переход по словному адресу 0x000000.
document = ET.fromstring(subprocess.check_output([str(compiler / 'bin/ofd2000.exe'), '-x', str(image.with_suffix('.out'))])) # Извлекает исходную точку входа COFF до её переопределения транспортным заголовком SCI8.
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
@@ -0,0 +1,20 @@
#ifndef SET_SCI_READBACK_H /* Дополнение подключается к одной копии Shared_Boot.c официального RAM-ядра TI. */
#define SET_SCI_READBACK_H /* Защищает определения от повторного включения в исходник ядра. */
static Uint16 SetSciVerify; /* ReadReservedFn явно устанавливает режим до стирания, поэтому инициализация C runtime не требуется. */
static Uint16 SetSciSectorMask; /* Встроенное ядро получает маску A–H из проверенного host-заголовка SM1 до первого вызова Flash_Erase. */
static void SetSciSendWord(Uint16 value) { /* Передаёт физически прочитанное слово в том же little-endian порядке, что полезные данные SCI8. */
while (!SciaRegs.SCICTL2.bit.TXRDY) {} /* Ожидает освобождения передатчика SCI-A перед младшими восемью битами слова. */
SciaRegs.SCITXBUF = value & 0xFF; /* Маска 0xFF выделяет младший октет 16-битного слова C28x для линии 8N1. */
while (!SciaRegs.SCICTL2.bit.TXRDY) {} /* Старший октет не должен перезаписать ещё не переданный младший октет. */
SciaRegs.SCITXBUF = (value >> 8) & 0xFF; /* Сдвиг на восемь бит выделяет старшую половину считанного слова Flash. */
} /* Заканчивает передачу одного считанного слова без изменения штатной checksum входящего потока. */
static Uint16 SetSciProgram(Uint16 *destination, Uint16 *buffer, Uint32 count, FLASH_ST *status) { /* Оборачивает штатный Flash API, сохраняя адреса, число слов и результат программирования TI. */
Uint16 result = Flash_Program(destination, buffer, count, status); /* Записывает принятую порцию до любого чтения; ошибку TI обработает исходный CopyData. */
Uint32 index; /* 32-битный индекс согласован с единицами длины официального Flash API. */
volatile Uint16 *flash = destination; /* Volatile заставляет читать реальные ячейки Flash, исключая повторную выдачу staging-буфера RAM. */
if (result == STATUS_SUCCESS && SetSciVerify) { /* Чтение выполняется только после успешной записи и явного запроса VR1 от host. */
for (index = 0; index < count; ++index) SetSciSendWord(flash[index]); /* Передаёт каждое физическое слово; нулевой остаток TI не добавляет байты перед checksum. */
} /* После чтения исходный CopyData отправит свою checksum, которую host проверит отдельно от содержимого Flash. */
return result; /* Исходные ветви отказа Flash API остаются обязательными и не подтверждают неудачную запись. */
} /* Заканчивает необязательное чтение порции до разрешения следующей записи или перехода к entry приложения. */
#endif /* Заканчивает дополнение VR1 к официальному TI Flash Kernel A. */
+3 -1
View File
@@ -4,10 +4,12 @@
#ifdef __cplusplus /* C++-потребители используют тот же ABI без изменения имён функций. */
extern "C" { /* Открывает C-связность публичных функций. */
#endif /* Завершает условное начало C-связности. */
PCAN_ABI_API int c2000_sci_decode(const uint8_t *source, size_t size, uint8_t *output, size_t capacity, size_t *written); /* Принимает бинарный SCI8 либо ASCII SCI8 TI со STX/ETX; не принимает Intel HEX. */
PCAN_ABI_API int c2000_sci_decode(const uint8_t *source, size_t size, uint8_t *output, size_t capacity, size_t *written); /* Принимает бинарный/ASCII SCI8 и прежний Intel HEX C2Prog со словными адресами C28x; байтовый HEX других MCU остаётся отдельным форматом. */
PCAN_ABI_API int c2000_sci_validate(const uint8_t *data, size_t size, int flash, uint32_t *entry, uint16_t *sectors); /* Проверяет таблицу, адреса слов C28x, перекрытия и присутствие точки входа до передачи. */
PCAN_ABI_API size_t c2000_sci_session_size(void); /* Возвращает размер хранилища, принадлежащего вызывающему приложению. */
PCAN_ABI_API int c2000_sci_begin(void *storage, size_t size, const uint8_t *kernel, size_t kernel_size, const uint8_t *image, size_t image_size); /* Сохраняет указатели на неизменяемые буферы и проверяет оба образа до autobaud. */
PCAN_ABI_API int c2000_sci_verify(void *storage); /* До autobaud включает чтение каждой записанной порции; требует метку VR версии 1 в резерве RAM-ядра. */
PCAN_ABI_API uint32_t c2000_sci_error_address(const void *storage); /* Возвращает словный адрес первого несовпадения Flash для диагностики Verify. */
PCAN_ABI_API int c2000_sci_next(void *storage, uint8_t *tx, size_t capacity, size_t *tx_size, size_t *rx_size, uint32_t *delay_ms); /* Возвращает 1 для обмена, 2 для паузы, 0 после терминатора и отрицательное число при ошибке состояния. */
PCAN_ABI_API int c2000_sci_accept(void *storage, const uint8_t *rx, size_t size); /* Сверяет эхо ROM либо checksum TI Kernel A, затем разрешает следующий шаг. */
PCAN_ABI_API unsigned c2000_sci_progress(const void *storage); /* Возвращает завершённую долю передачи 0..100 без доступа к системным часам. */
+60 -6
View File
@@ -6,17 +6,56 @@ typedef struct { /* Контекст не владеет образами и н
size_t kernel_size, image_size, kernel_at, image_at, pending_bytes; /* Позиции и длины измеряются физическими октетами файлов. */
unsigned phase, wait, remaining, block_words, extra_zero; /* Отделяет autobaud, байтовое эхо ROM и порционные подтверждения Flash. */
uint16_t expected; /* Хранит ожидаемое эхо либо сумму октетов по контракту TI Kernel A. */
uint16_t sector_mask; /* Маска TI вычисляется по проверенным Flash-блокам; сектор A соответствует младшему биту. */
unsigned verify; /* Режим VR1 запрашивает физическое чтение Flash перед checksum каждой непустой порции. */
size_t readback_at, readback_size; /* Ожидаемые октеты берутся только из полезной части текущей секции SCI8, без её заголовка. */
uint32_t block_address, error_address; /* Адреса выражены 16-битными словами C28x, как адреса LOAD в таблице TI. */
} sci_session_t; /* Размер структуры скрыт за функцией session_size для стабильного ABI. */
static uint16_t word(const uint8_t *p) { return (uint16_t)((uint16_t)p[0] | ((uint16_t)p[1] << 8)); } /* SCI8 передаёт каждый 16-битный элемент младшей октетой вперёд. */
static uint32_t address(const uint8_t *p) { return ((uint32_t)word(p) << 16) | word(p + 2); } /* Адрес состоит из старшего слова C28x, затем младшего слова. */
static int white(uint8_t c) { return c == ' ' || c == '\t' || c == '\r' || c == '\n'; } /* ASCII SCI8 допускает стандартные разделители между октетами. */
static int digit(uint8_t c) { return c >= '0' && c <= '9' ? c - '0' : c >= 'A' && c <= 'F' ? c - 'A' + 10 : c >= 'a' && c <= 'f' ? c - 'a' + 10 : -1; } /* Декодирует только шестнадцатеричные цифры TI ASCII. */
int c2000_sci_decode(const uint8_t *source, size_t size, uint8_t *output, size_t capacity, size_t *written) { /* Приводит оба поддержанных формата к одному бинарному буферу SCI8. */
static void put_word(uint8_t *p, uint16_t value) { p[0] = (uint8_t)value; p[1] = (uint8_t)(value >> 8); } /* SCI8 хранит каждое слово младшим октетом вперёд независимо от порядка байтов Intel HEX. */
static void put_address(uint8_t *p, uint32_t value) { put_word(p, (uint16_t)(value >> 16)); put_word(p + 2, (uint16_t)value); } /* Адрес SCI8 передаётся старшим словом вперёд, сохраняя little endian внутри обоих слов. */
static int decode_word_hex(const uint8_t *source, size_t size, uint8_t *output, size_t capacity, size_t *written) { /* Читает прежний HEX C2Prog: адреса обозначают слова C28x, а пары октетов записаны старшим байтом вперёд. */
size_t at = 0, count = 22, block_at = 0, index, length; uint32_t base = 0, start, next_address = 0, target = 0x33FFF6UL; unsigned eof = 0, sum, type; uint8_t record[260]; /* Аппаратный codestart F28335 занимает слова 33FFF6–33FFF7; явная запись entry имеет приоритет. */
if (capacity < 24) return -2; memset(output, 0, 22); output[0] = 0xAA; output[1] = 0x08; /* Формирует заголовок SCI8 без изменения адресов будущих Flash-блоков. */
while (at < size) { /* Каждая запись полностью проверяется до добавления её данных в результат. */
while (at < size && white(source[at])) ++at; if (at == size) break; /* Разрешает CRLF, LF и пустые строки между записями. */
if (eof || source[at++] != ':' || size - at < 2 || digit(source[at]) < 0 || digit(source[at + 1]) < 0) return -12; /* Запрещает скрытые записи после EOF и повреждённое начало строки. */
length = (size_t)((digit(source[at]) << 4) | digit(source[at + 1])); sum = 0; /* Поле длины Intel HEX измеряет октеты данных даже при словной адресации TI. */
if (size - at < (length + 5) * 2) return -12; /* До чтения ограничивает длину полного заголовка, данных и checksum. */
for (index = 0; index < length + 5; ++index) { /* Контрольная сумма включает длину, адрес, тип и каждый октет полезных данных. */
int high = digit(source[at++]), low = digit(source[at++]); if (high < 0 || low < 0) return -12; /* Не принимает нечётные пары или символы вне шестнадцатеричного алфавита. */
record[index] = (uint8_t)((high << 4) | low); sum += record[index]; /* Сохраняет не более 255 октетов данных в ограниченном локальном буфере. */
} /* Завершает разбор одной Intel HEX-записи без heap. */
if ((sum & 0xFFU) || (at < size && !white(source[at]))) return -12; type = record[3]; /* Дополнение checksum обязано давать ноль по модулю 256, а строка должна закончиться. */
if (type == 0) { /* Адреса данных интерпретируются только по контракту C2000, а не как байтовые адреса STM32. */
uint32_t offset = ((uint32_t)record[1] << 8) | record[2]; if (!length) continue; /* Пустая запись не создаёт нулевой блок, который в SCI8 обозначает конец образа. */
if (length % 2 || base > UINT32_MAX - offset) return -12; start = base + offset; /* Каждая пара октетов должна составлять полное слово без переполнения адреса. */
if (!block_at || start != next_address || (size_t)word(output + block_at) + length / 2 > 0xFFFFU) { /* Сливает соседние записи в секцию SCI8 вместо создания тысяч мелких Flash-блоков. */
if (count > capacity || capacity - count < 6 + length + 2) return -2; block_at = count; memset(output + count, 0, 6); put_address(output + count + 2, start); count += 6; /* Новый заголовок содержит число слов и исходный словный адрес TI; резервирует место терминатора. */
} else if (count > capacity || capacity - count < length + 2) return -2; /* Продолжение секции также оставляет два октета для конечного нулевого размера. */
for (index = 0; index < length; index += 2) { output[count + index] = record[5 + index]; output[count + index + 1] = record[4 + index]; } /* HEX romwidth=16 хранит старший октет первым; SCI8 и COFF используют младший первым. */
put_word(output + block_at, (uint16_t)(word(output + block_at) + length / 2)); count += length; /* В SCI8 размер блока измеряется 16-битными словами, а длина буфера — октетами. */
if (start > UINT32_MAX - length / 2) return -6; next_address = start + (uint32_t)(length / 2); /* Следующая запись может продолжить блок только с точного следующего словного адреса. */
} else if (type == 1) { if (length || record[1] || record[2]) return -12; eof = 1; } /* EOF не содержит данных и запрещает дальнейшие записи. */
else if (type == 2 || type == 4) { if (length != 2 || record[1] || record[2]) return -12; base = (((uint32_t)record[4] << 8) | record[5]) << (type == 2 ? 4 : 16); } /* Поддерживает расширенный сегментный и линейный адрес без удвоения адресов C28x. */
else if (type == 3 || type == 5) { /* Явная точка входа поддерживается обоими стандартными типами стартовой записи Intel HEX. */
if (length != 4 || record[1] || record[2]) return -12; target = type == 3 ? ((((uint32_t)record[4] << 8) | record[5]) << 4) + (((uint32_t)record[6] << 8) | record[7]) : ((uint32_t)record[4] << 24) | ((uint32_t)record[5] << 16) | ((uint32_t)record[6] << 8) | record[7]; /* Стартовый адрес сохраняет те же словные единицы, что адреса данных текущего HEX. */
} else return -12; /* Неизвестный тип записи нельзя молча пропускать в файле для программирования Flash. */
} /* После полного разбора адресная таблица проходит общую проверку Flash и области CSM. */
if (!eof || !block_at || capacity - count < 2) return -12; put_word(output + count, 0); count += 2; put_address(output + 18, target); /* Сохраняет точку входа и добавляет единственный терминатор SCI8. */
{ int status = c2000_sci_validate(output, count, 1, NULL, NULL); if (status) return status; } /* Отвергает реальные словные пересечения, отсутствующий codestart и защищённые адреса. */
*written = count; return 0; /* Публикует только полностью проверенный образ, готовый для существующего SCI-автомата. */
} /* Завершает преобразование прежнего HEX без зависимости от установленного hex2000. */
int c2000_sci_decode(const uint8_t *source, size_t size, uint8_t *output, size_t capacity, size_t *written) { /* Приводит бинарный SCI8, ASCII SCI8 TI и прежний словный Intel HEX к единому проверяемому буферу SCI8. */
size_t at = 0, count = 0; int high, low; /* Хранит позиции отдельно от результата до полного завершения разбора. */
if (written) *written = 0; /* Ошибка никогда не оставляет длину частично принятого файла. */
if (!source || !output || !written || size < 2) return -1; /* Проверяет указатели и минимальный ключ до чтения данных. */
if (source[0] == 0xAA && source[1] == 0x08) { if (size > capacity) return -2; memmove(output, source, size); *written = size; return 0; } /* Бинарный SCI8 сохраняется побайтно. */
while (at < size && white(source[at])) ++at; /* Пропускает пустые строки перед STX. */
if (at < size && source[at] == ':') return decode_word_hex(source + at, size - at, output, capacity, written); /* В явном SCI-маршруте старый Intel HEX TI разбирается словным кодеком, сохраняя общий байтовый парсер других MCU. */
if (at == size || source[at++] != 2) return -3; /* ASCII TI начинается управляющим STX, а не Intel HEX-двоеточием. */
for (;;) { /* Принимает только завершённый ETX поток двухзначных октетов. */
while (at < size && white(source[at])) ++at; /* Разделители не входят в передаваемые байты. */
@@ -59,13 +98,22 @@ int c2000_sci_begin(void *storage, size_t size, const uint8_t *kernel, size_t ke
sci_session_t *s = (sci_session_t *)storage; int status; /* Контекст размещён в памяти вызывающего порта. */
if (!s || size < sizeof(*s)) return -1; memset(s, 0, sizeof(*s)); /* Не оставляет состояние предыдущей передачи. */
status = c2000_sci_validate(kernel, kernel_size, 0, NULL, NULL); if (status) return status; /* В RAM можно передать только корректное ядро. */
status = c2000_sci_validate(image, image_size, 1, NULL, NULL); if (status) return status; /* Ошибочный Flash-образ не должен даже запускать загрузку ядра. */
status = c2000_sci_validate(image, image_size, 1, NULL, &s->sector_mask); if (status) return status; /* Проверка приложения одновременно вычисляет точную маску стирания для встроенного ядра. */
s->kernel = kernel; s->kernel_size = kernel_size; s->image = image; s->image_size = image_size; return 0; /* Срок жизни буферов остаётся обязанностью порта. */
} /* Завершает инициализацию сеанса. */
int c2000_sci_verify(void *storage) { /* Явный запрос Verify не меняет поведение прежней функции begin и старых клиентов. */
sci_session_t *s = (sci_session_t *)storage; /* Режим устанавливается в уже проверенном контексте до первого аппаратного обмена. */
if (!s || !s->kernel || s->phase || s->wait || s->kernel_at) return -8; /* Нельзя включать чтение после начала передачи или при отсутствии подготовленного ядра. */
if (memcmp(s->kernel + 2, "VR\1\0", 4)) return -11; /* Резерв SCI8 RAM-ядра содержит сигнатуру VR и 16-битную версию 1 только у расширенного сборщика. */
s->verify = 1; return 0; /* Реальная проверка будет обязательной для каждой программируемой порции до передачи терминатора. */
} /* Завершает включение аппаратного чтения Flash. */
uint32_t c2000_sci_error_address(const void *storage) { /* Предоставляет диагностический адрес без раскрытия структуры C-контекста. */
const sci_session_t *s = (const sci_session_t *)storage; return s ? s->error_address : 0; /* Нулевой адрес для отсутствующего контекста не может совпасть с разрешённой внутренней Flash. */
} /* Завершает получение адреса ошибки Verify. */
int c2000_sci_next(void *storage, uint8_t *tx, size_t capacity, size_t *tx_size, size_t *rx_size, uint32_t *delay_ms) { /* Планирует ровно один обмен либо обязательную паузу TI. */
sci_session_t *s = (sci_session_t *)storage; size_t count, i; /* Длины считаются октетами, кроме remaining в словах Flash. */
if (!s || !tx || !tx_size || !rx_size || !delay_ms || s->wait || !s->kernel) return -8; *tx_size = *rx_size = 0; *delay_ms = 0; /* Запрещает новый пакет до проверки ответа на предыдущий. */
if (s->phase == 9) return 0; /* Нулевой терминатор уже передан; аппаратная проверка чтением не заявляется. */
if (s->phase == 9) return 0; /* Терминатор разрешён только после подтверждения всех порций, включая чтение Flash при включённом Verify. */
if (s->phase == 2 || s->phase == 4) { ++s->phase; *delay_ms = 3000; return 2; } /* TI f05_DownloadImage выдерживает три секунды после ядра и после его autobaud. */
if (!capacity) return -2; /* Даже одиночный символ синхронизации должен помещаться в буфер. */
if (s->phase == 0 || s->phase == 3) { tx[0] = 'A'; *tx_size = *rx_size = 1; s->expected = 'A'; } /* ROM и Kernel A независимо определяют скорость по эху ASCII A. */
@@ -74,20 +122,26 @@ int c2000_sci_next(void *storage, uint8_t *tx, size_t capacity, size_t *tx_size,
else { /* Прикладной поток подтверждается суммой порций после успешного вызова Flash API. */
if (s->phase == 5) { count = 22; s->image_at = 0; } /* Заголовок подтверждается после стирания выбранных ядром секторов. */
else { /* Обрабатывает полный SCI8-блок без передачи следующего до подтверждения текущего. */
if (!s->remaining) { s->block_words = s->remaining = word(s->image + s->image_at); s->extra_zero = s->block_words > SCI_CHUNK_WORDS && s->block_words % SCI_CHUNK_WORDS == 0; } /* Учитывает точный размер порции TI и его особый пустой остаток. */
if (!s->remaining) { s->block_words = s->remaining = word(s->image + s->image_at); s->extra_zero = s->block_words > SCI_CHUNK_WORDS && s->block_words % SCI_CHUNK_WORDS == 0; if (s->remaining) s->block_address = address(s->image + s->image_at + 2); } /* Читает адрес только непустой секции и учитывает дополнительный ACK пустого остатка TI. */
if (!s->remaining) { if (capacity < 2) return -2; memcpy(tx, s->image + s->image_at, 2); *tx_size = 2; s->image_at += 2; s->phase = 9; return 1; } /* Терминатор завершает программирование и передаёт управление entry приложения. */
count = (size_t)(s->remaining > SCI_CHUNK_WORDS ? SCI_CHUNK_WORDS : s->remaining) * 2; /* Полезная часть порции не превышает RAM-буфер TI. */
if (s->remaining == s->block_words) count += 6; /* Первая порция включает размер секции и 32-битный словный адрес. */
} /* Получена длина заголовка либо одной порции приложения. */
if (capacity < count) return -2; memcpy(tx, s->image + s->image_at, count); *tx_size = count; *rx_size = 2; s->expected = 0; /* Копирует готовые байты без повторной сборки таблицы в порту GUI. */
s->readback_size = 0; /* Заголовок erase и служебные подтверждения не представляют содержимое Flash. */
if (s->verify && s->phase == 5) { tx[2] = 'V'; tx[3] = 'R'; tx[4] = 1; tx[5] = 0; } /* Первые два резервных слова заголовка включают VR1; исходный BIN и его SHA-256 остаются неизменными. */
if (s->phase == 5 && !memcmp(s->kernel + 6, "SM\1\0", 4)) { if (!s->verify) memset(tx + 2, 0, 4); tx[6] = 'S'; tx[7] = 'M'; tx[8] = (uint8_t)s->sector_mask; tx[9] = 0; tx[10] = (uint8_t)(s->sector_mask ^ 0xFFU); tx[11] = 0; } /* SM1 передаёт точную маску и инверсию; при выключенном Verify резерв исходного BIN не может самовольно включить чтение в ядре. */
if (s->verify && s->phase == 6) { s->readback_at = s->image_at + (s->remaining == s->block_words ? 6 : 0); s->readback_size = count - (s->readback_at - s->image_at); *rx_size += s->readback_size; } /* Ожидает физические октеты текущей порции, затем штатную двухоктетную checksum TI. */
for (i = 0; i < count; ++i) s->expected = (uint16_t)(s->expected + tx[i]); s->pending_bytes = count; /* Сумма октетов по модулю 65536 совпадает с TI SendCheckSum. */
} /* Ответ на запланированный обмен должен быть принят до следующего шага. */
s->wait = (unsigned)*rx_size; return 1; /* Нулевой rx_size означает отправку терминатора без недостоверного ожидания ACK. */
} /* Завершает формирование следующего действия. */
int c2000_sci_accept(void *storage, const uint8_t *rx, size_t size) { /* Проверяет фактические ответы ROM и Flash Kernel A. */
sci_session_t *s = (sci_session_t *)storage; unsigned words_sent; /* Состояние алгоритма меняется только после достоверного ответа. */
sci_session_t *s = (sci_session_t *)storage; unsigned words_sent; size_t i; /* Индекс октета позволяет сообщить точный словный адрес первого несовпадения Flash. */
if (!s || !rx || !s->wait || size != s->wait) return -8; /* Не принимает пустое, лишнее или усечённое подтверждение. */
if ((size == 1 ? rx[0] : word(rx)) != s->expected) return -9; s->wait = 0; /* Несовпадение эха или checksum останавливает передачу. */
if ((size == 1 ? rx[0] : word(rx + size - 2)) != s->expected) return -9; /* Checksum завершает ответ как в исходном TI-протоколе, так и после физического чтения VR1. */
if (s->verify && s->phase == 6) { for (i = 0; i < s->readback_size; ++i) if (rx[i] != s->image[s->readback_at + i]) { s->error_address = s->block_address + s->block_words - s->remaining + (uint32_t)(i / 2); return -10; } } /* Сравнивает каждый октет Flash с неизменяемым BIN и сохраняет адрес C28x; ошибка запрещает следующий блок и запуск приложения. */
s->wait = 0; /* Следующий пакет разрешён только после успешной проверки checksum и всех запрошенных байтов Flash. */
if (s->phase == 0) s->phase = 1; /* После первого autobaud начинается байтовая передача RAM-ядра. */
else if (s->phase == 1) { if (++s->kernel_at == s->kernel_size) s->phase = 2; } /* Последний подтверждённый октет ядра запускает паузу его старта. */
else if (s->phase == 3) s->phase = 4; /* После autobaud ядра выдерживается пауза перед стиранием Flash. */
+9
View File
@@ -0,0 +1,9 @@
cmake_minimum_required(VERSION 3.13) # Использует ту же минимальную версию CMake, что и проект потребителя прошивки.
project(uart_usb C) # Собирает единственный C99 кодек и соответствующий порт настольного транспорта.
add_library(uart_usb SHARED uart_usb.c) # Создаёт библиотеку для ctypes без второй реализации wire-протокола.
target_include_directories(uart_usb PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}) # Публикует общий стабильный ABI заголовка uart_usb.h.
set_target_properties(uart_usb PROPERTIES C_STANDARD 99 C_STANDARD_REQUIRED YES PREFIX "") # Сохраняет имя uart_usb.dll на Windows и требует переносимый стандарт C99.
if(WIN32) # Настольный USB транспорт этой версии реализован для штатного WinUSB.
target_sources(uart_usb PRIVATE ports/windows/uart_usb_winusb.c) # Добавляет очередь шестнадцати overlapped RX вместо синхронного опроса из GUI.
target_link_libraries(uart_usb PRIVATE winusb setupapi) # Использует системные библиотеки Windows без зависимости от libusb или PyUSB.
endif() # MCU компилирует uart_usb.c и stm32g474 порт напрямую своим проектом.
+122
View File
@@ -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` без служебных заголовков и перекодирования.
На неподключённой плате измерение реальной скорости и проверка проводов
не выполняются; это отдельная аппаратная проверка.

Some files were not shown because too many files have changed in this diff Show More