feat(protocan): добавь JNI-разбор идентификатора

Добавлены реализации низкоуровневой шины для STM32G431/G474 и
STM32F407VET6 с шаблонами onewire_config.h под каждый камень.
Логика повторяет порт STM32F1: открытый сток, задержки по DWT,
запрет прерываний на один тайм-слот.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

.gitignore

@@ -22,3 +22,4 @@ __pycache__/
 *.uvguix.*
 Thumbs.db
 Desktop.ini
+.codex-build/

NEW_PROJECT.md

@@ -0,0 +1,100 @@
+# Новый проект на переносимых библиотеках
+
+Этот репозиторий содержит два разных типа кода:
+
+1. `c/<library>/include` и `c/<library>/src` — переносимое ядро;
+2. `c/<library>/ports/<family>` — небольшой аппаратный порт конкретного
+   семейства микроконтроллеров.
+
+Привязка выводов, частоты шин и выбранной периферии принадлежит плате и всегда
+остаётся в проекте в `app_config.h` либо в узком конфигурационном заголовке
+библиотеки, например `onewire_config.h`.
+
+## Рекомендуемая структура прошивки
+
+```text
+my-device/
+  app/                    логика изделия
+    include/
+    src/
+  board/                  одна конкретная плата
+    app_config.h          выводы, частоты, адреса, возможности платы
+  port/                   связь библиотек с SDK выбранного МК
+    display_port.c
+    keypad_port.c
+    eeprom_port.c
+    can_port.c
+  vendor/                 CMSIS, startup, linker script или Cube-generated код
+  lib/templates/          git submodule этого репозитория
+```
+
+Не следует помещать `stm32xxxx.h`, `HAL_*`, регистры, IRQ handlers и номера
+выводов в `app/` или в ядро библиотеки. Тогда при переходе на другой МК
+заменяются только `board/`, `port/`, startup и linker script.
+
+## Выбор готового порта DS18B20
+
+| Целевой МК | Файл порта | Шаблон конфигурации |
+|---|---|---|
+| STM32F103 | `c/ds18b20/ports/stm32f1/onewire_stm32f1.c` | `onewire_config.f103.template.h` |
+| STM32G431 | `c/ds18b20/ports/stm32g4/onewire_stm32g4.c` | `onewire_config.g431.template.h` |
+| STM32G474 | `c/ds18b20/ports/stm32g4/onewire_stm32g4.c` | `onewire_config.g474.template.h` |
+
+В сборку добавляются ровно три файла:
+
+```text
+c/ds18b20/src/onewire.c
+c/ds18b20/src/ds18b20.c
+c/ds18b20/ports/<family>/onewire_<family>.c
+```
+
+Пути включения:
+
+```text
+c/ds18b20/include
+board
+```
+
+Нужный шаблон копируется в `board/onewire_config.h`; после этого в нём
+меняются только порт, номер вывода и бит тактирования GPIO.
+
+G431 и G474 намеренно используют один исходник порта: GPIO, RCC и DWT для
+этой задачи совместимы. Раздельными остаются конфигурация платы, startup,
+linker script и выбранный CMSIS device define.
+
+Рабочий пример полноценного G474-порта находится в соседнем проекте
+`candleLight_fw`: `src/device/device_g4.c` отвечает за clock/GPIO,
+`src/can/m_can.c` — за FDCAN, а `include/config.h` — за привязку платы
+STM32G474VET6. Эти файлы остаются в прошивке, поскольку зависят от STM32 HAL,
+USB gs_usb и конкретной разводки адаптера; переносимая логика протоколов
+остаётся в `templates`.
+
+## Какие части KONOR уже общие
+
+| Возможность | Переносимое ядро | Что остаётся в `port/` проекта |
+|---|---|---|
+| DS18B20/1-Wire | `c/ds18b20` | готовый порт выбранного семейства и вывод |
+| дисплей ST7789 | `c/st7789` | SPI, DC, CS, RESET, подсветка и задержка |
+| кнопки | `c/keypad` | настройка GPIO и чтение уровней |
+| меню | `c/menu` | только привязка painter к дисплею |
+| EEPROM FT24C256 | `c/eeprom-ft24c256` | I2C write/write-read и задержка |
+| CAN SETTINGS | `c/can-sensor` | bxCAN для F103 либо FDCAN для G431/G474 |
+
+Порт дисплея, EEPROM и CAN нельзя честно сделать только по названию МК:
+нужно знать экземпляр периферии, альтернативную функцию и выводы конкретной
+платы. Поэтому библиотеки принимают таблицы обратных вызовов, а короткие
+адаптеры лежат в проекте рядом с `app_config.h`.
+
+## Порядок создания проекта
+
+1. Создать проект в CubeMX/Keil либо добавить CMSIS, startup и linker script.
+2. Подключить `templates` сабмодулем.
+3. Добавить только ядра нужных библиотек.
+4. Выбрать готовый 1-Wire порт по таблице выше.
+5. Создать `board/app_config.h` с выводами и частотами.
+6. Реализовать короткие адаптеры SPI/GPIO/I2C/CAN в `port/`.
+7. Сначала прогнать host-тесты библиотек, затем проверить аппаратные порты
+   логическим анализатором или осциллографом.
+
+Так новый проект не является копией старого: он использует общие ядра одной
+версии, а аппаратные отличия видны в одном небольшом каталоге `port/`.

README.md

@@ -15,6 +15,9 @@ templates/
   python/   модули на чистом Python 3.9+, только stdlib
 ```
 
+Пошаговая раскладка нового проекта и выбор портов для STM32F103, STM32G431
+и STM32G474 описаны в [`NEW_PROJECT.md`](NEW_PROJECT.md).
+
 ## Что лежит
 
 ### C
@@ -26,9 +29,13 @@ templates/
 | [`c/menu`](c/menu) | экранное меню: стек экранов, курсор, прокрутка, тема | `stdint.h` | заливка прямоугольника, вывод строки |
 | [`c/eeprom-ft24c256`](c/eeprom-ft24c256) | EEPROM 24Cxx по I²C с нарезкой записи по страницам | `stdint.h` | две I²C-транзакции, задержка |
 | [`c/can-sensor`](c/can-sensor) | передача 64-битных ROM датчиков парой CAN-кадров | `stdint.h` | отправка и приём CAN-кадра |
-| [`c/ds18b20`](c/ds18b20) | термометры DS18B20 поверх программной 1-Wire | `stdint.h` | Init, DelayUs, Reset, WriteBit, ReadBit — **порт STM32F1 в комплекте** |
-| [`c/protocan-transport`](c/protocan-transport) | транспорт ProtoCAN: кадр, канал, CRC, общее адресное пространство, каталог GUI | `stdint.h` | запись в поток и запрос свободного места — **порт STM32F4 в комплекте** |
+| [`c/ds18b20`](c/ds18b20) | термометры DS18B20 поверх программной 1-Wire | `stdint.h` | Init, DelayUs, Reset, WriteBit, ReadBit — **порты STM32F103, STM32G431 и STM32G474 в комплекте** |
+| [`c/protocan-transport`](c/protocan-transport) | транспорт ProtoCAN: кадр, канал, CRC, общее адресное пространство, каталог GUI и стабильный host ABI | `stdint.h` | запись в поток и запрос свободного места — **порты STM32F4, Windows/Linux/macOS FFI и Android JNI в комплекте** |
+| [`c/protocan-boot`](c/protocan-boot) | адресная прошивка по ProtoCAN: A/B-слоты, сессия, CRC32, verify и rollback-контракт | C99 | CAN TX, erase/write Flash, boot metadata, проверка образа и reboot |
+| [`c/rs485-boot`](c/rs485-boot) | прошивка по RS-485 в формате SETGUI v1: потоковый parser, CRC32 и resume | C99 | UART TX/RX, DE, Flash — **порты STM32F103 и STM32G474VET в комплекте** |
+| [`c/set-protocol`](c/set-protocol) | единый SET protocol v2: управление, real-time телеметрия и обновление прошивки через UART/CAN/USB/Ethernet | C99 | доставка целого stream/datagram-кадра, часы, backend карты и загрузчика |
 | [`c/rtc-service`](c/rtc-service) | RTC с резервированным backup-томом | `stdint.h` | доступ к RTC и backup-памяти — **порт K1921VK028 в комплекте** |
+| [`c/firmware-info`](c/firmware-info) | SemVer, build stamp и git build ID работающего образа | C99 | config-порты STM32F1/F4/G4 и К1921ВК028; упаковка для Modbus/SETGUI |
 
 ### Python
 
@@ -69,10 +76,12 @@ git subtree pull --prefix lib/templates https://git.rd12.ru/Andrey/templates.git
 
 | Проект | Что берёт |
 |---|---|
-| `KONOR_ds18b20` | st7789, keypad, menu, eeprom-ft24c256, can-sensor, ds18b20 |
+| `KONOR_ds18b20` | st7789, keypad, menu, eeprom-ft24c256, can-sensor, ds18b20, firmware-info |
 | `OpticalTester` | st7789, keypad, menu, eeprom-ft24c256 |
 | `CAN_to_RS485` | protocan-transport, python/protocan |
+| `candleLight_fw` | эталон разделения общей логики и G431/G474 FDCAN-порта; общий ProtoCAN Boot переносится по контракту `protocan-boot` |
 | `SETGUI` | python/protocan |
+| новые устройства SET и `SETGUI` v2 | set-protocol |
 | `k1921vk028` | rtc-service |
 
 ## Что сюда не попало и почему

c/can-sensor/README.md

@@ -1,27 +1,27 @@
 # can-sensor
 
-Передача 64-битных идентификаторов датчиков (ROM 1-Wire) по шине CAN.
+Однокадровый транспорт SETCAN SETTINGS для привязки 64-битного ROM 1-Wire к
+локации «номер сборки + позиция» по шине CAN.
 
 Ядро на C99: не включает заголовки периферии, не обращается к регистрам,
 не пользуется прерываниями. Обмен идёт через таблицу `CanSensor_Io`,
 которую заполняет порт платы.
 
-Сообщение состоит из двух классических CAN-кадров — 64-битный идентификатор
-и преамбула вместе не помещаются в восемь байтов поля данных:
+Сообщение помещается в один Extended CAN-кадр: локация находится в Body
+29-битного ID, а ROM — в восьми байтах payload:
 
 ```
