Compare commits
11
Commits
device-tools
...
main
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
824fe55fe9 | ||
|
|
afdf62cfa4 | ||
|
|
4825465583 | ||
|
|
e627d088e0 | ||
|
|
34d9016118 | ||
|
|
28fe22439c | ||
|
|
a197437985 | ||
|
|
ae018a1347 | ||
|
|
80d8fe1794 | ||
|
|
d057df7698 | ||
|
|
f9d369d032 |
@@ -4,3 +4,8 @@
|
||||
|
||||
*.pdf binary
|
||||
*.png binary
|
||||
|
||||
# CMD.exe требует CRLF в BAT, иначе после переноса Git часть команд разбирается неверно.
|
||||
*.bat text eol=crlf
|
||||
# Командные файлы CMD выполняются тем же интерпретатором Windows и требуют CRLF.
|
||||
*.cmd text eol=crlf
|
||||
|
||||
@@ -7,6 +7,8 @@ cmake-build-*/
|
||||
*.a
|
||||
*.elf
|
||||
*.bin
|
||||
# Встроенные ядра F28335 являются ресурсами поставки, а не промежуточными результатами пользовательской сборки.
|
||||
!python/set_devices/sci_kernels/*.bin
|
||||
*.hex
|
||||
*.map
|
||||
*.lst
|
||||
|
||||
@@ -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, задержка |
|
||||
|
||||
@@ -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-шина для этих тестов не требуются.
|
||||
@@ -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.
|
||||
@@ -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-кадра. */
|
||||
@@ -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-журнала. */
|
||||
@@ -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 /* Завершает интерфейс проверяемого отдельно парсера. */
|
||||
@@ -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. */
|
||||
@@ -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. */
|
||||
@@ -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 /* Завершает интерфейс общих кодов ошибок. */
|
||||
@@ -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, подписи и политики разрешения. */
|
||||
@@ -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 /* Ни один клапан или компрессор не управляется по догадке. */
|
||||
@@ -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. */
|
||||
@@ -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. */
|
||||
@@ -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 /* Завершает проверяемый менеджер процедур. */
|
||||
@@ -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. */
|
||||
@@ -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 /* Завершает безопасный реестр автомобильных данных. */
|
||||
@@ -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-ответом. */
|
||||
@@ -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; /* Записывает символ только после полной проверки ёмкости. */
|
||||
} /* Завершает неблокирующий шаг построчного парсера. */
|
||||
@@ -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
@@ -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 после блока. */
|
||||
} /* Завершает ограниченный шаг передачи и контроля таймаутов. */
|
||||
@@ -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; } /* Границы проверяются до чтения записи. */
|
||||
@@ -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 является корректным положительным результатом. */
|
||||
} /* Завершает декодер без зависимости от транспорта. */
|
||||
@@ -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. */
|
||||
@@ -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. */
|
||||
} /* Завершает шаг менеджера сервисных функций. */
|
||||
@@ -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*, неизвестный код остаётся явным. */
|
||||
} /* Завершает каталог стандартных отрицательных ответов. */
|
||||
} /* Возвращённые строки неизменяемы и не требуют освобождения. */
|
||||
@@ -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 не разрешает передачу. */
|
||||
@@ -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
@@ -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; } /* Успех сообщается только после реального прохождения всех проверок. */
|
||||
@@ -0,0 +1,45 @@
|
||||
# Загрузчик F28335 по RS для periph_28335
|
||||
|
||||
Постоянный загрузчик принимает `INITLOAD` (58), `LOAD` (51) и `TFLASH` (55),
|
||||
совместимые с Flash RS в терминале `periph_28335` SETGUI. Ядро не зависит от
|
||||
UART, GPIO, ОС и Qt. Оно использует существующий валидатор и writer
|
||||
`c/protocan-boot/ports/tms320f28335`, сохраняя единый формат SCI8/FAB1.
|
||||
|
||||
Слои: клиент periph_28335 → автомат RS → проверка SCI8/FAB1 → callbacks платы
|
||||
→ TI Flash API. Передаются октеты; адреса CPU считаются 16-битными словами.
|
||||
|
||||
| Файл | Назначение и зависимости |
|
||||
|---|---|
|
||||
| `include/f28335_rs_boot.h`, `src/f28335_rs_boot.c` | Переносимый автомат, зависит от protocan-boot |
|
||||
| `ports/tms320f28335/flash_api.c` | Официальный TI API v2.10, заголовки устройства, частота F28335_RS_CPU_HZ |
|
||||
| `ports/tms320f28335/boot.cmd` | Постоянный сектор A, отдельные RAMAPI, RAMFUNCS и стек |
|
||||
| `tools/build.py` | Сборка boot и выпуск проверенных Flash OUT/SCI8 с manifest/SHA-256 |
|
||||
| `tests/test_boot.py` | Настоящий автомат и writer в модели RAM/Flash без оборудования |
|
||||
|
||||
Приложение занимает `[0x300000,0x338000)`, первые 16 слов содержат FAB1.
|
||||
Сектор A и переход `0x33FFF6` принадлежат постоянному загрузчику.
|
||||
`INITLOAD` разрешает только staging `0x200000`, чётный размер 24..130560
|
||||
октетов. Ошибочные CRC, таймаут и ошибка UART отзывают подтверждение LOAD.
|
||||
Перед erase повторно проверяются RAM, CRC32, все адреса, entry и FAB1.
|
||||
Общий writer пишет FAB1 последним и проверяет физическую Flash.
|
||||
Ошибка не удаляет recovery; перезапуск разрешён после успешного ACK.
|
||||
|
||||
Контракт callbacks: `stage_write(user, offset, octet)` и `stage.read(user,
|
||||
offset, buffer, size)` обслуживают RAM относительно начала файла;
|
||||
`transmit(user, data, size)` возвращает true после физического окончания TX;
|
||||
`program(user, image)` вызывает общий Flash writer; `reboot(user)` сбрасывает
|
||||
контроллер. Все чтения/записи должны завершиться полностью либо вернуть false.
|
||||
Прерывания в постоянном загрузчике запрещены, watchdog выключен на время
|
||||
стирания. Межбайтовый таймаут аппаратный порт передаёт в `f28335_rs_abort`.
|
||||
|
||||
Быстрый старт: выделить `f28335_rs_boot_t` в RAM, заполнить пять callbacks,
|
||||
вызвать `f28335_rs_init(&boot, &port, 16)` и передавать каждый октет SCI
|
||||
через `f28335_rs_feed(&boot, octet)`. До запуска приложения вызвать
|
||||
`f28335_flash_app_validate`, после успеха перейти на возвращённый entry.
|
||||
Аппаратные таймауты, выключение силовых выходов и выбор скорости задаёт плата.
|
||||
|
||||
Подключено в `prolitarski_ups`: SCI-A/RS-422, 115200 8N1, адрес 16;
|
||||
Monitor №93=1 в остановленном состоянии запрашивает boot через watchdog.
|
||||
Первичная установка требует записи двух OUT через JTAG с сохранением
|
||||
сектора A при загрузке приложения. Все последующие RS-обновления меняют B–H.
|
||||
Повреждённое приложение оставляет устройство в RS recovery после сброса.
|
||||
@@ -0,0 +1,23 @@
|
||||
#ifndef F28335_RS_BOOT_H /* Один контракт обслуживает постоянный загрузчик и его модель на ПК. */
|
||||
#define F28335_RS_BOOT_H /* Исключает повторные объявления при подключении аппаратного порта. */
|
||||
#include "../../protocan-boot/ports/tms320f28335/f28335_flash_update.h" /* Повторно использует проверку SCI8/FAB1 и запись с защитой сектора A. */
|
||||
#define F28335_RS_STAGE 0x200000UL /* Адрес слова внешней RAM совпадает с INITLOAD в periph_28335. */
|
||||
#define F28335_RS_LIMIT F28335_AB_SLOT_BYTES /* Проверяемый SCI8 ограничен 130560 октетами общего валидатора F28335. */
|
||||
typedef struct { /* Аппаратная плата владеет памятью и UART; ядро владеет только состоянием протокола. */
|
||||
bool (*stage_write)(void *, uint32_t, unsigned int); /* Записывает один октет по относительному смещению staging RAM. */
|
||||
f28335_boot_io_t stage; /* Читает октеты staging для повторной CRC32 и проверки всех адресов перед erase. */
|
||||
bool (*transmit)(void *, const unsigned int *, unsigned int); /* Передаёт полный ответ и дожидается последнего стопового бита. */
|
||||
unsigned int (*program)(void *, f28335_flash_update_t *); /* Возвращает 0 после записи и проверки, код TI либо 1004/1006 при защите или ошибке проверки; управление остаётся в секторе A. */
|
||||
void (*reboot)(void *); /* Выполняет reset только после успешного ответа о завершении записи. */
|
||||
void *user; /* Независимый контекст UART, Flash и модели испытаний. */
|
||||
} f28335_rs_port_t; /* Аппаратный порт не собирает кадры и не дублирует алгоритм проверки образа. */
|
||||
typedef struct { /* Экземпляр допускает работу без heap и без прерываний. */
|
||||
f28335_rs_port_t port; /* Сохраняет callbacks на весь сеанс обновления. */
|
||||
f28335_flash_update_t image; /* Ограниченный индекс адресных секций и страничный кеш общего валидатора. */
|
||||
uint32_t length, position, expected, received, crc32; /* Длины и позиции считаются октетами, независимо от sizeof(char) C28x. */
|
||||
unsigned int address, command, crc16, wire_crc, loaded, fault, header[16]; /* Заголовок вмещает максимальный фиксированный запрос TFLASH на 16 октетов. */
|
||||
} f28335_rs_boot_t; /* Загруженный блок никогда не исполняется как произвольный код RAM. */
|
||||
void f28335_rs_init(f28335_rs_boot_t *s, const f28335_rs_port_t *port, unsigned int address); /* Настраивает адрес 1..255 и сбрасывает разрешение программирования. */
|
||||
void f28335_rs_abort(f28335_rs_boot_t *s); /* Сбрасывает неполный кадр и подтверждение LOAD при таймауте или аппаратной ошибке SCI. */
|
||||
void f28335_rs_feed(f28335_rs_boot_t *s, unsigned int value); /* Принимает один восьмибитный октет совместимых INITLOAD/LOAD/TFLASH. */
|
||||
#endif /* Завершает публичный интерфейс общего RS-загрузчика. */
|
||||
@@ -0,0 +1,28 @@
|
||||
MEMORY /* Все адреса и размеры относятся к 16-битным словам CPU C28x. */
|
||||
{ /* Постоянный загрузчик использует только сектор A и внутреннюю RAM. */
|
||||
PAGE 0: /* Исполняемый код и адреса загрузки из Flash. */
|
||||
FLASHA : origin = 0x338000, length = 0x007F80 /* Область постоянного boot заканчивается до служебной области CSM. */
|
||||
BEGIN : origin = 0x33FFF6, length = 0x000002 /* Два слова аппаратного перехода Boot ROM в режиме Flash. */
|
||||
RAMAPI : origin = 0x008000, length = 0x001800 /* 6144 слова предназначены для копии официального TI Flash API. */
|
||||
RAMFUNCS : origin = 0x00F800, length = 0x000800 /* InitFlash выполняется из RAM, не затрагивая код самого API. */
|
||||
RESET : origin = 0x3FFFC0, length = 0x000002 /* Вектор reset находится в ROM и не программируется. */
|
||||
PAGE 1: /* Данные загрузчика не зависят от размещения будущего приложения. */
|
||||
RAMM0 : origin = 0x000058, length = 0x0003A8 /* Слова 50..57 сохранены для запроса boot через watchdog reset. */
|
||||
RAMM1 : origin = 0x000400, length = 0x000400 /* Стек на 1024 слова вмещает буфер writer и контекст runtime. */
|
||||
RAMDATA : origin = 0x00E000, length = 0x001800 /* Индекс SCI8, состояния протокола и аппаратные данные находятся в RAM. */
|
||||
} /* Внешняя RAM используется через callbacks и не содержит исполняемого кода. */
|
||||
SECTIONS /* C runtime загрузчика, в отличие от приложения, целиком сохраняется в A. */
|
||||
{ /* Размещение API указано до общей .text, чтобы извлечь все его код и константы. */
|
||||
codestart : > BEGIN, PAGE = 0 /* Штатный TI startup запрещает watchdog и вызывает _c_int00 загрузчика. */
|
||||
flash_api : { -lFlash28335_API_V210.lib(.text) -lFlash28335_API_V210.lib(.econst) } LOAD = FLASHA, RUN = RAMAPI, LOAD_START(_FlashApiLoadStart), LOAD_END(_FlashApiLoadEnd), RUN_START(_FlashApiRunStart), PAGE = 0 /* Ни одна функция TI API не исполняется из занятого банка Flash. */
|
||||
.text : > FLASHA, PAGE = 0 /* Протокол, валидатор и собственный runtime загрузчика остаются после обновления приложения. */
|
||||
.cinit : > FLASHA, PAGE = 0 /* Инициализация данных не зависит от целостности B–H. */
|
||||
.pinit : > FLASHA, PAGE = 0 /* Поддерживает стандартную секцию инициализации COFF. */
|
||||
.econst : > FLASHA, PAGE = 0 /* Таблицы и константы загрузчика также защищены от erase B–H. */
|
||||
.switch : > FLASHA, PAGE = 0 /* Таблицы переходов автомата не находятся в заменяемом приложении. */
|
||||
ramfuncs : LOAD = FLASHA, RUN = RAMFUNCS, LOAD_START(_RamfuncsLoadStart), LOAD_END(_RamfuncsLoadEnd), RUN_START(_RamfuncsRunStart), PAGE = 0 /* InitFlash переносится до изменения Flash wait states. */
|
||||
.stack : > RAMM1, PAGE = 1 /* Стек отделён от handoff и буфера внешней RAM. */
|
||||
.ebss : > RAMDATA, PAGE = 1 /* Нулевая инициализация касается только состояния boot. */
|
||||
.esysmem : > RAMDATA, PAGE = 1 /* Оставляет корректную секцию runtime без использования heap в алгоритме. */
|
||||
.reset : > RESET, PAGE = 0, TYPE = DSECT /* ROM-вектор не попадает в программируемый OUT. */
|
||||
} /* Пароли CSM, OTP и сектора приложения не создаются в образе загрузчика. */
|
||||
@@ -0,0 +1,33 @@
|
||||
#include "DSP2833x_Device.h" /* Использует официальные описания регистров выбранной платы F28335. */
|
||||
#include "../../include/f28335_rs_boot.h" /* Получает общий writer с повторной проверкой staging перед erase. */
|
||||
#include "Flash2833x_API_Library.h" /* Официальный TI API v2.10 выполняет физические операции внутренней Flash. */
|
||||
#include <string.h> /* Копирует код и таблицы TI API в RAM до изменения общего банка Flash. */
|
||||
extern Uint16 FlashApiLoadStart, FlashApiLoadEnd, FlashApiRunStart; /* LOAD/RUN-символы создаёт linker постоянного загрузчика. */
|
||||
static FLASH_ST api_status; /* Диагностика TI хранится в RAM и доступна во время занятости Flash. */
|
||||
static unsigned int api_error; /* Код последней операции TI передаётся клиенту без подмены успехом. */
|
||||
static bool erase(void *user) /* Стирает исключительно семь секторов приложения B–H. */
|
||||
{ /* Сам API исполняется из RAM; вызывающий код продолжит работу из сохранённого сектора A. */
|
||||
(void)user; api_error = Flash_Erase(0x00FEU, &api_status); return api_error == STATUS_SUCCESS; /* В TI v2.10 бит 0 выбирает A, маска FE исключает его и сохраняет recovery; результат сохраняет диагностику API. */
|
||||
} /* Ненулевой результат запрещает программирование данных. */
|
||||
static bool program(void *user, uint32_t address, uint16_t *data, unsigned int words) /* Записывает и немедленно проверяет одну ограниченную порцию. */
|
||||
{ /* Дополнительная аппаратная проверка диапазона защищает boot независимо от wire-парсера. */
|
||||
Uint16 result; (void)user; /* Результат официального API не подменяется успешным кодом протокола. */
|
||||
if (!words || address < F28335_FLASH_APP_START || address >= F28335_FLASH_APP_STOP || words > F28335_FLASH_APP_STOP - address) return false; /* Исключает сектор A, CSM, OTP и переполнение верхней границы. */
|
||||
result = Flash_Program((Uint16 *)address, data, words, &api_status); /* Данные и рабочий буфер находятся в RAM. */
|
||||
if (!result) result = Flash_Verify((Uint16 *)address, data, words, &api_status); /* Подтверждает физическую запись до перехода к следующей порции. */
|
||||
api_error = result; return result == STATUS_SUCCESS; /* Ошибка оставляет FAB1 неопубликованным, сохраняет код TI и RS recovery. */
|
||||
} /* Все прерывания остаются запрещёнными на протяжении жизни постоянного загрузчика. */
|
||||
uint16_t F28335Rs_ReadFlash(void *user, uint32_t address) /* Читает физическое слово для общей проверки приложения перед запуском. */
|
||||
{ /* Общий валидатор ограничивает адреса диапазоном B–H. */
|
||||
(void)user; return *(volatile Uint16 *)address; /* Чтение применяется только вне активной операции Flash API. */
|
||||
} /* Стёртые промежутки проверяются вместе с загруженными секциями. */
|
||||
unsigned int F28335Rs_Program(void *user, f28335_flash_update_t *image) /* Callback работает из сектора A и возвращает полный статус, совместимый с Flash RS periph_28335. */
|
||||
{ /* Проект задаёт реальный SYSCLK в герцах через F28335_RS_CPU_HZ при компиляции. */
|
||||
f28335_flash_ops_t ops; (void)user; /* Таблица операций не содержит обращений к приложению из B–H. */
|
||||
if (CsmRegs.CSMSCR.bit.SECURE) return 0x1004U; /* Не начинает стирание защищённого CSM устройства и передаёт клиенту стандартный статус защиты. */
|
||||
memcpy(&FlashApiRunStart, &FlashApiLoadStart, &FlashApiLoadEnd - &FlashApiLoadStart); /* Все .text и .econst TI API копируются во внутреннюю RAM. */
|
||||
Flash_CPUScaleFactor = (Uint32)(1048576.0L * 200.0L * F28335_RS_CPU_HZ / 1000000000.0L); /* Формула IQ20 из TI v2.10 учитывает фактическую частоту CPU, единицы — Гц. */
|
||||
Flash_CallbackPtr = 0; ops.erase = erase; ops.program = program; ops.read = F28335Rs_ReadFlash; ops.user = 0; /* Callback во Flash во время erase/program запрещён. */
|
||||
api_error = 0U; if (f28335_flash_update_program(image, &ops)) return 0U; /* Повторная CRC staging, запись FAB1 последним и CRC физической Flash находятся в общем writer; ноль означает подтверждённый успех. */
|
||||
return api_error ? api_error : 0x1006U; /* Ошибка TI сохраняет свой код, отказ структуры/readback без ошибки API получает отдельный ненулевой статус. */
|
||||
} /* После отказа управление остаётся в постоянном загрузчике и допускает новый LOAD. */
|
||||
@@ -0,0 +1,79 @@
|
||||
#include "../include/f28335_rs_boot.h" /* Единственная реализация автомата используется платой и host-тестами. */
|
||||
#include <string.h> /* Сбрасывает состояние без динамического выделения памяти. */
|
||||
static unsigned int crc16(unsigned int crc, unsigned int value) /* CRC16 Modbus защищает запросы и ответы существующего periph_28335. */
|
||||
{ /* Все операции явно ограничены 16 битами и подходят для 16-битного int C28x. */
|
||||
unsigned int bit; /* Каждый принятый октет содержит ровно восемь значащих битов. */
|
||||
crc ^= value & 255U; /* Старшие биты аппаратного регистра SCI не являются данными протокола. */
|
||||
for (bit = 0U; bit < 8U; ++bit) crc = (crc & 1U) ? ((crc >> 1) ^ 0xA001U) : (crc >> 1); /* Отражённый полином A001 соответствует CRC16 Modbus. */
|
||||
return crc & 65535U; /* На ПК unsigned int шире C28x, поэтому маска сохраняет одинаковый результат. */
|
||||
} /* Завершает переносимый шаг CRC. */
|
||||
static uint32_t get32(const unsigned int *p) /* Поля BIOS передаются младшим октетом вперёд, в отличие от адреса внутри SCI8. */
|
||||
{ /* Приведение перед сдвигом исключает потерю старших битов на 16-битном int. */
|
||||
return (uint32_t)p[0] | ((uint32_t)p[1] << 8) | ((uint32_t)p[2] << 16) | ((uint32_t)p[3] << 24); /* Возвращает адрес слова либо длину октетов по назначению поля. */
|
||||
} /* Формат запроса совпадает с periph28335_firmware.request. */
|
||||
static bool reply(f28335_rs_boot_t *s, unsigned int command, unsigned int status) /* TFLASH сообщает конкретный статус, остальные успешные команды — короткий ACK. */
|
||||
{ /* Ответ не содержит хвостового паддинга, который клиент periph_28335 считает необязательным. */
|
||||
unsigned int frame[6], crc = 0xFFFFU, i, size = command == 55U ? 4U : 2U; /* CMD_TFLASH=55 включает два октета результата; ACK INITLOAD/LOAD содержит адрес и команду. */
|
||||
frame[0] = s->address; frame[1] = command; frame[2] = status & 255U; frame[3] = status >> 8; /* Сохраняет принятый адрес и little-endian статус. */
|
||||
for (i = 0U; i < size; ++i) crc = crc16(crc, frame[i]); /* Контрольная сумма защищает все значащие поля ответа. */
|
||||
frame[size] = crc & 255U; frame[size + 1U] = crc >> 8; /* CRC16 передаётся младшим октетом вперёд. */
|
||||
return s->port.transmit(s->port.user, frame, size + 2U); /* Reset разрешается только после фактического завершения передачи. */
|
||||
} /* Ошибка UART никогда не превращается в разрешение перезапуска. */
|
||||
void f28335_rs_abort(f28335_rs_boot_t *s) /* Инвалидирует частичный кадр и прежнее подтверждение образа. */
|
||||
{ /* Порт вызывает эту функцию при межбайтовом таймауте, переполнении либо RXERROR. */
|
||||
s->position = 0UL; s->loaded = 0U; s->length = 0UL; s->image.valid = false; /* Новый TFLASH после сбоя требует полного нового INITLOAD/LOAD. */
|
||||
} /* Прерывание сеанса не изменяет действующую Flash. */
|
||||
void f28335_rs_init(f28335_rs_boot_t *s, const f28335_rs_port_t *port, unsigned int address) /* Создаёт независимый экземпляр без скрытых глобальных переменных. */
|
||||
{ /* Конфигурация платы должна передать все обязательные callbacks. */
|
||||
memset(s, 0, sizeof(*s)); s->port = *port; s->address = address; /* Обнуляет кеш, счётчики и разрешение LOAD до первого принятого кадра. */
|
||||
} /* Аппаратная инициализация SCI и GPIO остаётся в проекте платы. */
|
||||
static void execute(f28335_rs_boot_t *s) /* Выполняет только полностью принятый запрос с подтверждённой CRC16. */
|
||||
{ /* Транспортные поля никогда не разыменовываются как произвольные CPU-адреса. */
|
||||
uint32_t source, destination, length; unsigned int status = 0U; pcan_boot_manifest_t manifest; /* Manifest общего валидатора используется только для размера и транспортной CRC32. */
|
||||
if (s->command == 58U) { /* CMD_INITLOAD=58 резервирует фиксированный безопасный staging вместо произвольной записи памяти. */
|
||||
source = get32(s->header + 2); length = get32(s->header + 6); s->loaded = 0U; s->length = 0UL; /* Новая подготовка всегда отзывает подтверждение прежнего блока. */
|
||||
if (source == F28335_RS_STAGE && length >= 24UL && length <= F28335_RS_LIMIT && !(length & 1UL)) { s->length = length; reply(s, 58U, 0U); } /* Чётный SCI8 должен поместиться в предел общего проверяемого формата. */
|
||||
} else if (s->command == 51U) { /* CMD_LOAD=51 уже принял поток в staging, но до этой точки не разрешал запись Flash. */
|
||||
if (!s->fault && s->length) { s->loaded = 1U; reply(s, 51U, 0U); } /* Подтверждает блок только после полного приёма, успешной записи RAM и CRC16. */
|
||||
} else if (s->command == 55U) { /* CMD_TFLASH=55 совместим с шестибайтовым статусом periph_28335. */
|
||||
destination = get32(s->header + 2); source = get32(s->header + 6); length = get32(s->header + 10); /* Назначение, источник и размер сохраняют порядок полей существующего GUI. */
|
||||
if (destination || source || length) { /* Нулевая тройка служит безопасной пробой поддержки без стирания и запуска. */
|
||||
if (!s->loaded || destination != F28335_FLASH_APP_START || source != F28335_RS_STAGE || length != s->length) status = 0x1003U; /* Требует ровно тот блок, который подтвердил завершённый LOAD. */
|
||||
else { /* Общий валидатор повторно читает RAM и сравнивает CRC32, записанную при приёме. */
|
||||
memset(&manifest, 0, sizeof(manifest)); manifest.image_size = length; manifest.image_crc32 = s->crc32; /* Не доверяет CRC из непроверенного пользовательского manifest. */
|
||||
if (!f28335_flash_update_validate(&s->image, &s->port.stage, 0UL, &manifest)) status = 0x1002U; /* Отвергает сектор A, CSM, OTP, перекрытия, неверный FAB1 и повреждённые данные до erase. */
|
||||
else status = s->port.program(s->port.user, &s->image); /* Сохраняет конкретный код TI, защиту CSM 1004 и ошибку readback 1006; отказ оставляет RS recovery доступным. */
|
||||
} /* Завершает проверку и аппаратную запись текущего образа. */
|
||||
s->loaded = 0U; /* Повторная команда записи требует нового подтверждённого LOAD независимо от результата. */
|
||||
} /* Безопасная проба не потребляет подтверждённый блок RAM. */
|
||||
if (reply(s, 55U, status) && !status && length) s->port.reboot(s->port.user); /* Успешный reset следует только после записи, проверки физической Flash и отправки ACK. */
|
||||
} /* Остальные команды не поддерживаются и не меняют память. */
|
||||
} /* EEPROM параметров не входит ни в один callback загрузчика. */
|
||||
void f28335_rs_feed(f28335_rs_boot_t *s, unsigned int value) /* Разбирает запросы последовательно без большого приёмного массива. */
|
||||
{ /* Один вызов обрабатывает ровно один октет; время межбайтового ожидания контролирует порт. */
|
||||
uint32_t position = s->position; pcan_boot_byte_t octet = value & 255U; /* Маска исключает флаги SCI и старшие биты широкого char. */
|
||||
if (!position) { /* Новый кадр начинается только с адреса этого устройства. */
|
||||
if (octet != s->address || !s->address || s->address > 255U) return; /* Чужой адрес не получает ACK и не запускает запись RAM. */
|
||||
s->crc16 = 0xFFFFU; s->wire_crc = 0U; s->fault = 0U; /* CRC16 каждого запроса начинается со значения FFFF протокола Modbus. */
|
||||
} /* После первого октета автомат ожидает номер команды. */
|
||||
if (position == 1UL) { /* Второй октет задаёт фиксированную либо потоковую длину кадра. */
|
||||
s->command = octet; /* Сохраняет неизменный номер BIOS-команды. */
|
||||
if (octet == 58U) s->expected = 12UL; /* INITLOAD содержит адрес/команду, два u32 и CRC16: 12 октетов. */
|
||||
else if (octet == 55U) s->expected = 16UL; /* TFLASH содержит три u32 и занимает 16 октетов с CRC16. */
|
||||
else if (octet == 51U && s->length) { s->expected = s->length + 4UL; s->loaded = 0U; s->crc32 = 0UL; } /* LOAD состоит из адреса/команды, точного SCI8 и CRC16. */
|
||||
else { f28335_rs_abort(s); return; } /* Неизвестная команда не позволяет использовать оставшиеся байты как адрес CPU. */
|
||||
} /* Только распознанный заголовок разрешает приём полезных данных. */
|
||||
if (position < 2UL || s->command != 51U) { if (position < 16UL) s->header[position] = octet; } /* Фиксированные запросы сохраняются в ограниченном заголовке. */
|
||||
else if (position < s->expected - 2UL) { /* Поток LOAD записывается в RAM, пока завершающая CRC16 ещё не подтверждена. */
|
||||
if (!s->port.stage_write(s->port.user, position - 2UL, octet)) s->fault = 1U; /* Ошибка RAM запрещает подтверждение и последующий erase. */
|
||||
s->crc32 = pcan_boot_crc32_update(s->crc32, &octet, 1U); /* Независимая CRC32 позволяет обнаружить изменение staging после LOAD. */
|
||||
} /* Два завершающих октета CRC не попадают в staging образа. */
|
||||
if (position < 2UL || position < s->expected - 2UL) s->crc16 = crc16(s->crc16, octet); /* CRC16 включает адрес, команду и всю полезную нагрузку. */
|
||||
else if (position == s->expected - 2UL) s->wire_crc = octet; /* Первый октет контрольной суммы является младшим. */
|
||||
else s->wire_crc |= (unsigned int)octet << 8; /* Второй октет завершает 16-битную CRC принятого кадра. */
|
||||
s->position = position + 1UL; /* Продвигает курсор только после обработки текущего октета. */
|
||||
if (position >= 1UL && s->position == s->expected) { /* Запрос исполняется ровно один раз после получения последнего октета. */
|
||||
s->position = 0UL; /* Следующий адрес начнёт независимый кадр даже при ошибочной CRC текущего. */
|
||||
if (s->wire_crc == s->crc16) execute(s); else f28335_rs_abort(s); /* Повреждённый кадр отзывает прежний LOAD и никогда не вызывает program. */
|
||||
} /* Частичный кадр остаётся в ожидании следующего октета либо внешнего timeout. */
|
||||
} /* Автомат не использует системные часы, регистры MCU или динамическую память. */
|
||||
File diff suppressed because one or more lines are too long
@@ -0,0 +1,88 @@
|
||||
"""Проверяет production-автомат RS и общий writer на модели сбоев без платы.""" # Не вызывает JTAG, COM и TI Flash API.
|
||||
import ctypes # Передаёт октеты настоящему скомпилированному C-автомату.
|
||||
import importlib.util # Использует общий подписыватель FAB1 для корректных тестовых образов.
|
||||
import os # Добавляет runtime GCC только в окружение тестового процесса.
|
||||
from pathlib import Path # Разрешает пути относительно установленной библиотеки templates.
|
||||
import struct # Формирует стандартные поля запросов и адресные секции SCI8.
|
||||
import subprocess # Собирает C-модель с production-исходниками GCC.
|
||||
import tempfile # Удаляет только собственные временные DLL проверки.
|
||||
import unittest # Каждый отказ выполняется независимо и получает отдельный результат.
|
||||
LIBRARY = Path(__file__).resolve().parents[1]; TEMPLATES = LIBRARY.parents[1]; PORT = TEMPLATES / "c/protocan-boot/ports/tms320f28335" # Тест использует те же валидатор и writer, которые компилируются для платы.
|
||||
spec = importlib.util.spec_from_file_location("boot_test_contract", TEMPLATES / "python/protocan/f28335_flash.py"); contract = importlib.util.module_from_spec(spec); spec.loader.exec_module(contract) # Эталон FAB1 берётся из действующей общей библиотеки.
|
||||
|
||||
def section(address, words): # Создаёт адресный блок TI без дополнительных правил обновления.
|
||||
return struct.pack("<HHH", len(words), address >> 16, address & 65535) + struct.pack("<" + "H" * len(words), *words) # Длина считается словами, каждое слово little endian, адрес — старшим словом вперёд.
|
||||
|
||||
def image(): # Минимальный правильный образ содержит разрыв для проверки CRC стёртых промежутков.
|
||||
entry = contract.APP_DATA; loaded = {entry: 0x1234, entry + 1: 0x5678, entry + 12: 0xAABB, entry + 13: 0xCCDD} # Промежуток между двумя секциями должен остаться FFFF после erase.
|
||||
return b"\xaa\x08" + bytes(16) + struct.pack("<HH", entry >> 16, entry & 65535) + section(contract.APP_START, struct.unpack("<16H", contract.descriptor(entry, loaded))) + section(entry, [0x1234, 0x5678]) + section(entry + 12, [0xAABB, 0xCCDD]) + bytes(2) # Заголовок FAB1 передаётся первым, но writer обязан опубликовать его последним.
|
||||
|
||||
class BootTests(unittest.TestCase): # Проверяет наблюдаемое поведение полного обмена, а не отдельные строки реализации.
|
||||
@classmethod # DLL компилируется один раз для всех сценариев отказа.
|
||||
def setUpClass(cls): # Изолирует бинарный результат и зависимости GCC.
|
||||
gcc = Path(os.environ.get("CC", "C:/msys64/mingw64/bin/gcc.exe")); os.environ["PATH"] = str(gcc.parent) + os.pathsep + os.environ["PATH"] # CC позволяет выбрать другой совместимый GCC без изменения теста.
|
||||
cls.temporary = tempfile.TemporaryDirectory(prefix="f28335-rs-tests-"); dll = Path(cls.temporary.name) / "model.dll" # Все артефакты испытания находятся вне прошивки пользователя.
|
||||
subprocess.run([str(gcc), "-shared", "-std=c99", "-Wall", "-Wextra", "-Werror", str(LIBRARY / "tests/model.c"), str(PORT / "f28335_flash_app.c"), str(PORT / "f28335_flash_update.c"), str(TEMPLATES / "c/protocan-boot/src/pcan_boot.c"), "-o", str(dll)], check=True) # Компилирует production parser, CRC, validator и writer без извлечения копий функций.
|
||||
cls.native = ctypes.CDLL(str(dll)); cls.native.model_crc.argtypes = [ctypes.c_char_p, ctypes.c_uint]; cls.native.model_crc.restype = ctypes.c_uint; cls.native.model_value.restype = ctypes.c_uint # ABI содержит только явно заданные целые числа и октеты.
|
||||
|
||||
@classmethod # Windows требует освободить библиотеку до удаления DLL.
|
||||
def tearDownClass(cls): # Закрывает только дескриптор, созданный этим тестом.
|
||||
if os.name == "nt": # На Windows открытая DLL удерживает файл от удаления.
|
||||
release = ctypes.WinDLL("kernel32").FreeLibrary; release.argtypes = [ctypes.c_void_p]; release.restype = ctypes.c_int; release(cls.native._handle) # Освобождает единственную тестовую DLL с полным размером указателя.
|
||||
cls.temporary.cleanup() # Временные файлы не остаются в библиотеке или проекте ИБП.
|
||||
|
||||
def setUp(self): self.native.model_reset() # Стирает модель между тестами, сохраняя независимость сценариев.
|
||||
|
||||
def frame(self, command, payload=b"", address=16): # Формирует запросы совместимого BIOS для управления production-автоматом.
|
||||
body = bytes((address, command)) + payload; return body + struct.pack("<H", self.native.model_crc(body, len(body))) # Повреждение CRC тестируется отдельно, а фиксированный probe-вектор проверяет численное значение.
|
||||
|
||||
def send(self, data): # Аппаратные границы чтений могут разделить кадр после любого октета.
|
||||
for octet in data: self.native.model_feed(octet) # Никакая модель не собирает кадр за production-автомат.
|
||||
return bytes(self.native.model_value(10 + i) for i in range(self.native.model_value(0))) # Получает фактический ACK/status, отправленный callback transmit.
|
||||
|
||||
def load(self, payload): # Выполняет стандартный INITLOAD/LOAD без TFLASH.
|
||||
self.assertEqual(len(self.send(self.frame(58, struct.pack("<II", 0x200000, len(payload))))), 4) # Подготовка RAM требует точного короткого ACK.
|
||||
self.assertEqual(len(self.send(self.frame(51, payload))), 4) # Правильный LOAD подтверждается только после полной CRC16.
|
||||
|
||||
def program(self, payload): return self.send(self.frame(55, struct.pack("<III", 0x300000, 0x200000, len(payload)))) # Адреса и порядок полей совпадают с program_request periph_28335.
|
||||
|
||||
def assert_protected(self): self.assertEqual(self.native.model_value(5), 0xA55A) # Постоянный сектор A должен сохраняться даже после отказа на любой стадии записи.
|
||||
|
||||
def test_probe_and_success(self): # Полный успешный обмен должен подтвердить физическую Flash до reset.
|
||||
probe = self.frame(55, bytes(12)); self.assertEqual(probe.hex(), "1037000000000000000000000000f066") # Вектор независимо подтверждён setprotocol.dll через protocan.periph28335.with_crc и обнаруживает изменение wire-формата.
|
||||
response = self.send(probe); self.assertEqual(response[:4], bytes((16, 55, 0, 0))); self.assertEqual(self.native.model_value(1), 0) # Probe ничего не стирает и не останавливает действующую программу.
|
||||
payload = image(); self.load(payload); response = self.program(payload); self.assertEqual(response[:4], bytes((16, 55, 0, 0))) # Успешный TFLASH сообщает нулевой статус.
|
||||
self.assertEqual(self.native.model_value(4), 1); self.assertEqual(self.native.model_value(3), 1); self.assert_protected() # Реальный валидатор принимает физическую Flash, и только затем запрошен reset.
|
||||
|
||||
def test_wrong_address_crc_and_timeout(self): # Чужие либо оборванные запросы не должны разрешать запись.
|
||||
payload = image(); self.assertEqual(self.send(self.frame(58, struct.pack("<II", 0x200000, len(payload)), address=17)), b"") # Чужой адрес не получает подтверждения INITLOAD.
|
||||
self.load(payload); self.send(self.frame(58, struct.pack("<II", 0x200000, len(payload)))[:5]); self.native.model_abort() # Таймаут отбрасывает недопринятый запрос и старое подтверждение LOAD.
|
||||
self.assertEqual(self.program(payload)[2:4], b"\x03\x10"); self.assertEqual(self.native.model_value(1), 0) # Без нового LOAD статус 1003 возникает до erase.
|
||||
self.load(payload); damaged = bytearray(self.frame(55, struct.pack("<III", 0x300000, 0x200000, len(payload)))); damaged[-1] ^= 1; self.assertEqual(self.send(damaged), b"") # Неверная CRC TFLASH не вызывает никакого ответа об успехе.
|
||||
self.assertEqual(self.native.model_value(1), 0); self.assert_protected() # Ни timeout, ни повреждение запроса не затронули Flash.
|
||||
|
||||
def test_changed_ram_and_read_failure(self): # CRC32 staging повторно проверяется после успешного LOAD.
|
||||
payload = image(); self.load(payload); self.native.model_corrupt(60); self.assertEqual(self.program(payload)[2:4], b"\x02\x10") # Изменение RAM не скрывается первоначальным успешным ACK LOAD.
|
||||
self.assertEqual(self.native.model_value(1), 0); self.load(payload); self.native.model_fault(0, 0, 1); self.assertEqual(self.program(payload)[2:4], b"\x02\x10") # Ошибка чтения staging также запрещает первый erase.
|
||||
self.assertEqual(self.native.model_value(1), 0); self.assert_protected() # Память приложения и boot остались прежними.
|
||||
|
||||
def test_forbidden_addresses_and_bad_image(self): # Проверяет все опасные границы Flash и неполную таблицу.
|
||||
for address in (0x2FFFFF, 0x338000, 0x33FFF6, 0x33FFF8, 0x380400): # Включает RAM/границу приложения, boot, CSM и OTP.
|
||||
with self.subTest(address=hex(address)): # Ошибка конкретного диапазона видна отдельно в отчёте.
|
||||
self.native.model_reset(); payload = image()[:-2] + section(address, [1, 2]) + bytes(2); self.load(payload); self.assertEqual(self.program(payload)[2:4], b"\x02\x10") # Правильная CRC16 не разрешает опасный LOAD-адрес внутри SCI8.
|
||||
self.assertEqual(self.native.model_value(1), 0); self.assert_protected() # Неверная структура отвергается раньше физического стирания.
|
||||
for payload in (image()[:-2], image() + bytes(2), image()[:-2] + section(contract.APP_DATA, [1]) + bytes(2)): # Проверяет отсутствующий терминатор, хвост и перекрытие секций.
|
||||
self.native.model_reset(); self.load(payload); self.assertEqual(self.program(payload)[2:4], b"\x02\x10"); self.assertEqual(self.native.model_value(1), 0) # Любое нарушение структуры запрещает erase.
|
||||
|
||||
def test_failure_at_each_write_and_retry(self): # Имитирует обрыв каждого этапа программирования и последующее восстановление.
|
||||
for operation in (100, 1, 2, 3): # 100 обозначает erase; три program-порции — две секции данных и последний FAB1.
|
||||
with self.subTest(operation=operation): # Все стадии проверяются независимо на свежей модели Flash.
|
||||
self.native.model_reset(); payload = image(); self.load(payload); self.native.model_fault(operation, 0, 0); self.assertEqual(self.program(payload)[2:4], b"\x16\x00") # Отказ writer передаёт статус ошибки TI вместо успешного ACK.
|
||||
self.assertEqual(self.native.model_value(4), 0); self.assertEqual(self.native.model_value(3), 0); self.assert_protected() # Частичный образ не запускается, reset не запрошен, постоянный boot сохранён.
|
||||
self.native.model_fault(0, 0, 0); self.load(payload); self.assertEqual(self.program(payload)[2:4], bytes(2)); self.assertEqual(self.native.model_value(4), 1) # Новый полный LOAD восстанавливает приложение через тот же оставшийся boot.
|
||||
|
||||
def test_failed_ack_prevents_reset(self): # Потеря передачи результата не должна перезапускать контроллер неожиданно для клиента.
|
||||
payload = image(); self.load(payload); self.native.model_fault(0, 1, 0); self.program(payload) # Запись проходит успешно, но transmit возвращает ошибку.
|
||||
self.assertEqual(self.native.model_value(4), 1); self.assertEqual(self.native.model_value(3), 0); self.assert_protected() # Физическая Flash готова, однако boot остаётся в recovery до явного последующего reset.
|
||||
|
||||
if __name__ == "__main__": unittest.main(verbosity=2) # Самостоятельный запуск выводит результаты модели без утверждений о проверке платы.
|
||||
@@ -0,0 +1,105 @@
|
||||
"""Собирает постоянный RS boot и выпускает проверенное Flash-приложение CCS.""" # Все аппаратные пути и исходники передаются проектом платы.
|
||||
import argparse # Разбирает режим полной сборки либо postbuild уже собранного приложения.
|
||||
from datetime import datetime # Восстанавливает двенадцать слов встроенного паспорта текущего prebuild.
|
||||
import importlib.util # Подключает существующие инструменты firmware-info и FAB1 без копирования алгоритмов.
|
||||
import json # Читает проектные настройки и сохраняет отдельные manifest приложения и boot.
|
||||
from pathlib import Path # Разрешает пути независимо от текущего каталога CCS.
|
||||
import re # Разбирает стандартные относительные ссылки PARENT-N-PROJECT_LOC в Eclipse.
|
||||
import shutil # Переносит только проверенный комплект из временного каталога.
|
||||
import struct # Сопоставляет двенадцать 16-битных слов паспорта точным октетам COFF.
|
||||
import subprocess # Запускает TI compiler/OFD/hex2000 без shell и без доступа к программатору.
|
||||
import tempfile # Изолирует объекты и неполные выпуски текущей попытки.
|
||||
import xml.etree.ElementTree as ET # Читает реальные linked resources и include paths выбранной конфигурации CCS.
|
||||
TEMPLATES = Path(__file__).resolve().parents[3] # Каталог tools расположен в templates/c/f28335-rs-boot/tools.
|
||||
LIBRARY = Path(__file__).resolve().parents[1] # Общие исходники и linker boot берутся из того же checkout templates.
|
||||
FLASH = TEMPLATES / "c/protocan-boot/ports/tms320f28335" # Использует единые валидатор FAB1 и writer SCI8.
|
||||
|
||||
def module(name, path): # Загружает существующий инструмент по конкретному пути выбранной библиотеки.
|
||||
spec = importlib.util.spec_from_file_location(name, path) # Избегает случайного импорта другого установленного protocan.
|
||||
result = importlib.util.module_from_spec(spec); spec.loader.exec_module(result); return result # Ошибка общей зависимости останавливает выпуск.
|
||||
|
||||
identity = module("rs_boot_identity", TEMPLATES / "c/firmware-info/tools/identity.py") # Сохраняет общие manifest, SHA-256 и имена архивов.
|
||||
contract = module("rs_boot_contract", TEMPLATES / "python/protocan/f28335_flash.py") # Сохраняет единый формат подписания и проверки FAB1.
|
||||
|
||||
def project_paths(args): # Получает фактические C/ASM и include paths из настроек проекта.
|
||||
project = args.project.resolve(); sources = [] # Проектный каталог содержит .project/.cproject и generated отдельной конфигурации.
|
||||
for link in ET.parse(project / ".project").findall(".//linkedResources/link"): # Заголовки, OBJ и старые linker-файлы не компилируются как исходники.
|
||||
uri = link.findtext("locationURI", ""); prefix, separator, relative = uri.partition("/") # Eclipse хранит корень ссылки отдельно от относительного пути.
|
||||
match = re.fullmatch(r"PARENT-(\d+)-PROJECT_LOC", prefix) # Поддерживает переносимые ссылки любого уровня, не зашивая репозиторий платы.
|
||||
root = project.parents[int(match[1]) - 1] if match else project # PARENT-1 указывает непосредственно на родителя CCS-проекта.
|
||||
if separator and (match or prefix == "PROJECT_LOC") and Path(relative).suffix.lower() in (".c", ".asm"): sources.append((root / relative).resolve()) # Сохраняет только реальные C/ASM linked resources.
|
||||
sources.extend((project / "setgui_firmware_identity").glob("*.c")) # Подключённый ранее паспорт SETGUI остаётся частью приложения.
|
||||
config = next(item for item in ET.parse(project / ".cproject").findall(".//configuration") if item.get("name") == args.configuration) # Выбирает именно Debug либо Release, запрошенный CCS.
|
||||
option = next(item for item in config.findall(".//tool/option") if "compilerID.INCLUDE_PATH" in item.get("superClass", "")) # Сохраняет порядок поиска действующих заголовков платы.
|
||||
includes = []; macros = {"${PROJECT_ROOT}": project, "${PROJECT_LOC}": project, "${CG_TOOL_ROOT}": args.compiler.resolve(), "${BuildDirectory}": args.build_dir.resolve()} # Разрешает только ожидаемые файловые макросы CCS.
|
||||
for item in option.findall("listOptionValue"): # Каждая include-настройка применяется без shell expansion.
|
||||
value = item.get("value", "") # Пустой путь не должен означать случайный текущий каталог.
|
||||
for macro, replacement in macros.items(): value = value.replace(macro, str(replacement)) # Подставляет фактические абсолютные пути текущей конфигурации.
|
||||
if not value or "${" in value: raise ValueError("Не разрешён include path CCS: " + value) # Отсутствующую зависимость требуется исправить до компиляции.
|
||||
includes.append(Path(value)) # Сохраняет приоритет dev_sup перед дополнительными TI-заголовками.
|
||||
return list(dict.fromkeys(sources)), includes # Не компилирует повторную ссылку на один исходник дважды.
|
||||
|
||||
def compile_image(args, sources, includes, linker, output, optimize=False, api=False): # Создаёт самостоятельный COFF с собственным runtime.
|
||||
compiler = args.compiler.resolve(); support = args.support.resolve(); objects = [] # Объекты boot не смешиваются с объектами приложения.
|
||||
with tempfile.TemporaryDirectory(prefix="objects-", dir=output.parent) as directory: # Не использует старые OBJ из Debug либо другой версии исходников.
|
||||
for index, source in enumerate(sources): # Уникальный индекс исключает коллизии одинаковых имён модулей из разных каталогов.
|
||||
obj = Path(directory) / (str(index) + "_" + source.stem + ".obj") # Каждый результат принадлежит только этой попытке сборки.
|
||||
command = [str(compiler / "bin/cl2000.exe"), "-v28", "-ml", "-mt", "--float_support=fpu32", "--abi=coffabi", "--gen_func_subsections=on", "--define=F28335_RS_CPU_HZ=150000000UL"] # Архитектура и частота соответствуют F28335 платы ИБП; частота используется формулой TI Flash API.
|
||||
if source.suffix.lower() == ".c": command.append("--c99") # C99 требуется общим bool/stdint, но не передаётся как режим ассемблера.
|
||||
if optimize: command.append("-O2") # Оптимизация boot уменьшает постоянный сектор A; алгоритмы управления приложения сохраняют штатный режим без оптимизации.
|
||||
command.extend("--include_path=" + str(path) for path in includes) # Пути передаются отдельными аргументами, включая пробелы Windows.
|
||||
subprocess.run(command + ["--compile_only", "--output_file=" + str(obj), str(source)], check=True); objects.append(obj) # Ненулевой код TI останавливает сборку до линковки.
|
||||
command = [str(compiler / "bin/cl2000.exe"), "-v28", "--float_support=fpu32", "--abi=coffabi", "-z", "--rom_model", "--heap_size=0", "--stack_size=0x400", "--warn_sections", "--search_path=" + str(compiler / "lib"), "--search_path=" + str(support / "source")] # Отдельный runtime сохраняет boot работоспособным при пустом приложении.
|
||||
if api: command.append("--search_path=" + str(args.flash_api.resolve() / "lib")) # Библиотека TI берётся из локальной установки и не копируется в templates.
|
||||
command.extend(str(path) for path in objects) # Линкер получает только свежие объекты этой попытки.
|
||||
command.extend([str(linker), str(support / "source/DSP2833x_Headers_nonBIOS.cmd"), "-lrts2800_fpu32.lib", "--map_file=" + str(output.with_suffix(".map")), "--output_file=" + str(output)]) # Общие регистры и runtime согласованы с COFF/FPU32 действующего проекта.
|
||||
if not api: command.append(str(support / "source/rts2800_fpu32_fast_supplement.lib")) # Приложение сохраняет ускоренные sincos/sqrt/div/atan2 в прежней ramfuncs.
|
||||
subprocess.run(command, check=True) # Отсутствие Flash API или переполнение RAM/Flash запрещает выпуск.
|
||||
|
||||
def build_boot(args, output): # Компилирует постоянный сектор A с независимыми исходниками платы.
|
||||
support = args.support.resolve(); port = LIBRARY / "ports/tms320f28335" # Общий аппаратный порт не содержит GPIO конкретного изделия.
|
||||
sources = [args.board.resolve(), LIBRARY / "src/f28335_rs_boot.c", port / "flash_api.c", FLASH / "f28335_flash_app.c", FLASH / "f28335_flash_update.c", TEMPLATES / "c/protocan-boot/src/pcan_boot.c", support / "source/DSP2833x_GlobalVariableDefs.c", support / "source/init28335_func.c", support / "source/DSP2833x_CodeStartBranch.asm"] # UART/GPIO принадлежат только board.c; формат и writer повторно используются из templates.
|
||||
includes = [support / "include", LIBRARY / "include", args.flash_api.resolve() / "include", args.compiler.resolve() / "include"] # Все зависимости TI должны существовать до компиляции.
|
||||
compile_image(args, sources, includes, port / "boot.cmd", output, optimize=True, api=True) # Boot использует только FLASHA и выделенные RAMAPI/RAMFUNCS.
|
||||
document = ET.fromstring(subprocess.check_output([str(args.compiler / "bin/ofd2000.exe"), "-x", str(output)])) # Проверяет фактические LOAD-секции, а не только текст linker-команды.
|
||||
for section in document.findall(".//ti_coff/section"): # Учитывает также Flash LOAD копируемого в RAM кода API.
|
||||
if section.findtext("raw_data") is None or section.findtext("copy") == "true": continue # Незагружаемые секции отладки не программируются.
|
||||
start = int(section.findtext("virtual_addr", "0"), 0); size = int(section.findtext("raw_data_size", "0"), 0) // 2 # OFD хранит LOAD как virtual_addr, размер raw_data измеряет октетами.
|
||||
if not (0x338000 <= start < start + size <= 0x33FF80 or start == 0x33FFF6 and size == 2): raise ValueError("Boot OUT содержит LOAD вне постоянного сектора A") # Запрещает приложение, RAM LOAD, CSM и OTP в установочном образе boot.
|
||||
|
||||
def publish(args): # Проверяет оба независимых OUT перед переносом нового выпуска в постоянный каталог.
|
||||
project = args.project.resolve(); build = args.build_dir.resolve(); metadata_path = build / "generated/firmware_identity.json" # Каждый Debug/Release использует собственный паспорт prebuild.
|
||||
metadata = json.loads(metadata_path.read_text(encoding="utf-8")); settings = json.loads((project / "firmware_identity.json").read_text(encoding="utf-8-sig")) # Не резервирует дополнительную версию после компиляции.
|
||||
if any(metadata.get(field) != settings.get(field) for field in ("product", "target", "version", "flashing")): raise ValueError("Настройки изменились: повторите prebuild и сборку") # Не связывает старый OUT с новым продуктом, номером либо маршрутом прошивки.
|
||||
output = build / "firmware"; output.mkdir(parents=True, exist_ok=True) # Все временные и постоянные результаты принадлежат выбранной конфигурации CCS.
|
||||
with tempfile.TemporaryDirectory(prefix=".rs-release-", dir=build) as directory: # Частичная сборка никогда не заменяет предыдущий выпуск.
|
||||
stage = Path(directory); app = stage / "flash" / (args.artifact + ".out"); app.parent.mkdir() # Flash OUT приложения хранится отдельно от boot.
|
||||
shutil.copy2(build / (args.artifact + ".out"), app); contract.seal_coff(app, args.compiler / "bin/ofd2000.exe") # Заполняет только заранее выделенный FAB1 после проверки всех LOAD-адресов приложения.
|
||||
document = ET.fromstring(subprocess.check_output([str(args.compiler / "bin/ofd2000.exe"), "-x", str(app)])); entry, loaded, sections = contract.coff_sections(document) # Содержимое извлекается официальным TI OFD из реального COFF.
|
||||
built = datetime.fromisoformat(metadata["built_at_utc"]); build_id = metadata["build_id"].encode("ascii"); expected = (1, *metadata["version"], built.year, built.month << 8 | built.day, built.hour << 8 | built.minute, built.second, *(build_id[i] << 8 | build_id[i + 1] for i in range(0, 8, 2))) # Двенадцать слов повторяют публичный firmware_info_static контракт паспорта без изменения версии.
|
||||
if sum(tuple(loaded.get(address + i) for i in range(12)) == expected for address in loaded) != 1: raise ValueError("OUT не содержит единственный паспорт текущего prebuild") # Старый объект, чужая версия либо дублированный паспорт не выпускаются.
|
||||
serial = stage / "rs" / (args.artifact + "_flash_rs.bin"); serial.parent.mkdir() # RS-клиент выбирает только SCI8 приложения, исключая постоянный boot.
|
||||
subprocess.run([str(args.compiler / "bin/hex2000.exe"), str(app), "-boot", "-sci8", "-b", "-o", str(serial), "-map", str(serial.with_suffix(".bin.map"))], check=True) # Официальный конвертор сохраняет адресные секции TI SCI8.
|
||||
contract.parse_sci8(serial.read_bytes()); boot = stage / "boot" / (args.artifact + "_boot.out"); boot.parent.mkdir(); build_boot(args, boot) # Проверяет BIN независимо от OUT и создаёт отдельный проверенный установочный boot.
|
||||
shutil.copy2(build / (args.artifact + ".map"), app.with_suffix(".map")) # Карта соответствует неизменным адресам приложения до заполнения заголовка.
|
||||
for image, kind in ((app, "COFF-FLASH"), (serial, "SCI8-FLASH"), (boot, "COFF-RS-BOOT")): # Каждый тип получает собственный manifest и SHA-256 точных байтов.
|
||||
specific = dict(metadata, execution="BOOTLOADER" if image == boot else "FLASH", image_format=kind, boot_contract="f28335-universal-v1", boot_protected=True) # Явно разделяет установку постоянного boot и обновление приложения.
|
||||
if image == boot: specific["flashing"] = {"default_loader": "f28335-jtag", "profiles": {"f28335-jtag": {}}} # Постоянный загрузчик устанавливается через JTAG и никогда не выбирается для RS TFLASH.
|
||||
current = stage / "manifest-source.json"; current.write_text(json.dumps(specific, ensure_ascii=False, indent=2), encoding="utf-8"); identity.seal(image, current); identity.verify(image, image.with_suffix(image.suffix + ".manifest.json")) # Все стороны используют существующие проверенные средства firmware-info.
|
||||
(stage / "manifest-source.json").unlink(); shutil.copy2(metadata_path, stage / "firmware_identity.json") # В архив попадает один исходный паспорт текущей компиляции.
|
||||
destination = output / identity.build_folder_name(metadata); shutil.copytree(stage, destination, dirs_exist_ok=True) # Сохраняет предыдущие архивы и переносит только полностью проверенный выпуск.
|
||||
shutil.copy2(app, build / app.name) # Основной OUT CCS получает тот же FAB1, что опубликованные RS BIN и Flash OUT.
|
||||
if settings.get("copy_to") and not args.no_export: identity.export_build(destination, (project / settings["copy_to"]).resolve(), "rs/" + serial.name) # Установленный проектный export проверяет BIN в папке rs и применяется после всех локальных проверок.
|
||||
print("[firmware-build] RS boot package: " + str(destination)); return destination # Показывает точный постоянный каталог для JTAG и последующего RS-обновления.
|
||||
|
||||
def main(): # Одна точка входа используется проектной обёрткой и проверкой воспроизводимости.
|
||||
parser = argparse.ArgumentParser(description=__doc__); parser.add_argument("command", choices=("build", "postbuild")) # build компилирует приложение; postbuild использует OUT, уже собранный CCS.
|
||||
for name in ("project", "compiler", "build-dir", "support", "board", "app-linker", "flash-api"): parser.add_argument("--" + name, type=Path, required=True) # Все аппаратные исходники и установки выбирает проект-потребитель.
|
||||
parser.add_argument("--artifact", required=True); parser.add_argument("--configuration", default="Debug", choices=("Debug", "Release")); parser.add_argument("--no-export", action="store_true") # Локальная проверка может отключить дополнительное копирование в GUI.
|
||||
args = parser.parse_args(); args.compiler = args.compiler.resolve(); args.build_dir = args.build_dir.resolve(); args.build_dir.mkdir(parents=True, exist_ok=True) # Нормализует только ожидаемые пути без shell expansion.
|
||||
if Path(args.artifact).name != args.artifact or any(char in args.artifact for char in '\\/:*?"<>|'): parser.error("artifact должен быть именем OUT без расширения") # Имя файла не может выйти за выбранный каталог выпуска.
|
||||
if args.command == "build": # Ручной полный build полезен для проверки проекта вне запущенной IDE.
|
||||
sources, includes = project_paths(args); compile_image(args, sources, includes, args.app_linker.resolve(), args.build_dir / (args.artifact + ".out")) # Использует действующие linked resources без ручного списка копий исходников.
|
||||
publish(args) # Ненулевые коды компиляции, конверсии и проверки распространяются в CCS.
|
||||
|
||||
if __name__ == "__main__": main() # Импорт тестами не запускает компилятор и не изменяет рабочую версию.
|
||||
@@ -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. */
|
||||
@@ -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 без доступа к системным часам. */
|
||||
|
||||
@@ -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. */
|
||||
|
||||
@@ -0,0 +1,9 @@
|
||||
cmake_minimum_required(VERSION 3.13) # Использует ту же минимальную версию CMake, что и проект потребителя прошивки.
|
||||
project(uart_usb C) # Собирает единственный C99 кодек и соответствующий порт настольного транспорта.
|
||||
add_library(uart_usb SHARED uart_usb.c) # Создаёт библиотеку для ctypes без второй реализации wire-протокола.
|
||||
target_include_directories(uart_usb PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}) # Публикует общий стабильный ABI заголовка uart_usb.h.
|
||||
set_target_properties(uart_usb PROPERTIES C_STANDARD 99 C_STANDARD_REQUIRED YES PREFIX "") # Сохраняет имя uart_usb.dll на Windows и требует переносимый стандарт C99.
|
||||
if(WIN32) # Настольный USB транспорт этой версии реализован для штатного WinUSB.
|
||||
target_sources(uart_usb PRIVATE ports/windows/uart_usb_winusb.c) # Добавляет очередь шестнадцати overlapped RX вместо синхронного опроса из GUI.
|
||||
target_link_libraries(uart_usb PRIVATE winusb setupapi) # Использует системные библиотеки Windows без зависимости от libusb или PyUSB.
|
||||
endif() # MCU компилирует uart_usb.c и stm32g474 порт напрямую своим проектом.
|
||||
@@ -0,0 +1,122 @@
|
||||
# USART → USB
|
||||
|
||||
Минимальный двоичный мультиплексор 2–4 UART-каналов в USB: независимый RX,
|
||||
TX только на канале 1, настройка скорости, подтверждения и диагностика потерь.
|
||||
Переносимое ядро C99 не содержит HAL, ОС, heap и глобального состояния.
|
||||
|
||||
Слои: SETGUI → Python/Qt порт → C-кодек / WinUSB → USB bulk → C-кодек →
|
||||
STM32G474 DMA → USART. Применяется в `CAN_projects`, ветка `candle-g474`.
|
||||
|
||||
| Файл | Назначение | Зависимость |
|
||||
|---|---|---|
|
||||
| `uart_usb.h`, `uart_usb.c` | Формат, потоковый parser, builders, смысловые события ABI | C99, stdint, string |
|
||||
| `ports/stm32g474/uart_usb_g474.*` | Кольцевой RX DMA, один TX DMA | CMSIS STM32G474 |
|
||||
| `ports/windows/uart_usb_winusb.c` | 16 запросов IN одновременно, SetupDi, WinUSB | Windows 7+, WinUSB, SetupAPI |
|
||||
| `python/set_devices/uart_usb.py` | ctypes, жизненный цикл USB handle | Python stdlib, собранная DLL |
|
||||
| `python/set_devices/qt_ports/uart_usb_terminal.py` | Worker, четыре окна, запись исходных байтов | Qt5/Qt6 |
|
||||
|
||||
## Аппаратный порт STM32G474VET6
|
||||
|
||||
| Канал | Блок | RX | TX | DMAMUX RX |
|
||||
|---|---|---|---|---|
|
||||
| 1 | USART2 | PA3, AF7 | PA2, AF7 | 26 |
|
||||
| 2 | USART3 | PB11, AF7 | выключен | 28 |
|
||||
| 3 | UART4 | PC11, AF5 | выключен | 30 |
|
||||
| 4 | UART5 | PD2, AF5 | выключен | 32 |
|
||||
|
||||
USART1 PA9/PA10 остаётся загрузчику. CAN PB8/PB9 и USB PA11/PA12 сохраняются.
|
||||
Выводы сверены с таблицами alternate function
|
||||
[STM32G474xE](https://www.st.com/resource/en/datasheet/stm32g474mb.pdf),
|
||||
DMA — с [RM0440](https://www.st.com/resource/en/reference_manual/dm00355726-stm32g4-series-advanced-armbased-32bit-mcus-stmicroelectronics.pdf).
|
||||
Используйте логические уровни платы и общую GND; внешний RS232/RS485 требует
|
||||
соответствующего трансивера.
|
||||
|
||||
`UART_USB_CHANNELS=2`, `3` или `4` задаётся сборкой, по умолчанию 4.
|
||||
DMA1 Channel1…4 обслуживают RX, Channel5 — USART2 TX.
|
||||
PCLK1=144 МГц, 8N1, oversampling 16, диапазон 1200…6000000 бит/с,
|
||||
погрешность BRR до 2%. По умолчанию каждый вход работает на 1000000 бит/с.
|
||||
Одновременные четыре входа по 1 Мбит/с дают 400000 байт/с полезных данных.
|
||||
USB FS имеет общую пропускную способность для всех USART и CAN; предел
|
||||
каждого отдельного UART не является гарантией суммарной скорости USB.
|
||||
|
||||
Каждый вход имеет DMA-кольцо 4096 байт; при отставании потребителя сохраняется
|
||||
новейшая половина кольца и точно увеличивается счётчик программно потерянных
|
||||
байтов. Вторая половина оставляет запас от перезаписи во время копирования.
|
||||
Аппаратные ORE/FE/NE/PE и TE считаются событиями; число утраченных до DMA байтов
|
||||
при ORE аппаратурой не сообщается. Счётчики uint32 сбрасываются при START
|
||||
и переполняются по модулю 2^32. STOP, USB reset и suspend прекращают захват;
|
||||
оставшийся в DMA хвост не гарантирован после STOP. Resume требует нового START.
|
||||
|
||||
## Контракт порта
|
||||
|
||||
`ub_g474_init()`, `ub_g474_config(channel, baud)`, `ub_g474_start()`,
|
||||
`ub_g474_stop()`, `ub_g474_tx(data, length)`, `ub_g474_read(channel, out, capacity)`,
|
||||
`ub_g474_stats(channel, &lost, &errors)` и `ub_g474_abort()` вызываются одним
|
||||
основным циклом с защитой от USB reset. Только обработчики DMA меняют счётчики
|
||||
оборотов. Порт использует статическую память и не вызывает пользовательские
|
||||
callbacks. `UB_BUSY` гарантирует отсутствие побочного действия команды.
|
||||
|
||||
## Протокол версии 1
|
||||
|
||||
USB interface 2: class `FF`, subclass `55`, protocol `01`, bulk IN `83`,
|
||||
bulk OUT `03`, max packet 64. CAN и DFU сохраняют номера 0 и 1.
|
||||
Windows получает WinUSB через Microsoft OS 1.0. USART использует отдельный GUID
|
||||
`{8a650f40-8fb3-49b5-a067-5b2494740001}`, чтобы CAN-клиенты gs_usb не считали
|
||||
новый интерфейс ещё одним CAN-адаптером. Ревизия USB bcdDevice=0x0001 обновляет
|
||||
кэш состава интерфейсов Windows после прошивки; переподключите кабель USB.
|
||||
|
||||
Запись: `A7 | (type << 4) OR channel | length_lo | length_hi | payload`.
|
||||
Payload 0…60 байт, длина little-endian. Данные не экранируются;
|
||||
целостность обеспечивает USB CRC и повтор транзакций. Parser допускает
|
||||
произвольные разрывы и несколько записей в одном системном чтении.
|
||||
Повреждённый заголовок пропускается до следующей синхронизации.
|
||||
|
||||
| type | Направление | channel | payload |
|
||||
|---|---|---|---|
|
||||
| 1 CONFIG | host → MCU | 1…N | baud uint32 LE, только до START |
|
||||
| 2 START | host → MCU | 0 | пусто; запускает все входы и обнуляет счётчики |
|
||||
| 3 STOP | host → MCU | 0 | пусто; BUSY до окончания стопового бита TX |
|
||||
| 4 TX | host → MCU | 1 | 1…60 исходных байтов |
|
||||
| 8 ACK | MCU → host | как в команде | command, status, rx_channels, tx_channel; четыре uint8 |
|
||||
| 9 RX | MCU → host | 1…N | 1…60 исходных байтов |
|
||||
| 10 STATS | MCU → host | 1…N | lost uint32 LE, errors uint32 LE; раз в секунду |
|
||||
|
||||
Статусы: 0 OK, 1 INVALID, 2 BUSY. Одновременно ожидается один ACK.
|
||||
Хост повторяет только явно отклонённые BUSY команды. После потери ACK
|
||||
не повторяет TX: отключает сессию, исключая неопределённое дублирование байтов.
|
||||
ACK TX означает принятие в DMA. STOP подтверждается после физического завершения TX.
|
||||
|
||||
Быстрый старт в C после открытия собственного USB IN:
|
||||
|
||||
```c
|
||||
#include "uart_usb.h" /* Подключает общую структуру записи и parser. */
|
||||
ub_parser parser = {0}; /* Выделяет независимое состояние одного USB-потока. */
|
||||
ub_frame frame; /* Принимает один проверенный заголовок и его payload. */
|
||||
ub_event event; /* Возвращает смысловые поля без ручного разбора смещений. */
|
||||
uint8_t out[64]; /* Вмещает максимальную команду USB FS. */
|
||||
uint16_t size = ub_make_config(1, 1000000, out); /* Настраивает RX1 на 1 Мбит/с. */
|
||||
usb_write(out, size); /* Порт приложения передаёт команду выбранному интерфейсу. */
|
||||
uint16_t used = ub_feed(&parser, incoming, received, &frame); /* Parser потребляет очередной фрагмент USB. */
|
||||
if (frame.type && ub_describe(&frame, &event)) { /* Обрабатывает только целый корректный ответ. */
|
||||
handle_event(&event); /* Приложение получает уже разобранную модель события. */
|
||||
} /* Остаток incoming после used снова передаётся ub_feed. */
|
||||
```
|
||||
|
||||
## Сборка DLL и проверки
|
||||
|
||||
Соберите `cmake -S templates/c/uart-usb -B build/uart-usb -A x64`, затем
|
||||
`cmake --build build/uart-usb --config Release`. Для Win32 используйте отдельный
|
||||
каталог и `-A Win32`. DLL должна совпадать по разрядности с Python/SETGUI.
|
||||
Установите `uart_usb.dll` в `src/gui_desktop/native`, рядом с модулем Python
|
||||
либо задайте `UART_USB_LIBRARY`. Отсутствие DLL является явной ошибкой установки.
|
||||
|
||||
Проверки: `python -m pytest templates/c/uart-usb/tests -q` при настроенных
|
||||
`PYTHONPATH=templates/python` и `UART_USB_LIBRARY=<полный путь DLL>`.
|
||||
Эталоны включают все 65 разрывов максимальной записи, шум, неправильные длины,
|
||||
1000 сообщений в случайных фрагментах и несовместимые ACK.
|
||||
|
||||
Терминал обновляет только последние 8 КиБ каждого RX. Для полного захвата
|
||||
выберите «Запись RX…» до START: worker создаст отдельную папку сессии
|
||||
и `rx1.bin`…`rx4.bin` без служебных заголовков и перекодирования.
|
||||
На неподключённой плате измерение реальной скорости и проверка проводов
|
||||
не выполняются; это отдельная аппаратная проверка.
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user