From 48254655832153f17ccd35f7639a8f1311a11c10 Mon Sep 17 00:00:00 2001 From: Andrey Date: Tue, 17 Nov 2026 17:31:28 +0300 Subject: [PATCH] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=B8=D1=82?= =?UTF-8?q?=D1=8C=20=D0=BE=D0=B1=D1=89=D0=B5=D0=B5=20=D1=8F=D0=B4=D1=80?= =?UTF-8?q?=D0=BE=20=D0=B0=D0=B2=D1=82=D0=BE=D0=BC=D0=BE=D0=B1=D0=B8=D0=BB?= =?UTF-8?q?=D1=8C=D0=BD=D0=BE=D0=B9=20=D0=B4=D0=B8=D0=B0=D0=B3=D0=BD=D0=BE?= =?UTF-8?q?=D1=81=D1=82=D0=B8=D0=BA=D0=B8=20=D0=B8=20=D0=BF=D0=BE=D1=80?= =?UTF-8?q?=D1=82=20SETGUI?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Вынести ISO-TP, OBD-II, UDS, профили, сервисный автомат, журнал и симулятор программирования в переносимый модуль C11. Добавить единый ABI и тонкий Python-порт, переносимые тесты и независимую сборку CMake. Оставить неподтверждённые фирменные команды и реальную запись ECU отключёнными. --- c/automotive/CMakeLists.txt | 23 ++++ c/automotive/README.md | 29 +++++ c/automotive/include/can_frame.h | 12 ++ c/automotive/include/can_logger.h | 14 ++ c/automotive/include/cli.h | 13 ++ c/automotive/include/diag_abi.h | 27 ++++ c/automotive/include/diag_engine.h | 32 +++++ c/automotive/include/diag_status.h | 20 +++ c/automotive/include/ecu_programmer.h | 16 +++ c/automotive/include/isotp.h | 27 ++++ c/automotive/include/landrover_suspension.h | 7 + c/automotive/include/obd2_dtc.h | 8 ++ c/automotive/include/obd2_pid.h | 11 ++ c/automotive/include/service_manager.h | 15 +++ c/automotive/include/uds.h | 14 ++ c/automotive/include/vehicle_manager.h | 16 +++ c/automotive/src/can_logger.c | 36 ++++++ c/automotive/src/cli.c | 19 +++ c/automotive/src/diag_abi.c | 25 ++++ c/automotive/src/diag_engine.c | 134 ++++++++++++++++++++ c/automotive/src/ecu_programmer.c | 36 ++++++ c/automotive/src/isotp.c | 116 +++++++++++++++++ c/automotive/src/landrover_suspension.c | 12 ++ c/automotive/src/obd2_dtc.c | 29 +++++ c/automotive/src/obd2_pid.c | 44 +++++++ c/automotive/src/service_manager.c | 38 ++++++ c/automotive/src/uds.c | 65 ++++++++++ c/automotive/src/vehicle_manager.c | 33 +++++ c/automotive/tests/test_logger.c | 18 +++ c/automotive/tests/test_managers.c | 42 ++++++ c/automotive/tests/test_protocols.c | 98 ++++++++++++++ python/automotive/__init__.py | 45 +++++++ 32 files changed, 1074 insertions(+) create mode 100644 c/automotive/CMakeLists.txt create mode 100644 c/automotive/README.md create mode 100644 c/automotive/include/can_frame.h create mode 100644 c/automotive/include/can_logger.h create mode 100644 c/automotive/include/cli.h create mode 100644 c/automotive/include/diag_abi.h create mode 100644 c/automotive/include/diag_engine.h create mode 100644 c/automotive/include/diag_status.h create mode 100644 c/automotive/include/ecu_programmer.h create mode 100644 c/automotive/include/isotp.h create mode 100644 c/automotive/include/landrover_suspension.h create mode 100644 c/automotive/include/obd2_dtc.h create mode 100644 c/automotive/include/obd2_pid.h create mode 100644 c/automotive/include/service_manager.h create mode 100644 c/automotive/include/uds.h create mode 100644 c/automotive/include/vehicle_manager.h create mode 100644 c/automotive/src/can_logger.c create mode 100644 c/automotive/src/cli.c create mode 100644 c/automotive/src/diag_abi.c create mode 100644 c/automotive/src/diag_engine.c create mode 100644 c/automotive/src/ecu_programmer.c create mode 100644 c/automotive/src/isotp.c create mode 100644 c/automotive/src/landrover_suspension.c create mode 100644 c/automotive/src/obd2_dtc.c create mode 100644 c/automotive/src/obd2_pid.c create mode 100644 c/automotive/src/service_manager.c create mode 100644 c/automotive/src/uds.c create mode 100644 c/automotive/src/vehicle_manager.c create mode 100644 c/automotive/tests/test_logger.c create mode 100644 c/automotive/tests/test_managers.c create mode 100644 c/automotive/tests/test_protocols.c create mode 100644 python/automotive/__init__.py diff --git a/c/automotive/CMakeLists.txt b/c/automotive/CMakeLists.txt new file mode 100644 index 0000000..929756e --- /dev/null +++ b/c/automotive/CMakeLists.txt @@ -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-шина для этих тестов не требуются. diff --git a/c/automotive/README.md b/c/automotive/README.md new file mode 100644 index 0000000..18022ed --- /dev/null +++ b/c/automotive/README.md @@ -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. diff --git a/c/automotive/include/can_frame.h b/c/automotive/include/can_frame.h new file mode 100644 index 0000000..9e4be1e --- /dev/null +++ b/c/automotive/include/can_frame.h @@ -0,0 +1,12 @@ +#ifndef CAN_FRAME_H /* Отделяет переносимый формат кадра от STM32 HAL. */ +#define CAN_FRAME_H /* Используется одновременно аппаратным драйвером и host-тестами протоколов. */ +#include /* Тип признака extended не зависит от представления HAL. */ +#include /* 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-кадра. */ diff --git a/c/automotive/include/can_logger.h b/c/automotive/include/can_logger.h new file mode 100644 index 0000000..9a30ce9 --- /dev/null +++ b/c/automotive/include/can_logger.h @@ -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-журнала. */ diff --git a/c/automotive/include/cli.h b/c/automotive/include/cli.h new file mode 100644 index 0000000..7f9d2a6 --- /dev/null +++ b/c/automotive/include/cli.h @@ -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 /* Признак discard запрещает выполнение усечённых команд. */ +#include /* Входные байты 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 /* Завершает интерфейс проверяемого отдельно парсера. */ diff --git a/c/automotive/include/diag_abi.h b/c/automotive/include/diag_abi.h new file mode 100644 index 0000000..6ac93a5 --- /dev/null +++ b/c/automotive/include/diag_abi.h @@ -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. */ diff --git a/c/automotive/include/diag_engine.h b/c/automotive/include/diag_engine.h new file mode 100644 index 0000000..ccce683 --- /dev/null +++ b/c/automotive/include/diag_engine.h @@ -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. */ diff --git a/c/automotive/include/diag_status.h b/c/automotive/include/diag_status.h new file mode 100644 index 0000000..29ce162 --- /dev/null +++ b/c/automotive/include/diag_status.h @@ -0,0 +1,20 @@ +#ifndef DIAG_STATUS_H /* Исключает повторное объявление общих результатов операций. */ +#define DIAG_STATUS_H /* Объединяет аппаратные и протокольные ошибки одним интерфейсом. */ +#include /* Задаёт одинаковую разрядность времени на ПК и 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 /* Завершает интерфейс общих кодов ошибок. */ diff --git a/c/automotive/include/ecu_programmer.h b/c/automotive/include/ecu_programmer.h new file mode 100644 index 0000000..6c62cf2 --- /dev/null +++ b/c/automotive/include/ecu_programmer.h @@ -0,0 +1,16 @@ +#ifndef ECU_PROGRAMMER_H /* Защищает исключительно симуляционную подсистему проверки обновления ECU. */ +#define ECU_PROGRAMMER_H /* Здесь принципиально отсутствует выходной CAN callback для записи реального автомобиля. */ +#include "diag_status.h" /* Проверки целостности, питания и последовательности возвращают явный отказ. */ +#include /* Признаки подписи и питания не заменяются неявными значениями по умолчанию. */ +#include /* Ёмкости образа и блоков проверяются до копирования. */ +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, подписи и политики разрешения. */ diff --git a/c/automotive/include/isotp.h b/c/automotive/include/isotp.h new file mode 100644 index 0000000..6bd965e --- /dev/null +++ b/c/automotive/include/isotp.h @@ -0,0 +1,27 @@ +#ifndef ISOTP_H /* Защищает независимый от HAL транспортный интерфейс. */ +#define ISOTP_H /* Общий автомат реализует SF, FF, CF и FC классического CAN с нормальной адресацией. */ +#include /* Размеры буферов передаются явно для контроля границ. */ +#include /* Кодек работает с байтами одинаково на ПК и 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 с нормальной адресацией. */ diff --git a/c/automotive/include/landrover_suspension.h b/c/automotive/include/landrover_suspension.h new file mode 100644 index 0000000..87afdf9 --- /dev/null +++ b/c/automotive/include/landrover_suspension.h @@ -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 /* Ни один клапан или компрессор не управляется по догадке. */ diff --git a/c/automotive/include/obd2_dtc.h b/c/automotive/include/obd2_dtc.h new file mode 100644 index 0000000..d766bb8 --- /dev/null +++ b/c/automotive/include/obd2_dtc.h @@ -0,0 +1,8 @@ +#ifndef OBD2_DTC_H /* Защищает интерфейс стандартных двухбайтовых DTC. */ +#define OBD2_DTC_H /* Производительские расшифровки не выводятся из одного лишь номера кода. */ +#include "diag_status.h" /* Некорректные длины возвращают общий код ошибки. */ +#include /* Количество кодов и ёмкость массива передаются отдельно. */ +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. */ diff --git a/c/automotive/include/obd2_pid.h b/c/automotive/include/obd2_pid.h new file mode 100644 index 0000000..705c80e --- /dev/null +++ b/c/automotive/include/obd2_pid.h @@ -0,0 +1,11 @@ +#ifndef OBD2_PID_H /* Защищает интерфейс формул стандартных PID. */ +#define OBD2_PID_H /* Физические величины представлены без потери четвертей оборота. */ +#include /* Декодер проверяет фактическую длину ответа. */ +#include /* Сырой 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. */ diff --git a/c/automotive/include/service_manager.h b/c/automotive/include/service_manager.h new file mode 100644 index 0000000..4361c61 --- /dev/null +++ b/c/automotive/include/service_manager.h @@ -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 /* Завершает проверяемый менеджер процедур. */ diff --git a/c/automotive/include/uds.h b/c/automotive/include/uds.h new file mode 100644 index 0000000..0713b64 --- /dev/null +++ b/c/automotive/include/uds.h @@ -0,0 +1,14 @@ +#ifndef UDS_H /* Защищает независимый от HAL менеджер UDS. */ +#define UDS_H /* Операции изменения состояния выключены до подтверждённого профиля ECU. */ +#include "diag_status.h" /* Общие результаты различают отрицательный ответ, ожидание и ошибку длины. */ +#include /* Флаг разрешения сессии по умолчанию сброшен. */ +#include /* Длины запросов и ответов проверяются до чтения полей. */ +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. */ diff --git a/c/automotive/include/vehicle_manager.h b/c/automotive/include/vehicle_manager.h new file mode 100644 index 0000000..2ddeddf --- /dev/null +++ b/c/automotive/include/vehicle_manager.h @@ -0,0 +1,16 @@ +#ifndef VEHICLE_MANAGER_H /* Защищает реестр проверяемых автомобильных профилей. */ +#define VEHICLE_MANAGER_H /* База данных и алгоритмы диагностического обмена разделены. */ +#include "diag_status.h" /* Неподтверждённая конфигурация возвращает явный отказ. */ +#include /* Проверенность источника хранится отдельно от наличия числового адреса. */ +#include /* Таблицы 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 /* Завершает безопасный реестр автомобильных данных. */ diff --git a/c/automotive/src/can_logger.c b/c/automotive/src/can_logger.c new file mode 100644 index 0000000..4b9fb86 --- /dev/null +++ b/c/automotive/src/can_logger.c @@ -0,0 +1,36 @@ +#include "can_logger.h" /* Пассивный анализатор повторно использует действующий ISO-TP автомат. */ +#include /* Ограниченный snprintf обеспечивает безопасный текстовый и CSV экспорт. */ +#include /* Контексты наблюдения выделяются вызывающим статически. */ +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-ответом. */ diff --git a/c/automotive/src/cli.c b/c/automotive/src/cli.c new file mode 100644 index 0000000..e4edefb --- /dev/null +++ b/c/automotive/src/cli.c @@ -0,0 +1,19 @@ +#include "cli.h" /* Подключает независимый от аппаратуры конечный автомат строки. */ +#include /* Обнуление контекста не выделяет динамическую память. */ +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; /* Записывает символ только после полной проверки ёмкости. */ +} /* Завершает неблокирующий шаг построчного парсера. */ diff --git a/c/automotive/src/diag_abi.c b/c/automotive/src/diag_abi.c new file mode 100644 index 0000000..d1a21ad --- /dev/null +++ b/c/automotive/src/diag_abi.c @@ -0,0 +1,25 @@ +#include "diag_abi.h" /* Плоские функции служат только адаптером типов, без второго диагностического автомата. */ +#include /* Входные байты копируются только после проверки длины. */ +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); } /* Некорректный внешний код нормализуется в явную аппаратную ошибку. */ diff --git a/c/automotive/src/diag_engine.c b/c/automotive/src/diag_engine.c new file mode 100644 index 0000000..40ab754 --- /dev/null +++ b/c/automotive/src/diag_engine.c @@ -0,0 +1,134 @@ +#include "diag_engine.h" /* Объединяет OBD, ISO-TP и UDS, сохраняя независимость от физического транспорта. */ +#include "obd2_dtc.h" /* Стандартные DTC форматируются только общим C-кодеком. */ +#include /* Все данные хранятся в статических массивах с проверяемой длиной. */ +#include /* Ограниченный snprintf создаёт диагностический текст без выделения памяти приложением. */ +static void event(auto_engine_t *ctx, uint32_t kind, uint32_t ecu, uint32_t parameter, uint32_t code, int32_t value, const char *text) /* Публикует полностью сформированное событие в ограниченную очередь. */ +{ /* Отказ очереди учитывается и не перезаписывает непрочитанное событие. */ + uint32_t next = (ctx->event_head + 1U) % AUTO_EVENT_SIZE; if (next == ctx->event_tail) { ctx->queue_dropped++; return; } /* Очередь событий имеет собственную ёмкость, независимую от числа TX-кадров. */ + auto_event_t *entry = &ctx->events[ctx->event_head]; memset(entry, 0, sizeof(*entry)); /* Удаляет старый текст из повторно используемого слота. */ + entry->kind = kind; entry->ecu = ecu; entry->service = ctx->service; entry->parameter = parameter; entry->code = code; entry->value = value; /* Сохраняет сырые числовые идентификаторы отдельно от отображаемой строки. */ + if (text != NULL) { (void)snprintf(entry->text, sizeof(entry->text), "%s", text); } ctx->event_head = next; /* Ограниченный текст всегда заканчивается нулём. */ +} /* Завершает атомарную относительно вызывающего цикла публикацию события. */ +static void log_frame(auto_engine_t *ctx, const can_frame_t *frame, uint32_t direction) /* Журнал работает также при пассивном диагностическом движке. */ +{ /* При переполнении сохраняет самые свежие 127 кадров и увеличивает счётчик потерь. */ + uint32_t next = (ctx->log_head + 1U) % 128U; if (next == ctx->log_tail) { ctx->log_tail = (ctx->log_tail + 1U) % 128U; ctx->log_dropped++; } /* Ограниченная память не растёт во время длительного мониторинга. */ + ctx->log[ctx->log_head].frame = *frame; ctx->log[ctx->log_head].direction = direction; ctx->log_head = next; /* Копия кадра сохраняет ID, тип, длину и время. */ +} /* Завершает регистрацию одного CAN-кадра. */ +static diag_status_t queue_frame(auto_engine_t *ctx, const can_frame_t *frame) /* Общий выходной порт ISO-TP для всех ECU. */ +{ /* Сама постановка в программную очередь не считается аппаратным подтверждением ACK. */ + uint32_t next = (ctx->tx_head + 1U) % AUTO_QUEUE_SIZE; if (!ctx->enabled) { return DIAG_PASSIVE; } /* Отключённый движок не отвечает даже Flow Control. */ + if (next == ctx->tx_tail) { ctx->queue_dropped++; return DIAG_BUSY; } /* ISO-TP ограничит повторные попытки своими N_As/N_Ar/N_Cs. */ + ctx->tx[ctx->tx_head] = *frame; ctx->tx_head = next; return DIAG_OK; /* Физический порт забирает независимую копию позже. */ +} /* Завершает ограниченный неблокирующий выход кадра. */ +static diag_status_t tp_output(const can_frame_t *frame, void *user) /* Адаптирует один ISO-TP канал к общей очереди CAN. */ +{ auto_ecu_t *ecu = user; return queue_frame(ecu->owner, frame); } /* В контексте канала хранится единственный владелец очереди. */ +static void finish(auto_engine_t *ctx) /* Завершает запрос после физического ответа либо окончания функционального окна. */ +{ ctx->active = false; event(ctx, AUTO_DONE, 0U, ctx->parameter, 0U, (int32_t)ctx->replies, "complete"); } /* Сканирование карт может продолжиться отдельным ограниченным шагом auto_poll. */ +static void tp_payload(const uint8_t *payload, size_t length, void *user) /* Вызывается только для полностью проверенного ISO-TP сообщения одного ECU. */ +{ /* Ни один частичный VIN или DTC не выдаётся как успешный результат. */ + auto_ecu_t *ecu = user; auto_engine_t *ctx = ecu->owner; uint32_t id = ecu->tp.rx_id; uint8_t pid = (uint8_t)ctx->parameter; /* Адрес берётся из физического канала, а не из содержимого ответа. */ + if (!ctx->active || length == 0U) { return; } /* Поздние сообщения после отмены не меняют таблицу параметров. */ + if (ctx->service >= 0x10U) { /* UDS отделён от универсальных OBD Mode01..0A. */ + diag_status_t result = uds_response(&ecu->uds, payload, length, ctx->now); /* Проверяет эхо, NRC и P2/P2* в одном общем менеджере. */ + if (result == DIAG_BUSY) { event(ctx, AUTO_NRC, id, ctx->parameter, ecu->uds.nrc, 0, uds_nrc_name(ecu->uds.nrc)); return; } /* ResponsePending не завершает активную транзакцию. */ + if (result != DIAG_OK) { event(ctx, result == DIAG_IO ? AUTO_NRC : AUTO_ERROR, id, ctx->parameter, ecu->uds.nrc, result, uds_nrc_name(ecu->uds.nrc)); if (result != DIAG_INVALID) { ctx->active = false; } return; } /* Неправильный SID не отменяет ожидание корректного ответа. */ + char text[96]; size_t used = 0U; for (size_t i = 0U; i < length && used + 3U < sizeof(text); ++i) { int written = snprintf(&text[used], sizeof(text) - used, "%02X ", payload[i]); if (written < 0) { break; } used += (size_t)written; } text[used] = '\0'; /* GUI получает проверенный raw payload без самостоятельного UDS-парсера. */ + event(ctx, AUTO_UDS, id, ctx->parameter, (uint32_t)length, 0, text); ctx->replies++; finish(ctx); return; /* Физический UDS-запрос относится ровно к одному ECU. */ + } /* Завершает независимую ветвь UDS. */ + if (length == 3U && payload[0] == 0x7FU && payload[1] == ctx->service) { if ((ctx->negative_mask & (1U << ecu->slot)) == 0U) { ctx->negative_mask |= 1U << ecu->slot; event(ctx, AUTO_NRC, id, ctx->parameter, payload[2], 0, uds_nrc_name(payload[2])); } if (ctx->target != 255U) { ctx->active = false; } return; } /* Отрицательный ответ каждого ECU выводится один раз за функциональный запрос. */ + if (payload[0] != (uint8_t)(ctx->service + 0x40U)) { return; } /* Чужой положительный SID игнорируется без изменения таблицы. */ + if ((ctx->reply_mask & (1U << ecu->slot)) != 0U) { return; } /* Повторный положительный ответ не увеличивает число ECU и не дублирует DTC. */ + if (ctx->service == 0x01U || ctx->service == 0x02U) { /* Mode02 использует тот же каталог формул, но добавляет номер freeze frame. */ + size_t offset = ctx->service == 0x02U ? 3U : 2U; int32_t value; /* В данных Mode01 идут SID/PID, Mode02 — SID/PID/frame. */ + if (length < offset || payload[1] != pid || (ctx->service == 0x02U && payload[2] != (uint8_t)(ctx->parameter >> 8U))) { return; } /* Проверяет эхо PID и номера кадра перед вычислением. */ + if ((pid & 0x1FU) == 0U && pid <= 0x60U) { /* Блочные карты PID хранятся отдельно для каждого ECU. */ + if (length != offset + 4U) { event(ctx, AUTO_ERROR, id, pid, DIAG_INVALID, 0, "PID map length"); return; } /* Каждая карта содержит ровно четыре байта. */ + uint8_t block = pid / 32U; ecu->maps[block] = ((uint32_t)payload[offset] << 24U) | ((uint32_t)payload[offset + 1U] << 16U) | ((uint32_t)payload[offset + 2U] << 8U) | payload[offset + 3U]; ecu->map_valid |= (uint8_t)(1U << block); /* Старший бит соответствует первому PID после базового номера блока. */ + event(ctx, AUTO_ECU, id, pid, ecu->maps[block], 0, "supported PIDs"); /* В GUI передаётся карта конкретного физического ответчика. */ + } else if (pid == 0x01U) { if (length != offset + 4U) { return; } event(ctx, AUTO_VALUE, id, pid, payload[offset] >> 7U, (int32_t)(payload[offset] & 0x7FU), "MIL / DTC count"); } /* MIL и число DTC читаются из первого байта PID01 без смешения ECU. */ + else { diag_status_t result = obd2_pid_decode(pid, &payload[offset], length - offset, &value); if (result != DIAG_OK) { event(ctx, AUTO_ERROR, id, pid, (uint32_t)result, 0, "PID decode"); return; } event(ctx, AUTO_VALUE, id, pid, 0U, value, ""); } /* Числовая формула выполняется только C-каталогом. */ + } else if (ctx->service == 0x03U || ctx->service == 0x07U || ctx->service == 0x0AU) { /* Все три класса DTC имеют собственный сервис и общую кодировку двухбайтовых записей. */ + uint16_t codes[64]; size_t count; diag_status_t result = obd2_dtc_decode(payload, length, codes, 64U, &count); /* Отдельный кодек проверяет CAN-байт количества и полную длину сообщения. */ + if (result != DIAG_OK) { event(ctx, AUTO_ERROR, id, 0U, (uint32_t)result, 0, "DTC decode"); return; } /* Переполненный либо усечённый список не считается успешным. */ + size_t free_events = AUTO_EVENT_SIZE - 1U - ((ctx->event_head + AUTO_EVENT_SIZE - ctx->event_tail) % AUTO_EVENT_SIZE); if (count + 1U > free_events) { event(ctx, AUTO_ERROR, id, 0U, DIAG_OVERFLOW, 0, "DTC event queue full"); return; } /* Проверяет место для всего списка и завершающего события до публикации первого DTC. */ + for (size_t i = 0U; i < count; ++i) { char text[96], code[6]; obd2_dtc_format(codes[i], code); (void)snprintf(text, sizeof(text), "%s %s", code, obd2_dtc_description(codes[i])); event(ctx, AUTO_DTC, id, ctx->service, codes[i], 0, text); } /* Каждый DTC сохраняет класс, ECU и числовой исходник. */ + } else if (ctx->service == 0x09U && pid == 0x02U) { /* Стандартный VIN имеет семнадцать символов и номер информационного сообщения один. */ + char vin[18]; if (length != 20U || payload[1] != 0x02U || payload[2] != 0x01U) { event(ctx, AUTO_ERROR, id, pid, DIAG_INVALID, 0, "VIN length"); return; } /* Проверяет всю структуру 49 02 01 + VIN17. */ + for (size_t i = 0U; i < 17U; ++i) { uint8_t c = payload[3U + i]; if (!((c >= '0' && c <= '9') || (c >= 'A' && c <= 'Z' && c != 'I' && c != 'O' && c != 'Q'))) { event(ctx, AUTO_ERROR, id, pid, DIAG_INVALID, 0, "VIN character"); return; } vin[i] = (char)c; } vin[17] = '\0'; /* Не выдаёт бинарный мусор или запрещённые VIN-символы за идентификатор автомобиля. */ + event(ctx, AUTO_VIN, id, pid, 0U, 0, vin); /* Готовая строка не требует повторного парсинга в GUI. */ + } else if (ctx->service == 0x04U) { if (length != 1U) { return; } event(ctx, AUTO_RAW, id, 0U, 0U, 0, "DTC clear acknowledged"); } /* Сброс подтверждается только валидным ответом 44 на заранее подтверждённый запрос. */ + else { if (length < 2U || payload[1] != pid) { return; } event(ctx, AUTO_RAW, id, pid, (uint32_t)length, 0, "Raw monitor/identification data in CAN log"); } /* Mode06 и прочая Mode09 информация сохраняется сырым журналом без неподтверждённых формул. */ + ecu->present = true; ctx->reply_mask |= 1U << ecu->slot; ctx->replies++; if (ctx->target != 255U) { finish(ctx); } /* Функциональное окно собирает по одному ответу каждого ECU. */ +} /* Завершает единый разбор полной диагностической транзакции. */ +void auto_init(auto_engine_t *ctx) /* Стандартная адресация OBD известна независимо от профиля Ford или JLR. */ +{ /* init не обращается к CAN и оставляет enabled=false. */ + if (ctx == NULL) { return; } memset(ctx, 0, sizeof(*ctx)); ctx->interval_ms = 100U; /* Не больше десяти запросов в секунду; фактическая частота также ограничена ожиданием ответа. */ + for (uint8_t i = 0U; i < AUTO_ECU_COUNT; ++i) { auto_ecu_t *ecu = &ctx->ecu[i]; ecu->owner = ctx; ecu->slot = i; isotp_init(&ecu->tp, 0x7E0U + i, 0x7E8U + i, false, tp_output, tp_payload, ecu); uds_init(&ecu->uds); } /* 0x7E0..7E7 и 0x7E8..7EF — стандартные физические пары ISO 15765-4. */ +} /* Завершает пассивное создание восьми независимых соединений. */ +void auto_enable(auto_engine_t *ctx, bool enabled) /* Физический порт включает активный режим только после явного действия оператора. */ +{ /* Отключение не подразумевает, что автомобильный исполнительный механизм автоматически выключился. */ + if (ctx == NULL) { return; } ctx->enabled = enabled; if (enabled) { return; } /* Разрешение само по себе ещё не инициирует запросов. */ + ctx->active = false; ctx->scanning = false; ctx->tx_tail = ctx->tx_head; /* Смена режима удаляет ещё не отправленные запросы. */ + for (uint8_t i = 0U; i < AUTO_ECU_COUNT; ++i) { isotp_abort(&ctx->ecu[i].tp); ctx->ecu[i].uds.active = false; } /* Никакой старый ISO-TP канал не продолжит CF или FC после отмены. */ +} /* Завершает явное управление активностью диагностики. */ +int auto_pid_supported(const auto_engine_t *ctx, uint8_t target, uint8_t pid) /* Не считает все параметры поддерживаемыми каждым ECU. */ +{ /* Карта известна только после корректного ответа соответствующего ECU. */ + if (ctx == NULL || target >= AUTO_ECU_COUNT || pid == 0U || pid > 0x80U) { return -1; } uint8_t block = (uint8_t)((pid - 1U) / 32U); /* PID20 относится к предыдущей карте, как предписывает SAE J1979. */ + if ((ctx->ecu[target].map_valid & (1U << block)) == 0U) { return -1; } return (ctx->ecu[target].maps[block] & (1UL << (31U - ((pid - 1U) % 32U)))) != 0U ? 1 : 0; /* Нулевой бит означает подтверждённое отсутствие конкретного PID. */ +} /* Завершает запрос возможностей без смешения ECU-карт. */ +static diag_status_t begin(auto_engine_t *ctx, uint8_t service, uint16_t parameter, uint8_t target, uint32_t now) /* Общая проверка конечной диагностической транзакции. */ +{ /* Вызывающий строит payload только после успешного разрешения запроса. */ + if (ctx == NULL || (target >= AUTO_ECU_COUNT && target != 255U)) { return DIAG_INVALID; } if (!ctx->enabled) { return DIAG_PASSIVE; } /* Неправильный адрес и пассивный режим не приводят к CAN TX. */ + if (ctx->active || (ctx->ever_requested && diag_elapsed(now, ctx->last_request) < ctx->interval_ms)) { return DIAG_BUSY; } /* Один запрос одновременно предотвращает неоднозначное сопоставление ответов. */ + ctx->now = now; ctx->service = service; ctx->parameter = parameter; ctx->target = target; ctx->started = now; ctx->last_request = now; ctx->active = true; ctx->ever_requested = true; ctx->replies = 0U; ctx->reply_mask = 0U; ctx->negative_mask = 0U; /* Новая транзакция не наследует маски ответчиков предыдущего запроса. */ + for (uint8_t i = 0U; i < AUTO_ECU_COUNT; ++i) { isotp_abort(&ctx->ecu[i].tp); } return DIAG_OK; /* Новая транзакция не принимает хвост незавершённого предыдущего сообщения. */ +} /* Завершает проверку контекста и ограничителя частоты. */ +diag_status_t auto_request(auto_engine_t *ctx, uint8_t service, uint16_t parameter, uint8_t target, bool confirmed, uint32_t now) /* Поддерживает стандартные операции OBD поверх Classic CAN. */ +{ /* Произвольные сервисы UDS этим входом не отправляются. */ + uint8_t payload[3] = {service, (uint8_t)parameter, (uint8_t)(parameter >> 8U)}; size_t length = 1U; /* Дополнительный байт Mode02 задаёт номер freeze frame. */ + if (service == 0x01U || service == 0x06U || service == 0x09U) { length = 2U; if (parameter > 255U) { return DIAG_INVALID; } } /* Параметры перечисленных сервисов занимают один байт. */ + else if (service == 0x02U) { length = 3U; } /* Freeze Frame использует PID и номер снимка. */ + else if (service == 0x04U) { if (!confirmed) { return DIAG_PASSIVE; } } /* Сброс DTC невозможен без отдельного явного подтверждения вызывающего. */ + else if (service != 0x03U && service != 0x07U && service != 0x0AU) { return DIAG_UNSUPPORTED; } /* Нет лазейки для actuator/programming команд через произвольный SID. */ + if (ctx != NULL && service == 0x01U && target < AUTO_ECU_COUNT && auto_pid_supported(ctx, target, (uint8_t)parameter) == 0) { return DIAG_UNSUPPORTED; } /* Подтверждённо отсутствующий PID не запрашивается у выбранного ECU. */ + diag_status_t result = begin(ctx, service, parameter, target, now); if (result != DIAG_OK) { return result; } /* Все проверки состояния выполняются до первой передачи. */ + if (target == 255U) { can_frame_t frame = {0}; frame.id = 0x7DFU; frame.length = 8U; frame.timestamp_ms = now; result = isotp_sf_encode(payload, length, frame.data); if (result == DIAG_OK) { result = queue_frame(ctx, &frame); } } /* Функциональный запрос остаётся единственным стандартным ID, без перебора всей шины. */ + else { result = isotp_transmit(&ctx->ecu[target].tp, payload, length, now); } /* Физический запрос использует собственную пару адресов и ISO-TP автомат. */ + if (result != DIAG_OK) { ctx->active = false; } return result; /* Отказ постановки запроса не оставляет ложное активное ожидание. */ +} /* Завершает построение проверенного OBD-запроса. */ +diag_status_t auto_scan(auto_engine_t *ctx, uint32_t now) /* Начинает обнаружение без перебора неизвестных CAN ID. */ +{ diag_status_t result = auto_request(ctx, 0x01U, 0U, 255U, false, now); if (result == DIAG_OK) { ctx->scanning = true; for (uint8_t i = 0U; i < AUTO_ECU_COUNT; ++i) { ctx->ecu[i].map_valid = 0U; ctx->ecu[i].map_attempted = 1U; ctx->ecu[i].present = false; } } return result; } /* Новое сканирование не наследует возможности прежнего автомобиля. */ +diag_status_t auto_uds_request(auto_engine_t *ctx, uint8_t target, uint8_t service, uint16_t parameter, uint32_t now) /* Допускает только физический канал и политику менеджера UDS. */ +{ /* Расширенное чтение не создаёт автоматические сессии или SecurityAccess. */ + uint8_t payload[8]; size_t length; if (ctx == NULL || target >= AUTO_ECU_COUNT) { return DIAG_INVALID; } /* Функциональный UDS не используется без подтверждённого профиля. */ + diag_status_t result = uds_request(&ctx->ecu[target].uds, service, parameter, now, payload, sizeof(payload), &length); if (result != DIAG_OK) { return result; } /* Запрещённый SID не доходит до общей очереди. */ + result = begin(ctx, service, parameter, target, now); if (result == DIAG_OK) { result = isotp_transmit(&ctx->ecu[target].tp, payload, length, now); } /* Запрос связан с одним ожидаемым DID и одной сессией. */ + if (result != DIAG_OK) { ctx->ecu[target].uds.active = false; } return result; /* Ошибка занятости не оставляет phantom-сессию UDS. */ +} /* Завершает безопасный запуск расширенного чтения. */ +void auto_feed(auto_engine_t *ctx, const can_frame_t *frame, uint32_t now) /* CAN-порт вызывает метод только после нормализации аппаратного кадра. */ +{ /* Логирование не включает активную диагностику автоматически. */ + if (ctx == NULL || frame == NULL || frame->length > 8U || frame->id > (frame->extended ? 0x1FFFFFFFU : 0x7FFU)) { return; } ctx->now = now; log_frame(ctx, frame, 0U); /* Валидирует размер до хранения и разбора. */ + if (!ctx->enabled || !ctx->active || diag_elapsed(frame->timestamp_ms, ctx->started) > diag_elapsed(now, ctx->started) || (ctx->service < 0x10U && diag_elapsed(now, ctx->started) >= 1000U)) { return; } /* Старый кадр из аппаратной очереди и будущая метка не могут завершить новый запрос даже при совпавшем PID. */ + for (uint8_t i = 0U; i < AUTO_ECU_COUNT; ++i) { if (ctx->target == 255U || ctx->target == i) { isotp_on_frame(&ctx->ecu[i].tp, frame, now); } } /* Канал дополнительно проверяет собственный rx_id и тип идентификатора. */ +} /* Завершает маршрутизацию одного принятого кадра. */ +void auto_poll(auto_engine_t *ctx, uint32_t now) /* Регулярный вызов обеспечивает конечные таймауты и неблокирующий scan. */ +{ /* Переключение скорости и транспорта требует auto_enable(false) до повторного подключения. */ + if (ctx == NULL || !ctx->enabled) { return; } ctx->now = now; /* Пассивный движок не создаёт FC или диагностические запросы. */ + if (ctx->active) { /* Только текущая транзакция может использовать исходящую очередь. */ + for (uint8_t i = 0U; i < AUTO_ECU_COUNT; ++i) { isotp_poll(&ctx->ecu[i].tp, now); if (ctx->ecu[i].tp.error != DIAG_OK) { event(ctx, AUTO_ERROR, ctx->ecu[i].tp.rx_id, ctx->parameter, (uint32_t)ctx->ecu[i].tp.error, 0, "ISO-TP"); ctx->ecu[i].tp.error = DIAG_OK; } } /* Ошибки разных ECU видны отдельно и не теряются между poll. */ + bool timed_out = ctx->service >= 0x10U ? uds_poll(&ctx->ecu[ctx->target].uds, now) == DIAG_TIMEOUT : diag_elapsed(now, ctx->started) >= 1000U; /* UDS использует P2/P2*, OBD — конечное окно в одну секунду. */ + if (timed_out) { if (ctx->replies == 0U) { event(ctx, AUTO_ERROR, 0U, ctx->parameter, DIAG_TIMEOUT, 0, "response timeout"); } finish(ctx); } /* Отсутствие ответа никогда не выдаётся за нулевое физическое значение. */ + } /* Завершает шаг активной транзакции. */ + if (ctx->scanning && !ctx->active && diag_elapsed(now, ctx->last_request) >= ctx->interval_ms) { /* Продолжение scan выполняет максимум один следующий физический запрос за шаг. */ + for (uint8_t i = 0U; i < AUTO_ECU_COUNT; ++i) { for (uint8_t block = 1U; block < 4U; ++block) { auto_ecu_t *ecu = &ctx->ecu[i]; if ((ecu->map_valid & (1U << (block - 1U))) != 0U && (ecu->maps[block - 1U] & 1U) != 0U && (ecu->map_attempted & (1U << block)) == 0U) { ecu->map_attempted |= (uint8_t)(1U << block); (void)auto_request(ctx, 0x01U, (uint16_t)(block * 32U), i, false, now); return; } } } /* Следующий диапазон запрашивается только если предыдущая карта ECU объявила его наличие. */ + ctx->scanning = false; event(ctx, AUTO_DONE, 0U, 0U, 0U, 0, "scan complete"); /* Неответившие диапазоны не опрашиваются бесконечно. */ + } /* Завершает дополнительное обнаружение поддержанных диапазонов PID. */ +} /* Завершает общий шаг диагностики без блокирующего ожидания ECU. */ +diag_status_t auto_take_tx(auto_engine_t *ctx, can_frame_t *frame) /* Порт забирает кадры по порядку и проверяет реальный результат отправки. */ +{ if (ctx == NULL || frame == NULL) { return DIAG_INVALID; } if (ctx->tx_head == ctx->tx_tail) { return DIAG_EMPTY; } *frame = ctx->tx[ctx->tx_tail]; ctx->tx_tail = (ctx->tx_tail + 1U) % AUTO_QUEUE_SIZE; log_frame(ctx, frame, 1U); return DIAG_OK; } /* TX в журнале означает выдачу порту; аппаратный отказ регистрируется отдельным событием. */ +diag_status_t auto_take_event(auto_engine_t *ctx, auto_event_t *entry) /* Интерфейс одинаков для UART CLI и Python ABI. */ +{ if (ctx == NULL || entry == NULL) { return DIAG_INVALID; } if (ctx->event_head == ctx->event_tail) { return DIAG_EMPTY; } *entry = ctx->events[ctx->event_tail]; ctx->event_tail = (ctx->event_tail + 1U) % AUTO_EVENT_SIZE; return DIAG_OK; } /* Применяет отдельную ёмкость полной очереди результатов диагностики. */ +diag_status_t auto_take_log(auto_engine_t *ctx, auto_log_t *entry) /* Позволяет выгружать CSV без изменения протокольного автомата. */ +{ if (ctx == NULL || entry == NULL) { return DIAG_INVALID; } if (ctx->log_head == ctx->log_tail) { return DIAG_EMPTY; } *entry = ctx->log[ctx->log_tail]; ctx->log_tail = (ctx->log_tail + 1U) % 128U; return DIAG_OK; } /* Журнал выдаётся в исходном порядке временных меток. */ +void auto_transport_error(auto_engine_t *ctx, diag_status_t error) /* Вызывается при bus-off, отключении USB/COM или отказе send. */ +{ if (ctx != NULL) { auto_enable(ctx, false); event(ctx, AUTO_ERROR, 0U, 0U, (uint32_t)error, 0, "CAN transport stopped"); } } /* Отказ транспорта прекращает также Data Stream и не инициирует автоматическое восстановление. */ diff --git a/c/automotive/src/ecu_programmer.c b/c/automotive/src/ecu_programmer.c new file mode 100644 index 0000000..553ce0a --- /dev/null +++ b/c/automotive/src/ecu_programmer.c @@ -0,0 +1,36 @@ +#include "ecu_programmer.h" /* Исполняет проверяемую архитектуру обновления только на изолированном симуляторе. */ +#include "gui_frame.h" /* CRC32 используется из существующего общего templates, без дублирования алгоритма целостности. */ +#include /* Локальная Flash симулятора является ограниченным массивом RAM. */ +void programming_simulator_init(programming_simulator_t *sim, uint32_t ecu_id, uint32_t hardware, uint32_t software) /* Идентичность виртуального ECU задаёт тестовый стенд явно. */ +{ if (sim != NULL) { memset(sim, 0, sizeof(*sim)); memset(sim->flash, 0xFF, sizeof(sim->flash)); sim->ecu_id = ecu_id; sim->hardware = hardware; sim->software = software; sim->power_good = true; } } /* Стирание затрагивает только массив sim->flash и не может обратиться к реальному ECU. */ +diag_status_t programming_simulator_block(programming_simulator_t *sim, uint8_t sequence, const uint8_t *data, size_t length) /* Моделирует проверяемую семантику TransferData. */ +{ /* Номер блока проверяется до изменения смещения и содержимого виртуальной Flash. */ + if (sim == NULL || data == NULL || length == 0U || length > 32U || !sim->download_open || !sim->power_good || sequence != sim->expected_sequence) { return DIAG_INVALID; } /* Не допускает приём без RequestDownload, неверный sequence и потерю питания. */ + if (sim->received > sim->expected_length || length > sim->expected_length - sim->received || sim->expected_length > sizeof(sim->flash)) { return DIAG_OVERFLOW; } /* Вычитание выполняется только после проверки, исключающей underflow. */ + memcpy(&sim->flash[sim->received], data, length); sim->received += length; sim->expected_sequence++; return DIAG_OK; /* uint8_t обеспечивает стандартный переход счётчика блока через ноль. */ +} /* Завершает приём одного локального блока без CAN. */ +static void programming_fail(ecu_programmer_t *ctx, diag_status_t error) /* Единый путь отказа никогда не запускает реальную recovery-последовательность. */ +{ ctx->error = error; ctx->state = PROGRAM_FAILED; if (ctx->sim != NULL) { ctx->sim->download_open = false; } } /* Непроверенный локальный образ не становится новой версией ПО даже после частичной передачи. */ +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) /* Все сведения о совместимости и целостности проверяются до download. */ +{ /* Принципиально не принимает дескриптор CAN, UDS либо произвольный передающий callback. */ + if (ctx == NULL || sim == NULL || manifest == NULL || image == NULL || length == 0U || length > sizeof(sim->flash) || manifest->length != length) { return DIAG_INVALID; } /* Образ ограничен явной ёмкостью виртуального устройства. */ + if (!sim->power_good || sim->download_open || manifest->ecu_id != sim->ecu_id || manifest->hardware != sim->hardware) { return DIAG_PASSIVE; } /* Чужой ECU, аппаратная версия и неподходящее питание блокируют даже симуляционный запуск. */ + if (gui_crc32(image, length) != manifest->crc32) { return DIAG_INVALID; } /* Реальная CRC32 проверяет целостность файла до первого изменения RAM-образа. */ + if (manifest->signed_image && (manifest->verify_signature == NULL || !manifest->verify_signature(image, length, manifest->signature_user))) { return DIAG_UNSUPPORTED; } /* Криптографическая подпись не заменяется CRC и не считается проверенной без провайдера. */ + memset(ctx, 0, sizeof(*ctx)); ctx->sim = sim; ctx->manifest = *manifest; ctx->image = image; ctx->started = now; ctx->maximum_ms = 10000U; ctx->sequence = 1U; ctx->state = PROGRAM_CHECK; return DIAG_OK; /* Буфер image обязан жить до терминального состояния автомата. */ +} /* Завершает подготовку исключительно локального процесса. */ +void ecu_programmer_poll(ecu_programmer_t *ctx, uint32_t now) /* Один ограниченный шаг не ждёт ответа в бесконечном цикле. */ +{ /* Все этапы имеют общий конечный предел десять секунд. */ + if (ctx == NULL || ctx->state == PROGRAM_IDLE || ctx->state >= PROGRAM_COMPLETE) { return; } /* Терминальный автомат никогда не начинает новую запись самостоятельно. */ + if (!ctx->sim->power_good || diag_elapsed(now, ctx->started) >= ctx->maximum_ms) { programming_fail(ctx, !ctx->sim->power_good ? DIAG_IO : DIAG_TIMEOUT); return; } /* Потеря питания и времени закрывает виртуальный download. */ + switch (ctx->state) { /* SID в журнале относятся к виртуальным этапам, не к CAN-пакетам. */ + case PROGRAM_CHECK: if (ctx->sim->ecu_id != ctx->manifest.ecu_id || ctx->sim->hardware != ctx->manifest.hardware) { programming_fail(ctx, DIAG_INVALID); } else { ctx->state = PROGRAM_SESSION; } break; /* Идентичность повторно проверяется перед виртуальной сессией. */ + case PROGRAM_SESSION: ctx->trace[ctx->trace_count++] = 0x10U; ctx->state = PROGRAM_DOWNLOAD; break; /* Только локальное моделирование DiagnosticSessionControl, без реального backend. */ + case PROGRAM_DOWNLOAD: ctx->trace[ctx->trace_count++] = 0x34U; ctx->sim->expected_length = ctx->manifest.length; ctx->sim->received = 0U; ctx->sim->expected_sequence = 1U; ctx->sim->download_open = true; ctx->state = PROGRAM_TRANSFER; break; /* RequestDownload объявляет точный размер виртуального образа. */ + case PROGRAM_TRANSFER: { size_t length = ctx->manifest.length - ctx->offset; if (length > 32U) { length = 32U; } diag_status_t result = programming_simulator_block(ctx->sim, ctx->sequence, &ctx->image[ctx->offset], length); if (result != DIAG_OK) { programming_fail(ctx, result); break; } ctx->trace[ctx->trace_count++] = 0x36U; ctx->sequence++; ctx->offset += length; if (ctx->offset == ctx->manifest.length) { ctx->state = PROGRAM_VERIFY; } break; } /* Передаёт один блок и принимает его только с ожидаемым счётчиком. */ + case PROGRAM_VERIFY: ctx->trace[ctx->trace_count++] = 0x37U; ctx->sim->download_open = false; if (ctx->sim->received != ctx->manifest.length || gui_crc32(ctx->sim->flash, ctx->sim->received) != ctx->manifest.crc32) { programming_fail(ctx, DIAG_INVALID); } else { ctx->sim->software = ctx->manifest.software; ctx->state = PROGRAM_COMPLETE; } break; /* RequestTransferExit обновляет версию лишь после полного readback и CRC. */ + default: programming_fail(ctx, DIAG_INVALID); break; /* Неизвестное состояние не обращается к памяти за пределами симулятора. */ + } /* Максимум 32 TransferData + 3 служебных записи помещаются в trace[64] при лимите Flash 1024 байта. */ +} /* Завершает проверяемый шаг симулятора программирования. */ +void ecu_programmer_cancel(ecu_programmer_t *ctx) /* Отмена не отправляет неизвестные команды аппаратному ECU. */ +{ if (ctx != NULL && ctx->state > PROGRAM_IDLE && ctx->state < PROGRAM_COMPLETE) { ctx->state = PROGRAM_CANCELLED; ctx->sim->download_open = false; } } /* Частичный локальный образ не повышает software version. */ diff --git a/c/automotive/src/isotp.c b/c/automotive/src/isotp.c new file mode 100644 index 0000000..bbe9ac4 --- /dev/null +++ b/c/automotive/src/isotp.c @@ -0,0 +1,116 @@ +#include "isotp.h" /* Подключает единственный публичный контракт кодека Single Frame. */ +#include /* Ограниченные 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 после блока. */ +} /* Завершает ограниченный шаг передачи и контроля таймаутов. */ diff --git a/c/automotive/src/landrover_suspension.c b/c/automotive/src/landrover_suspension.c new file mode 100644 index 0000000..25dd0e8 --- /dev/null +++ b/c/automotive/src/landrover_suspension.c @@ -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; } /* Границы проверяются до чтения записи. */ diff --git a/c/automotive/src/obd2_dtc.c b/c/automotive/src/obd2_dtc.c new file mode 100644 index 0000000..a0a2d4c --- /dev/null +++ b/c/automotive/src/obd2_dtc.c @@ -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 является корректным положительным результатом. */ +} /* Завершает декодер без зависимости от транспорта. */ diff --git a/c/automotive/src/obd2_pid.c b/c/automotive/src/obd2_pid.c new file mode 100644 index 0000000..4cf5ad7 --- /dev/null +++ b/c/automotive/src/obd2_pid.c @@ -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. */ diff --git a/c/automotive/src/service_manager.c b/c/automotive/src/service_manager.c new file mode 100644 index 0000000..168d9df --- /dev/null +++ b/c/automotive/src/service_manager.c @@ -0,0 +1,38 @@ +#include "service_manager.h" /* Менеджер исполняет только явно переданную проверенную процедуру. */ +#include /* Контекст не требует динамической памяти. */ +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. */ +} /* Завершает шаг менеджера сервисных функций. */ diff --git a/c/automotive/src/uds.c b/c/automotive/src/uds.c new file mode 100644 index 0000000..73cce72 --- /dev/null +++ b/c/automotive/src/uds.c @@ -0,0 +1,65 @@ +#include "uds.h" /* Предоставляет безопасные построители и конечный автомат ожидания ответа. */ +#include /* Контекст инициализируется без 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*, неизвестный код остаётся явным. */ + } /* Завершает каталог стандартных отрицательных ответов. */ +} /* Возвращённые строки неизменяемы и не требуют освобождения. */ diff --git a/c/automotive/src/vehicle_manager.c b/c/automotive/src/vehicle_manager.c new file mode 100644 index 0000000..0417850 --- /dev/null +++ b/c/automotive/src/vehicle_manager.c @@ -0,0 +1,33 @@ +#include "vehicle_manager.h" /* Проверяет данные профиля до их использования аппаратным или диагностическим портом. */ +#include /* Реестр полностью инициализируется без динамической памяти. */ +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 не разрешает передачу. */ diff --git a/c/automotive/tests/test_logger.c b/c/automotive/tests/test_logger.c new file mode 100644 index 0000000..7843937 --- /dev/null +++ b/c/automotive/tests/test_logger.c @@ -0,0 +1,18 @@ +#include "can_logger.h" /* Проверяет формат журнала и пассивную сборку тем же ISO-TP кодом. */ +#include /* Ошибка теста завершает процесс до отчёта об успехе. */ +#include /* Итог содержит только фактически исполненные условия. */ +#include /* Сравнивает точные 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 наблюдателя. */ +} /* Завершает изолированную проверку журнала. */ diff --git a/c/automotive/tests/test_managers.c b/c/automotive/tests/test_managers.c new file mode 100644 index 0000000..3664d57 --- /dev/null +++ b/c/automotive/tests/test_managers.c @@ -0,0 +1,42 @@ +#include "service_manager.h" /* Проверяет реальные переходы общего сервисного автомата без автомобиля. */ +#include "ecu_programmer.h" /* Любое обновление выполняется исключительно на RAM-симуляторе ECU. */ +#include "landrover_suspension.h" /* Непроверенные JLR операции должны оставаться заблокированными. */ +#include "gui_frame.h" /* Эталон CRC32 относится к существующей общей реализации templates. */ +#include /* Нарушение любой гарантии завершает процесс с ненулевым кодом. */ +#include /* Итог выводится после реального завершения проверок. */ +#include /* Содержимое виртуальной Flash проверяется побайтно. */ +static unsigned checks, operations, recoveries, validations; /* Счётчики фиксируют реально выполненные callback и условия. */ +#define CHECK(value) do { checks++; assert(value); } while (0) /* Макрос не отключается тестовой конфигурацией сборки. */ +static diag_status_t precondition(void *user, uint32_t now) { (void)user; (void)now; validations++; return DIAG_OK; } /* Тестовый стенд подтверждает исходные условия без реальных датчиков. */ +static diag_status_t execute(void *user, uint32_t now) { (void)user; (void)now; operations++; return DIAG_OK; } /* Синтетическая операция изменяет только локальный счётчик, не CAN. */ +static diag_status_t verify(void *user, uint32_t now) { (void)user; return now < 10U ? DIAG_BUSY : DIAG_OK; } /* Проверяет неблокирующее ожидание документированного тестового критерия. */ +static diag_status_t recover(void *user, uint32_t now) { (void)user; (void)now; recoveries++; return DIAG_OK; } /* Безопасное завершение стендовой операции также является наблюдаемым отдельным шагом. */ +static diag_status_t stuck(void *user, uint32_t now) { (void)user; (void)now; return DIAG_BUSY; } /* Моделирует потерю подтверждения recovery для проверки конечного срока. */ +static void test_service(void) /* Подтверждение оператора не обходит статус непроверенного профиля. */ +{ /* Условные команды стенда не являются производительскими процедурами Ford/JLR. */ + service_manager_t manager; service_manager_init(&manager); service_profile_t profile = {0}; profile.name = "Local fixture"; profile.source = "Tests/test_managers.c: RAM fixture only"; profile.maximum_ms = 100U; profile.recovery_ms = 20U; profile.category = UDS_ACTUATOR_CONTROL; profile.preconditions = precondition; profile.independent_check = precondition; profile.execute = execute; profile.verify = verify; profile.recover = recover; profile.evidence = PROFILE_UNVERIFIED; /* Полный набор callback ещё не доказывает проверенность ECU-команд. */ + CHECK(service_start(&manager, &profile, NULL, true, 0U) == DIAG_UNSUPPORTED && operations == 0U); profile.evidence = PROFILE_SUPPORTED; CHECK(service_start(&manager, &profile, NULL, false, 0U) == DIAG_PASSIVE); /* Неизвестный профиль и отсутствие подтверждения блокируют execute независимо. */ + CHECK(service_start(&manager, &profile, NULL, true, 0U) == DIAG_PASSIVE); CHECK(service_protected_mode(&manager, true) == DIAG_OK); CHECK(service_start(&manager, &profile, NULL, true, 0U) == DIAG_OK); for (uint32_t now = 0U; now < 15U; ++now) { service_poll(&manager, now); } CHECK(manager.state == SERVICE_COMPLETE && operations == 1U && validations == 2U && recoveries == 1U); /* Даже подтверждённая процедура недоступна до отдельного защищённого режима стенда. */ + CHECK(service_start(&manager, &profile, NULL, true, 0U) == DIAG_OK); for (uint32_t now = 0U; now < 5U; ++now) { service_poll(&manager, now); } CHECK(manager.touched_ecu); service_cancel(&manager); service_poll(&manager, 5U); CHECK(manager.state == SERVICE_RECOVERY); service_poll(&manager, 6U); CHECK(manager.state == SERVICE_CANCELLED && recoveries == 2U); /* Отмена после воздействия не считается выключением без вызова recovery. */ + profile.recover = stuck; CHECK(service_start(&manager, &profile, NULL, true, 0U) == DIAG_OK); for (uint32_t now = 0U; now < 5U; ++now) { service_poll(&manager, now); } service_link_error(&manager, DIAG_IO, 5U); service_poll(&manager, 25U); CHECK(manager.state == SERVICE_FAILED && manager.recovery_incomplete && manager.error == DIAG_TIMEOUT); /* Неоконченная процедура явно требует внешнего безопасного завершения. */ +} /* Завершает проверки сервисного автомата на изолированном стенде. */ +static void test_profiles(void) /* Профили не должны создавать неподтверждённую фирменную адресацию. */ +{ /* Реестр описывает возможности и источники, а не угадывает параметры конкретного VIN. */ + vehicle_manager_t vehicles; vehicle_manager_init(&vehicles); CHECK(vehicles.count == 9U); CHECK(vehicle_ecu_verified(&vehicles.profiles[0]->ecu[0])); CHECK(!vehicle_ecu_verified(&vehicles.profiles[1]->ecu[0])); /* Только универсальная стандартная OBD запись считается проверенным маршрутом. */ + CHECK(vehicle_select(&vehicles, 100U) == DIAG_INVALID && vehicles.selected == 0U); CHECK(vehicle_select(&vehicles, 3U) == DIAG_OK); /* Ошибочный индекс не меняет выбранный профиль. */ + for (size_t i = 0U; i < landrover_suspension_count(); ++i) { const suspension_operation_t *operation = landrover_suspension_operation(i); CHECK(operation != NULL && operation->evidence == PROFILE_UNVERIFIED && operation->service == 0U && operation->did == 0U && operation->routine == 0U); } /* Ни одна процедура подвески не содержит вымышленной активной команды. */ + CHECK(landrover_suspension_operation(100U) == NULL); /* Контроль границ применяется также к справочным таблицам. */ +} /* Завершает проверки данных автомобилей. */ +static void test_programmer(void) /* Проверяет фактическую передачу локального образа и отказ при несовместимости. */ +{ /* Массивы симулятора не имеют аппаратного адреса и не могут программировать реальный ECU. */ + programming_simulator_t sim; ecu_programmer_t programmer = {0}; uint8_t image[97]; for (size_t i = 0U; i < sizeof(image); ++i) { image[i] = (uint8_t)i; } programmer_manifest_t manifest = {0}; manifest.ecu_id = 17U; manifest.hardware = 2U; manifest.software = 3U; manifest.length = sizeof(image); manifest.crc32 = gui_crc32(image, sizeof(image)); /* Четыре блока включают неполный последний блок длиной один байт. */ + CHECK(gui_crc32((const uint8_t *)"123456789", 9U) == 0xCBF43926U); programming_simulator_init(&sim, 17U, 2U, 1U); /* CRC32 проверяется независимым стандартным эталоном IEEE. */ + CHECK(ecu_programmer_begin_simulation(&programmer, &sim, &manifest, image, sizeof(image), 0U) == DIAG_OK); for (uint32_t now = 0U; now < 12U; ++now) { ecu_programmer_poll(&programmer, now); } CHECK(programmer.state == PROGRAM_COMPLETE && sim.software == 3U && memcmp(sim.flash, image, sizeof(image)) == 0 && programmer.trace_count == 7U); /* Версия обновляется только после полного readback и CRC; журнал содержит 10/34/36*4/37. */ + programming_simulator_init(&sim, 17U, 7U, 1U); CHECK(ecu_programmer_begin_simulation(&programmer, &sim, &manifest, image, sizeof(image), 0U) == DIAG_PASSIVE); /* Несовместимая аппаратная версия блокирует начало до RequestDownload. */ + programming_simulator_init(&sim, 17U, 2U, 1U); manifest.crc32 ^= 1U; CHECK(ecu_programmer_begin_simulation(&programmer, &sim, &manifest, image, sizeof(image), 0U) == DIAG_INVALID); manifest.crc32 ^= 1U; /* Повреждённый файл не начинает даже симуляционную запись. */ + manifest.signed_image = true; CHECK(ecu_programmer_begin_simulation(&programmer, &sim, &manifest, image, sizeof(image), 0U) == DIAG_UNSUPPORTED); manifest.signed_image = false; /* Отсутствующий verifier нельзя заменить успешным CRC. */ + CHECK(ecu_programmer_begin_simulation(&programmer, &sim, &manifest, image, sizeof(image), 0U) == DIAG_OK); for (uint32_t now = 0U; now < 3U; ++now) { ecu_programmer_poll(&programmer, now); } CHECK(programming_simulator_block(&sim, 2U, image, 4U) == DIAG_INVALID && sim.received == 0U); /* Неправильный первый sequence не изменяет Flash и счётчик приёма. */ + sim.power_good = false; ecu_programmer_poll(&programmer, 4U); CHECK(programmer.state == PROGRAM_FAILED && !sim.download_open && sim.software == 1U); /* Потеря питания не выдаёт частичный образ за новую версию ПО. */ + programming_simulator_init(&sim, 17U, 2U, 1U); CHECK(ecu_programmer_begin_simulation(&programmer, &sim, &manifest, image, sizeof(image), 0U) == DIAG_OK); ecu_programmer_cancel(&programmer); CHECK(programmer.state == PROGRAM_CANCELLED && !sim.download_open); /* Отмена не обращается к ECU Reset или физическому CAN. */ +} /* Завершает реальные испытания симулятора обновления. */ +int main(void) { test_service(); test_profiles(); test_programmer(); printf("PASS: %u manager/simulator checks\n", checks); return 0; } /* Успех выводится только после выполнения всех стендовых условий. */ diff --git a/c/automotive/tests/test_protocols.c b/c/automotive/tests/test_protocols.c new file mode 100644 index 0000000..89ca82b --- /dev/null +++ b/c/automotive/tests/test_protocols.c @@ -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 /* Любое нарушение эталонных байтов завершает тест с ненулевым кодом. */ +#include /* Выводит только итог фактически выполненных проверок. */ +#include /* Сравнивает 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; } /* Успех сообщается только после реального прохождения всех проверок. */ diff --git a/python/automotive/__init__.py b/python/automotive/__init__.py new file mode 100644 index 0000000..1245788 --- /dev/null +++ b/python/automotive/__init__.py @@ -0,0 +1,45 @@ +import ctypes as ct # C ABI является единственным источником протокольных правил, формул и диагностических состояний. +from pathlib import Path # Приложение передаёт абсолютный путь к отдельной automotive DLL. +class Event(ct.Structure): # Структура отражает только стабильный ABI, а не внутреннее устройство протокольных контекстов. + _fields_ = [(name, ct.c_uint32) for name in ('kind', 'ecu', 'service', 'parameter', 'code')] + [('value', ct.c_int32), ('text', ct.c_char * 96)] # Типы и порядок точно соответствуют auto_event_t версии ABI 1. + @property # Декодирование UTF-8 является преобразованием представления, без интерпретации протокольных байтов. + def message(self): return bytes(self.text).decode('utf-8', errors='replace') # Числовой исходник кода сохраняется независимо от локализованного текста. +class DiagnosticEngine: # Тонкий host-порт хранит буфер C и сигнатуры функций без алгоритмического fallback. + def __init__(self, library): # Отсутствующая библиотека делает действия недоступными и не заменяется Python-кодеком. + self.library = ct.CDLL(str(Path(library).resolve())) # Загружает отдельную библиотеку, не заменяя SETProtocol уже работающих вкладок. + signatures = {'diagnostic_abi_version': (ct.c_uint32, []), 'diagnostic_context_size': (ct.c_uint32, []), 'diagnostic_init': (ct.c_int, [ct.c_void_p, ct.c_uint32]), 'diagnostic_enable': (None, [ct.c_void_p, ct.c_int]), 'diagnostic_request': (ct.c_int, [ct.c_void_p, ct.c_uint32, ct.c_uint32, ct.c_uint32, ct.c_int, ct.c_uint32]), 'diagnostic_scan': (ct.c_int, [ct.c_void_p, ct.c_uint32]), 'diagnostic_uds': (ct.c_int, [ct.c_void_p, ct.c_uint32, ct.c_uint32, ct.c_uint32, ct.c_uint32]), 'diagnostic_feed': (None, [ct.c_void_p, ct.c_uint32, ct.c_void_p, ct.c_uint32, ct.c_int, ct.c_uint32]), 'diagnostic_poll': (None, [ct.c_void_p, ct.c_uint32]), 'diagnostic_busy': (ct.c_int, [ct.c_void_p]), 'diagnostic_supported': (ct.c_int, [ct.c_void_p, ct.c_uint32, ct.c_uint32]), 'diagnostic_pid_count': (ct.c_uint32, []), 'diagnostic_pid_code': (ct.c_uint32, [ct.c_uint32]), 'diagnostic_pid_name': (ct.c_char_p, [ct.c_uint32]), 'diagnostic_pid_unit': (ct.c_char_p, [ct.c_uint32]), 'diagnostic_error': (None, [ct.c_void_p, ct.c_uint32]), 'diagnostic_event': (ct.c_int, [ct.c_void_p, ct.POINTER(Event)]), 'diagnostic_tx': (ct.c_int, [ct.c_void_p, ct.POINTER(ct.c_uint32), ct.c_void_p, ct.POINTER(ct.c_uint32), ct.POINTER(ct.c_uint32)])} # Механическое описание типов исключает усечение указателей на 64-битной Windows. + for name, (result, arguments) in signatures.items(): function = getattr(self.library, name); function.restype = result; function.argtypes = arguments # Все вызовы получают явный ABI до первого обращения к контексту. + if self.library.diagnostic_abi_version() != 1: raise RuntimeError('Неподдерживаемая версия automotive ABI') # Несовместимая DLL не используется молча. + self.memory = ct.create_string_buffer(self.library.diagnostic_context_size()) # Память контекста принадлежит экземпляру порта и живёт до его уничтожения. + self.check(self.library.diagnostic_init(self.memory, len(self.memory))) # C проверяет размер, выравнивание и создаёт пассивный контекст. + @staticmethod # Обработка результатов не воспроизводит диагностический протокол. + def check(status): # Значения соответствуют общим diag_status_t публичного ABI. + if status != 0: raise RuntimeError(f'Диагностика: статус {status}') # Ошибка не подменяется физическим значением ноль. + def enable(self, enabled): self.library.diagnostic_enable(self.memory, bool(enabled)) # Само разрешение не создаёт кадров. + def scan(self, now): return self.library.diagnostic_scan(self.memory, now) # Поиск и PID-карты целиком обрабатываются C-ядром. + def request(self, service, parameter, target, now, confirmed=False): return self.library.diagnostic_request(self.memory, service, parameter, target, confirmed, now) # Подтверждение сброса передаётся только после отдельного действия UI. + def uds(self, target, service, parameter, now): return self.library.diagnostic_uds(self.memory, target, service, parameter, now) # Запрещённый SID будет отклонён внутри C независимо от UI. + def feed(self, identifier, data, extended, now): # Преобразует транспортные байты в указатель ABI, не разбирая PCI/SID/PID. + data = bytes(data); buffer = ct.create_string_buffer(data); self.library.diagnostic_feed(self.memory, identifier, buffer, len(data), extended, now) # C сам проверяет Classic CAN DLC до копирования payload. + def poll(self, now): self.library.diagnostic_poll(self.memory, now) # Монотонное время Qt передаётся непосредственно автоматам C. + @property # Планировщику UI нужен только признак занятости, а не внутренние состояния ISO-TP. + def busy(self): return bool(self.library.diagnostic_busy(self.memory)) # Сканирование диапазонов PID также считается занятым состоянием. + def supported(self, target, pid): return self.library.diagnostic_supported(self.memory, target, pid) # Неизвестная карта остаётся -1, а не превращается в разрешение опроса. + def catalog(self): # Создаёт только представление неизменяемого C-каталога. + return [(self.library.diagnostic_pid_code(i), self.library.diagnostic_pid_name(i).decode('utf-8'), self.library.diagnostic_pid_unit(i).decode('utf-8')) for i in range(self.library.diagnostic_pid_count())] # Формулы и список PID не копируются в Python. + def outputs(self): # Выдаёт готовые CAN-кадры до полного опустошения ограниченной C-очереди. + result = [] # Список содержит только транспортные поля, не новую диагностическую модель. + for _ in range(16): # Бюджет не даёт повреждённой DLL заблокировать GUI бесконечным перечислением. + identifier, length, extended = ct.c_uint32(), ct.c_uint32(), ct.c_uint32(); data = (ct.c_uint8 * 8)() # Каждый выходной буфер соответствует Classic CAN. + status = self.library.diagnostic_tx(self.memory, ct.byref(identifier), data, ct.byref(length), ct.byref(extended)) # Готовые wire-байты приходят из C. + if status == 1: break # DIAG_EMPTY завершает перечисление без ошибки. + self.check(status); result.append((identifier.value, bytes(data[:length.value]), bool(extended.value))) # Никакой дополнительный PCI или SID в Python не создаётся. + return result # Владелец адаптера обязан проверить результат фактического send. + def events(self): # Возвращает уже проверенные значения, VIN, DTC и диагностические ошибки. + result = [] # Очередь принадлежит C-контексту, а возвращаемые записи являются независимыми копиями. + for _ in range(128): # Ограничивает работу GUI при большой пачке событий. + entry = Event(); status = self.library.diagnostic_event(self.memory, ct.byref(entry)) # Размер записи закреплён версией ABI. + if status == 1: break # Пустая очередь не означает ошибку сеанса. + self.check(status); result.append(entry) # Физическое значение уже выражено в тысячных единицы C-каталога. + return result # Отображение не интерпретирует сырые ECU-ответы повторно. + def transport_error(self): self.library.diagnostic_error(self.memory, 6) # DIAG_IO отменяет сеанс после фактического разрыва адаптера.