-   кадр 1 — преамбула, DLC = 2    | команда | позиция |
-   кадр 2 — идентификатор, DLC = 8|      ROM 8 байт    |
+   запрос  0x17FEZZYY: DLC=0 — GET, DLC=8 — WRITE/REPLACE/CLEAR
+   ответ   0x1FFEZZYY: DLC=8 — текущий ROM, DLC=1 — код ошибки
 ```
 
 ## Состав
 
 | Файл | Что делает | Зависимости |
 |---|---|---|
-| `can_sensor.h`, `can_sensor.c` | сборка и разбор пары кадров, повторы передачи, счётчики обмена | `stdint.h` |
+| `can_sensor.h`, `can_sensor.c` | сборка и разбор SETTINGS, повторы передачи, счётчики обмена | `stdint.h` |
 
-Приём собирает сообщение сам: кадр ROM без преамбулы и кадр с неверной
-длиной отбрасываются и учитываются в `dropped_frames`.
+`ZZ` — номер сборки, `YY` — позиция. Нулевой ROM с DLC=8 очищает локацию.
 
 ## Что нужно от платформы
 
@@ -38,10 +38,10 @@ uint8_t receive(void *ctx, CanSensor_Frame *frame);        /* 1 — кадр п
 CanSensor link;
 CanSensor_Io io = { .send = bxcan_send, .receive = bxcan_receive, .context = &board };
 CanSensor_Config config;
-CanSensor_ConfigDefault(&config);      /* tx_id 0x200, кадр ROM 0x201, 3 попытки */
+CanSensor_ConfigDefault(&config);      /* TX 0x1FFE0000, RX 0x17FE0000 */
 
 CanSensor_Init(&link, &io, &config);
-CanSensor_SendId(&link, position, rom);
+CanSensor_SendId(&link, position, assembly_serial, rom);
 
 CanSensor_Message message;
 if (CanSensor_Poll(&link, &message)) { /* принят идентификатор */ }

c/can-sensor/can_sensor.c

@@ -1,72 +1,35 @@
 /**
  * @file can_sensor.c
- * @brief Сборка, передача и разбор сообщений «преамбула + идентификатор».
- *
- * Реализация не хранит очередей и не пользуется временем: состояние приёма
- * ограничено признаком принятой преамбулы, поэтому библиотека одинаково
- * работает и в главном цикле, и в обработчике прерывания порта.
+ * @brief Однокадровый транспорт SETCAN SETTINGS для локаций DS18B20.
  */
 
 #include "can_sensor.h"
 
-/**
- * @brief Возвращает идентификатор кадра данных для заданных настроек.
- *
- * @param config Настройки узла.
- * @return Идентификатор кадра ROM при передаче.
- */
-static uint32_t can_sensor_tx_data_id(const CanSensor_Config *config)
+/** Возвращает 1, если все восемь байтов ROM равны нулю. */
+static uint8_t can_sensor_rom_is_zero(const uint8_t *rom)
 {
-    if (config->tx_data_id != 0U) {
-        return config->tx_data_id;
+    uint8_t index;
+
+    for (index = 0U; index < CAN_SENSOR_ID_SIZE; index++) {
+        if (rom[index] != 0U) {
+            return 0U;
+        }
     }
-    return config->tx_id + CAN_SENSOR_DATA_ID_OFFSET;
+    return 1U;
 }
 
-/**
- * @brief Возвращает ожидаемый идентификатор преамбулы при приёме.
- *
- * @param config Настройки узла.
- * @return Идентификатор кадра преамбулы.
- */
-static uint32_t can_sensor_rx_id(const CanSensor_Config *config)
-{
-    if (config->rx_id != 0U) {
-        return config->rx_id;
-    }
-    return config->tx_id;
-}
-
-/**
- * @brief Возвращает ожидаемый идентификатор кадра ROM при приёме.
- *
- * @param config Настройки узла.
- * @return Идентификатор кадра идентификатора датчика.
- */
-static uint32_t can_sensor_rx_data_id(const CanSensor_Config *config)
-{
-    if (config->rx_data_id != 0U) {
-        return config->rx_data_id;
-    }
-    return can_sensor_rx_id(config) + CAN_SENSOR_DATA_ID_OFFSET;
-}
-
-/**
- * @brief Передаёт один кадр с повторами при отказе контроллера.
- *
- * @param link Состояние узла.
- * @param frame Передаваемый кадр.
- * @return 1, если кадр принят контроллером, иначе 0.
- */
+/** Передаёт уже собранный кадр с ограниченным числом повторов. */
 static uint8_t can_sensor_send_frame(CanSensor *link, const CanSensor_Frame *frame)
 {
     uint8_t attempt;
 
     for (attempt = 0U; attempt < link->config.retries; attempt++) {
         if (link->io.send(link->io.context, frame) != 0U) {
+            link->sent_messages++;
             return 1U;
         }
     }
+    link->send_errors++;
     return 0U;
 }
 
@@ -76,22 +39,17 @@ void CanSensor_ConfigDefault(CanSensor_Config *config)
         return;
     }
     config->tx_id = CAN_SENSOR_DEFAULT_TX_ID;
-    config->tx_data_id = CAN_SENSOR_DEFAULT_TX_ID + CAN_SENSOR_DATA_ID_OFFSET;
-    config->rx_id = CAN_SENSOR_DEFAULT_TX_ID;
-    config->rx_data_id = CAN_SENSOR_DEFAULT_TX_ID + CAN_SENSOR_DATA_ID_OFFSET;
-    config->extended = 0U;
+    config->rx_id = CAN_SENSOR_DEFAULT_RX_ID;
+    config->extended = 1U;
     config->retries = CAN_SENSOR_DEFAULT_RETRIES;
 }
 
 uint8_t CanSensor_Init(CanSensor *link, const CanSensor_Io *io,
                        const CanSensor_Config *config)
 {
-    uint8_t index;
-
     if ((link == 0) || (io == 0) || (io->send == 0)) {
         return 0U;
     }
-
     link->io = *io;
     if (config != 0) {
         link->config = *config;
@@ -101,16 +59,15 @@ uint8_t CanSensor_Init(CanSensor *link, const CanSensor_Io *io,
     if (link->config.tx_id == 0U) {
         link->config.tx_id = CAN_SENSOR_DEFAULT_TX_ID;
     }
+    if (link->config.rx_id == 0U) {
+        link->config.rx_id = CAN_SENSOR_DEFAULT_RX_ID;
+    }
+    link->config.tx_id &= CAN_SENSOR_HEADER_MASK;
+    link->config.rx_id &= CAN_SENSOR_HEADER_MASK;
+    link->config.extended = 1U;
     if (link->config.retries == 0U) {
         link->config.retries = CAN_SENSOR_DEFAULT_RETRIES;
     }
-
-    link->rx.command = 0U;
-    link->rx.position = 0U;
-    for (index = 0U; index < CAN_SENSOR_ID_SIZE; index++) {
-        link->rx.id[index] = 0U;
-    }
-    link->rx_preamble = 0U;
     link->sent_messages = 0U;
     link->send_errors = 0U;
     link->received_messages = 0U;
@@ -118,114 +75,114 @@ uint8_t CanSensor_Init(CanSensor *link, const CanSensor_Io *io,
     return 1U;
 }
 
-uint8_t CanSensor_BuildPreamble(const CanSensor_Config *config, CanSensor_Frame *frame,
-                                uint8_t command, uint16_t position)
+uint8_t CanSensor_BuildFrame(const CanSensor_Config *config, CanSensor_Frame *frame,
+                             uint8_t response, uint8_t position,
+                             uint8_t assembly_serial, const uint8_t *data,
+                             uint8_t length)
 {
     uint8_t index;
+    uint32_t base;
 
-    if ((config == 0) || (frame == 0)) {
+    if ((config == 0) || (frame == 0) || (length > CAN_SENSOR_MAX_DATA)
+        || ((length != 0U) && (data == 0))) {
         return 0U;
     }
-    frame->id = config->tx_id;
-    frame->extended = config->extended;
-    frame->length = CAN_SENSOR_PREAMBLE_SIZE;
-    frame->data[0] = command;
-    /* Позиция занимает два байта в порядке от старшего к младшему. */
-    frame->data[1] = (uint8_t)((position >> 8U) & 0xFFU);
-    frame->data[2] = (uint8_t)(position & 0xFFU);
-    for (index = CAN_SENSOR_PREAMBLE_SIZE; index < CAN_SENSOR_MAX_DATA; index++) {
-        frame->data[index] = 0U;
+    base = (response != 0U) ? config->tx_id : config->rx_id;
+    frame->id = (base & CAN_SENSOR_HEADER_MASK)
+                | ((uint32_t)assembly_serial << 8U) | (uint32_t)position;
+    frame->extended = 1U;
+    frame->length = length;
+    for (index = 0U; index < CAN_SENSOR_MAX_DATA; index++) {
+        frame->data[index] = (index < length) ? data[index] : 0U;
     }
     return 1U;
 }
 
-uint8_t CanSensor_BuildIdFrame(const CanSensor_Config *config, CanSensor_Frame *frame,
-                               const uint8_t *id)
-{
-    uint8_t index;
-
-    if ((config == 0) || (frame == 0)) {
-        return 0U;
-    }
-    frame->id = can_sensor_tx_data_id(config);
-    frame->extended = config->extended;
-    frame->length = CAN_SENSOR_ID_SIZE;
-    for (index = 0U; index < CAN_SENSOR_ID_SIZE; index++) {
-        frame->data[index] = (id != 0) ? id[index] : 0U;
-    }
-    return 1U;
-}
-
-uint8_t CanSensor_Send(CanSensor *link, uint8_t command, uint16_t position,
-                       const uint8_t *id)
+uint8_t CanSensor_SendId(CanSensor *link, uint8_t position,
+                         uint8_t assembly_serial, const uint8_t *id)
 {
     CanSensor_Frame frame;
 
-    if ((link == 0) || (link->io.send == 0)) {
+    if ((link == 0) || (id == 0) || (link->io.send == 0)) {
         return 0U;
     }
-    (void)CanSensor_BuildPreamble(&link->config, &frame, command, position);
-    if (can_sensor_send_frame(link, &frame) == 0U) {
+    if (CanSensor_BuildFrame(&link->config, &frame, 1U, position,
+                             assembly_serial, id, CAN_SENSOR_ID_SIZE) == 0U) {
         link->send_errors++;
         return 0U;
     }
-    (void)CanSensor_BuildIdFrame(&link->config, &frame, id);
-    if (can_sensor_send_frame(link, &frame) == 0U) {
-        /* Одиночная преамбула приёмником отбрасывается, позиция не изменится. */
-        link->send_errors++;
-        return 0U;
-    }
-    link->sent_messages++;
-    return 1U;
+    return can_sensor_send_frame(link, &frame);
 }
 
-uint8_t CanSensor_SendId(CanSensor *link, uint16_t position, const uint8_t *id)
+uint8_t CanSensor_SendError(CanSensor *link, uint8_t position,
+                            uint8_t assembly_serial, uint8_t result)
 {
-    if (id == 0) {
+    CanSensor_Frame frame;
+
+    if ((link == 0) || (link->io.send == 0) || (result == CAN_SENSOR_RESULT_OK)) {
         return 0U;
     }
-    return CanSensor_Send(link, CAN_SENSOR_CMD_WRITE_POSITION, position, id);
+    if (CanSensor_BuildFrame(&link->config, &frame, 1U, position,
+                             assembly_serial, &result, 1U) == 0U) {
+        link->send_errors++;
+        return 0U;
+    }
+    return can_sensor_send_frame(link, &frame);
 }
 
 uint8_t CanSensor_HandleFrame(CanSensor *link, const CanSensor_Frame *frame,
                               CanSensor_Message *out)
 {
+    CanSensor_Message message;
+    uint32_t header;
     uint8_t index;
 
     if ((link == 0) || (frame == 0)) {
         return 0U;
     }
+    if (frame->extended == 0U) {
+        return 0U;
+    }
+    header = frame->id & CAN_SENSOR_HEADER_MASK;
+    if (header == (link->config.rx_id & CAN_SENSOR_HEADER_MASK)) {
+        message.request = 1U;
+    } else if (header == (link->config.tx_id & CAN_SENSOR_HEADER_MASK)) {
+        message.request = 0U;
+    } else {
+        return 0U;
+    }
 
-    if ((frame->id == can_sensor_rx_id(&link->config))
-        && (frame->extended == link->config.extended)) {
-        if (frame->length < CAN_SENSOR_PREAMBLE_SIZE) {
-            link->dropped_frames++;
-            return 0U;
+    message.assembly_serial = (uint8_t)((frame->id >> 8U) & 0xFFU);
+    message.position = (uint8_t)(frame->id & 0xFFU);
+    message.result = CAN_SENSOR_RESULT_OK;
+    for (index = 0U; index < CAN_SENSOR_ID_SIZE; index++) {
+        message.id[index] = (index < frame->length) ? frame->data[index] : 0U;
+    }
+
+    if (message.request != 0U) {
+        if (frame->length == 0U) {
+            message.operation = CAN_SENSOR_OPERATION_GET;
+        } else if (frame->length == CAN_SENSOR_ID_SIZE) {
+            message.operation = (can_sensor_rom_is_zero(message.id) != 0U)
+                                    ? CAN_SENSOR_OPERATION_CLEAR
+                                    : CAN_SENSOR_OPERATION_WRITE;
+        } else {
+            message.operation = CAN_SENSOR_OPERATION_INVALID;
+            message.result = CAN_SENSOR_RESULT_INVALID_DLC;
         }
-        link->rx.command = frame->data[0];
-        link->rx.position = (uint16_t)(((uint16_t)frame->data[1] << 8U)
-                                       | frame->data[2]);
-        link->rx_preamble = 1U;
-        return 0U;
-    }
-
-    if ((frame->id != can_sensor_rx_data_id(&link->config))
-        || (frame->extended != link->config.extended)) {
-        return 0U;
-    }
-    if ((link->rx_preamble == 0U) || (frame->length < CAN_SENSOR_ID_SIZE)) {
-        /* Идентификатор без преамбулы не говорит, в какую позицию его писать. */
-        link->rx_preamble = 0U;
+    } else if (frame->length == CAN_SENSOR_ID_SIZE) {
+        message.operation = CAN_SENSOR_OPERATION_RESPONSE;
+    } else if (frame->length == 1U) {
+        message.operation = CAN_SENSOR_OPERATION_ERROR;
+        message.result = frame->data[0];
+    } else {
         link->dropped_frames++;
         return 0U;
     }
-    for (index = 0U; index < CAN_SENSOR_ID_SIZE; index++) {
-        link->rx.id[index] = frame->data[index];
-    }
-    link->rx_preamble = 0U;
+
     link->received_messages++;
     if (out != 0) {
-        *out = link->rx;
+        *out = message;
     }
     return 1U;
 }

c/can-sensor/can_sensor.h

@@ -1,30 +1,19 @@
 /**
  * @file can_sensor.h
- * @brief Портируемая передача идентификаторов датчиков по шине CAN.
+ * @brief Портируемый транспорт SETTINGS для привязки DS18B20 к локации.
  *
- * Библиотека не привязана к микроконтроллеру: она не включает заголовки
- * периферии, не обращается к регистрам и не пользуется прерываниями. Обмен
- * идёт через таблицу обратных вызовов CanSensor_Io, которую заполняет порт
- * платы (для этой сборки — @c src/can.c поверх bxCAN STM32F103C8T6).
- *
- * Сообщение состоит из двух кадров классического CAN, потому что 64-битный
- * идентификатор датчика и преамбула вместе не помещаются в восемь байтов
- * поля данных:
+ * Один Extended CAN-кадр содержит полную операцию. Поля локации находятся в
+ * Body идентификатора SETCAN, а восьмибайтовый ROM — в payload:
  *
  * @code
- *   кадр 1 — преамбула, DLC = 2   +---------+----------+
- *                                 | команда | позиция  |
- *                                 +---------+----------+
- *   кадр 2 — идентификатор, DLC=8 +----------------------------+
- *                                 | ROM датчика, байты 0..7     |
- *                                 +----------------------------+
+ *   Priority=1, DeviceType=0x7, DeviceID=0xF, MsgType=0xE (SETTINGS)
+ *   Body[15:8] = номер сборки, Body[7:0] = позиция
  * @endcode
  *
- * Преамбула несёт команду записи датчика в позицию: первый байт — код
- * команды (@ref CAN_SENSOR_CMD_WRITE_POSITION), второй — номер позиции в
- * таблице узла-приёмника. Кадр идентификатора передаётся сразу за преамбулой
- * и без неё считается недействительным, поэтому приёмник не запишет ROM в
- * позицию, которая ему не была назначена.
+ * Запрос ПМ использует Route=0 (0x17FEZZYY), ответ прибора — Route=1
+ * (0x1FFEZZYY). DLC=0 означает GET, DLC=8 с ненулевым ROM — SET/REPLACE,
+ * DLC=8 с нулевым ROM — CLEAR. Успешный ответ возвращает текущий ROM с DLC=8,
+ * ошибка — однобайтовый код с DLC=1.
  */
 
 #ifndef CAN_SENSOR_H
@@ -32,186 +21,107 @@
 
 #include <stdint.h>
 
-/** Длина идентификатора датчика (ROM 1-Wire) в байтах. */
-#define CAN_SENSOR_ID_SIZE        8U
+/** Длина ROM 1-Wire и максимального payload classic CAN. */
+#define CAN_SENSOR_ID_SIZE          8U
+#define CAN_SENSOR_MAX_DATA         8U
 
-/** Длина преамбулы: код команды (1 байт) и номер позиции (2 байта, u16 BE). */
-#define CAN_SENSOR_PREAMBLE_SIZE  3U
+/** Назначенный проекту тип сообщения SETCAN SETTINGS. */
+#define CAN_SENSOR_MSGTYPE_SETTINGS 0xEU
 
-/** Предельная длина поля данных классического кадра CAN. */
-#define CAN_SENSOR_MAX_DATA       8U
+/** Маска полей SETCAN от Priority до MsgType; Body под маской не находится. */
+#define CAN_SENSOR_HEADER_MASK      0x1FFF0000UL
+#define CAN_SENSOR_BODY_MASK        0x0000FFFFUL
 
-/** Код команды «записать идентификатор датчика в позицию». */
-#define CAN_SENSOR_CMD_WRITE_POSITION 0xA1U
+/** Базовые ID SETTINGS для выбранных DeviceType=0x7 и DeviceID=0xF. */
+#define CAN_SENSOR_DEFAULT_TX_ID    0x1FFE0000UL
+#define CAN_SENSOR_DEFAULT_RX_ID    0x17FE0000UL
 
-/** Код команды «очистить позицию»; кадр идентификатора передаётся нулевым. */
-#define CAN_SENSOR_CMD_CLEAR_POSITION 0xA2U
+/** Число попыток помещения кадра в почтовый ящик. */
+#define CAN_SENSOR_DEFAULT_RETRIES  3U
 
-/** Смещение идентификатора кадра данных относительно кадра преамбулы. */
-#define CAN_SENSOR_DATA_ID_OFFSET 1U
+/** Операции, полученные из направления, DLC и payload кадра. */
+#define CAN_SENSOR_OPERATION_GET       0U
+#define CAN_SENSOR_OPERATION_WRITE     1U
+#define CAN_SENSOR_OPERATION_CLEAR     2U
+#define CAN_SENSOR_OPERATION_RESPONSE  3U
+#define CAN_SENSOR_OPERATION_ERROR     4U
+#define CAN_SENSOR_OPERATION_INVALID   5U
 
-/** Число попыток передачи одного кадра по умолчанию. */
-#define CAN_SENSOR_DEFAULT_RETRIES 3U
+/** Коды результата SETTINGS, передаваемые ответом с DLC=1. */
+#define CAN_SENSOR_RESULT_OK                0x00U
+#define CAN_SENSOR_RESULT_INVALID_DLC       0x01U
+#define CAN_SENSOR_RESULT_INVALID_ROM_CRC   0x02U
+#define CAN_SENSOR_RESULT_NOT_FOUND         0x03U
+#define CAN_SENSOR_RESULT_ALREADY_ASSIGNED  0x04U
+#define CAN_SENSOR_RESULT_EEPROM_ERROR       0x05U
+#define CAN_SENSOR_RESULT_INVALID_LOCATION  0x06U
+#define CAN_SENSOR_RESULT_BUSY               0x07U
 
-/** Идентификатор кадра преамбулы по умолчанию (стандартный, 11 бит). */
-#define CAN_SENSOR_DEFAULT_TX_ID  0x200U
-
-/**
- * @brief Кадр шины CAN в форме, не зависящей от контроллера.
- */
+/** Кадр CAN в форме, не зависящей от периферийного контроллера. */
 typedef struct {
-    uint32_t id;                       /**< Идентификатор кадра, 11 или 29 бит. */
-    uint8_t extended;                  /**< 1 — расширенный идентификатор. */
-    uint8_t length;                    /**< Число значащих байтов поля данных. */
-    uint8_t data[CAN_SENSOR_MAX_DATA]; /**< Поле данных кадра. */
+    uint32_t id;                       /**< Расширенный идентификатор, 29 бит. */
+    uint8_t extended;                  /**< Для SETTINGS всегда 1. */
+    uint8_t length;                    /**< DLC, 0..8. */
+    uint8_t data[CAN_SENSOR_MAX_DATA]; /**< Payload. */
 } CanSensor_Frame;
 
-/**
- * @brief Принятое или собранное сообщение: преамбула и идентификатор датчика.
- */
+/** Разобранная команда или ответ SETTINGS. */
 typedef struct {
-    uint8_t command;                 /**< Код команды из преамбулы. */
-    uint16_t position;               /**< Позиция записи из преамбулы. */
-    uint8_t id[CAN_SENSOR_ID_SIZE];  /**< Идентификатор датчика. */
+    uint8_t operation;               /**< CAN_SENSOR_OPERATION_*. */
+    uint8_t request;                 /**< 1 — запрос Route=0, 0 — ответ Route=1. */
+    uint8_t assembly_serial;         /**< Body[15:8], номер сборки Z. */
+    uint8_t position;                /**< Body[7:0], позиция Y. */
+    uint8_t result;                  /**< Код ошибки для ERROR/INVALID. */
+    uint8_t id[CAN_SENSOR_ID_SIZE];  /**< ROM для WRITE/RESPONSE, нули для CLEAR. */
 } CanSensor_Message;
 
-/**
- * @brief Доступ библиотеки к контроллеру CAN.
- *
- * Обязателен только @c send; при нулевом @c receive функция CanSensor_Poll()
- * ничего не делает и узел работает только на передачу.
- */
+/** Доступ переносимой части к CAN-контроллеру. */
 typedef struct {
-    /** Ставит кадр в очередь передачи; 1 — кадр принят контроллером. */
     uint8_t (*send)(void *context, const CanSensor_Frame *frame);
-    /** Забирает принятый кадр; 1 — кадр получен, 0 — очередь пуста. */
     uint8_t (*receive)(void *context, CanSensor_Frame *frame);
-    void *context; /**< Контекст порта, передаётся вызовам без изменений. */
+    void *context;
 } CanSensor_Io;
 
-/**
- * @brief Идентификаторы кадров и режим передачи.
- *
- * Нулевые поля заменяются значениями по умолчанию вызовом
- * CanSensor_ConfigDefault() или самой CanSensor_Init().
- */
+/** Базовые идентификаторы SETTINGS и режим транспорта. */
 typedef struct {
-    uint32_t tx_id;      /**< Идентификатор кадра преамбулы при передаче. */
-    uint32_t tx_data_id; /**< Идентификатор кадра ROM; 0 — @c tx_id + 1. */
-    uint32_t rx_id;      /**< Ожидаемая преамбула при приёме; 0 — @c tx_id. */
-    uint32_t rx_data_id; /**< Ожидаемый кадр ROM; 0 — @c rx_id + 1. */
-    uint8_t extended;    /**< 1 — расширенные идентификаторы 29 бит. */
-    uint8_t retries;     /**< Попыток передачи кадра; 0 — значение по умолчанию. */
+    uint32_t tx_id;   /**< База ответа 0x1FFE0000, Body должен быть нулевым. */
+    uint32_t rx_id;   /**< База запроса 0x17FE0000, Body должен быть нулевым. */
+    uint8_t extended; /**< 1 — Extended CAN ID. */
+    uint8_t retries;  /**< Число попыток передачи. */
 } CanSensor_Config;
 
-/**
- * @brief Состояние узла: настройки, счётчики и сборка принимаемого сообщения.
- */
+/** Состояние транспорта и диагностические счётчики. */
 typedef struct {
-    CanSensor_Io io;             /**< Обратные вызовы порта. */
-    CanSensor_Config config;     /**< Идентификаторы кадров и режим передачи. */
-    CanSensor_Message rx;        /**< Собираемое сообщение приёма. */
-    uint8_t rx_preamble;         /**< 1 — преамбула принята, ожидается кадр ROM. */
-    uint32_t sent_messages;      /**< Полностью переданные сообщения. */
-    uint32_t send_errors;        /**< Сообщения, не ушедшие в шину. */
-    uint32_t received_messages;  /**< Полностью принятые сообщения. */
-    uint32_t dropped_frames;     /**< Кадры без преамбулы или с неверной длиной. */
+    CanSensor_Io io;
+    CanSensor_Config config;
+    uint32_t sent_messages;
+    uint32_t send_errors;
+    uint32_t received_messages;
+    uint32_t dropped_frames;
 } CanSensor;
 
-/**
- * @brief Заполняет настройки значениями по умолчанию.
- *
- * Идентификатор преамбулы — @ref CAN_SENSOR_DEFAULT_TX_ID, кадр ROM идёт
- * следующим идентификатором, приём настроен на те же значения.
- *
- * @param config Настройки, принадлежащие вызывающему коду.
- */
 void CanSensor_ConfigDefault(CanSensor_Config *config);
 
-/**
- * @brief Готовит узел к работе.
- *
- * @param link Состояние узла, принадлежащее вызывающему коду.
- * @param io Обратные вызовы порта; копируются внутрь состояния.
- * @param config Настройки либо 0 для значений по умолчанию.
- * @return 1 при успешной настройке, 0 при неполных аргументах.
- */
 uint8_t CanSensor_Init(CanSensor *link, const CanSensor_Io *io,
                        const CanSensor_Config *config);
 
-/**
- * @brief Собирает кадр преамбулы.
- *
- * @param config Настройки узла.
- * @param frame Кадр приёмника.
- * @param command Код команды, например @ref CAN_SENSOR_CMD_WRITE_POSITION.
- * @param position Номер позиции записи датчика.
- * @return 1 при успешной сборке, иначе 0.
- */
-uint8_t CanSensor_BuildPreamble(const CanSensor_Config *config, CanSensor_Frame *frame,
-                                uint8_t command, uint16_t position);
+/** Собирает SETTINGS-кадр на базе tx_id или rx_id. */
+uint8_t CanSensor_BuildFrame(const CanSensor_Config *config, CanSensor_Frame *frame,
+                             uint8_t response, uint8_t position,
+                             uint8_t assembly_serial, const uint8_t *data,
+                             uint8_t length);
 
-/**
- * @brief Собирает кадр идентификатора датчика.
- *
- * @param config Настройки узла.
- * @param frame Кадр приёмника.
- * @param id Идентификатор датчика длиной @ref CAN_SENSOR_ID_SIZE либо 0 для
- *           нулевого кадра команды очистки.
- * @return 1 при успешной сборке, иначе 0.
- */
-uint8_t CanSensor_BuildIdFrame(const CanSensor_Config *config, CanSensor_Frame *frame,
-                               const uint8_t *id);
+/** Передаёт успешный ответ с текущим ROM (DLC=8). */
+uint8_t CanSensor_SendId(CanSensor *link, uint8_t position,
+                         uint8_t assembly_serial, const uint8_t *id);
 
-/**
- * @brief Передаёт преамбулу и идентификатор датчика.
- *
- * Кадры уходят подряд; при отказе контроллера передача повторяется
- * @c retries раз. Если преамбула ушла, а кадр ROM — нет, сообщение считается
- * несостоявшимся: приёмник отбросит одиночную преамбулу.
- *
- * @param link Состояние узла.
- * @param command Код команды преамбулы.
- * @param position Номер позиции записи датчика.
- * @param id Идентификатор датчика либо 0 для команды очистки позиции.
- * @return 1, если оба кадра приняты контроллером, иначе 0.
- */
-uint8_t CanSensor_Send(CanSensor *link, uint8_t command, uint16_t position,
-                       const uint8_t *id);
+/** Передаёт ошибку SETTINGS (DLC=1). */
+uint8_t CanSensor_SendError(CanSensor *link, uint8_t position,
+                            uint8_t assembly_serial, uint8_t result);
 
-/**
- * @brief Передаёт команду записи датчика в позицию.
- *
- * Краткая форма CanSensor_Send() с кодом @ref CAN_SENSOR_CMD_WRITE_POSITION.
- *
- * @param link Состояние узла.
- * @param position Номер позиции записи датчика.
- * @param id Идентификатор датчика длиной @ref CAN_SENSOR_ID_SIZE.
- * @return 1, если оба кадра приняты контроллером, иначе 0.
- */
-uint8_t CanSensor_SendId(CanSensor *link, uint16_t position, const uint8_t *id);
-
-/**
- * @brief Разбирает принятый кадр и собирает из пары кадров сообщение.
- *
- * Кадр идентификатора без предшествующей преамбулы отбрасывается, а новая
- * преамбула заменяет незавершённую: сборка не требует таймера.
- *
- * @param link Состояние узла.
- * @param frame Принятый кадр.
- * @param out Приёмник готового сообщения либо 0.
- * @return 1, если сообщение собрано полностью, иначе 0.
- */
 uint8_t CanSensor_HandleFrame(CanSensor *link, const CanSensor_Frame *frame,
                               CanSensor_Message *out);
 
-/**
- * @brief Забирает кадры у порта и возвращает первое собранное сообщение.
- *
- * @param link Состояние узла.
- * @param out Приёмник сообщения либо 0.
- * @return 1, если сообщение собрано, иначе 0.
- */
 uint8_t CanSensor_Poll(CanSensor *link, CanSensor_Message *out);
 
 #endif /* CAN_SENSOR_H */

c/ds18b20/README.md

@@ -23,7 +23,9 @@
 |---|---|---|
 | `include/ds18b20.h`, `src/ds18b20.c` | перечень датчиков, измерения, запись TH/TL/разрешения | `onewire.h`, `stdint.h` |
 | `include/onewire.h`, `src/onewire.c` | байты и блоки, CRC8 Dallas/Maxim, обход SEARCH ROM | `stdint.h` |
-| `ports/stm32f1/` | тайминги Maxim, вывод с открытым стоком, задержки по DWT | CMSIS `stm32f10x.h` |
+| `ports/stm32f1/` | STM32F103: тайминги Maxim, открытый сток, задержки по DWT | CMSIS `stm32f10x.h` |
+| `ports/stm32g4/` | то же для STM32G431 и STM32G474 | CMSIS `stm32g4xx.h` |
+| `ports/stm32f4/` | то же для STM32F407VET6 и родственных F4 | CMSIS `stm32f4xx.h` |
 | `tests/` | симулятор шины с виртуальными датчиками и host-тесты | — |
 
 ## Порт: что нужно от платформы
@@ -48,7 +50,7 @@ uint8_t OneWire_ReadBit(void);
 микросекундных задержек — счётчик тактов ядра `DWT->CYCCNT`.
 
 Привязку вывода порт берёт из `onewire_config.h`, который предоставляет
-приложение — шаблон лежит рядом:
+приложение — шаблон `onewire_config.f103.template.h` лежит рядом:
 
 ```c
 #include "stm32f10x.h"
@@ -60,6 +62,33 @@ uint8_t OneWire_ReadBit(void);
 
 Требуется внешняя подтяжка 4.7 кОм к питанию.
 
+### Готовые порты STM32G4 и STM32F4
+
+Логика та же, что и в порте STM32F1: открытый сток, чтение через `IDR`,
+задержки по `DWT->CYCCNT`, запрет прерываний только на один тайм-слот.
+Отличается лишь настройка вывода — у G4 и F4 это `MODER`/`OTYPER`/
+`OSPEEDR`/`PUPDR` вместо `CRL`/`CRH`, а низкий уровень выставляется
+через верхнюю половину `BSRR`.
+
+STM32G431 и STM32G474 обслуживает один порт `ports/stm32g4/`: блок GPIO и
+шина тактирования у них совпадают, различается только CMSIS-заголовок в
+`onewire_config.h`. Шаблоны лежат рядом — по одному на каждый камень:
+
+```c
+/* ports/stm32g4/onewire_config.g474.template.h */
+#include "stm32g4xx.h"
+
+#define ONEWIRE_GPIO        GPIOA
+#define ONEWIRE_PIN         1U
+#define ONEWIRE_GPIO_CLOCK  RCC_AHB2ENR_GPIOAEN   /* у F4 — RCC_AHB1ENR_GPIOAEN */
+```
+
+Порт `ports/stm32f4/` написан под STM32F407VET6 и подходит любому F4 с тем
+же блоком GPIO; тактирование включается в `RCC->AHB1ENR`.
+
+Подтяжка 4.7 кОм — внешняя и здесь: внутренняя `PUPDR` намеренно
+оставлена выключенной, её сопротивления для шины не хватает.
+
 ## Использование
 
 ```c

c/ds18b20/include/onewire.h

@@ -13,7 +13,7 @@
  *                   и OneWire_ReadBit.
  *
  * Чтобы перенести библиотеку на другой микроконтроллер, достаточно написать
- * эти пять функций - остальное собирается как есть.
+ * эти пять функций - остальное собирается как есть. ТЕСТ
  */
 
 #ifndef ONEWIRE_H

c/ds18b20/ports/stm32f1/onewire_config.f103.template.h

@@ -1,6 +1,6 @@
 /**
- * @file onewire_config.template.h
- * @brief Шаблон привязки шины 1-Wire для порта STM32F1.
+ * @file onewire_config.f103.template.h
+ * @brief Шаблон привязки шины 1-Wire для STM32F103 (порт stm32f1).
  *
  * Скопируйте в своё приложение под именем onewire_config.h и положите на
  * путь поиска заголовков. Библиотека сама этот файл не подставляет:

c/ds18b20/ports/stm32f1/onewire_stm32f1.c

@@ -8,7 +8,8 @@
  * терять байты USART во время обмена.
  *
  * Привязка вывода приходит из onewire_config.h, который предоставляет
- * приложение. Шаблон - onewire_config.template.h рядом с этим файлом.
+ * приложение. Шаблон для STM32F103 —
+ * onewire_config.f103.template.h рядом с этим файлом.
  */
 
 #include "onewire.h"

c/ds18b20/ports/stm32f4/onewire_config.f407.template.h

@@ -0,0 +1,26 @@
+/**
+ * @file onewire_config.f407.template.h
+ * @brief Шаблон привязки шины 1-Wire для STM32F407VET6 (порт stm32f4).
+ *
+ * Скопируйте в своё приложение под именем onewire_config.h и положите на
+ * путь поиска заголовков. Библиотека сама этот файл не подставляет:
+ * привязка выводов принадлежит плате, а не драйверу.
+ *
+ * Требуется внешняя подтяжка 4.7 кОм к питанию.
+ */
+
+#ifndef ONEWIRE_CONFIG_H
+#define ONEWIRE_CONFIG_H
+
+#include "stm32f4xx.h"
+
+/** Порт вывода шины. */
+#define ONEWIRE_GPIO        GPIOA
+
+/** Номер вывода в порту, 0..15. */
+#define ONEWIRE_PIN         1U
+
+/** Бит включения тактирования порта в RCC->AHB1ENR. */
+#define ONEWIRE_GPIO_CLOCK  RCC_AHB1ENR_GPIOAEN
+
+#endif /* ONEWIRE_CONFIG_H */

c/ds18b20/ports/stm32f4/onewire_stm32f4.c

@@ -0,0 +1,170 @@
+/**
+ * @file onewire_stm32f4.c
+ * @brief Порт шины 1-Wire на STM32F4: тайминги, вывод и задержки.
+ *
+ * Написан под STM32F407VET6 и подходит любому STM32F4 с тем же блоком GPIO:
+ * различается только CMSIS-заголовок, который подставляет onewire_config.h.
+ *
+ * Вывод постоянно настроен как выход с открытым стоком: чтение уровня
+ * выполняется через регистр IDR, поэтому переключать режим не требуется.
+ * Прерывания запрещаются только на длительность одного тайм-слота, чтобы не
+ * терять байты USART во время обмена.
+ *
+ * Привязка вывода приходит из onewire_config.h, который предоставляет
+ * приложение. Шаблон — onewire_config.f407.template.h рядом с этим файлом.
+ */
+
+#include "onewire.h"
+
+#include "onewire_config.h"
+
+#if !defined(ONEWIRE_GPIO) || !defined(ONEWIRE_PIN) || !defined(ONEWIRE_GPIO_CLOCK)
+#error "onewire_config.h должен задать ONEWIRE_GPIO, ONEWIRE_PIN и ONEWIRE_GPIO_CLOCK"
+#endif
+
+/** Длительности тайм-слотов в микросекундах согласно рекомендациям Maxim. */
+#define OW_RESET_LOW_US     480U
+#define OW_PRESENCE_WAIT_US 70U
+#define OW_RESET_TAIL_US    410U
+#define OW_WRITE1_LOW_US    6U
+#define OW_WRITE1_TAIL_US   64U
+#define OW_WRITE0_LOW_US    60U
+#define OW_WRITE0_TAIL_US   10U
+#define OW_READ_LOW_US      6U
+#define OW_READ_SAMPLE_US   9U
+#define OW_READ_TAIL_US     55U
+
+/** Число тактов ядра на микросекунду; заполняется в OneWire_Init. */
+static uint32_t g_cycles_per_us = 168U;
+
+/**
+ * @brief Переводит вывод шины в активный низкий уровень.
+ */
+static void ow_drive_low(void)
+{
+    ONEWIRE_GPIO->BSRR = (uint32_t)(1UL << (ONEWIRE_PIN + 16U));
+}
+
+/**
+ * @brief Отпускает шину; уровень поднимает внешний резистор подтяжки.
+ */
+static void ow_release(void)
+{
+    ONEWIRE_GPIO->BSRR = (uint32_t)(1UL << ONEWIRE_PIN);
+}
+
+/**
+ * @brief Читает текущий уровень на выводе шины.
+ *
+ * @return 1 для высокого уровня, 0 для низкого.
+ */
+static uint8_t ow_read_pin(void)
+{
+    return (uint8_t)((ONEWIRE_GPIO->IDR >> ONEWIRE_PIN) & 1U);
+}
+
+void OneWire_DelayUs(uint32_t microseconds)
+{
+    const uint32_t start = DWT->CYCCNT;
+    const uint32_t ticks = microseconds * g_cycles_per_us;
+
+    while ((DWT->CYCCNT - start) < ticks) {
+        __NOP();
+    }
+}
+
+void OneWire_Init(void)
+{
+    uint32_t config;
+
+    g_cycles_per_us = SystemCoreClock / 1000000U;
+    if (g_cycles_per_us == 0U) {
+        g_cycles_per_us = 1U;
+    }
+
+    /* Счётчик тактов ядра — единственный источник микросекундных задержек. */
+    CoreDebug->DEMCR |= CoreDebug_DEMCR_TRCENA_Msk;
+    DWT->CYCCNT = 0U;
+    DWT->CTRL |= DWT_CTRL_CYCCNTENA_Msk;
+
+    RCC->AHB1ENR |= ONEWIRE_GPIO_CLOCK;
+
+    /* Открытый сток: OTYPER = 1. */
+    ONEWIRE_GPIO->OTYPER |= (uint32_t)(1UL << ONEWIRE_PIN);
+
+    /* Подтяжка внешняя, внутренняя не нужна: PUPDR = 00. */
+    config = ONEWIRE_GPIO->PUPDR;
+    config &= ~(0x3UL << (ONEWIRE_PIN * 2U));
+    ONEWIRE_GPIO->PUPDR = config;
+
+    /* Максимальная скорость фронта: OSPEEDR = 11. */
+    config = ONEWIRE_GPIO->OSPEEDR;
+    config |= (0x3UL << (ONEWIRE_PIN * 2U));
+    ONEWIRE_GPIO->OSPEEDR = config;
+
+    /* Уровень отпускаем до перевода в выход, чтобы не дёрнуть шину вниз. */
+    ow_release();
+
+    /* Обычный выход: MODER = 01. */
+    config = ONEWIRE_GPIO->MODER;
+    config &= ~(0x3UL << (ONEWIRE_PIN * 2U));
+    config |= (0x1UL << (ONEWIRE_PIN * 2U));
+    ONEWIRE_GPIO->MODER = config;
+
+    OneWire_DelayUs(OW_RESET_LOW_US);
+}
+
+uint8_t OneWire_Reset(void)
+{
+    uint32_t primask;
+    uint8_t presence;
+
+    /* Удлинение импульса сброса безопасно, поэтому прерывания не запрещаем. */
+    ow_drive_low();
+    OneWire_DelayUs(OW_RESET_LOW_US);
+
+    primask = __get_PRIMASK();
+    __disable_irq();
+    ow_release();
+    OneWire_DelayUs(OW_PRESENCE_WAIT_US);
+    presence = (uint8_t)(ow_read_pin() == 0U);
+    __set_PRIMASK(primask);
+
+    OneWire_DelayUs(OW_RESET_TAIL_US);
+    return (uint8_t)(presence && (ow_read_pin() != 0U));
+}
+
+void OneWire_WriteBit(uint8_t bit)
+{
+    const uint32_t primask = __get_PRIMASK();
+
+    __disable_irq();
+    ow_drive_low();
+    if (bit != 0U) {
+        OneWire_DelayUs(OW_WRITE1_LOW_US);
+        ow_release();
+        OneWire_DelayUs(OW_WRITE1_TAIL_US);
+    } else {
+        OneWire_DelayUs(OW_WRITE0_LOW_US);
+        ow_release();
+        OneWire_DelayUs(OW_WRITE0_TAIL_US);
+    }
+    __set_PRIMASK(primask);
+}
+
+uint8_t OneWire_ReadBit(void)
+{
+    const uint32_t primask = __get_PRIMASK();
+    uint8_t bit;
+
+    __disable_irq();
+    ow_drive_low();
+    OneWire_DelayUs(OW_READ_LOW_US);
+    ow_release();
+    OneWire_DelayUs(OW_READ_SAMPLE_US);
+    bit = ow_read_pin();
+    __set_PRIMASK(primask);
+
+    OneWire_DelayUs(OW_READ_TAIL_US);
+    return bit;
+}

c/ds18b20/ports/stm32g4/onewire_config.g431.template.h

@@ -0,0 +1,26 @@
+/**
+ * @file onewire_config.g431.template.h
+ * @brief Шаблон привязки шины 1-Wire для STM32G431 (порт stm32g4).
+ *
+ * Скопируйте в своё приложение под именем onewire_config.h и положите на
+ * путь поиска заголовков. Библиотека сама этот файл не подставляет:
+ * привязка выводов принадлежит плате, а не драйверу.
+ *
+ * Требуется внешняя подтяжка 4.7 кОм к питанию.
+ */
+
+#ifndef ONEWIRE_CONFIG_H
+#define ONEWIRE_CONFIG_H
+
+#include "stm32g4xx.h"
+
+/** Порт вывода шины. */
+#define ONEWIRE_GPIO        GPIOA
+
+/** Номер вывода в порту, 0..15. */
+#define ONEWIRE_PIN         1U
+
+/** Бит включения тактирования порта в RCC->AHB2ENR. */
+#define ONEWIRE_GPIO_CLOCK  RCC_AHB2ENR_GPIOAEN
+
+#endif /* ONEWIRE_CONFIG_H */

c/ds18b20/ports/stm32g4/onewire_config.g474.template.h

@@ -0,0 +1,26 @@
+/**
+ * @file onewire_config.g474.template.h
+ * @brief Шаблон привязки шины 1-Wire для STM32G474 (порт stm32g4).
+ *
+ * Скопируйте в своё приложение под именем onewire_config.h и положите на
+ * путь поиска заголовков. Библиотека сама этот файл не подставляет:
+ * привязка выводов принадлежит плате, а не драйверу.
+ *
+ * Требуется внешняя подтяжка 4.7 кОм к питанию.
+ */
+
+#ifndef ONEWIRE_CONFIG_H
+#define ONEWIRE_CONFIG_H
+
+#include "stm32g4xx.h"
+
+/** Порт вывода шины. */
+#define ONEWIRE_GPIO        GPIOA
+
+/** Номер вывода в порту, 0..15. */
+#define ONEWIRE_PIN         1U
+
+/** Бит включения тактирования порта в RCC->AHB2ENR. */
+#define ONEWIRE_GPIO_CLOCK  RCC_AHB2ENR_GPIOAEN
+
+#endif /* ONEWIRE_CONFIG_H */

c/ds18b20/ports/stm32g4/onewire_stm32g4.c

@@ -0,0 +1,172 @@
+/**
+ * @file onewire_stm32g4.c
+ * @brief Порт шины 1-Wire на STM32G4: тайминги, вывод и задержки.
+ *
+ * Подходит и STM32G431, и STM32G474 — периферия GPIO и шина тактирования
+ * у них одинаковы, различается только CMSIS-заголовок, который подставляет
+ * onewire_config.h.
+ *
+ * Вывод постоянно настроен как выход с открытым стоком: чтение уровня
+ * выполняется через регистр IDR, поэтому переключать режим не требуется.
+ * Прерывания запрещаются только на длительность одного тайм-слота, чтобы не
+ * терять байты USART во время обмена.
+ *
+ * Привязка вывода приходит из onewire_config.h, который предоставляет
+ * приложение. Шаблоны — onewire_config.g431.template.h и
+ * onewire_config.g474.template.h рядом с этим файлом.
+ */
+
+#include "onewire.h"
+
+#include "onewire_config.h"
+
+#if !defined(ONEWIRE_GPIO) || !defined(ONEWIRE_PIN) || !defined(ONEWIRE_GPIO_CLOCK)
+#error "onewire_config.h должен задать ONEWIRE_GPIO, ONEWIRE_PIN и ONEWIRE_GPIO_CLOCK"
+#endif
+
+/** Длительности тайм-слотов в микросекундах согласно рекомендациям Maxim. */
+#define OW_RESET_LOW_US     480U
+#define OW_PRESENCE_WAIT_US 70U
+#define OW_RESET_TAIL_US    410U
+#define OW_WRITE1_LOW_US    6U
+#define OW_WRITE1_TAIL_US   64U
+#define OW_WRITE0_LOW_US    60U
+#define OW_WRITE0_TAIL_US   10U
+#define OW_READ_LOW_US      6U
+#define OW_READ_SAMPLE_US   9U
+#define OW_READ_TAIL_US     55U
+
+/** Число тактов ядра на микросекунду; заполняется в OneWire_Init. */
+static uint32_t g_cycles_per_us = 170U;
+
+/**
+ * @brief Переводит вывод шины в активный низкий уровень.
+ */
+static void ow_drive_low(void)
+{
+    ONEWIRE_GPIO->BSRR = (uint32_t)(1UL << (ONEWIRE_PIN + 16U));
+}
+
+/**
+ * @brief Отпускает шину; уровень поднимает внешний резистор подтяжки.
+ */
+static void ow_release(void)
+{
+    ONEWIRE_GPIO->BSRR = (uint32_t)(1UL << ONEWIRE_PIN);
+}
+
+/**
+ * @brief Читает текущий уровень на выводе шины.
+ *
+ * @return 1 для высокого уровня, 0 для низкого.
+ */
+static uint8_t ow_read_pin(void)
+{
+    return (uint8_t)((ONEWIRE_GPIO->IDR >> ONEWIRE_PIN) & 1U);
+}
+
+void OneWire_DelayUs(uint32_t microseconds)
+{
+    const uint32_t start = DWT->CYCCNT;
+    const uint32_t ticks = microseconds * g_cycles_per_us;
+
+    while ((DWT->CYCCNT - start) < ticks) {
+        __NOP();
+    }
+}
+
+void OneWire_Init(void)
+{
+    uint32_t config;
+
+    g_cycles_per_us = SystemCoreClock / 1000000U;
+    if (g_cycles_per_us == 0U) {
+        g_cycles_per_us = 1U;
+    }
+
+    /* Счётчик тактов ядра — единственный источник микросекундных задержек. */
+    CoreDebug->DEMCR |= CoreDebug_DEMCR_TRCENA_Msk;
+    DWT->CYCCNT = 0U;
+    DWT->CTRL |= DWT_CTRL_CYCCNTENA_Msk;
+
+    RCC->AHB2ENR |= ONEWIRE_GPIO_CLOCK;
+
+    /* Открытый сток: OTYPER = 1. */
+    ONEWIRE_GPIO->OTYPER |= (uint32_t)(1UL << ONEWIRE_PIN);
+
+    /* Подтяжка внешняя, внутренняя не нужна: PUPDR = 00. */
+    config = ONEWIRE_GPIO->PUPDR;
+    config &= ~(0x3UL << (ONEWIRE_PIN * 2U));
+    ONEWIRE_GPIO->PUPDR = config;
+
+    /* Максимальная скорость фронта: OSPEEDR = 11. */
+    config = ONEWIRE_GPIO->OSPEEDR;
+    config |= (0x3UL << (ONEWIRE_PIN * 2U));
+    ONEWIRE_GPIO->OSPEEDR = config;
+
+    /* Уровень отпускаем до перевода в выход, чтобы не дёрнуть шину вниз. */
+    ow_release();
+
+    /* Обычный выход: MODER = 01. */
+    config = ONEWIRE_GPIO->MODER;
+    config &= ~(0x3UL << (ONEWIRE_PIN * 2U));
+    config |= (0x1UL << (ONEWIRE_PIN * 2U));
+    ONEWIRE_GPIO->MODER = config;
+
+    OneWire_DelayUs(OW_RESET_LOW_US);
+}
+
+uint8_t OneWire_Reset(void)
+{
+    uint32_t primask;
+    uint8_t presence;
+
+    /* Удлинение импульса сброса безопасно, поэтому прерывания не запрещаем. */
+    ow_drive_low();
+    OneWire_DelayUs(OW_RESET_LOW_US);
+
+    primask = __get_PRIMASK();
+    __disable_irq();
+    ow_release();
+    OneWire_DelayUs(OW_PRESENCE_WAIT_US);
+    presence = (uint8_t)(ow_read_pin() == 0U);
+    __set_PRIMASK(primask);
+
+    OneWire_DelayUs(OW_RESET_TAIL_US);
+    return (uint8_t)(presence && (ow_read_pin() != 0U));
+}
+
+void OneWire_WriteBit(uint8_t bit)
+{
+    const uint32_t primask = __get_PRIMASK();
+
+    __disable_irq();
+    ow_drive_low();
+    if (bit != 0U) {
+        OneWire_DelayUs(OW_WRITE1_LOW_US);
+        ow_release();
+        OneWire_DelayUs(OW_WRITE1_TAIL_US);
+    } else {
+        OneWire_DelayUs(OW_WRITE0_LOW_US);
+        ow_release();
+        OneWire_DelayUs(OW_WRITE0_TAIL_US);
+    }
+    __set_PRIMASK(primask);
+}
+
+uint8_t OneWire_ReadBit(void)
+{
+    const uint32_t primask = __get_PRIMASK();
+    uint8_t bit;
+
+    __disable_irq();
+    ow_drive_low();
+    OneWire_DelayUs(OW_READ_LOW_US);
+    ow_release();
+    OneWire_DelayUs(OW_READ_SAMPLE_US);
+    bit = ow_read_pin();
+    __set_PRIMASK(primask);
+
+    OneWire_DelayUs(OW_READ_TAIL_US);
+    return bit;
+}

c/firmware-info/CMakeLists.txt

@@ -0,0 +1,8 @@
+cmake_minimum_required(VERSION 3.16)
+project(firmware_info C)
+add_library(firmware_info src/firmware_info.c)
+target_include_directories(firmware_info PUBLIC include)
+add_executable(test_firmware_info tests/test_firmware_info.c)
+target_link_libraries(test_firmware_info PRIVATE firmware_info)
+enable_testing()
+add_test(NAME firmware_info COMMAND test_firmware_info)

c/firmware-info/PORTING.md

@@ -0,0 +1,11 @@
+# PORTING
+
+Аппаратно-зависимый контракт ограничен `firmware_info_config.h`:
+`FIRMWARE_VERSION_MAJOR`, `FIRMWARE_VERSION_MINOR`, `FIRMWARE_VERSION_PATCH` и
+необязательный `FIRMWARE_BUILD_ID`. Выберите порт по семейству МК или создайте
+его копию. Публикация — ответственность транспорта: 12 `uint16_t` для Modbus
+либо 24 little-endian байта для SETGUI.
+
+При переносе проверьте: поддержку `__DATE__`/`__TIME__`, наличие generated в
+include path, запуск генератора до компиляции и декодирование build ID как двух
+ASCII-байтов в каждом логическом слове.

c/firmware-info/README.md

@@ -0,0 +1,27 @@
+# Firmware Info
+
+Переносимая библиотека версии реально запущенной прошивки. Повторяет контракт
+`FirmwareInfo` из `john103C6T6NewVer`, но оформлена как template: ядро не знает
+ни о HAL, ни о конкретном протоколе, ни о модели МК.
+
+Контракт v1 содержит 12 слов: версия контракта, `major.minor.patch`, дата/время
+компиляции и 8-символьный build ID. `firmware_info_to_registers()` подходит для
+Modbus, `firmware_info_to_le_bytes()` — для SETGUI и других byte-протоколов.
+
+## Подключение
+
+1. Добавьте `include`, `src/firmware_info.c` и `src/firmware_info_port.c`.
+2. Скопируйте подходящий `ports/<mcu>/firmware_info_config.template.h` в проект
+   как `firmware_info_config.h` и задайте SemVer.
+3. Добавьте каталог с config и `include` в include path.
+4. Перед сборкой запустите `tools/make_build_id.ps1`; каталог generated также
+   должен быть в include path. Чистая сборка получает 8 знаков git commit,
+   dirty-сборка — 7 знаков и `+`, сборка без Git — `NOGIT000`.
+
+Готовые конфигурации есть для STM32F1, STM32F4, STM32G4 и К1921ВК028. Порт не
+содержит регистров МК: стандартные `__DATE__`/`__TIME__` одинаковы для GCC,
+Arm Compiler 5/6 и Clang. Поэтому добавление следующего МК требует только
+config, а не дублирования ядра.
+
+KONOR публикует эти 24 байта ответом `FIRMWARE_INFO (0x03)`, сохраняя старый
+32-байтовый `DEVICE_INFO` без изменений.

c/firmware-info/include/firmware_info.h

@@ -0,0 +1,48 @@
+#ifndef FIRMWARE_INFO_H
+#define FIRMWARE_INFO_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define FIRMWARE_INFO_CONTRACT_VERSION 1U
+#define FIRMWARE_INFO_REGISTER_COUNT 12U
+#define FIRMWARE_INFO_PAYLOAD_SIZE (FIRMWARE_INFO_REGISTER_COUNT * 2U)
+#define FIRMWARE_INFO_BUILD_ID_SIZE 8U
+
+typedef struct {
+    uint16_t major;
+    uint16_t minor;
+    uint16_t patch;
+    uint16_t year;
+    uint8_t month;
+    uint8_t day;
+    uint8_t hour;
+    uint8_t minute;
+    uint8_t second;
+    char build_id[FIRMWARE_INFO_BUILD_ID_SIZE + 1U];
+} firmware_info_t;
+
+typedef enum {
+    FIRMWARE_INFO_OK = 0,
+    FIRMWARE_INFO_INVALID_ARGUMENT,
+    FIRMWARE_INFO_OUT_OF_RANGE
+} firmware_info_status_t;
+
+firmware_info_status_t firmware_info_validate(const firmware_info_t *info);
+firmware_info_status_t firmware_info_parse_build_stamp(
+    const char *date_text, const char *time_text, firmware_info_t *info);
+firmware_info_status_t firmware_info_set_build_id(
+    firmware_info_t *info, const char *build_id);
+firmware_info_status_t firmware_info_to_registers(
+    const firmware_info_t *info, uint16_t *registers, size_t count);
+firmware_info_status_t firmware_info_to_le_bytes(
+    const firmware_info_t *info, uint8_t *payload, size_t size);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

c/firmware-info/include/firmware_info_port.h

@@ -0,0 +1,18 @@
+#ifndef FIRMWARE_INFO_PORT_H
+#define FIRMWARE_INFO_PORT_H
+
+#include "firmware_info.h"
+
+/* Include-path selects one MCU project configuration named firmware_info_config.h. */
+#include "firmware_info_config.h"
+
+#ifndef FIRMWARE_VERSION_PATCH
+#define FIRMWARE_VERSION_PATCH 0U
+#endif
+#ifndef FIRMWARE_BUILD_ID
+#define FIRMWARE_BUILD_ID "LOCALDEV"
+#endif
+
+firmware_info_status_t firmware_info_port_describe(firmware_info_t *info);
+
+#endif

c/firmware-info/ports/k1921vk028/firmware_info_config.template.h

@@ -0,0 +1,11 @@
+#ifndef FIRMWARE_INFO_CONFIG_H
+#define FIRMWARE_INFO_CONFIG_H
+#define FIRMWARE_VERSION_MAJOR 1U
+#define FIRMWARE_VERSION_MINOR 0U
+#define FIRMWARE_VERSION_PATCH 0U
+#if defined(__has_include)
+# if __has_include("firmware_build_id.h")
+#  include "firmware_build_id.h"
+# endif
+#endif
+#endif

c/firmware-info/ports/stm32f1/firmware_info_config.template.h

@@ -0,0 +1,12 @@
+#ifndef FIRMWARE_INFO_CONFIG_H
+#define FIRMWARE_INFO_CONFIG_H
+#define FIRMWARE_VERSION_MAJOR 1U
+#define FIRMWARE_VERSION_MINOR 0U
+#define FIRMWARE_VERSION_PATCH 0U
+/* Optional: generated by tools/make_build_id.ps1. */
+#if defined(__has_include)
+# if __has_include("firmware_build_id.h")
+#  include "firmware_build_id.h"
+# endif
+#endif
+#endif

c/firmware-info/ports/stm32f4/firmware_info_config.template.h

@@ -0,0 +1,11 @@
+#ifndef FIRMWARE_INFO_CONFIG_H
+#define FIRMWARE_INFO_CONFIG_H
+#define FIRMWARE_VERSION_MAJOR 1U
+#define FIRMWARE_VERSION_MINOR 0U
+#define FIRMWARE_VERSION_PATCH 0U
+#if defined(__has_include)
+# if __has_include("firmware_build_id.h")
+#  include "firmware_build_id.h"
+# endif
+#endif
+#endif

c/firmware-info/ports/stm32g4/firmware_info_config.template.h

@@ -0,0 +1,11 @@
+#ifndef FIRMWARE_INFO_CONFIG_H
+#define FIRMWARE_INFO_CONFIG_H
+#define FIRMWARE_VERSION_MAJOR 1U
+#define FIRMWARE_VERSION_MINOR 0U
+#define FIRMWARE_VERSION_PATCH 0U
+#if defined(__has_include)
+# if __has_include("firmware_build_id.h")
+#  include "firmware_build_id.h"
+# endif
+#endif
+#endif

c/firmware-info/src/firmware_info.c

@@ -0,0 +1,121 @@
+#include "firmware_info.h"
+
+static const char months[12][4] = {
+    "Jan", "Feb", "Mar", "Apr", "May", "Jun",
+    "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
+};
+
+static int is_digit(char value) { return (value >= '0') && (value <= '9'); }
+
+static int two_digits(const char *text, uint8_t *result)
+{
+    char high = text[0];
+    char low = text[1];
+    if (high == ' ') high = '0';
+    if (!is_digit(high) || !is_digit(low)) return 0;
+    *result = (uint8_t)(((uint8_t)(high - '0') * 10U) + (uint8_t)(low - '0'));
+    return 1;
+}
+
+static int four_digits(const char *text, uint16_t *result)
+{
+    uint16_t value = 0U;
+    uint8_t i;
+    for (i = 0U; i < 4U; ++i) {
+        if (!is_digit(text[i])) return 0;
+        value = (uint16_t)(value * 10U + (uint16_t)(text[i] - '0'));
+    }
+    *result = value;
+    return 1;
+}
+
+firmware_info_status_t firmware_info_validate(const firmware_info_t *info)
+{
+    uint8_t i;
+    if (info == NULL) return FIRMWARE_INFO_INVALID_ARGUMENT;
+    if ((info->major > 255U) || (info->minor > 255U) || (info->patch > 999U)
+        || (info->year < 2000U) || (info->year > 2199U)
+        || (info->month < 1U) || (info->month > 12U)
+        || (info->day < 1U) || (info->day > 31U)
+        || (info->hour > 23U) || (info->minute > 59U) || (info->second > 59U)) {
+        return FIRMWARE_INFO_OUT_OF_RANGE;
+    }
+    for (i = 0U; i < FIRMWARE_INFO_BUILD_ID_SIZE; ++i) {
+        if ((info->build_id[i] < 0x20) || (info->build_id[i] > 0x7e))
+            return FIRMWARE_INFO_OUT_OF_RANGE;
+    }
+    return FIRMWARE_INFO_OK;
+}
+
+firmware_info_status_t firmware_info_set_build_id(firmware_info_t *info,
+                                                   const char *build_id)
+{
+    uint8_t i;
+    if ((info == NULL) || (build_id == NULL)) return FIRMWARE_INFO_INVALID_ARGUMENT;
+    for (i = 0U; i < FIRMWARE_INFO_BUILD_ID_SIZE && build_id[i] != '\0'; ++i) {
+        if ((build_id[i] < 0x20) || (build_id[i] > 0x7e))
+            return FIRMWARE_INFO_OUT_OF_RANGE;
+        info->build_id[i] = build_id[i];
+    }
+    for (; i < FIRMWARE_INFO_BUILD_ID_SIZE; ++i) info->build_id[i] = '0';
+    info->build_id[FIRMWARE_INFO_BUILD_ID_SIZE] = '\0';
+    return FIRMWARE_INFO_OK;
+}
+
+firmware_info_status_t firmware_info_parse_build_stamp(
+    const char *date_text, const char *time_text, firmware_info_t *info)
+{
+    uint8_t month;
+    uint8_t found = 0U;
+    if ((date_text == NULL) || (time_text == NULL) || (info == NULL))
+        return FIRMWARE_INFO_INVALID_ARGUMENT;
+    for (month = 0U; month < 12U; ++month) {
+        if ((date_text[0] == months[month][0]) && (date_text[1] == months[month][1])
+            && (date_text[2] == months[month][2])) { found = 1U; break; }
+    }
+    if (!found || !two_digits(&date_text[4], &info->day)
+        || !four_digits(&date_text[7], &info->year)
+        || !two_digits(&time_text[0], &info->hour)
+        || !two_digits(&time_text[3], &info->minute)
+        || !two_digits(&time_text[6], &info->second)) return FIRMWARE_INFO_OUT_OF_RANGE;
+    info->month = (uint8_t)(month + 1U);
+    return FIRMWARE_INFO_OK;
+}
+
+firmware_info_status_t firmware_info_to_registers(
+    const firmware_info_t *info, uint16_t *registers, size_t count)
+{
+    uint8_t i;
+    firmware_info_status_t status;
+    if ((registers == NULL) || (count < FIRMWARE_INFO_REGISTER_COUNT))
+        return FIRMWARE_INFO_INVALID_ARGUMENT;
+    status = firmware_info_validate(info);
+    if (status != FIRMWARE_INFO_OK) return status;
+    registers[0] = FIRMWARE_INFO_CONTRACT_VERSION;
+    registers[1] = info->major; registers[2] = info->minor; registers[3] = info->patch;
+    registers[4] = info->year;
+    registers[5] = (uint16_t)(((uint16_t)info->month << 8U) | info->day);
+    registers[6] = (uint16_t)(((uint16_t)info->hour << 8U) | info->minute);
+    registers[7] = info->second;
+    for (i = 0U; i < 4U; ++i)
+        registers[8U + i] = (uint16_t)(((uint16_t)(uint8_t)info->build_id[i * 2U] << 8U)
+                                      | (uint8_t)info->build_id[i * 2U + 1U]);
+    return FIRMWARE_INFO_OK;
+}
+
+firmware_info_status_t firmware_info_to_le_bytes(
+    const firmware_info_t *info, uint8_t *payload, size_t size)
+{
+    uint16_t words[FIRMWARE_INFO_REGISTER_COUNT];
+    uint8_t i;
+    firmware_info_status_t status;
+    if ((payload == NULL) || (size < FIRMWARE_INFO_PAYLOAD_SIZE))
+        return FIRMWARE_INFO_INVALID_ARGUMENT;
+    status = firmware_info_to_registers(info, words, FIRMWARE_INFO_REGISTER_COUNT);
+    if (status != FIRMWARE_INFO_OK) return status;
+    for (i = 0U; i < FIRMWARE_INFO_REGISTER_COUNT; ++i) {
+        payload[i * 2U] = (uint8_t)words[i];
+        payload[i * 2U + 1U] = (uint8_t)(words[i] >> 8U);
+    }
+    return FIRMWARE_INFO_OK;
+}

c/firmware-info/src/firmware_info_port.c

@@ -0,0 +1,13 @@
+#include "firmware_info_port.h"
+
+firmware_info_status_t firmware_info_port_describe(firmware_info_t *info)
+{
+    firmware_info_status_t status;
+    if (info == NULL) return FIRMWARE_INFO_INVALID_ARGUMENT;
+    info->major = (uint16_t)FIRMWARE_VERSION_MAJOR;
+    info->minor = (uint16_t)FIRMWARE_VERSION_MINOR;
+    info->patch = (uint16_t)FIRMWARE_VERSION_PATCH;
+    status = firmware_info_set_build_id(info, FIRMWARE_BUILD_ID);
+    if (status != FIRMWARE_INFO_OK) return status;
+    return firmware_info_parse_build_stamp(__DATE__, __TIME__, info);
+}

c/firmware-info/tests/test_firmware_info.c

@@ -0,0 +1,20 @@
+#include "firmware_info.h"
+#include <assert.h>
+#include <string.h>
+
+int main(void)
+{
+    firmware_info_t info = {1U, 2U, 3U, 0U, 0U, 0U, 0U, 0U, 0U, ""};
+    uint16_t words[FIRMWARE_INFO_REGISTER_COUNT];
+    uint8_t bytes[FIRMWARE_INFO_PAYLOAD_SIZE];
+    assert(firmware_info_set_build_id(&info, "abc") == FIRMWARE_INFO_OK);
+    assert(strcmp(info.build_id, "abc00000") == 0);
+    assert(firmware_info_parse_build_stamp("Aug 30 2026", "12:34:56", &info) == FIRMWARE_INFO_OK);
+    assert(firmware_info_to_registers(&info, words, FIRMWARE_INFO_REGISTER_COUNT) == FIRMWARE_INFO_OK);
+    assert(words[0] == 1U && words[1] == 1U && words[4] == 2026U);
+    assert(words[5] == 0x081eU && words[6] == 0x0c22U && words[7] == 56U);
+    assert(words[8] == 0x6162U && words[9] == 0x6330U);
+    assert(firmware_info_to_le_bytes(&info, bytes, sizeof(bytes)) == FIRMWARE_INFO_OK);
+    assert(bytes[0] == 1U && bytes[1] == 0U && bytes[16] == 0x62U && bytes[17] == 0x61U);
+    return 0;
+}

c/firmware-info/tools/make_build_id.ps1

@@ -0,0 +1,18 @@
+param(
+    [string]$Repository = (Resolve-Path (Join-Path $PSScriptRoot '..\..\..\..\..')).Path,
+    [string]$Output = (Join-Path $PSScriptRoot '..\generated\firmware_build_id.h')
+)
+
+$id = 'NOGIT000'
+$hash = (& git -C $Repository rev-parse --short=8 HEAD 2>$null)
+if ($LASTEXITCODE -eq 0 -and $hash) {
+    & git -C $Repository diff --quiet HEAD 2>$null
+    $id = if ($LASTEXITCODE -eq 0) { $hash.Substring(0, 8) } else { $hash.Substring(0, 7) + '+' }
+}
+$directory = Split-Path -Parent $Output
+New-Item -ItemType Directory -Force -Path $directory | Out-Null
+$body = "#ifndef FIRMWARE_BUILD_ID_H`n#define FIRMWARE_BUILD_ID_H`n#define FIRMWARE_BUILD_ID `"$id`"`n#endif`n"
+if (!(Test-Path -LiteralPath $Output) -or ((Get-Content -Raw $Output) -ne $body)) {
+    [IO.File]::WriteAllText($Output, $body, [Text.UTF8Encoding]::new($false))
+}
+Write-Host "[firmware-info] build-id: $id"

c/protocan-boot/CMakeLists.txt

@@ -0,0 +1,22 @@
+cmake_minimum_required(VERSION 3.13)
+project(protocan_boot C)
+
+set(CMAKE_C_STANDARD 99)
+set(CMAKE_C_STANDARD_REQUIRED ON)
+
+add_library(protocan_boot STATIC src/pcan_boot.c)
+target_include_directories(protocan_boot PUBLIC include)
+
+if(MSVC)
+    target_compile_options(protocan_boot PRIVATE /W4)
+else()
+    target_compile_options(protocan_boot PRIVATE -Wall -Wextra -Wpedantic)
+endif()
+
+option(PCAN_BOOT_BUILD_TESTS "Собирать тесты ProtoCAN boot" ON)
+if(PCAN_BOOT_BUILD_TESTS)
+    enable_testing()
+    add_executable(test_pcan_boot tests/test_pcan_boot.c)
+    target_link_libraries(test_pcan_boot PRIVATE protocan_boot)
+    add_test(NAME pcan_boot COMMAND test_pcan_boot)
+endif()

c/protocan-boot/README.md

@@ -0,0 +1,175 @@
+# ProtoCAN Boot
+
+`protocan-boot` — переносимое C99-ядро адресной прошивки приборов по classic
+CAN 2.0B и 29-битному ProtoCAN ID. Оно реализует сессию обновления, два
+логических слота по 512 КиБ либо single-slot обновление, последовательную запись 8-байтовых блоков,
+CRC32, проверку совместимости, продолжение по номеру следующего блока и
+безопасный выбор неактивного слота.
+
+Это не готовый загрузчик конкретного STM32: внутри нет HAL, регистров Flash,
+linker script, обработчиков прерываний, криптографии и перехода в приложение.
+Эти операции предоставляет проект через таблицу callbacks.
+
+Для STM32G474VET6 из `candleLight_fw` задаются `slot_count = 1` и
+`max_image_size = 480 * 1024`. В этом режиме запись идёт в единственную
+область приложения, callback `set_pending_slot` не требуется, а аппаратный
+rollback недоступен. Значение `slot_count = 0` сохраняет прежний A/B-режим.
+
+## Слои
+
+```text
+приложение / CAN RX loop
+        |
+        v
+pcan_boot_process()       — протокол и state machine
+        |
+        v
+pcan_boot_port_t          — Flash, политика подписи, commit, reboot
+        |
+        v
+STM32 HAL / другой MCU / host-тест
+```
+
+## Файлы
+
+| Файл | Назначение | Зависимости |
+|---|---|---|
+| `include/pcan_boot.h` | публичный API, команды и структуры | C99 stdint/stdbool |
+| `src/pcan_boot.c` | ProtoCAN ID, state machine и CRC32 | только публичный заголовок |
+| `tests/test_pcan_boot.c` | хостовые тесты с RAM вместо Flash | стандартная библиотека C |
+| `CMakeLists.txt` | сборка библиотеки и теста | CMake 3.13+ |
+
+Модуль не зависит от `protocan-transport`: разбор пяти полей 29-битного ID
+сделан переносимыми сдвигами, без непереносимых C-битовых полей.
+
+## Карта `MsgType`
+
+| Значение | Имя | Назначение |
+|---:|---|---|
+| `0x9` | `BOOT_CONTROL` | команды и метаданные |
+| `0xA` | `BOOT_DATA_A` | блоки слота A |
+| `0xB` | `BOOT_DATA_B` | блоки слота B |
+| `0xC` | `BOOT_STATUS` | ответы и прогресс |
+| `0xD` | `BOOT_DISCOVERY` | идентификация |
+
+Для `BOOT_DATA_A/B` поле `MsgBody` — номер блока `0..65535`, а payload —
+8 байт образа:
+
+```text
+offset = MsgBody * 8
+512 КиБ = 512 * 1024 = 524 288 байт
+524 288 / 8 = 65 536 блоков на слот
+```
+
+| `MsgBody` | Номер блока | Смещение | Байты слота |
+|---:|---:|---:|---:|
+| `0x0000` | 0 | `0x00000` | `0x00000..0x00007` |
+| `0x0001` | 1 | `0x00008` | `0x00008..0x0000F` |
+| `0xFFFF` | 65 535 | `0x7FFF8` | `0x7FFF8..0x7FFFF` |
+
+Последний блок заканчивается на смещении `0x7FFFF`. Значение `0x80000`
+равно размеру слота и является первой позицией за его границей. В коде эти
+границы заданы константами `PCAN_BOOT_BLOCK_COUNT=65536` и
+`PCAN_BOOT_SLOT_SIZE=524288`.
+
+Последний кадр дополняется `0xFF`; ядро передаёт во Flash только оставшиеся
+байты фактического образа и включает в CRC только их.
+
+## Контракт порта
+
+```c
+typedef struct {
+    bool (*send)(void *, uint32_t can_id, const uint8_t *, uint8_t dlc);
+    bool (*erase_slot)(void *, uint8_t slot);
+    bool (*write_slot)(void *, uint8_t slot, uint32_t offset,
+                       const uint8_t *, uint8_t length);
+    bool (*authorize)(void *, const pcan_boot_manifest_t *);
+    bool (*verify_image)(void *, uint8_t slot,
+                         const pcan_boot_manifest_t *);
+    bool (*set_pending_slot)(void *, uint8_t slot,
+                             const pcan_boot_manifest_t *);
+    bool (*confirm_running_slot)(void *);
+    void (*reboot)(void *);
+} pcan_boot_port_t;
+```
+
+Обязательны `send`, `erase_slot`, `write_slot` и `set_pending_slot`.
+`authorize` проверяет политику до стирания (тип, версия, anti-rollback).
+`verify_image` выполняет платформенную проверку подписанного контейнера после
+CRC32. Если callbacks отсутствуют, соответствующие дополнительные проверки
+пропускаются; для серийного изделия их следует реализовать.
+
+`set_pending_slot` должен атомарно сохранить boot metadata. До подтверждения
+нового приложения загрузчик сохраняет возможность отката. `confirm_running_slot`
+снимает pending-флаг после самопроверки приложения.
+
+## Быстрый старт
+
+```c
+pcan_boot_t boot;
+pcan_boot_config_t cfg = {
+    .device_type = 3, .device_id = 5, .product_type = 0x1234,
+    .hardware_revision = 2, .firmware_version = 0x01020000,
+    .active_slot = 0, .ack_window = 16
+};
+pcan_boot_port_t port = {
+    .send = can_send, .erase_slot = flash_erase_slot,
+    .write_slot = flash_write_slot, .authorize = image_authorize,
+    .verify_image = image_verify_signature,
+    .set_pending_slot = boot_set_pending, .reboot = system_reboot
+};
+
+pcan_boot_init(&boot, &cfg, &port, &board);
+/* Из CAN RX-задачи, не из длительного Flash-прерывания: */
+pcan_boot_process(&boot, rx.ExtId, rx.Data, rx.DLC);
+```
+
+## Последовательность обновления
+
+1. `IDENTIFY` или discovery получает тип и версии прибора.
+2. `ENTER_BOOT` открывает ненулевой `SessionID`.
+3. `BEGIN_IMAGE` передаёт размер и CRC32.
+4. `BEGIN_COMPAT` передаёт тип изделия, диапазон HW и версию FW.
+5. Ядро выбирает неактивный слот и отвечает его номером.
+6. `ERASE` вызывает порт стирания.
+7. `BOOT_DATA_A` либо `BOOT_DATA_B` передаются строго по порядку.
+8. `VERIFY` сравнивает CRC32 и вызывает проверку образа/подписи порта.
+9. `COMMIT` атомарно помечает слот как pending.
+10. После reboot приложение подтверждает запуск через `CONFIRM`.
+
+Все изменяющие Flash команды адресуются конкретному `DeviceType/DeviceID`.
+Ядро не принимает broadcast-запись и игнорирует кадры с чужим адресом или
+`Route=FROM_DEVICE`.
+
+## State machine
+
+```text
+IDLE -> ENTER_BOOT -> METADATA -> BEGIN_IMAGE + BEGIN_COMPAT
+     -> READY_TO_ERASE -> ERASE -> RECEIVING -> VERIFY -> VERIFIED
+     -> COMMIT -> REBOOT -> CONFIRM
+```
+
+При ошибке Flash, CRC, совместимости или подписи состояние переходит в
+`FAILED`. Новая сессия начинается командой `ENTER_BOOT`; `ABORT` очищает
+текущую сессию без изменения Flash.
+
+## Сборка тестов
+
+```sh
+cmake -S . -B build
+cmake --build build
+ctest --test-dir build --output-on-failure
+```
+
+## Что остаётся проекту устройства
+
+- зарезервировать bootloader, slot A/B и metadata в linker script;
+- реализовать выравнивание и размеры страниц Flash;
+- не выполнять длительное стирание непосредственно в CAN IRQ;
+- атомарно хранить active/pending/confirmed и счётчик попыток запуска;
+- проверить вектор, границы и подпись образа;
+- включить watchdog и rollback при неподтверждённом запуске;
+- согласовать фильтры CAN для `MsgType=0x9..0xD`.
+
+Проект пока не подключён ни к одной конкретной плате; это самостоятельный
+шаблон для интеграции в будущие загрузчики приборов SET.

c/protocan-boot/include/pcan_boot.h

@@ -0,0 +1,147 @@
+#ifndef PCAN_BOOT_H
+#define PCAN_BOOT_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define PCAN_BOOT_VERSION          1U
+#define PCAN_BOOT_BLOCK_SIZE       8U
+#define PCAN_BOOT_BLOCK_COUNT      65536UL
+#define PCAN_BOOT_SLOT_SIZE        (PCAN_BOOT_BLOCK_COUNT * PCAN_BOOT_BLOCK_SIZE)
+#define PCAN_BOOT_SLOT_NONE        0xFFU
+
+#define PCAN_BOOT_MSG_CONTROL      0x9U
+#define PCAN_BOOT_MSG_DATA_A       0xAU
+#define PCAN_BOOT_MSG_DATA_B       0xBU
+#define PCAN_BOOT_MSG_STATUS       0xCU
+#define PCAN_BOOT_MSG_DISCOVERY    0xDU
+
+#define PCAN_BOOT_ROUTE_FROM_PM      0U
+#define PCAN_BOOT_ROUTE_FROM_DEVICE  1U
+
+typedef enum {
+    PCAN_BOOT_CMD_IDENTIFY       = 0x01U,
+    PCAN_BOOT_CMD_ENTER_BOOT     = 0x02U,
+    PCAN_BOOT_CMD_BEGIN_IMAGE    = 0x03U,
+    PCAN_BOOT_CMD_BEGIN_COMPAT   = 0x04U,
+    PCAN_BOOT_CMD_ERASE          = 0x05U,
+    PCAN_BOOT_CMD_VERIFY         = 0x06U,
+    PCAN_BOOT_CMD_COMMIT         = 0x07U,
+    PCAN_BOOT_CMD_CONFIRM        = 0x08U,
+    PCAN_BOOT_CMD_REBOOT         = 0x09U,
+    PCAN_BOOT_CMD_ABORT          = 0x0AU,
+    PCAN_BOOT_CMD_QUERY_PROGRESS = 0x0BU
+} pcan_boot_command_t;
+
+typedef enum {
+    PCAN_BOOT_STATUS_OK              = 0x00U,
+    PCAN_BOOT_STATUS_BUSY            = 0x01U,
+    PCAN_BOOT_STATUS_INVALID_COMMAND = 0x02U,
+    PCAN_BOOT_STATUS_WRONG_DEVICE    = 0x03U,
+    PCAN_BOOT_STATUS_WRONG_HARDWARE  = 0x04U,
+    PCAN_BOOT_STATUS_INVALID_SIZE    = 0x05U,
+    PCAN_BOOT_STATUS_CRC_ERROR       = 0x06U,
+    PCAN_BOOT_STATUS_FLASH_ERROR     = 0x07U,
+    PCAN_BOOT_STATUS_SEQUENCE_ERROR  = 0x08U,
+    PCAN_BOOT_STATUS_SIGNATURE_ERROR = 0x09U,
+    PCAN_BOOT_STATUS_SESSION_ERROR   = 0x0AU,
+    PCAN_BOOT_STATUS_VOLTAGE_ERROR   = 0x0BU,
+    PCAN_BOOT_STATUS_INVALID_STATE   = 0x0CU
+} pcan_boot_status_t;
+
+typedef enum {
+    PCAN_BOOT_STATE_IDLE = 0,
+    PCAN_BOOT_STATE_METADATA,
+    PCAN_BOOT_STATE_READY_TO_ERASE,
+    PCAN_BOOT_STATE_RECEIVING,
+    PCAN_BOOT_STATE_VERIFIED,
+    PCAN_BOOT_STATE_FAILED
+} pcan_boot_state_t;
+
+typedef struct {
+    uint32_t image_size;
+    uint32_t image_crc32;
+    uint32_t firmware_version;
+    uint16_t product_type;
+    uint8_t hardware_revision_min;
+    uint8_t hardware_revision_max;
+} pcan_boot_manifest_t;
+
+typedef struct {
+    uint8_t device_type;
+    uint8_t device_id;
+    uint16_t product_type;
+    uint8_t hardware_revision;
+    uint32_t firmware_version;
+    uint8_t active_slot;
+    /** 1 for an in-place/single-slot target, 2 for A/B. Zero keeps legacy A/B. */
+    uint8_t slot_count;
+    /** Writable image capacity. Zero uses PCAN_BOOT_SLOT_SIZE. */
+    uint32_t max_image_size;
+    uint8_t ack_window; /**< 1 — ACK каждого блока, 16 — ACK каждых 16 блоков. */
+} pcan_boot_config_t;
+
+typedef struct {
+    bool (*send)(void *user, uint32_t can_id, const uint8_t *data, uint8_t dlc);
+    bool (*erase_slot)(void *user, uint8_t slot);
+    bool (*write_slot)(void *user, uint8_t slot, uint32_t offset,
+                       const uint8_t *data, uint8_t length);
+    bool (*authorize)(void *user, const pcan_boot_manifest_t *manifest);
+    bool (*verify_image)(void *user, uint8_t slot,
+                         const pcan_boot_manifest_t *manifest);
+    bool (*set_pending_slot)(void *user, uint8_t slot,
+                             const pcan_boot_manifest_t *manifest);
+    bool (*confirm_running_slot)(void *user);
+    void (*reboot)(void *user);
+} pcan_boot_port_t;
+
+typedef struct {
+    pcan_boot_config_t config;
+    pcan_boot_port_t port;
+    void *port_user;
+    pcan_boot_manifest_t manifest;
+    pcan_boot_state_t state;
+    uint32_t running_crc32;
+    uint32_t bytes_received;
+    uint16_t next_block;
+    uint8_t session_id;
+    uint8_t target_slot;
+    uint8_t last_status;
+    bool have_image;
+    bool have_compat;
+} pcan_boot_t;
+
+/** Инициализирует экземпляр. Все обязательные callbacks должны быть заданы. */
+bool pcan_boot_init(pcan_boot_t *boot, const pcan_boot_config_t *config,
+                    const pcan_boot_port_t *port, void *port_user);
+
+/** Сбрасывает незавершённую сессию, не меняя конфигурацию и callbacks. */
+void pcan_boot_abort(pcan_boot_t *boot);
+
+/**
+ * Обрабатывает один Extended CAN-кадр.
+ * Возвращает true, если кадр принадлежал загрузочному сервису этого прибора.
+ */
+bool pcan_boot_process(pcan_boot_t *boot, uint32_t can_id,
+                       const uint8_t *data, uint8_t dlc);
+
+/** Переносимые операции с 29-битным ProtoCAN ID. */
+uint32_t pcan_boot_make_id(uint8_t priority, uint8_t route,
+                           uint8_t device_type, uint8_t device_id,
+                           uint8_t msg_type, uint16_t msg_body);
+uint8_t pcan_boot_id_route(uint32_t can_id);
+uint8_t pcan_boot_id_device_type(uint32_t can_id);
+uint8_t pcan_boot_id_device_id(uint32_t can_id);
+uint8_t pcan_boot_id_msg_type(uint32_t can_id);
+uint16_t pcan_boot_id_msg_body(uint32_t can_id);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* PCAN_BOOT_H */

c/protocan-boot/src/pcan_boot.c

@@ -0,0 +1,349 @@
+#include "pcan_boot.h"
+
+#include <string.h>
+
+#define PCAN_BOOT_ID_MASK 0x1FFFFFFFUL
+
+static uint16_t get_u16(const uint8_t *p)
+{
+    return (uint16_t)((uint16_t)p[0] | ((uint16_t)p[1] << 8));
+}
+
+static uint32_t get_u32(const uint8_t *p)
+{
+    return (uint32_t)p[0]
+         | ((uint32_t)p[1] << 8)
+         | ((uint32_t)p[2] << 16)
+         | ((uint32_t)p[3] << 24);
+}
+
+static void put_u16(uint8_t *p, uint16_t value)
+{
+    p[0] = (uint8_t)value;
+    p[1] = (uint8_t)(value >> 8);
+}
+
+static void put_u32(uint8_t *p, uint32_t value)
+{
+    p[0] = (uint8_t)value;
+    p[1] = (uint8_t)(value >> 8);
+    p[2] = (uint8_t)(value >> 16);
+    p[3] = (uint8_t)(value >> 24);
+}
+
+static uint32_t crc32_update(uint32_t crc, const uint8_t *data, size_t length)
+{
+    size_t i;
+    crc = ~crc;
+    for (i = 0U; i < length; ++i) {
+        uint8_t bit;
+        crc ^= data[i];
+        for (bit = 0U; bit < 8U; ++bit) {
+            crc = (crc >> 1) ^ ((crc & 1U) != 0U ? 0xEDB88320UL : 0U);
+        }
+    }
+    return ~crc;
+}
+
+uint32_t pcan_boot_make_id(uint8_t priority, uint8_t route,
+                           uint8_t device_type, uint8_t device_id,
+                           uint8_t msg_type, uint16_t msg_body)
+{
+    return ((((uint32_t)priority & 1U) << 28)
+          | (((uint32_t)route & 1U) << 27)
+          | (((uint32_t)device_type & 7U) << 24)
+          | (((uint32_t)device_id & 15U) << 20)
+          | (((uint32_t)msg_type & 15U) << 16)
+          | msg_body) & PCAN_BOOT_ID_MASK;
+}
+
+uint8_t pcan_boot_id_route(uint32_t can_id) { return (uint8_t)((can_id >> 27) & 1U); }
+uint8_t pcan_boot_id_device_type(uint32_t can_id) { return (uint8_t)((can_id >> 24) & 7U); }
+uint8_t pcan_boot_id_device_id(uint32_t can_id) { return (uint8_t)((can_id >> 20) & 15U); }
+uint8_t pcan_boot_id_msg_type(uint32_t can_id) { return (uint8_t)((can_id >> 16) & 15U); }
+uint16_t pcan_boot_id_msg_body(uint32_t can_id) { return (uint16_t)can_id; }
+
+static bool send_frame(pcan_boot_t *boot, uint8_t msg_type, uint16_t body,
+                       const uint8_t *data, uint8_t dlc)
+{
+    uint32_t id = pcan_boot_make_id(1U, PCAN_BOOT_ROUTE_FROM_DEVICE,
+                                    boot->config.device_type,
+                                    boot->config.device_id,
+                                    msg_type, body);
+    return boot->port.send(boot->port_user, id, data, dlc);
+}
+
+static bool send_status(pcan_boot_t *boot, uint8_t command, uint8_t status)
+{
+    uint8_t data[8];
+    uint16_t body = (uint16_t)(((uint16_t)boot->session_id << 8) | command);
+    data[0] = status;
+    data[1] = boot->target_slot;
+    put_u16(&data[2], boot->next_block);
+    put_u32(&data[4], boot->running_crc32);
+    boot->last_status = status;
+    return send_frame(boot, PCAN_BOOT_MSG_STATUS, body, data, 8U);
+}
+
+static bool send_identity(pcan_boot_t *boot)
+{
+    uint8_t data[8];
+    put_u16(&data[0], boot->config.product_type);
+    data[2] = boot->config.hardware_revision;
+    data[3] = PCAN_BOOT_VERSION;
+    put_u32(&data[4], boot->config.firmware_version);
+    return send_frame(boot, PCAN_BOOT_MSG_DISCOVERY, 1U, data, 8U);
+}
+
+void pcan_boot_abort(pcan_boot_t *boot)
+{
+    if (boot == NULL) {
+        return;
+    }
+    (void)memset(&boot->manifest, 0, sizeof(boot->manifest));
+    boot->state = PCAN_BOOT_STATE_IDLE;
+    boot->running_crc32 = 0U;
+    boot->bytes_received = 0U;
+    boot->next_block = 0U;
+    boot->session_id = 0U;
+    boot->target_slot = PCAN_BOOT_SLOT_NONE;
+    boot->last_status = PCAN_BOOT_STATUS_OK;
+    boot->have_image = false;
+    boot->have_compat = false;
+}
+
+bool pcan_boot_init(pcan_boot_t *boot, const pcan_boot_config_t *config,
+                    const pcan_boot_port_t *port, void *port_user)
+{
+    uint8_t slot_count;
+    if ((boot == NULL) || (config == NULL) || (port == NULL)
+            || (config->device_type > 7U) || (config->device_id > 15U)
+            || (config->active_slot > 1U)
+            || (port->send == NULL) || (port->erase_slot == NULL)
+            || (port->write_slot == NULL)) {
+        return false;
+    }
+    slot_count = config->slot_count == 0U ? 2U : config->slot_count;
+    if ((slot_count > 2U) || (config->active_slot >= slot_count)
+            || ((slot_count == 2U) && (port->set_pending_slot == NULL))) {
+        return false;
+    }
+    (void)memset(boot, 0, sizeof(*boot));
+    boot->config = *config;
+    boot->port = *port;
+    boot->port_user = port_user;
+    boot->config.slot_count = slot_count;
+    if (boot->config.max_image_size == 0U) {
+        boot->config.max_image_size = PCAN_BOOT_SLOT_SIZE;
+    }
+    if (boot->config.ack_window == 0U) {
+        boot->config.ack_window = 1U;
+    }
+    pcan_boot_abort(boot);
+    return true;
+}
+
+static bool metadata_complete(pcan_boot_t *boot, uint8_t command)
+{
+    if (!boot->have_image || !boot->have_compat) {
+        boot->state = PCAN_BOOT_STATE_METADATA;
+        return send_status(boot, command, PCAN_BOOT_STATUS_OK);
+    }
+    if ((boot->manifest.image_size == 0U)
+            || (boot->manifest.image_size > boot->config.max_image_size)) {
+        boot->state = PCAN_BOOT_STATE_FAILED;
+        return send_status(boot, command, PCAN_BOOT_STATUS_INVALID_SIZE);
+    }
+    if ((boot->manifest.product_type != boot->config.product_type)
+            || (boot->config.hardware_revision < boot->manifest.hardware_revision_min)
+            || (boot->config.hardware_revision > boot->manifest.hardware_revision_max)) {
+        boot->state = PCAN_BOOT_STATE_FAILED;
+        return send_status(boot, command, PCAN_BOOT_STATUS_WRONG_HARDWARE);
+    }
+    if ((boot->port.authorize != NULL)
+            && !boot->port.authorize(boot->port_user, &boot->manifest)) {
+        boot->state = PCAN_BOOT_STATE_FAILED;
+        return send_status(boot, command, PCAN_BOOT_STATUS_SIGNATURE_ERROR);
+    }
+    boot->target_slot = boot->config.slot_count == 1U
+                      ? boot->config.active_slot
+                      : (uint8_t)(boot->config.active_slot ^ 1U);
+    boot->state = PCAN_BOOT_STATE_READY_TO_ERASE;
+    return send_status(boot, command, PCAN_BOOT_STATUS_OK);
+}
+
+static bool process_control(pcan_boot_t *boot, uint16_t body,
+                            const uint8_t *data, uint8_t dlc)
+{
+    uint8_t session = (uint8_t)(body >> 8);
+    uint8_t command = (uint8_t)body;
+
+    if (command == PCAN_BOOT_CMD_IDENTIFY) {
+        return send_identity(boot);
+    }
+    if (command == PCAN_BOOT_CMD_ENTER_BOOT) {
+        if (session == 0U) {
+            return send_status(boot, command, PCAN_BOOT_STATUS_SESSION_ERROR);
+        }
+        pcan_boot_abort(boot);
+        boot->session_id = session;
+        boot->state = PCAN_BOOT_STATE_METADATA;
+        return send_status(boot, command, PCAN_BOOT_STATUS_OK);
+    }
+    if ((session == 0U) || (session != boot->session_id)) {
+        return send_status(boot, command, PCAN_BOOT_STATUS_SESSION_ERROR);
+    }
+
+    switch (command) {
+    case PCAN_BOOT_CMD_BEGIN_IMAGE:
+        if ((dlc != 8U) || (boot->state != PCAN_BOOT_STATE_METADATA)) {
+            return send_status(boot, command, PCAN_BOOT_STATUS_INVALID_STATE);
+        }
+        boot->manifest.image_size = get_u32(&data[0]);
+        boot->manifest.image_crc32 = get_u32(&data[4]);
+        boot->have_image = true;
+        return metadata_complete(boot, command);
+
+    case PCAN_BOOT_CMD_BEGIN_COMPAT:
+        if ((dlc != 8U) || (boot->state != PCAN_BOOT_STATE_METADATA)) {
+            return send_status(boot, command, PCAN_BOOT_STATUS_INVALID_STATE);
+        }
+        boot->manifest.product_type = get_u16(&data[0]);
+        boot->manifest.hardware_revision_min = data[2];
+        boot->manifest.hardware_revision_max = data[3];
+        boot->manifest.firmware_version = get_u32(&data[4]);
+        boot->have_compat = true;
+        return metadata_complete(boot, command);
+
+    case PCAN_BOOT_CMD_ERASE:
+        if (boot->state != PCAN_BOOT_STATE_READY_TO_ERASE) {
+            return send_status(boot, command, PCAN_BOOT_STATUS_INVALID_STATE);
+        }
+        if (!boot->port.erase_slot(boot->port_user, boot->target_slot)) {
+            boot->state = PCAN_BOOT_STATE_FAILED;
+            return send_status(boot, command, PCAN_BOOT_STATUS_FLASH_ERROR);
+        }
+        boot->running_crc32 = 0U;
+        boot->bytes_received = 0U;
+        boot->next_block = 0U;
+        boot->state = PCAN_BOOT_STATE_RECEIVING;
+        return send_status(boot, command, PCAN_BOOT_STATUS_OK);
+
+    case PCAN_BOOT_CMD_VERIFY:
+        if ((boot->state != PCAN_BOOT_STATE_RECEIVING)
+                || (boot->bytes_received != boot->manifest.image_size)) {
+            return send_status(boot, command, PCAN_BOOT_STATUS_INVALID_STATE);
+        }
+        if (boot->running_crc32 != boot->manifest.image_crc32) {
+            boot->state = PCAN_BOOT_STATE_FAILED;
+            return send_status(boot, command, PCAN_BOOT_STATUS_CRC_ERROR);
+        }
+        if ((boot->port.verify_image != NULL)
+                && !boot->port.verify_image(boot->port_user, boot->target_slot,
+                                            &boot->manifest)) {
+            boot->state = PCAN_BOOT_STATE_FAILED;
+            return send_status(boot, command, PCAN_BOOT_STATUS_SIGNATURE_ERROR);
+        }
+        boot->state = PCAN_BOOT_STATE_VERIFIED;
+        return send_status(boot, command, PCAN_BOOT_STATUS_OK);
+
+    case PCAN_BOOT_CMD_COMMIT:
+        if (boot->state != PCAN_BOOT_STATE_VERIFIED) {
+            return send_status(boot, command, PCAN_BOOT_STATUS_INVALID_STATE);
+        }
+        if ((boot->config.slot_count == 2U)
+                && !boot->port.set_pending_slot(boot->port_user, boot->target_slot,
+                                                &boot->manifest)) {
+            return send_status(boot, command, PCAN_BOOT_STATUS_FLASH_ERROR);
+        }
+        return send_status(boot, command, PCAN_BOOT_STATUS_OK);
+
+    case PCAN_BOOT_CMD_CONFIRM:
+        if ((boot->port.confirm_running_slot == NULL)
+                || !boot->port.confirm_running_slot(boot->port_user)) {
+            return send_status(boot, command, PCAN_BOOT_STATUS_FLASH_ERROR);
+        }
+        return send_status(boot, command, PCAN_BOOT_STATUS_OK);
+
+    case PCAN_BOOT_CMD_QUERY_PROGRESS:
+        return send_status(boot, command, boot->last_status);
+
+    case PCAN_BOOT_CMD_ABORT:
+        pcan_boot_abort(boot);
+        boot->session_id = session;
+        return send_status(boot, command, PCAN_BOOT_STATUS_OK);
+
+    case PCAN_BOOT_CMD_REBOOT:
+        (void)send_status(boot, command, PCAN_BOOT_STATUS_OK);
+        if (boot->port.reboot != NULL) {
+            boot->port.reboot(boot->port_user);
+        }
+        return true;
+
+    default:
+        return send_status(boot, command, PCAN_BOOT_STATUS_INVALID_COMMAND);
+    }
+}
+
+static bool process_data(pcan_boot_t *boot, uint8_t msg_type, uint16_t block,
+                         const uint8_t *data, uint8_t dlc)
+{
+    uint8_t expected_type;
+    uint8_t write_length;
+    uint32_t remaining;
+
+    if (boot->state != PCAN_BOOT_STATE_RECEIVING) {
+        return send_status(boot, 0U, PCAN_BOOT_STATUS_INVALID_STATE);
+    }
+    expected_type = boot->target_slot == 0U ? PCAN_BOOT_MSG_DATA_A
+                                            : PCAN_BOOT_MSG_DATA_B;
+    if (msg_type != expected_type) {
+        return send_status(boot, 0U, PCAN_BOOT_STATUS_INVALID_STATE);
+    }
+    if ((block != boot->next_block) || (dlc != PCAN_BOOT_BLOCK_SIZE)) {
+        return send_status(boot, 0U, PCAN_BOOT_STATUS_SEQUENCE_ERROR);
+    }
+    remaining = boot->manifest.image_size - boot->bytes_received;
+    write_length = remaining < PCAN_BOOT_BLOCK_SIZE ? (uint8_t)remaining
+                                                    : PCAN_BOOT_BLOCK_SIZE;
+    if ((write_length == 0U)
+            || !boot->port.write_slot(boot->port_user, boot->target_slot,
+                                      boot->bytes_received, data, write_length)) {
+        boot->state = PCAN_BOOT_STATE_FAILED;
+        return send_status(boot, 0U, PCAN_BOOT_STATUS_FLASH_ERROR);
+    }
+    boot->running_crc32 = crc32_update(boot->running_crc32, data, write_length);
+    boot->bytes_received += write_length;
+    boot->next_block++;
+
+    if ((boot->bytes_received == boot->manifest.image_size)
+            || ((boot->next_block % boot->config.ack_window) == 0U)) {
+        return send_status(boot, 0U, PCAN_BOOT_STATUS_OK);
+    }
+    return true;
+}
+
+bool pcan_boot_process(pcan_boot_t *boot, uint32_t can_id,
+                       const uint8_t *data, uint8_t dlc)
+{
+    uint8_t msg_type;
+    if ((boot == NULL) || (dlc > 8U) || ((dlc != 0U) && (data == NULL))) {
+        return false;
+    }
+    msg_type = pcan_boot_id_msg_type(can_id);
+    if ((msg_type < PCAN_BOOT_MSG_CONTROL) || (msg_type > PCAN_BOOT_MSG_DISCOVERY)) {
+        return false;
+    }
+    if ((pcan_boot_id_route(can_id) != PCAN_BOOT_ROUTE_FROM_PM)
+            || (pcan_boot_id_device_type(can_id) != boot->config.device_type)
+            || (pcan_boot_id_device_id(can_id) != boot->config.device_id)) {
+        return false;
+    }
+    if (msg_type == PCAN_BOOT_MSG_CONTROL) {
+        return process_control(boot, pcan_boot_id_msg_body(can_id), data, dlc);
+    }
+    if ((msg_type == PCAN_BOOT_MSG_DATA_A) || (msg_type == PCAN_BOOT_MSG_DATA_B)) {
+        return process_data(boot, msg_type, pcan_boot_id_msg_body(can_id), data, dlc);
+    }
+    return false;
+}

c/protocan-boot/tests/test_pcan_boot.c

@@ -0,0 +1,306 @@
+#include "pcan_boot.h"
+
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+
+typedef struct {
+    uint8_t flash[2][64];
+    uint32_t last_id;
+    uint8_t last_data[8];
+    uint8_t last_dlc;
+    unsigned sends;
+    unsigned erases;
+    unsigned writes;
+    uint8_t pending_slot;
+    bool authorized;
+    bool verified;
+    bool rebooted;
+} fake_t;
+
+static bool fake_send(void *user, uint32_t id, const uint8_t *data, uint8_t dlc)
+{
+    fake_t *f = (fake_t *)user;
+    f->last_id = id;
+    f->last_dlc = dlc;
+    (void)memset(f->last_data, 0, sizeof(f->last_data));
+    if (dlc != 0U) {
+        (void)memcpy(f->last_data, data, dlc);
+    }
+    f->sends++;
+    return true;
+}
+
+static bool fake_erase(void *user, uint8_t slot)
+{
+    fake_t *f = (fake_t *)user;
+    (void)memset(f->flash[slot], 0xFF, sizeof(f->flash[slot]));
+    f->erases++;
+    return true;
+}
+
+static bool fake_write(void *user, uint8_t slot, uint32_t offset,
+                       const uint8_t *data, uint8_t length)
+{
+    fake_t *f = (fake_t *)user;
+    if ((slot > 1U) || (offset + length > sizeof(f->flash[slot]))) {
+        return false;
+    }
+    (void)memcpy(&f->flash[slot][offset], data, length);
+    f->writes++;
+    return true;
+}
+
+static bool fake_authorize(void *user, const pcan_boot_manifest_t *manifest)
+{
+    fake_t *f = (fake_t *)user;
+    (void)manifest;
+    return f->authorized;
+}
+
+static bool fake_verify(void *user, uint8_t slot,
+                        const pcan_boot_manifest_t *manifest)
+{
+    fake_t *f = (fake_t *)user;
+    (void)slot;
+    (void)manifest;
+    return f->verified;
+}
+
+static bool fake_pending(void *user, uint8_t slot,
+                         const pcan_boot_manifest_t *manifest)
+{
+    fake_t *f = (fake_t *)user;
+    (void)manifest;
+    f->pending_slot = slot;
+    return true;
+}
+
+static bool fake_confirm(void *user)
+{
+    (void)user;
+    return true;
+}
+
+static void fake_reboot(void *user)
+{
+    ((fake_t *)user)->rebooted = true;
+}
+
+static uint32_t crc32(const uint8_t *data, size_t length)
+{
+    uint32_t crc = 0xFFFFFFFFUL;
+    size_t i;
+    for (i = 0U; i < length; ++i) {
+        uint8_t bit;
+        crc ^= data[i];
+        for (bit = 0U; bit < 8U; ++bit) {
+            crc = (crc >> 1) ^ ((crc & 1U) != 0U ? 0xEDB88320UL : 0U);
+        }
+    }
+    return ~crc;
+}
+
+static void put_u16(uint8_t *p, uint16_t v)
+{
+    p[0] = (uint8_t)v;
+    p[1] = (uint8_t)(v >> 8);
+}
+
+static void put_u32(uint8_t *p, uint32_t v)
+{
+    p[0] = (uint8_t)v;
+    p[1] = (uint8_t)(v >> 8);
+    p[2] = (uint8_t)(v >> 16);
+    p[3] = (uint8_t)(v >> 24);
+}
+
+static uint32_t request_id(uint8_t type, uint16_t body)
+{
+    return pcan_boot_make_id(1U, PCAN_BOOT_ROUTE_FROM_PM, 3U, 5U, type, body);
+}
+
+static bool command(pcan_boot_t *boot, uint8_t session, uint8_t cmd,
+                    const uint8_t *data, uint8_t dlc)
+{
+    uint16_t body = (uint16_t)(((uint16_t)session << 8) | cmd);
+    return pcan_boot_process(boot, request_id(PCAN_BOOT_MSG_CONTROL, body), data, dlc);
+}
+
+static void setup(pcan_boot_t *boot, fake_t *fake)
+{
+    pcan_boot_config_t config;
+    pcan_boot_port_t port;
+    (void)memset(fake, 0, sizeof(*fake));
+    (void)memset(&config, 0, sizeof(config));
+    (void)memset(&port, 0, sizeof(port));
+    fake->authorized = true;
+    fake->verified = true;
+    fake->pending_slot = PCAN_BOOT_SLOT_NONE;
+    config.device_type = 3U;
+    config.device_id = 5U;
+    config.product_type = 0x1234U;
+    config.hardware_revision = 2U;
+    config.firmware_version = 0x01020304UL;
+    config.active_slot = 0U;
+    config.ack_window = 2U;
+    port.send = fake_send;
+    port.erase_slot = fake_erase;
+    port.write_slot = fake_write;
+    port.authorize = fake_authorize;
+    port.verify_image = fake_verify;
+    port.set_pending_slot = fake_pending;
+    port.confirm_running_slot = fake_confirm;
+    port.reboot = fake_reboot;
+    assert(pcan_boot_init(boot, &config, &port, fake));
+}
+
+static void begin_update(pcan_boot_t *boot, const uint8_t *image, uint32_t size)
+{
+    uint8_t data[8];
+    assert(command(boot, 7U, PCAN_BOOT_CMD_ENTER_BOOT, NULL, 0U));
+    put_u32(&data[0], size);
+    put_u32(&data[4], crc32(image, size));
+    assert(command(boot, 7U, PCAN_BOOT_CMD_BEGIN_IMAGE, data, 8U));
+    put_u16(&data[0], 0x1234U);
+    data[2] = 1U;
+    data[3] = 3U;
+    put_u32(&data[4], 0x02000000UL);
+    assert(command(boot, 7U, PCAN_BOOT_CMD_BEGIN_COMPAT, data, 8U));
+}
+
+static void test_id_layout(void)
+{
+    uint32_t id = pcan_boot_make_id(1U, 0U, 7U, 15U, 0xAU, 0x1234U);
+    assert(id == 0x17FA1234UL);
+    assert(pcan_boot_id_device_type(id) == 7U);
+    assert(pcan_boot_id_device_id(id) == 15U);
+    assert(pcan_boot_id_msg_type(id) == 0xAU);
+    assert(pcan_boot_id_msg_body(id) == 0x1234U);
+}
+
+static void test_crc32_reference(void)
+{
+    static const uint8_t reference[] = "123456789";
+    assert(crc32(reference, sizeof(reference) - 1U) == 0xCBF43926UL);
+}
+
+static void test_complete_update(void)
+{
+    static const uint8_t image[13] = {
+        0x10U, 0x11U, 0x12U, 0x13U, 0x14U, 0x15U, 0x16U, 0x17U,
+        0x20U, 0x21U, 0x22U, 0x23U, 0x24U
+    };
+    uint8_t block[8];
+    pcan_boot_t boot;
+    fake_t fake;
+    setup(&boot, &fake);
+    begin_update(&boot, image, sizeof(image));
+    assert(boot.state == PCAN_BOOT_STATE_READY_TO_ERASE);
+    assert(boot.target_slot == 1U);
+    assert(command(&boot, 7U, PCAN_BOOT_CMD_ERASE, NULL, 0U));
+    assert(fake.erases == 1U);
+
+    assert(pcan_boot_process(&boot, request_id(PCAN_BOOT_MSG_DATA_B, 0U), image, 8U));
+    (void)memset(block, 0xFF, sizeof(block));
+    (void)memcpy(block, &image[8], 5U);
+    assert(pcan_boot_process(&boot, request_id(PCAN_BOOT_MSG_DATA_B, 1U), block, 8U));
+    assert(boot.bytes_received == sizeof(image));
+    assert(boot.next_block == 2U);
+    assert(memcmp(fake.flash[1], image, sizeof(image)) == 0);
+
+    assert(command(&boot, 7U, PCAN_BOOT_CMD_VERIFY, NULL, 0U));
+    assert(boot.state == PCAN_BOOT_STATE_VERIFIED);
+    assert(command(&boot, 7U, PCAN_BOOT_CMD_COMMIT, NULL, 0U));
+    assert(fake.pending_slot == 1U);
+    assert(command(&boot, 7U, PCAN_BOOT_CMD_REBOOT, NULL, 0U));
+    assert(fake.rebooted);
+}
+
+static void test_rejects_wrong_address_and_sequence(void)
+{
+    uint8_t image[8] = {0U};
+    pcan_boot_t boot;
+    fake_t fake;
+    uint32_t other = pcan_boot_make_id(1U, 0U, 3U, 6U,
+                                      PCAN_BOOT_MSG_CONTROL,
+                                      (uint16_t)((7U << 8) | PCAN_BOOT_CMD_ENTER_BOOT));
+    setup(&boot, &fake);
+    assert(!pcan_boot_process(&boot, other, NULL, 0U));
+    begin_update(&boot, image, sizeof(image));
+    assert(command(&boot, 7U, PCAN_BOOT_CMD_ERASE, NULL, 0U));
+    assert(pcan_boot_process(&boot, request_id(PCAN_BOOT_MSG_DATA_B, 1U), image, 8U));
+    assert(fake.last_data[0] == PCAN_BOOT_STATUS_SEQUENCE_ERROR);
+    assert(fake.writes == 0U);
+}
+
+static void test_rejects_wrong_session_and_compatibility(void)
+{
+    uint8_t data[8] = {0U};
+    pcan_boot_t boot;
+    fake_t fake;
+    setup(&boot, &fake);
+    assert(command(&boot, 7U, PCAN_BOOT_CMD_ENTER_BOOT, NULL, 0U));
+    assert(command(&boot, 8U, PCAN_BOOT_CMD_ERASE, NULL, 0U));
+    assert(fake.last_data[0] == PCAN_BOOT_STATUS_SESSION_ERROR);
+    put_u32(&data[0], 8U);
+    put_u32(&data[4], 0U);
+    assert(command(&boot, 7U, PCAN_BOOT_CMD_BEGIN_IMAGE, data, 8U));
+    put_u16(&data[0], 0x9999U);
+    data[2] = 1U;
+    data[3] = 3U;
+    put_u32(&data[4], 1U);
+    assert(command(&boot, 7U, PCAN_BOOT_CMD_BEGIN_COMPAT, data, 8U));
+    assert(fake.last_data[0] == PCAN_BOOT_STATUS_WRONG_HARDWARE);
+    assert(boot.state == PCAN_BOOT_STATE_FAILED);
+}
+
+static void test_single_slot_update(void)
+{
+    static const uint8_t image[8] = { 1U, 2U, 3U, 4U, 5U, 6U, 7U, 8U };
+    pcan_boot_t boot;
+    fake_t fake;
+    pcan_boot_config_t config;
+    pcan_boot_port_t port;
+
+    (void)memset(&fake, 0, sizeof(fake));
+    (void)memset(&config, 0, sizeof(config));
+    (void)memset(&port, 0, sizeof(port));
+    fake.pending_slot = PCAN_BOOT_SLOT_NONE;
+    fake.authorized = true;
+    fake.verified = true;
+    config.device_type = 3U;
+    config.device_id = 5U;
+    config.product_type = 0x1234U;
+    config.hardware_revision = 2U;
+    config.slot_count = 1U;
+    config.max_image_size = sizeof(fake.flash[0]);
+    config.ack_window = 16U;
+    port.send = fake_send;
+    port.erase_slot = fake_erase;
+    port.write_slot = fake_write;
+    port.authorize = fake_authorize;
+    port.verify_image = fake_verify;
+    port.reboot = fake_reboot;
+    assert(pcan_boot_init(&boot, &config, &port, &fake));
+    begin_update(&boot, image, sizeof(image));
+    assert(boot.target_slot == 0U);
+    assert(command(&boot, 7U, PCAN_BOOT_CMD_ERASE, NULL, 0U));
+    assert(pcan_boot_process(&boot, request_id(PCAN_BOOT_MSG_DATA_A, 0U), image, 8U));
+    assert(command(&boot, 7U, PCAN_BOOT_CMD_VERIFY, NULL, 0U));
+    assert(command(&boot, 7U, PCAN_BOOT_CMD_COMMIT, NULL, 0U));
+    assert(fake.pending_slot == PCAN_BOOT_SLOT_NONE);
+    assert(memcmp(fake.flash[0], image, sizeof(image)) == 0);
+}
+
+int main(void)
+{
+    test_id_layout();
+    test_crc32_reference();
+    test_complete_update();
+    test_rejects_wrong_address_and_sequence();
+    test_rejects_wrong_session_and_compatibility();
+    test_single_slot_update();
+    puts("pcan_boot tests: OK");
+    return 0;
+}

c/protocan-transport/CMakeLists.txt

@@ -5,7 +5,8 @@ set(CMAKE_C_STANDARD 99)
 set(CMAKE_C_STANDARD_REQUIRED ON)
 
 # Ядро библиотеки: платформенных зависимостей нет, собирается под что угодно.
-add_library(protocan_transport STATIC
+set(PCAN_CORE_SOURCES
+    src/pcan_abi.c
     src/pcan_crc.c
     src/pcan_frame.c
     src/pcan_id.c
@@ -14,14 +15,36 @@ add_library(protocan_transport STATIC
     src/pcan_gas.c
 )
 
+add_library(protocan_transport STATIC ${PCAN_CORE_SOURCES})
+
 target_include_directories(protocan_transport PUBLIC include)
 
+option(PCAN_BUILD_SHARED "Build stable host ABI shared library" ON)
+if(PCAN_BUILD_SHARED)
+    add_library(setcore SHARED ${PCAN_CORE_SOURCES})
+    target_include_directories(setcore PUBLIC include)
+    target_compile_definitions(setcore PRIVATE PCAN_ABI_BUILD_DLL)
+    set_target_properties(setcore PROPERTIES
+        C_VISIBILITY_PRESET hidden
+        VISIBILITY_INLINES_HIDDEN YES
+        OUTPUT_NAME setcore
+    )
+endif()
+
 if(MSVC)
     target_compile_options(protocan_transport PRIVATE /W4)
 else()
     target_compile_options(protocan_transport PRIVATE -Wall -Wextra -Wpedantic)
 endif()
 
+if(TARGET setcore)
+    if(MSVC)
+        target_compile_options(setcore PRIVATE /W4)
+    else()
+        target_compile_options(setcore PRIVATE -Wall -Wextra -Wpedantic)
+    endif()
+endif()
+
 # Порт ports/stm32f4 сюда не входит: ему нужен CMSIS-заголовок stm32f4xx.h,
 # он подключается напрямую в проект прошивки.
 
@@ -32,4 +55,7 @@ if(PCAN_BUILD_TESTS)
     add_executable(test_transport tests/test_transport.c)
     target_link_libraries(test_transport PRIVATE protocan_transport)
     add_test(NAME transport COMMAND test_transport)
+    add_executable(test_abi tests/test_abi.c)
+    target_link_libraries(test_abi PRIVATE protocan_transport)
+    add_test(NAME abi COMMAND test_abi)
 endif()

c/protocan-transport/README.md

@@ -27,7 +27,9 @@
 | `pcan_ring` | кольцевой буфер, отдаёт непрерывный участок для DMA |
 | `pcan_id` | упаковка и разбор 29-битного идентификатора ProtoCAN |
 | `pcan_gas` | общее адресное пространство: карта регионов, чтение/запись, мост к кадрам |
+| `pcan_abi` | стабильный C ABI для Python, JNI, Swift и других FFI |
 | `ports/stm32f4` | готовый порт USART + DMA (пакетная передача, кольцевой приём) |
+| `ports/android` | JNI и Kotlin-фасад; собирает `libsetcore.so` из этого же C99-кода |
 
 ## Кадр
 
@@ -93,6 +95,21 @@ size_t my_space(void *ctx);
 cmake -B build && cmake --build build && ctest --test-dir build
 ```
 
+Для desktop CMake дополнительно собирает shared library `setcore`
+(`setcore.dll`, `libsetcore.so` или `libsetcore.dylib`). Публичная граница
+для приложений описана в `include/pcan_abi.h`; внутренние структуры ядра через
+FFI не экспортируются. Python-обёртка находится в `python/protocan/native.py`.
+
+Android-проект подключает `ports/android/Android.mk` и добавляет
+`ports/android/kotlin` в `sourceSets`. JNI-код занимается только преобразованием
+типов и временем жизни parser context, а правила кадра и CAN ID остаются в C.
+
+Если на Windows нет CMake, host-библиотеку тем же MSVC можно собрать так:
+
+```powershell
+python tools/build_host.py --output native/setcore.dll
+```
+
 Либо напрямую:
 
 ```bash

c/protocan-transport/include/pcan_abi.h

@@ -0,0 +1,74 @@
+/**
+ * @file pcan_abi.h
+ * @brief Stable C ABI for desktop, Android and other foreign runtimes.
+ *
+ * The firmware-facing API remains allocation free.  This header exposes
+ * scalar arguments and explicitly sized buffers so ctypes/JNI/Swift can use
+ * the same C99 implementation without reproducing the wire protocol.
+ */
+#ifndef PCAN_ABI_H
+#define PCAN_ABI_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#if defined(_WIN32) && defined(PCAN_ABI_BUILD_DLL)
+#  define PCAN_ABI_API __declspec(dllexport)
+#elif defined(_WIN32) && defined(PCAN_ABI_USE_DLL)
+#  define PCAN_ABI_API __declspec(dllimport)
+#elif defined(__GNUC__) && (__GNUC__ >= 4)
+#  define PCAN_ABI_API __attribute__((visibility("default")))
+#else
+#  define PCAN_ABI_API
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define PCAN_ABI_VERSION 1U
+
+typedef struct {
+    uint32_t can_id;
+    uint8_t sequence;
+    uint8_t flags;
+    uint8_t dlc;
+    uint8_t data[8];
+} pcan_abi_frame_t;
+
+PCAN_ABI_API uint32_t pcan_abi_version(void);
+
+PCAN_ABI_API uint32_t pcan_abi_id_pack(uint8_t priority, uint8_t route,
+                                       uint8_t device_type, uint8_t device_id,
+                                       uint8_t message_type, uint16_t body);
+
+PCAN_ABI_API void pcan_abi_id_unpack(uint32_t raw, uint8_t *priority,
+                                     uint8_t *route, uint8_t *device_type,
+                                     uint8_t *device_id, uint8_t *message_type,
+                                     uint16_t *body);
+
+PCAN_ABI_API uint16_t pcan_abi_crc16(const uint8_t *data, size_t size);
+
+PCAN_ABI_API size_t pcan_abi_frame_encode(uint8_t sequence, uint8_t flags,
+                                          uint32_t can_id,
+                                          const uint8_t *data, uint8_t dlc,
+                                          uint8_t *output,
+                                          size_t output_size);
+
+/* The caller owns parser_storage; no allocation is performed by the core. */
+PCAN_ABI_API size_t pcan_abi_parser_size(void);
+PCAN_ABI_API int pcan_abi_parser_init(void *parser_storage,
+                                      size_t storage_size);
+PCAN_ABI_API int pcan_abi_parser_push(void *parser_storage, uint8_t byte,
+                                      pcan_abi_frame_t *output);
+PCAN_ABI_API int pcan_abi_parser_stats(const void *parser_storage,
+                                       uint32_t *frames,
+                                       uint32_t *crc_errors,
+                                       uint32_t *bad_length,
+                                       uint32_t *stray_bytes);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* PCAN_ABI_H */

c/protocan-transport/include/protocan_transport.h

@@ -17,6 +17,7 @@
                               PCAN_VERSION_PATCH)
 
 #include "pcan_config.h"
+#include "pcan_abi.h"
 #include "pcan_crc.h"
 #include "pcan_frame.h"
 #include "pcan_gas.h"

c/protocan-transport/ports/android/Android.mk

@@ -0,0 +1,17 @@
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := setcore
+LOCAL_C_INCLUDES := $(LOCAL_PATH)/../../include
+LOCAL_SRC_FILES := \
+    ../../src/pcan_abi.c \
+    ../../src/pcan_crc.c \
+    ../../src/pcan_frame.c \
+    ../../src/pcan_id.c \
+    ../../src/pcan_link.c \
+    ../../src/pcan_ring.c \
+    ../../src/pcan_gas.c \
+    setcore_jni.c
+LOCAL_CFLAGS := -std=c99 -Wall -Wextra -Wpedantic -fvisibility=hidden
+LOCAL_LDLIBS := -llog
+include $(BUILD_SHARED_LIBRARY)

c/protocan-transport/ports/android/README.md

@@ -0,0 +1,10 @@
+# Android port
+
+`Android.mk` builds `libsetcore.so` from the same C99 sources used by MCU and
+desktop builds. `setcore_jni.c` contains only JNI marshalling; protocol rules
+remain in the core. Add the Kotlin directory as an Android source directory
+and include this `Android.mk` from the application NDK build.
+
+The JNI streaming parser returns fixed 15-byte records
+`SEQ | FLAGS | CAN_ID_LE | DLC | DATA[8]`. Dynamic allocation is confined to
+the Android adapter; the portable core remains allocation free.

c/protocan-transport/ports/android/kotlin/ru/setcorp/setcore/NativeProtoCan.kt

@@ -0,0 +1,33 @@
+package ru.setcorp.setcore
+
+/** Thin Kotlin facade over the shared C99 ProtoCAN core. */
+object NativeProtoCan {
+    val available: Boolean by lazy {
+        runCatching {
+            System.loadLibrary("setcore")
+            nativeAbiVersion() == 1
+        }.getOrDefault(false)
+    }
+
+    external fun nativeAbiVersion(): Int
+    external fun nativePackId(
+        priority: Int,
+        route: Int,
+        deviceType: Int,
+        deviceId: Int,
+        messageType: Int,
+        body: Int,
+    ): Long
+    external fun nativeUnpackId(raw: Long): IntArray?
+    external fun nativeCrc16(input: ByteArray): Int
+    external fun nativeEncodeFrame(
+        sequence: Int,
+        flags: Int,
+        canId: Long,
+        input: ByteArray,
+    ): ByteArray?
+    external fun nativeCreateParser(): Long
+    external fun nativeDestroyParser(handle: Long)
+    external fun nativeFeedParser(handle: Long, input: ByteArray): ByteArray?
+    external fun nativeParserStats(handle: Long): IntArray?
+}

c/protocan-transport/ports/android/setcore_jni.c

@@ -0,0 +1,209 @@
+#include <jni.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "pcan_abi.h"
+
+typedef struct {
+    uint8_t *storage;
+    size_t storage_size;
+    int last_sequence;
+    uint32_t sequence_lost;
+} android_parser_t;
+
+JNIEXPORT jint JNICALL
+Java_ru_setcorp_setcore_NativeProtoCan_nativeAbiVersion(JNIEnv *env, jobject self)
+{
+    (void)env;
+    (void)self;
+    return (jint)pcan_abi_version();
+}
+
+JNIEXPORT jlong JNICALL
+Java_ru_setcorp_setcore_NativeProtoCan_nativePackId(
+    JNIEnv *env, jobject self, jint priority, jint route, jint device_type,
+    jint device_id, jint message_type, jint body)
+{
+    (void)env;
+    (void)self;
+    return (jlong)pcan_abi_id_pack((uint8_t)priority, (uint8_t)route,
+                                   (uint8_t)device_type, (uint8_t)device_id,
+                                   (uint8_t)message_type, (uint16_t)body);
+}
+
+JNIEXPORT jintArray JNICALL
+Java_ru_setcorp_setcore_NativeProtoCan_nativeUnpackId(
+    JNIEnv *env, jobject self, jlong raw)
+{
+    (void)self;
+    uint8_t priority, route, device_type, device_id, message_type;
+    uint16_t body;
+    pcan_abi_id_unpack((uint32_t)raw, &priority, &route, &device_type,
+                       &device_id, &message_type, &body);
+    jint values[6] = { (jint)priority, (jint)route, (jint)device_type,
+                       (jint)device_id, (jint)message_type, (jint)body };
+    jintArray result = (*env)->NewIntArray(env, 6);
+    if (result != NULL) {
+        (*env)->SetIntArrayRegion(env, result, 0, 6, values);
+    }
+    return result;
+}
+
+JNIEXPORT jint JNICALL
+Java_ru_setcorp_setcore_NativeProtoCan_nativeCrc16(
+    JNIEnv *env, jobject self, jbyteArray input)
+{
+    (void)self;
+    jsize size = (*env)->GetArrayLength(env, input);
+    jbyte *data = (*env)->GetByteArrayElements(env, input, NULL);
+    if (data == NULL) {
+        return 0;
+    }
+    uint16_t crc = pcan_abi_crc16((const uint8_t *)data, (size_t)size);
+    (*env)->ReleaseByteArrayElements(env, input, data, JNI_ABORT);
+    return (jint)crc;
+}
+
+JNIEXPORT jbyteArray JNICALL
+Java_ru_setcorp_setcore_NativeProtoCan_nativeEncodeFrame(
+    JNIEnv *env, jobject self, jint sequence, jint flags, jlong can_id,
+    jbyteArray input)
+{
+    (void)self;
+    jsize size = (*env)->GetArrayLength(env, input);
+    if (size > 8) {
+        return NULL;
+    }
+    jbyte *data = (*env)->GetByteArrayElements(env, input, NULL);
+    if ((data == NULL) && (size != 0)) {
+        return NULL;
+    }
+    uint8_t output[19];
+    size_t written = pcan_abi_frame_encode(
+        (uint8_t)sequence, (uint8_t)flags, (uint32_t)can_id,
+        (const uint8_t *)data, (uint8_t)size, output, sizeof output);
+    if (data != NULL) {
+        (*env)->ReleaseByteArrayElements(env, input, data, JNI_ABORT);
+    }
+    if (written == 0U) {
+        return NULL;
+    }
+    jbyteArray result = (*env)->NewByteArray(env, (jsize)written);
+    if (result != NULL) {
+        (*env)->SetByteArrayRegion(env, result, 0, (jsize)written,
+                                  (const jbyte *)output);
+    }
+    return result;
+}
+
+JNIEXPORT jlong JNICALL
+Java_ru_setcorp_setcore_NativeProtoCan_nativeCreateParser(JNIEnv *env, jobject self)
+{
+    (void)env;
+    (void)self;
+    android_parser_t *parser = (android_parser_t *)calloc(1U, sizeof *parser);
+    if (parser == NULL) {
+        return 0;
+    }
+    parser->storage_size = pcan_abi_parser_size();
+    parser->storage = (uint8_t *)malloc(parser->storage_size);
+    parser->last_sequence = -1;
+    if ((parser->storage == NULL) ||
+        !pcan_abi_parser_init(parser->storage, parser->storage_size)) {
+        free(parser->storage);
+        free(parser);
+        return 0;
+    }
+    return (jlong)(intptr_t)parser;
+}
+
+JNIEXPORT void JNICALL
+Java_ru_setcorp_setcore_NativeProtoCan_nativeDestroyParser(
+    JNIEnv *env, jobject self, jlong handle)
+{
+    (void)env;
+    (void)self;
+    android_parser_t *parser = (android_parser_t *)(intptr_t)handle;
+    if (parser != NULL) {
+        free(parser->storage);
+        free(parser);
+    }
+}
+
+/* Each returned record is 15 bytes: seq, flags, id LE, dlc, data[8]. */
+JNIEXPORT jbyteArray JNICALL
+Java_ru_setcorp_setcore_NativeProtoCan_nativeFeedParser(
+    JNIEnv *env, jobject self, jlong handle, jbyteArray input)
+{
+    (void)self;
+    android_parser_t *parser = (android_parser_t *)(intptr_t)handle;
+    if (parser == NULL) {
+        return NULL;
+    }
+    jsize size = (*env)->GetArrayLength(env, input);
+    jbyte *data = (*env)->GetByteArrayElements(env, input, NULL);
+    if ((data == NULL) && (size != 0)) {
+        return NULL;
+    }
+    size_t capacity = ((size_t)size / 11U + 2U) * 15U;
+    uint8_t *records = (uint8_t *)malloc(capacity);
+    if (records == NULL) {
+        if (data != NULL) {
+            (*env)->ReleaseByteArrayElements(env, input, data, JNI_ABORT);
+        }
+        return NULL;
+    }
+    size_t used = 0U;
+    pcan_abi_frame_t frame;
+    for (jsize i = 0; i < size; ++i) {
+        if (pcan_abi_parser_push(parser->storage, (uint8_t)data[i], &frame) > 0) {
+            uint8_t *record = &records[used];
+            record[0] = frame.sequence;
+            record[1] = frame.flags;
+            record[2] = (uint8_t)frame.can_id;
+            record[3] = (uint8_t)(frame.can_id >> 8);
+            record[4] = (uint8_t)(frame.can_id >> 16);
+            record[5] = (uint8_t)(frame.can_id >> 24);
+            record[6] = frame.dlc;
+            memset(&record[7], 0, 8U);
+            memcpy(&record[7], frame.data, frame.dlc);
+            used += 15U;
+            if (parser->last_sequence >= 0) {
+                parser->sequence_lost += (uint8_t)(
+                    frame.sequence - (uint8_t)parser->last_sequence - 1U);
+            }
+            parser->last_sequence = frame.sequence;
+        }
+    }
+    if (data != NULL) {
+        (*env)->ReleaseByteArrayElements(env, input, data, JNI_ABORT);
+    }
+    jbyteArray result = (*env)->NewByteArray(env, (jsize)used);
+    if (result != NULL && used != 0U) {
+        (*env)->SetByteArrayRegion(env, result, 0, (jsize)used,
+                                  (const jbyte *)records);
+    }
+    free(records);
+    return result;
+}
+
+JNIEXPORT jintArray JNICALL
+Java_ru_setcorp_setcore_NativeProtoCan_nativeParserStats(
+    JNIEnv *env, jobject self, jlong handle)
+{
+    (void)self;
+    android_parser_t *parser = (android_parser_t *)(intptr_t)handle;
+    if (parser == NULL) {
+        return NULL;
+    }
+    uint32_t frames = 0U, crc = 0U, bad_len = 0U, stray = 0U;
+    pcan_abi_parser_stats(parser->storage, &frames, &crc, &bad_len, &stray);
+    jint values[5] = { (jint)frames, (jint)crc, (jint)bad_len,
+                       (jint)stray, (jint)parser->sequence_lost };
+    jintArray result = (*env)->NewIntArray(env, 5);
+    if (result != NULL) {
+        (*env)->SetIntArrayRegion(env, result, 0, 5, values);
+    }
+    return result;
+}

c/protocan-transport/src/pcan_abi.c

@@ -0,0 +1,136 @@
+#include "pcan_abi.h"
+
+#include <string.h>
+
+#include "pcan_crc.h"
+#include "pcan_frame.h"
+#include "pcan_id.h"
+
+uint32_t pcan_abi_version(void)
+{
+    return PCAN_ABI_VERSION;
+}
+
+uint32_t pcan_abi_id_pack(uint8_t priority, uint8_t route,
+                          uint8_t device_type, uint8_t device_id,
+                          uint8_t message_type, uint16_t body)
+{
+    pcan_id_t id;
+    id.msg_body = body;
+    id.msg_type = message_type;
+    id.device_id = device_id;
+    id.device_type = device_type;
+    id.route = route;
+    id.priority = priority;
+    return pcan_id_pack(&id);
+}
+
+void pcan_abi_id_unpack(uint32_t raw, uint8_t *priority, uint8_t *route,
+                        uint8_t *device_type, uint8_t *device_id,
+                        uint8_t *message_type, uint16_t *body)
+{
+    pcan_id_t id;
+    pcan_id_unpack(raw, &id);
+    if (priority != NULL) {
+        *priority = id.priority;
+    }
+    if (route != NULL) {
+        *route = id.route;
+    }
+    if (device_type != NULL) {
+        *device_type = id.device_type;
+    }
+    if (device_id != NULL) {
+        *device_id = id.device_id;
+    }
+    if (message_type != NULL) {
+        *message_type = id.msg_type;
+    }
+    if (body != NULL) {
+        *body = id.msg_body;
+    }
+}
+
+uint16_t pcan_abi_crc16(const uint8_t *data, size_t size)
+{
+    if ((data == NULL) && (size != 0U)) {
+        return 0U;
+    }
+    return pcan_crc16(data, size);
+}
+
+size_t pcan_abi_frame_encode(uint8_t sequence, uint8_t flags,
+                             uint32_t can_id, const uint8_t *data, uint8_t dlc,
+                             uint8_t *output, size_t output_size)
+{
+    pcan_frame_t frame;
+    if ((output == NULL) || (dlc > PCAN_DATA_MAX) ||
+        ((data == NULL) && (dlc != 0U))) {
+        return 0U;
+    }
+    memset(&frame, 0, sizeof frame);
+    frame.seq = sequence;
+    frame.flags = flags;
+    frame.id = can_id;
+    frame.dlc = dlc;
+    if (dlc != 0U) {
+        memcpy(frame.data, data, dlc);
+    }
+    return pcan_frame_encode(&frame, output, output_size);
+}
+
+size_t pcan_abi_parser_size(void)
+{
+    return sizeof(pcan_parser_t);
+}
+
+int pcan_abi_parser_init(void *parser_storage, size_t storage_size)
+{
+    if ((parser_storage == NULL) || (storage_size < sizeof(pcan_parser_t))) {
+        return 0;
+    }
+    pcan_parser_init((pcan_parser_t *)parser_storage);
+    return 1;
+}
+
+int pcan_abi_parser_push(void *parser_storage, uint8_t byte,
+                         pcan_abi_frame_t *output)
+{
+    pcan_frame_t frame;
+    if ((parser_storage == NULL) || (output == NULL)) {
+        return -1;
+    }
+    if (!pcan_parser_push((pcan_parser_t *)parser_storage, byte, &frame)) {
+        return 0;
+    }
+    output->can_id = frame.id;
+    output->sequence = frame.seq;
+    output->flags = frame.flags;
+    output->dlc = frame.dlc;
+    memset(output->data, 0, sizeof output->data);
+    memcpy(output->data, frame.data, frame.dlc);
+    return 1;
+}
+
+int pcan_abi_parser_stats(const void *parser_storage, uint32_t *frames,
+                          uint32_t *crc_errors, uint32_t *bad_length,
+                          uint32_t *stray_bytes)
+{
+    const pcan_parser_t *parser = (const pcan_parser_t *)parser_storage;
+    if (parser == NULL) {
+        return 0;
+    }
+    if (frames != NULL) {
+        *frames = parser->stats.frames;
+    }
+    if (crc_errors != NULL) {
+        *crc_errors = parser->stats.crc_errors;
+    }
+    if (bad_length != NULL) {
+        *bad_length = parser->stats.bad_len;
+    }
+    if (stray_bytes != NULL) {
+        *stray_bytes = parser->stats.stray_bytes;
+    }
+    return 1;
+}

c/protocan-transport/tests/test_abi.c

@@ -0,0 +1,43 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "pcan_abi.h"
+
+int main(void)
+{
+    uint32_t raw = pcan_abi_id_pack(1U, 0U, 7U, 14U, 3U, 0x1234U);
+    if (raw != 0x17E31234UL) {
+        return 1;
+    }
+
+    uint8_t data[] = { 0xAAU, 0xBBU };
+    uint8_t encoded[32];
+    size_t encoded_size = pcan_abi_frame_encode(
+        1U, 0x05U, raw, data, 2U, encoded, sizeof encoded);
+    if (encoded_size == 0U) {
+        return 2;
+    }
+
+    size_t parser_size = pcan_abi_parser_size();
+    void *parser = malloc(parser_size);
+    if ((parser == NULL) || !pcan_abi_parser_init(parser, parser_size)) {
+        free(parser);
+        return 3;
+    }
+
+    pcan_abi_frame_t frame;
+    memset(&frame, 0, sizeof frame);
+    int found = 0;
+    for (size_t i = 0U; i < encoded_size; ++i) {
+        found += pcan_abi_parser_push(parser, encoded[i], &frame) > 0;
+    }
+    free(parser);
+
+    if ((found != 1) || (frame.can_id != raw) || (frame.dlc != 2U) ||
+        (frame.data[0] != 0xAAU) || (frame.data[1] != 0xBBU)) {
+        return 4;
+    }
+    puts("ABI tests passed");
+    return 0;
+}

c/protocan-transport/tools/build_host.py

@@ -0,0 +1,88 @@
+"""Build the SETCore shared library without imposing one host toolchain.
+
+CMake remains the primary build.  On a Windows workstation where CMake is
+absent, the script locates Visual Studio and invokes MSVC directly.  Unix-like
+hosts fall back to the system C compiler.
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import platform
+import shutil
+import subprocess
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parent.parent
+INCLUDE = ROOT / "include"
+SOURCES = [
+    ROOT / "src" / name for name in (
+        "pcan_abi.c", "pcan_crc.c", "pcan_frame.c", "pcan_id.c",
+        "pcan_link.c", "pcan_ring.c", "pcan_gas.c",
+    )
+]
+
+
+def _visual_studio_vcvars() -> Path | None:
+    installer = Path(os.environ.get("ProgramFiles(x86)", r"C:\Program Files (x86)"))
+    vswhere = installer / "Microsoft Visual Studio" / "Installer" / "vswhere.exe"
+    if vswhere.exists():
+        result = subprocess.run(
+            [str(vswhere), "-latest", "-products", "*",
+             "-requires", "Microsoft.VisualStudio.Component.VC.Tools.x86.x64",
+             "-property", "installationPath"],
+            text=True, capture_output=True, check=False,
+        )
+        if result.returncode == 0 and result.stdout.strip():
+            candidate = (Path(result.stdout.strip()) / "VC" / "Auxiliary" /
+                         "Build" / "vcvars64.bat")
+            if candidate.exists():
+                return candidate
+    return None
+
+
+def _build_msvc(output: Path, build_dir: Path) -> None:
+    vcvars = _visual_studio_vcvars()
+    if vcvars is None:
+        raise SystemExit("Visual Studio C++ tools were not found")
+    quoted_sources = " ".join(f'"{source}"' for source in SOURCES)
+    command = (
+        f'call "{vcvars}" && cl /nologo /W4 /std:c11 '
+        f'/DPCAN_ABI_BUILD_DLL /I"{INCLUDE}" /LD {quoted_sources} '
+        f'/Fe"{output}"'
+    )
+    # shell=True is intentional on Windows: ``call`` must run the batch file
+    # in the same cmd.exe process that subsequently launches cl.exe.
+    subprocess.run(command, cwd=build_dir, check=True, shell=True)
+
+
+def _build_cc(output: Path, build_dir: Path) -> None:
+    compiler = shutil.which("cc") or shutil.which("clang") or shutil.which("gcc")
+    if compiler is None:
+        raise SystemExit("C compiler was not found")
+    command = [compiler, "-std=c99", "-Wall", "-Wextra", "-Wpedantic",
+               "-fPIC", "-shared", f"-I{INCLUDE}", *map(str, SOURCES),
+               "-o", str(output)]
+    subprocess.run(command, cwd=build_dir, check=True)
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--output", type=Path, required=True)
+    args = parser.parse_args()
+    output = args.output.resolve()
+    output.parent.mkdir(parents=True, exist_ok=True)
+    build_dir = output.parent / ".setcore-build"
+    build_dir.mkdir(parents=True, exist_ok=True)
+    if platform.system() == "Windows":
+        _build_msvc(output, build_dir)
+    else:
+        _build_cc(output, build_dir)
+    print(output)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

c/rs485-boot/CMakeLists.txt

@@ -0,0 +1,9 @@
+cmake_minimum_required(VERSION 3.16)
+project(rs485_boot C)
+add_library(rs485_boot src/rs485_boot.c)
+target_include_directories(rs485_boot PUBLIC include)
+if(BUILD_TESTING)
+  add_executable(test_rs485_boot tests/test_rs485_boot.c)
+  target_link_libraries(test_rs485_boot PRIVATE rs485_boot)
+  add_test(NAME rs485_boot COMMAND test_rs485_boot)
+endif()

c/rs485-boot/README.md

@@ -0,0 +1,26 @@
+# RS-485 firmware boot
+
+Переносимое ядро обновления прошивки по полудуплексному RS-485. Wire-протокол
+совместим с SETGUI protocol v1 проекта `KONOR_ds18b20`: кадры `A5 5A`, CRC32,
+команды `FIRMWARE_BEGIN/DATA/END/ABORT/STATUS` (`0x0B..0x0F`).
+
+Ядро не обращается к регистрам МК. Проект передаёт ему принятые байты через
+`rs485_boot_feed()` и реализует callbacks Flash/передачи из `rs485_boot_port_t`.
+Готовые порты находятся в `ports/stm32f103`, `ports/stm32g474vet`,
+`ports/tms320f2812` и `ports/tms320f28335`. TI-порты используют общее ядро
+`ports/c28x` для ABI C28x с 16-битным `char` и умеют зеркалировать Flash в RAM.
+
+Важно: линии A/B должны иметь терминацию и fail-safe bias. Порт держит DE
+активным до флага физического завершения передачи TC, затем возвращается в RX.
+
+## Подключение
+
+1. Добавить `src/rs485_boot.c` и порт нужного МК в проект.
+2. Скопировать `rs485_boot_port_config.template.h` в include-каталог проекта как
+   `rs485_boot_port_config.h` и проверить UART, DE, адрес приложения и Flash.
+3. Вызвать `rs485_boot_hw_init()`, затем `rs485_boot_init()` с callbacks из
+   `rs485_boot_hw_make_port()`.
+4. В основном цикле читать `rs485_boot_hw_get_byte()` и передавать байты ядру.
+
+Порт STM32F103 рассчитан на стандартную периферию STM32F10x. Порт G474VET
+использует CMSIS STM32G4 (`stm32g474xx.h`) и 64-битное программирование Flash.

c/rs485-boot/include/rs485_boot.h

@@ -0,0 +1,73 @@
+#ifndef RS485_BOOT_H
+#define RS485_BOOT_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define RS485_BOOT_VERSION          1U
+#define RS485_BOOT_MAX_PAYLOAD      512U
+#define RS485_BOOT_MAX_FRAME        (8U + RS485_BOOT_MAX_PAYLOAD + 4U)
+#define RS485_BOOT_DATA_HEADER_SIZE 8U
+#define RS485_BOOT_MAX_BLOCK        (RS485_BOOT_MAX_PAYLOAD - RS485_BOOT_DATA_HEADER_SIZE)
+
+typedef enum {
+    RS485_BOOT_IDLE = 0U,
+    RS485_BOOT_RECEIVING = 1U,
+    RS485_BOOT_READY = 2U,
+    RS485_BOOT_FAILED = 3U
+} rs485_boot_state_t;
+
+typedef enum {
+    RS485_BOOT_OK = 0U,
+    RS485_BOOT_INVALID_ARGUMENT = 1U,
+    RS485_BOOT_INVALID_LENGTH = 2U,
+    RS485_BOOT_BUSY = 5U,
+    RS485_BOOT_INTERNAL = 7U,
+    RS485_BOOT_UNSUPPORTED = 0x11U
+} rs485_boot_result_t;
+
+typedef struct {
+    uint32_t app_address;
+    uint32_t app_size;
+    uint16_t max_block_size;
+} rs485_boot_config_t;
+
+typedef struct {
+    bool (*transmit)(void *user, const uint8_t *data, uint16_t length);
+    bool (*erase)(void *user, uint32_t image_size);
+    bool (*write)(void *user, uint32_t offset, const uint8_t *data, uint16_t length);
+    bool (*read)(void *user, uint32_t offset, uint8_t *data, uint16_t length);
+    bool (*image_valid)(void *user, uint32_t image_size, uint32_t image_crc32);
+    void (*reboot)(void *user);
+} rs485_boot_port_t;
+
+typedef struct {
+    rs485_boot_config_t config;
+    rs485_boot_port_t port;
+    void *port_user;
+    uint8_t parser[RS485_BOOT_MAX_FRAME];
+    uint16_t parser_length;
+    uint8_t tx[RS485_BOOT_MAX_FRAME];
+    uint8_t scratch[32];
+    uint32_t image_size;
+    uint32_t image_crc32;
+    uint32_t next_offset;
+    uint32_t crc_errors;
+    rs485_boot_state_t state;
+} rs485_boot_t;
+
+bool rs485_boot_init(rs485_boot_t *boot, const rs485_boot_config_t *config,
+                     const rs485_boot_port_t *port, void *port_user);
+void rs485_boot_feed(rs485_boot_t *boot, const uint8_t *data, size_t length);
+void rs485_boot_abort(rs485_boot_t *boot);
+uint32_t rs485_boot_crc32(const uint8_t *data, size_t length);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

c/rs485-boot/ports/c28x/rs_boot_transport.c

@@ -0,0 +1,130 @@
+#include "rs_boot_transport.h"
+
+#define SOF0 0xA5U
+#define SOF1 0x5AU
+#define VERSION 1U
+#define HEADER 8U
+#define CRC_SIZE 4U
+#define MSG_BEGIN 0x0BU
+#define MSG_DATA 0x0CU
+#define MSG_END 0x0DU
+#define MSG_ABORT 0x0EU
+#define MSG_STATUS 0x0FU
+#define MSG_NACK 0x80U
+
+static rsbt_u16_t u16(const rsbt_byte_t *p)
+{ return (p[0] & 0xFFU) | ((p[1] & 0xFFU) << 8); }
+
+static rsbt_u32_t u32(const rsbt_byte_t *p)
+{
+    return (rsbt_u32_t)(p[0] & 0xFFU) |
+           ((rsbt_u32_t)(p[1] & 0xFFU) << 8) |
+           ((rsbt_u32_t)(p[2] & 0xFFU) << 16) |
+           ((rsbt_u32_t)(p[3] & 0xFFU) << 24);
+}
+
+static void put32(rsbt_byte_t *p, rsbt_u32_t v)
+{
+    p[0] = (rsbt_byte_t)(v & 0xFFU); p[1] = (rsbt_byte_t)((v >> 8) & 0xFFU);
+    p[2] = (rsbt_byte_t)((v >> 16) & 0xFFU); p[3] = (rsbt_byte_t)((v >> 24) & 0xFFU);
+}
+
+rsbt_u32_t rsbt_crc32(const rsbt_byte_t *p, rsbt_u16_t n)
+{
+    rsbt_u32_t crc = 0xFFFFFFFFUL;
+    rsbt_u16_t i, bit;
+    for (i = 0U; i < n; ++i) {
+        crc ^= (rsbt_u32_t)(p[i] & 0xFFU);
+        for (bit = 0U; bit < 8U; ++bit)
+            crc = (crc >> 1) ^ ((crc & 1U) ? 0xEDB88320UL : 0U);
+    }
+    return crc ^ 0xFFFFFFFFUL;
+}
+
+void rsbt_abort(rsbt_t *b)
+{
+    if (!b) return;
+    b->state = RSBT_IDLE; b->image_size = 0UL; b->flags = 0U;
+    b->image_crc = 0UL; b->next_offset = 0UL;
+}
+
+int rsbt_init(rsbt_t *b, const rsbt_config_t *c, const rsbt_port_t *p, void *u)
+{
+    rsbt_u16_t i;
+    if (!b || !c || !p || !c->app_size || !p->transmit || !p->erase || !p->write || !p->read) return 0;
+    for (i = 0U; i < RSBT_MAX_FRAME; ++i) { b->parser[i] = 0U; b->tx[i] = 0U; }
+    b->config = *c; b->port = *p; b->user = u; b->parser_length = 0U; b->crc_errors = 0UL;
+    if (!b->config.max_block || b->config.max_block > RSBT_MAX_BLOCK) b->config.max_block = RSBT_MAX_BLOCK;
+    rsbt_abort(b); return 1;
+}
+
+static int send_frame(rsbt_t *b, rsbt_byte_t type, rsbt_u16_t seq,
+                      const rsbt_byte_t *payload, rsbt_u16_t size)
+{
+    rsbt_u16_t i, total; rsbt_u32_t crc;
+    if (size > RSBT_MAX_PAYLOAD) return 0;
+    total = HEADER + size + CRC_SIZE;
+    b->tx[0]=SOF0; b->tx[1]=SOF1; b->tx[2]=VERSION; b->tx[3]=type;
+    b->tx[4]=(seq>>8)&0xFFU; b->tx[5]=seq&0xFFU;
+    b->tx[6]=(size>>8)&0xFFU; b->tx[7]=size&0xFFU;
+    for(i=0U;i<size;++i) b->tx[HEADER+i]=payload[i]&0xFFU;
+    crc=rsbt_crc32(&b->tx[2],6U+size); put32(&b->tx[HEADER+size],crc);
+    return b->port.transmit(b->user,b->tx,total);
+}
+
+static void nack(rsbt_t *b, rsbt_byte_t req, rsbt_u16_t seq, rsbt_u16_t result)
+{
+    rsbt_byte_t p[3]; p[0]=result&0xFFU; p[1]=(result>>8)&0xFFU; p[2]=req;
+    (void)send_frame(b,MSG_NACK,seq,p,3U);
+}
+
+static int matches(rsbt_t *b, rsbt_u32_t off, const rsbt_byte_t *p, rsbt_u16_t n)
+{
+    rsbt_u16_t done=0U,i,take;
+    while(done<n){take=n-done;if(take>32U)take=32U;
+        if(!b->port.read(b->user,off+done,b->scratch,take))return 0;
+        for(i=0U;i<take;++i)if((b->scratch[i]&0xFFU)!=(p[done+i]&0xFFU))return 0;
+        done+=take;} return 1;
+}
+
+static void process(rsbt_t *b, rsbt_byte_t type, rsbt_u16_t seq,
+                    const rsbt_byte_t *p, rsbt_u16_t size)
+{
+    rsbt_u32_t off,base; rsbt_u16_t n,sum,i;
+    if(type==MSG_BEGIN){if(size!=16U){nack(b,type,seq,2U);return;}
+        b->image_size=u32(p);b->image_crc=u32(&p[4]);b->flags=p[8]&RSBT_FLAG_MIRROR_RAM;base=u32(&p[12]);
+        if((b->flags&RSBT_FLAG_MIRROR_RAM)&&!b->port.write_ram){nack(b,type,seq,0x11U);return;}
+        if(!b->image_size||b->image_size>b->config.app_size||(base&&base!=b->config.app_address)){nack(b,type,seq,1U);return;}
+        b->next_offset=0UL;b->state=RSBT_RECEIVING;
+        if(!b->port.erase(b->user,b->image_size)){b->state=RSBT_FAILED;nack(b,type,seq,7U);return;}
+        put32(b->scratch,0UL);(void)send_frame(b,type,seq,b->scratch,4U);return;}
+    if(type==MSG_DATA){if(b->state!=RSBT_RECEIVING||size<8U){nack(b,type,seq,5U);return;}
+        off=u32(p);n=u16(&p[4]);sum=0U;for(i=0U;i<n&&8U+i<size;++i)sum=(sum+(p[8U+i]&0xFFU))&0xFFFFU;
+        if(!n||n>b->config.max_block||size!=8U+n||off>b->image_size||n>b->image_size-off){nack(b,type,seq,2U);return;}
+        if(sum!=u16(&p[6])){nack(b,type,seq,1U);return;}
+        if(off<b->next_offset){if(off+n>b->next_offset||!matches(b,off,&p[8],n)){nack(b,type,seq,1U);return;}}
+        else {if(off!=b->next_offset||!b->port.write(b->user,off,&p[8],n)||
+            ((b->flags&RSBT_FLAG_MIRROR_RAM)&&!b->port.write_ram(b->user,off,&p[8],n))){b->state=RSBT_FAILED;nack(b,type,seq,7U);return;}b->next_offset+=n;}
+        put32(b->scratch,b->next_offset);(void)send_frame(b,type,seq,b->scratch,4U);return;}
+    if(type==MSG_END){if(b->state!=RSBT_RECEIVING||size!=8U||u32(p)!=b->image_size||u32(&p[4])!=b->image_crc||b->next_offset!=b->image_size||(b->port.image_valid&&!b->port.image_valid(b->user,b->image_size,b->image_crc))){b->state=RSBT_FAILED;nack(b,type,seq,1U);return;}
+        b->state=RSBT_READY;(void)send_frame(b,type,seq,0,0U);if(b->port.reboot)b->port.reboot(b->user);return;}
+    if(type==MSG_ABORT){rsbt_abort(b);(void)send_frame(b,type,seq,0,0U);return;}
+    if(type==MSG_STATUS){b->scratch[0]=b->state;put32(&b->scratch[1],b->next_offset);b->scratch[5]=b->flags;(void)send_frame(b,type,seq,b->scratch,6U);return;}
+    nack(b,type,seq,0x11U);
+}
+
+static void discard(rsbt_t *b, rsbt_u16_t n)
+{ rsbt_u16_t i;if(n>=b->parser_length){b->parser_length=0U;return;}for(i=n;i<b->parser_length;++i)b->parser[i-n]=b->parser[i];b->parser_length-=n; }
+
+void rsbt_feed(rsbt_t *b, rsbt_byte_t byte)
+{
+    rsbt_u16_t payload,total,seq; rsbt_u32_t got;
+    if(!b)return;if(b->parser_length==RSBT_MAX_FRAME)b->parser_length=0U;
+    b->parser[b->parser_length++]=byte&0xFFU;
+    for(;;){while(b->parser_length>=2U&&(b->parser[0]!=SOF0||b->parser[1]!=SOF1))discard(b,1U);
+        if(b->parser_length<HEADER)return;if(b->parser[2]!=VERSION){discard(b,1U);continue;}
+        payload=((b->parser[6]&0xFFU)<<8)|(b->parser[7]&0xFFU);if(payload>RSBT_MAX_PAYLOAD){discard(b,1U);continue;}
+        total=HEADER+payload+CRC_SIZE;if(b->parser_length<total)return;got=u32(&b->parser[HEADER+payload]);
+        if(got!=rsbt_crc32(&b->parser[2],6U+payload)){++b->crc_errors;discard(b,1U);continue;}
+        seq=((b->parser[4]&0xFFU)<<8)|(b->parser[5]&0xFFU);process(b,b->parser[3],seq,&b->parser[HEADER],payload);discard(b,total);}
+}

c/rs485-boot/ports/c28x/rs_boot_transport.h

@@ -0,0 +1,62 @@
+#ifndef RS_BOOT_TRANSPORT_H
+#define RS_BOOT_TRANSPORT_H
+
+/*
+ * ProtoCAN RS boot transport for TI C28x.
+ * A C28x char is 16 bits, therefore every wire byte is stored in the low
+ * eight bits of rsbt_byte_t.  Never use sizeof() as a wire-byte count.
+ */
+typedef unsigned int  rsbt_byte_t;
+typedef unsigned int  rsbt_u16_t;
+typedef unsigned long rsbt_u32_t;
+
+#define RSBT_MAX_PAYLOAD 512U
+#define RSBT_MAX_FRAME   (8U + RSBT_MAX_PAYLOAD + 4U)
+#define RSBT_MAX_BLOCK   (RSBT_MAX_PAYLOAD - 8U)
+#define RSBT_FLAG_MIRROR_RAM 0x01U
+
+typedef enum {
+    RSBT_IDLE = 0U,
+    RSBT_RECEIVING = 1U,
+    RSBT_READY = 2U,
+    RSBT_FAILED = 3U
+} rsbt_state_t;
+
+typedef struct {
+    int (*transmit)(void *, const rsbt_byte_t *, rsbt_u16_t);
+    int (*erase)(void *, rsbt_u32_t);
+    int (*write)(void *, rsbt_u32_t, const rsbt_byte_t *, rsbt_u16_t);
+    int (*read)(void *, rsbt_u32_t, rsbt_byte_t *, rsbt_u16_t);
+    int (*write_ram)(void *, rsbt_u32_t, const rsbt_byte_t *, rsbt_u16_t);
+    int (*image_valid)(void *, rsbt_u32_t, rsbt_u32_t);
+    void (*reboot)(void *);
+} rsbt_port_t;
+
+typedef struct {
+    rsbt_u32_t app_address;
+    rsbt_u32_t app_size;
+    rsbt_u16_t max_block;
+} rsbt_config_t;
+
+typedef struct {
+    rsbt_config_t config;
+    rsbt_port_t port;
+    void *user;
+    rsbt_byte_t parser[RSBT_MAX_FRAME];
+    rsbt_byte_t tx[RSBT_MAX_FRAME];
+    rsbt_byte_t scratch[32];
+    rsbt_u16_t parser_length;
+    rsbt_u32_t image_size;
+    rsbt_u32_t image_crc;
+    rsbt_u32_t next_offset;
+    rsbt_u32_t crc_errors;
+    rsbt_byte_t flags;
+    rsbt_state_t state;
+} rsbt_t;
+
+int rsbt_init(rsbt_t *, const rsbt_config_t *, const rsbt_port_t *, void *);
+void rsbt_feed(rsbt_t *, rsbt_byte_t);
+void rsbt_abort(rsbt_t *);
+rsbt_u32_t rsbt_crc32(const rsbt_byte_t *, rsbt_u16_t);
+
+#endif

c/rs485-boot/ports/stm32f103/rs485_boot_port_config.template.h

@@ -0,0 +1,8 @@
+#ifndef RS485_BOOT_PORT_CONFIG_H
+#define RS485_BOOT_PORT_CONFIG_H
+#define RS485_BOOT_BAUDRATE 512000UL
+#define RS485_BOOT_APP_ADDRESS 0x08003000UL
+#define RS485_BOOT_FLASH_END 0x08010000UL
+#define RS485_BOOT_FLASH_PAGE 1024UL
+#define RS485_BOOT_DE_PIN 8U /* USART1 PA9/PA10; DE PA8, active high. */
+#endif