Merge remote-tracking branch 'origin/codex/trend-display-scale' into HEAD

Share PM67 upload protocol through C core
Добавить множитель и IQ в Python-тренды
2026-09-05 11:43:08 +03:00 · 2026-09-05 11:37:03 +03:00 · 2026-09-05 03:45:05 +03:00 · 2026-09-05 03:16:16 +03:00 · 2026-09-05 03:05:17 +03:00 · 2026-09-05 02:44:08 +03:00
234 changed files with 48852 additions and 522 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -2,6 +2,7 @@
 build/
 cmake-build-*/
 *.o
+*.obj
 *.d
 *.a
 *.elf
@@ -22,3 +23,4 @@ __pycache__/
 *.uvguix.*
 Thumbs.db
 Desktop.ini
+.codex-build/
--- a/NEW_PROJECT.md
+++ b/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/`.
--- a/README.md
+++ b/README.md
@@ -13,8 +13,15 @@
 templates/
  c/        библиотеки на C99: заголовок, реализация, README, где есть — порт и тесты
  python/   модули на чистом Python 3.9+, только stdlib
+  tools/    общие инструменты сборки и выпуска прошивок
 ```

+Пошаговая раскладка нового проекта и выбор портов для STM32F103, STM32G431
+и STM32G474 описаны в [`NEW_PROJECT.md`](NEW_PROJECT.md).
+
+Нормативная документация SETCAN/ProtoCAN, реестр общего адресного пространства
+и исходный Excel собраны в [`doc/setcan`](doc/setcan/README.md).
+
 ## Что лежит

 ### C
@@ -25,20 +32,39 @@ templates/
 | [`c/keypad`](c/keypad) | шесть кнопок: антидребезг, автоповтор, удержание, очередь событий | `stdint.h` | чтение уровня кнопки, время в мс |
 | [`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/can-sensor`](c/can-sensor) | однокадровые SETCAN SETTINGS для 64-битных ROM | ядро: `stdint.h`; порт F1: CMSIS | callbacks либо готовый bxCAN STM32F1 |
+| [`c/ds18b20`](c/ds18b20) | термометры DS18B20 поверх программной 1-Wire | `stdint.h` | Init, DelayUs, Reset, WriteBit, ReadBit — **порты STM32F103, STM32G431 и STM32G474 в комплекте** |
+| [`c/set-protocol`](c/set-protocol) | единое ядро SETProtocol: SET v2, совместимые ProtoCAN/GUI v1, GAS, телеметрия, firmware flow и стабильный host ABI | C99 | COM/SLCAN/SocketCAN/USB/Ethernet или callbacks — **Windows, Android и STM32F4-порты в комплекте** |
+| [`c/set-protocol/ports/stm32-bxcan`](c/set-protocol/ports/stm32-bxcan) | порт прикладного ProtoCAN для STM32, бывший SETCAN; сохранён API `PROTOCAN_*` | STM32 HAL CAN/RTC/TIM + общее ядро `pcan_id` | classic bxCAN; настройки платы предоставляет прошивка |
+| [`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/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 |
+| [`c/parallel-nand`](c/parallel-nand) | parallel NAND x8: raw main/OOB, bad-block marker и банковое окно GAS для SETGUI | C99, опционально `set-protocol/pcan_gas` | **порты TMS320F2812, STM32F407VE и STM32G474CEU6 в комплекте** |

 ### Python

 | Модуль | Что делает | Зависимости |
 |---|---|---|
 | [`python/protocan`](python/protocan) | разбор ProtoCAN, транспортный кадр моста, кадр SETGUI, кодеки каталога | stdlib, Python 3.9+ |
+| [`python/protocan/trends.py`](python/protocan/trends.py) | общие настройки графиков, ограниченная история, ctypes-декодер GAS/raw CAN | stdlib, опционально SETProtocol DLL/SO |

-Кодировщики `c/protocan-transport` и `python/protocan` дают побайтово
+### Инструменты
+
+| Инструмент | Что делает |
+|---|---|
+| [`tools/firmware-publish`](tools/firmware-publish) | единый BAT и конфигурации для проверки и публикации `.hex` Keil / `.bin` CCS 12 в каталоге SETGUI |
+
+Общие тренды для Android GUI и SETGUI: [формат JSON, C99-ядро и адаптеры](c/set-protocol/docs/GUI_TRENDS.md).
+Общие масштабирование и маркеры: [C99, JNI и Python/Qt](c/set-protocol/docs/GUI_PLOT.md).
+
+Кодировщики `c/set-protocol` и `python/protocan` дают побайтово
 одинаковый результат — это зафиксировано эталонами в тестах на C.

+Интерактивная документация общего ядра: [`doc/setprotocol.html`](doc/setprotocol.html).
+В ней отдельно описаны граница ядра, ABI, память, три wire format и состояние
+портов Windows, Android, Linux и MCU.
+
 ## Как подключить к проекту

 **Сабмодуль** — когда нужна одна конкретная версия и обновление по команде:
@@ -69,17 +95,18 @@ 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 |
+| `CAN_to_RS485` | set-protocol legacy transport, python/protocan |
+| `candleLight_fw` | эталон разделения общей логики и G431/G474 FDCAN-порта; общий ProtoCAN Boot переносится по контракту `protocan-boot` |
 | `SETGUI` | python/protocan |
+| `SETGUI`, Android GUI и новые устройства SET | set-protocol |
 | `k1921vk028` | rtc-service |

 ## Что сюда не попало и почему

 | Код | Почему не переносится | Что можно вытащить |
 |---|---|---|
-| `SETCAN/Src/protocan.c` | 59 вызовов `HAL_*`, привязка к `CAN_HandleTypeDef`, `RTC_HandleTypeDef`, `NVIC_SystemReset()` | разбиение длинных посылок на кадры и проверка даты — чистая логика, нужны два интерфейса: «отправить кадр» и «часы». Раскладка идентификатора уже вынесена в `pcan_id` |
 | `1921vk028/drivers/user/src/one_wire_user.c` | аппаратный 1-Wire `OWI_*` из `plib028`, мигание светодиодом прямо внутри опроса датчика | логика DS18B20 уже есть в `c/ds18b20` — переносится порт, а не алгоритм |
 | `1921vk028/drivers/GPIO`, `uart`, `optical`, `Interrupt` | целиком на регистрах `plib028` | переносить стоит не код, а приём: таблица описаний портов вместо `#define`, разбросанных по файлу |
 | `Drivers/` внутри прошивок | вендорный HAL и CMSIS | ничего, приходит со своим SDK |
--- a/RULES.md
+++ b/RULES.md
@@ -0,0 +1,80 @@
+# Правила общего кроссплатформенного кода
+
+Этот репозиторий — единственный источник общих алгоритмов для `GUI_Android`,
+`SETGUI`, прошивок и будущих GUI. Копирование одной реализации между Kotlin,
+Python, C# или другим языком запрещено.
+
+## 1. Граница C-ядра и порта
+
+В `c/set-protocol` на C99 обязательно размещаются:
+
+- форматы кадров и идентификаторов, CRC/checksum, endian-преобразования;
+- построение команд, разбор и проверка ответов;
+- автоматы обмена, сегментация, повтор, таймаутные состояния без системных часов;
+- общие вычисления, таблицы и каталоги, влияющие на поведение протокола;
+- проверка образов прошивки и других бинарных форматов.
+
+Порт на языке GUI содержит только:
+
+- вызовы C через стабильный ABI (`ctypes`, JNI, P/Invoke, Swift FFI и т. п.);
+- преобразование C-структур в модели языка без повторения алгоритма;
+- работу с USB, COM, Bluetooth, SocketCAN и API операционной системы;
+- жизненный цикл, потоки, разрешения, хранение настроек и UI;
+- локализованный текст и чисто визуальные преобразования.
+
+Порт не вычисляет CRC, не собирает wire-пакет и не разбирает его поля заново.
+Если для функции C-ядро недоступно, приложение сообщает об ошибке сборки или
+загрузки. Алгоритмический fallback на языке GUI запрещён: он снова создаёт две
+версии протокола.
+
+## 2. Разделение контроллеров
+
+Профили контроллеров нельзя сливать по совпадению названия транспорта:
+
+- **ПМ67 / TMS320F2812** — основной контроллер, собственные RS и CAN;
+- **ПМ35 / TMS320F28335 periph** — отдельный контроллер и отдельный CAN для
+  настроечного терминала, а также собственный прямой RS232/485-протокол.
+
+Выбор профиля выполняется в GUI, но выбранный профиль вызывает свой отдельный
+модуль C-ядра. Наличие одной CAN-линии не даёт права удалить или подменить
+другую.
+
+## 3. Порядок изменения протокола
+
+1. Добавить или изменить публичный заголовок и реализацию в
+   `c/set-protocol/include` и `c/set-protocol/src`.
+2. Зафиксировать эталонные байты и ошибочные случаи в C-тесте.
+3. При необходимости расширить `pcan_abi.h`, сохраняя бинарную совместимость.
+4. Добавить тонкие порты в `ports/<platform>` и `python/`; в них не должно быть
+   второго кодека.
+5. Одними и теми же векторами проверить C, Python и Android/JVM.
+6. Собрать SETGUI и Android с одним commit submodule `templates`.
+
+Изменение только в одном GUI считается незавершённым. Сначала меняется
+`templates`, затем оба потребителя обновляют ссылку submodule на проверенный
+commit.
+
+## 4. Требования к C-ядру
+
+- C99, без зависимости от GUI и конкретной ОС.
+- Буферы и их размеры передаются явно; владение памятью остаётся у вызывающего.
+- Для MCU основная логика не требует heap, исключений или файловой системы.
+- Endian и размеры целых задаются через `stdint.h`, структуры wire-формата не
+  передаются через ABI без явного стабильного представления.
+- Экспорт shared library идёт через `PCAN_ABI_API`; существующие символы не
+  меняют смысл и сигнатуру.
+- Ошибки возвращаются детерминированным кодом и тестируются наряду с успехом.
+
+## 5. Проверка на ревью
+
+Изменение нельзя принимать, если ответ «да» хотя бы на один вопрос:
+
+- появился одинаковый CRC/parser/builder в двух языках;
+- UI знает byte offset, endian или служебный байт wire-протокола;
+- Python и Kotlin содержат одинаковую таблицу команд, влияющую на обмен;
+- добавлен тихий fallback, поведение которого отличается от C;
+- обновлён один GUI без обновления и теста `templates`;
+- ПМ67 и ПМ35 сведены к одному соединению или одному состоянию контроллера.
+
+Текущее состояние и очередь переноса перечислены в
+[`doc/CROSS_PLATFORM_AUDIT.md`](doc/CROSS_PLATFORM_AUDIT.md).
--- a/c/can-sensor/CMakeLists.txt
+++ b/c/can-sensor/CMakeLists.txt
@@ -0,0 +1,22 @@
+cmake_minimum_required(VERSION 3.13)
+project(can_sensor C)
+
+set(CMAKE_C_STANDARD 99)
+set(CMAKE_C_STANDARD_REQUIRED ON)
+
+add_library(can_sensor STATIC can_sensor.c)
+target_include_directories(can_sensor PUBLIC .)
+
+if(MSVC)
+    target_compile_options(can_sensor PRIVATE /W4)
+else()
+    target_compile_options(can_sensor PRIVATE -Wall -Wextra -Wpedantic)
+endif()
+
+option(CAN_SENSOR_BUILD_TESTS "Собирать тесты транспорта CAN sensor" ON)
+if(CAN_SENSOR_BUILD_TESTS)
+    enable_testing()
+    add_executable(test_can_sensor tests/test_can_sensor.c)
+    target_link_libraries(test_can_sensor PRIVATE can_sensor)
+    add_test(NAME can_sensor COMMAND test_can_sensor)
+endif()
--- a/c/can-sensor/README.md
+++ b/c/can-sensor/README.md
@@ -1,27 +1,28 @@
 # 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, планировщик PULSE, повторы передачи, счётчики обмена | `stdint.h` |
+| `ports/stm32f1/` | опросный порт CAN1: GPIO, BTR, фильтр, mailbox/FIFO, тайм-аут ACK | CMSIS `stm32f10x.h` |

-Приём собирает сообщение сам: кадр ROM без преамбулы и кадр с неверной
-длиной отбрасываются и учитываются в `dropped_frames`.
+`ZZ` — номер сборки, `YY` — позиция. Нулевой ROM с DLC=8 очищает локацию.

 ## Что нужно от платформы

@@ -38,15 +39,45 @@ 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 */
+config.pulse_period_ms = 1000U;        /* 0 — PULSE выключен */

 CanSensor_Init(&link, &io, &config);
-CanSensor_SendId(&link, position, rom);
+CanSensor_SendId(&link, position, assembly_serial, rom);
+CanSensor_Task(&link, now_ms);

 CanSensor_Message message;
 if (CanSensor_Poll(&link, &message)) { /* принят идентификатор */ }
 ```

+Период можно менять во время работы через `CanSensor_SetPulsePeriod()`. Значение
+`0` именно выключает heartbeat: кадры PULSE больше не ставятся в очередь. При
+повторном включении первый кадр отправляется через полный заданный период.
+
+## Порт STM32F1
+
+Порт не использует STM32 HAL и не занимает прерывания. Скопируйте
+`ports/stm32f1/can_sensor_stm32f1_config.f103.template.h` в приложение под
+именем `can_sensor_stm32f1_config.h`, добавьте `ports/stm32f1` в include path и
+соберите `can_sensor_stm32f1.c` вместе с ядром:
+
+```c
+CanSensorStm32F1_Port bxcan = {0};
+CanSensor_Io io;
+
+CanSensorStm32F1_Start(&bxcan, 500000U, 0x17F00000UL, 0x1FF00000UL, 0U);
+io = CanSensorStm32F1_MakeIo(&bxcan);
+CanSensor_Init(&link, &io, &config);
+
+/* Из главного цикла: */
+CanSensorStm32F1_Task(&bxcan, now_ms, 20U);
+```
+
+Фильтр порта принимает только Extended data-кадры. Маска задаётся приложением:
+можно пропустить только SETTINGS либо оставить открытым `MsgType` для соседних
+команд того же узла. `CanSensorStm32F1_Receive()` доступна отдельно, если перед
+`CanSensor_HandleFrame()` приложению нужно разобрать такие команды самому.
+
 ## Проверено в проектах

 `KONOR_ds18b20` — bxCAN на STM32F103C8T6. Естественная пара — [`ds18b20`](../ds18b20):
--- a/c/can-sensor/can_sensor.c
+++ b/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,18 @@ 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->pulse_period_ms = 0U;
+    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,131 +60,133 @@ 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;
    link->dropped_frames = 0U;
+    link->pulse_last_ms = 0U;
+    link->pulse_counter = 0U;
+    link->pulse_armed = 0U;
    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;
 }
@@ -244,3 +205,51 @@ uint8_t CanSensor_Poll(CanSensor *link, CanSensor_Message *out)
    }
    return 0U;
 }
+
+void CanSensor_SetPulsePeriod(CanSensor *link, uint32_t period_ms)
+{
+    if (link == 0) {
+        return;
+    }
+    if (link->config.pulse_period_ms != period_ms) {
+        link->config.pulse_period_ms = period_ms;
+        /* После включения или смены периода отсчитываем полный новый период. */
+        link->pulse_armed = 0U;
+    }
+}
+
+uint32_t CanSensor_PulsePeriod(const CanSensor *link)
+{
+    return (link != 0) ? link->config.pulse_period_ms : 0U;
+}
+
+void CanSensor_Task(CanSensor *link, uint32_t now_ms)
+{
+    CanSensor_Frame frame;
+    const uint32_t period_ms = (link != 0) ? link->config.pulse_period_ms : 0U;
+
+    if ((link == 0) || (link->io.send == 0) || (period_ms == 0U)) {
+        return;
+    }
+    if (link->pulse_armed == 0U) {
+        link->pulse_last_ms = now_ms;
+        link->pulse_armed = 1U;
+        return;
+    }
+    if ((now_ms - link->pulse_last_ms) < period_ms) {
+        return;
+    }
+
+    frame.id = (link->config.tx_id & CAN_SENSOR_ADDRESS_MASK)
+               | ((uint32_t)CAN_SENSOR_MSGTYPE_PULSE << 16U);
+    frame.extended = 1U;
+    frame.length = 1U;
+    link->pulse_counter++;
+    frame.data[0] = link->pulse_counter;
+    if (can_sensor_send_frame(link, &frame) != 0U) {
+        link->pulse_last_ms = now_ms;
+    } else {
+        /* Счётчик меняется только для реально поставленных в очередь кадров. */
+        link->pulse_counter--;
+    }
+}
--- a/c/can-sensor/can_sensor.h
+++ b/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,126 @@

 #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
+#define CAN_SENSOR_MSGTYPE_PULSE    0xFU

-/** Предельная длина поля данных классического кадра CAN. */
-#define CAN_SENSOR_MAX_DATA       8U
+/** Маска полей SETCAN от Priority до MsgType; Body под маской не находится. */
+#define CAN_SENSOR_HEADER_MASK      0x1FFF0000UL
+#define CAN_SENSOR_ADDRESS_MASK     0x1FF00000UL
+#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;  /**< Число попыток передачи. */
+    uint32_t pulse_period_ms; /**< Период PULSE; 0 полностью отключает PULSE. */
 } 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;
+    uint32_t pulse_last_ms;
+    uint8_t pulse_counter;
+    uint8_t pulse_armed;
 } 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);

+/**
+ * @brief Меняет период PULSE во время работы.
+ *
+ * @param period_ms Период в миллисекундах; 0 выключает PULSE.
+ */
+void CanSensor_SetPulsePeriod(CanSensor *link, uint32_t period_ms);
+
+/** Возвращает действующий период PULSE; 0 означает «выключено». */
+uint32_t CanSensor_PulsePeriod(const CanSensor *link);
+
+/** Вызывает планировщик PULSE из главного цикла. */
+void CanSensor_Task(CanSensor *link, uint32_t now_ms);
+
 #endif /* CAN_SENSOR_H */
--- a/c/can-sensor/ports/stm32f1/can_sensor_stm32f1.c
+++ b/c/can-sensor/ports/stm32f1/can_sensor_stm32f1.c
@@ -0,0 +1,330 @@
+/**
+ * @file can_sensor_stm32f1.c
+ * @brief Опросный порт can-sensor на bxCAN STM32F1 без STM32 HAL.
+ */
+
+#include "can_sensor_stm32f1.h"
+
+#include "can_sensor_stm32f1_config.h"
+
+#if !defined(CAN_SENSOR_STM32F1_GPIO) \
+    || !defined(CAN_SENSOR_STM32F1_GPIO_CLOCK) \
+    || !defined(CAN_SENSOR_STM32F1_RX_PIN) \
+    || !defined(CAN_SENSOR_STM32F1_TX_PIN)
+#error "can_sensor_stm32f1_config.h должен задать GPIO, GPIO_CLOCK, RX_PIN и TX_PIN"
+#endif
+
+#define CAN_STM32F1_TQ_MAX 18U
+#define CAN_STM32F1_TQ_MIN 8U
+#define CAN_STM32F1_TIMEOUT_CYCLES 1000000U
+#define CAN_STM32F1_TSR_ALL_EMPTY (CAN_TSR_TME0 | CAN_TSR_TME1 | CAN_TSR_TME2)
+#define CAN_STM32F1_TSR_ALL_ABORT (CAN_TSR_ABRQ0 | CAN_TSR_ABRQ1 | CAN_TSR_ABRQ2)
+#define CAN_STM32F1_TSR_ANY_TXOK  (CAN_TSR_TXOK0 | CAN_TSR_TXOK1 | CAN_TSR_TXOK2)
+#define CAN_STM32F1_TSR_DONE_FLAGS                                             \
+    (CAN_TSR_RQCP0 | CAN_TSR_TXOK0 | CAN_TSR_ALST0 | CAN_TSR_TERR0            \
+     | CAN_TSR_RQCP1 | CAN_TSR_TXOK1 | CAN_TSR_ALST1 | CAN_TSR_TERR1          \
+     | CAN_TSR_RQCP2 | CAN_TSR_TXOK2 | CAN_TSR_ALST2 | CAN_TSR_TERR2)
+
+static uint32_t can_stm32f1_pclk1(void)
+{
+    static const uint8_t shift[8] = { 0U, 0U, 0U, 0U, 1U, 2U, 3U, 4U };
+    const uint32_t bits = (RCC->CFGR & RCC_CFGR_PPRE1) >> 8U;
+
+    return SystemCoreClock >> shift[bits & 0x7U];
+}
+
+static void can_stm32f1_configure_pin(GPIO_TypeDef *gpio, uint8_t pin,
+                                      uint32_t mode)
+{
+    uint32_t config;
+    uint32_t shift;
+
+    if (pin < 8U) {
+        shift = (uint32_t)pin * 4U;
+        config = gpio->CRL;
+        config = (config & ~(0xFUL << shift)) | (mode << shift);
+        gpio->CRL = config;
+    } else {
+        shift = ((uint32_t)pin - 8U) * 4U;
+        config = gpio->CRH;
+        config = (config & ~(0xFUL << shift)) | (mode << shift);
+        gpio->CRH = config;
+    }
+}
+
+static void can_stm32f1_configure_pins(void)
+{
+    RCC->APB2ENR |= CAN_SENSOR_STM32F1_GPIO_CLOCK | RCC_APB2ENR_AFIOEN;
+    /* RX: input pull-up; TX: alternate function push-pull, 50 MHz. */
+    can_stm32f1_configure_pin(CAN_SENSOR_STM32F1_GPIO,
+                              CAN_SENSOR_STM32F1_RX_PIN, 0x8UL);
+    can_stm32f1_configure_pin(CAN_SENSOR_STM32F1_GPIO,
+                              CAN_SENSOR_STM32F1_TX_PIN, 0xBUL);
+    CAN_SENSOR_STM32F1_GPIO->BSRR =
+        (uint32_t)(1UL << CAN_SENSOR_STM32F1_RX_PIN);
+}
+
+static uint8_t can_stm32f1_calc_timing(uint32_t bitrate, uint32_t *btr,
+                                       CanSensorStm32F1_Timing *timing)
+{
+    const uint32_t pclk = can_stm32f1_pclk1();
+    uint32_t total;
+    uint32_t tq;
+
+    if ((bitrate == 0U) || (btr == 0) || (pclk == 0U)
+        || ((pclk % bitrate) != 0U)) {
+        return 0U;
+    }
+    total = pclk / bitrate;
+    for (tq = CAN_STM32F1_TQ_MAX; tq >= CAN_STM32F1_TQ_MIN; tq--) {
+        const uint32_t prescaler = total / tq;
+
+        if (((total % tq) == 0U) && (prescaler >= 1U)
+            && (prescaler <= 1024U)) {
+            const uint32_t ts2 = tq / 5U;
+            const uint32_t ts1 = tq - 1U - ts2;
+
+            *btr = ((ts2 - 1U) << 20U) | ((ts1 - 1U) << 16U)
+                   | (prescaler - 1U);
+            if (timing != 0) {
+                timing->pclk_hz = pclk;
+                timing->prescaler = (uint16_t)prescaler;
+                timing->ts1 = (uint8_t)ts1;
+                timing->ts2 = (uint8_t)ts2;
+                timing->bitrate = pclk / (prescaler * tq);
+                timing->sample_point =
+                    (uint8_t)(((1U + ts1) * 100U) / tq);
+            }
+            return 1U;
+        }
+    }
+    return 0U;
+}
+
+uint8_t CanSensorStm32F1_CalcTiming(uint32_t bitrate,
+                                    CanSensorStm32F1_Timing *timing)
+{
+    uint32_t btr;
+
+    return can_stm32f1_calc_timing(bitrate, &btr, timing);
+}
+
+static void can_stm32f1_configure_filter(uint32_t id, uint32_t mask)
+{
+    const uint32_t filter_id = ((id & mask) << 3U) | CAN_RI0R_IDE;
+    const uint32_t filter_mask =
+        (mask << 3U) | CAN_RI0R_IDE | CAN_RI0R_RTR;
+
+    CAN1->FMR |= CAN_FMR_FINIT;
+    CAN1->FA1R &= ~1UL;
+    CAN1->FS1R |= 1UL;
+    CAN1->FM1R &= ~1UL;
+    CAN1->sFilterRegister[0].FR1 = filter_id;
+    CAN1->sFilterRegister[0].FR2 = filter_mask;
+    CAN1->FFA1R &= ~1UL;
+    CAN1->FA1R |= 1UL;
+    CAN1->FMR &= ~CAN_FMR_FINIT;
+}
+
+static void can_stm32f1_load_mailbox(uint32_t mailbox,
+                                     const CanSensor_Frame *frame)
+{
+    uint32_t identifier;
+    uint8_t index;
+
+    if (frame->extended != 0U) {
+        identifier = ((frame->id & 0x1FFFFFFFUL) << 3U) | CAN_TI0R_IDE;
+    } else {
+        identifier = (frame->id & 0x7FFUL) << 21U;
+    }
+    CAN1->sTxMailBox[mailbox].TDTR = (uint32_t)(frame->length & 0x0FU);
+    CAN1->sTxMailBox[mailbox].TDLR = 0U;
+    CAN1->sTxMailBox[mailbox].TDHR = 0U;
+    for (index = 0U; index < frame->length; index++) {
+        if (index < 4U) {
+            CAN1->sTxMailBox[mailbox].TDLR |=
+                (uint32_t)frame->data[index] << (index * 8U);
+        } else {
+            CAN1->sTxMailBox[mailbox].TDHR |=
+                (uint32_t)frame->data[index] << ((index - 4U) * 8U);
+        }
+    }
+    CAN1->sTxMailBox[mailbox].TIR = identifier | CAN_TI0R_TXRQ;
+}
+
+uint8_t CanSensorStm32F1_Start(CanSensorStm32F1_Port *port,
+                               uint32_t bitrate, uint32_t filter_id,
+                               uint32_t filter_mask, uint8_t loopback)
+{
+    uint32_t btr;
+    uint32_t guard;
+    uint32_t mode_bits;
+
+    if ((port == 0) || (filter_id > 0x1FFFFFFFUL)
+        || (filter_mask > 0x1FFFFFFFUL)
+        || (can_stm32f1_calc_timing(bitrate, &btr, &port->timing) == 0U)) {
+        return 0U;
+    }
+    CanSensorStm32F1_Stop(port);
+    can_stm32f1_configure_pins();
+    RCC->APB1ENR |= RCC_APB1ENR_CAN1EN;
+
+    CAN1->MCR &= ~CAN_MCR_SLEEP;
+    CAN1->MCR |= CAN_MCR_INRQ;
+    for (guard = 0U; guard < CAN_STM32F1_TIMEOUT_CYCLES; guard++) {
+        if ((CAN1->MSR & CAN_MSR_INAK) != 0U) {
+            break;
+        }
+    }
+    if ((CAN1->MSR & CAN_MSR_INAK) == 0U) {
+        return 0U;
+    }
+
+    mode_bits = (loopback != 0U) ? (CAN_BTR_LBKM | CAN_BTR_SILM) : 0U;
+    CAN1->MCR = CAN_MCR_INRQ | CAN_MCR_ABOM | CAN_MCR_TXFP;
+    CAN1->BTR = btr | mode_bits;
+    can_stm32f1_configure_filter(filter_id, filter_mask);
+    CAN1->MCR &= ~CAN_MCR_INRQ;
+    for (guard = 0U; guard < CAN_STM32F1_TIMEOUT_CYCLES; guard++) {
+        if ((CAN1->MSR & CAN_MSR_INAK) == 0U) {
+            break;
+        }
+    }
+    if ((CAN1->MSR & CAN_MSR_INAK) != 0U) {
+        return 0U;
+    }
+
+    port->bitrate = bitrate;
+    port->loopback = (uint8_t)(loopback != 0U);
+    port->no_transceiver = 0U;
+    port->tx_waiting = 0U;
+    port->ready = 1U;
+    return 1U;
+}
+
+void CanSensorStm32F1_Stop(CanSensorStm32F1_Port *port)
+{
+    if (port == 0) {
+        return;
+    }
+    RCC->APB1ENR |= RCC_APB1ENR_CAN1EN;
+    RCC->APB1RSTR |= RCC_APB1RSTR_CAN1RST;
+    RCC->APB1RSTR &= ~RCC_APB1RSTR_CAN1RST;
+    port->ready = 0U;
+    port->bitrate = 0U;
+    port->loopback = 0U;
+    port->no_transceiver = 0U;
+    port->tx_waiting = 0U;
+}
+
+uint8_t CanSensorStm32F1_Send(void *context, const CanSensor_Frame *frame)
+{
+    CanSensorStm32F1_Port *port = (CanSensorStm32F1_Port *)context;
+    uint32_t mailbox;
+
+    if ((port == 0) || (frame == 0) || (port->ready == 0U)
+        || (frame->length > CAN_SENSOR_MAX_DATA)) {
+        return 0U;
+    }
+    if ((CAN1->TSR & CAN_TSR_TME0) != 0U) {
+        mailbox = 0U;
+    } else if ((CAN1->TSR & CAN_TSR_TME1) != 0U) {
+        mailbox = 1U;
+    } else if ((CAN1->TSR & CAN_TSR_TME2) != 0U) {
+        mailbox = 2U;
+    } else {
+        return 0U;
+    }
+    can_stm32f1_load_mailbox(mailbox, frame);
+    return 1U;
+}
+
+uint8_t CanSensorStm32F1_Receive(void *context, CanSensor_Frame *frame)
+{
+    CanSensorStm32F1_Port *port = (CanSensorStm32F1_Port *)context;
+    uint32_t identifier;
+    uint32_t low;
+    uint32_t high;
+    uint8_t index;
+
+    if ((port == 0) || (frame == 0) || (port->ready == 0U)
+        || ((CAN1->RF0R & CAN_RF0R_FMP0) == 0U)) {
+        return 0U;
+    }
+    identifier = CAN1->sFIFOMailBox[0].RIR;
+    if ((identifier & CAN_RI0R_IDE) != 0U) {
+        frame->extended = 1U;
+        frame->id = (identifier >> 3U) & 0x1FFFFFFFUL;
+    } else {
+        frame->extended = 0U;
+        frame->id = (identifier >> 21U) & 0x7FFUL;
+    }
+    frame->length = (uint8_t)(CAN1->sFIFOMailBox[0].RDTR & 0x0FU);
+    if (frame->length > CAN_SENSOR_MAX_DATA) {
+        frame->length = CAN_SENSOR_MAX_DATA;
+    }
+    low = CAN1->sFIFOMailBox[0].RDLR;
+    high = CAN1->sFIFOMailBox[0].RDHR;
+    for (index = 0U; index < CAN_SENSOR_MAX_DATA; index++) {
+        if (index < 4U) {
+            frame->data[index] =
+                (uint8_t)((low >> (index * 8U)) & 0xFFU);
+        } else {
+            frame->data[index] =
+                (uint8_t)((high >> ((index - 4U) * 8U)) & 0xFFU);
+        }
+    }
+    CAN1->RF0R |= CAN_RF0R_RFOM0;
+    return 1U;
+}
+
+CanSensor_Io CanSensorStm32F1_MakeIo(CanSensorStm32F1_Port *port)
+{
+    CanSensor_Io io;
+
+    io.send = CanSensorStm32F1_Send;
+    io.receive = CanSensorStm32F1_Receive;
+    io.context = port;
+    return io;
+}
+
+void CanSensorStm32F1_Task(CanSensorStm32F1_Port *port, uint32_t now_ms,
+                           uint32_t timeout_ms)
+{
+    uint32_t status;
+
+    if ((port == 0) || (port->ready == 0U)) {
+        return;
+    }
+    status = CAN1->TSR;
+    if ((status & CAN_STM32F1_TSR_ALL_EMPTY) == CAN_STM32F1_TSR_ALL_EMPTY) {
+        if ((status & CAN_STM32F1_TSR_ANY_TXOK) != 0U) {
+            port->no_transceiver = 0U;
+        }
+        CAN1->TSR = status & CAN_STM32F1_TSR_DONE_FLAGS;
+        port->tx_waiting = 0U;
+        return;
+    }
+    if ((timeout_ms == 0U) || (port->tx_waiting == 0U)) {
+        port->tx_waiting = (uint8_t)(timeout_ms != 0U);
+        port->tx_started_ms = now_ms;
+        return;
+    }
+    if ((now_ms - port->tx_started_ms) < timeout_ms) {
+        return;
+    }
+    CAN1->TSR = CAN_STM32F1_TSR_ALL_ABORT;
+    CAN1->TSR = CAN_STM32F1_TSR_DONE_FLAGS;
+    port->tx_waiting = 0U;
+    port->tx_timeouts++;
+    port->no_transceiver = 1U;
+}
+
+uint8_t CanSensorStm32F1_BusError(const CanSensorStm32F1_Port *port)
+{
+    if ((port == 0) || (port->ready == 0U)) {
+        return 0U;
+    }
+    return (uint8_t)(((CAN1->ESR & (CAN_ESR_BOFF | CAN_ESR_EPVF)) != 0U)
+                     ? 1U : 0U);
+}
--- a/c/can-sensor/ports/stm32f1/can_sensor_stm32f1.h
+++ b/c/can-sensor/ports/stm32f1/can_sensor_stm32f1.h
@@ -0,0 +1,77 @@
+/**
+ * @file can_sensor_stm32f1.h
+ * @brief Опросный порт can-sensor на bxCAN микроконтроллеров STM32F1.
+ */
+
+#ifndef CAN_SENSOR_STM32F1_H
+#define CAN_SENSOR_STM32F1_H
+
+#include <stdint.h>
+
+#include "can_sensor.h"
+
+/** Разрядность бита, записанная портом в регистр BTR. */
+typedef struct {
+    uint32_t pclk_hz;
+    uint32_t bitrate;
+    uint16_t prescaler;
+    uint8_t ts1;
+    uint8_t ts2;
+    uint8_t sample_point;
+} CanSensorStm32F1_Timing;
+
+/** Состояние одного контроллера bxCAN. Поля доступны только для диагностики. */
+typedef struct {
+    uint32_t bitrate;
+    uint32_t tx_timeouts;
+    uint32_t tx_started_ms;
+    CanSensorStm32F1_Timing timing;
+    uint8_t ready;
+    uint8_t loopback;
+    uint8_t no_transceiver;
+    uint8_t tx_waiting;
+} CanSensorStm32F1_Port;
+
+/**
+ * @brief Проверяет достижимость скорости и рассчитывает поля BTR.
+ * @param bitrate Требуемая скорость, бит/с.
+ * @param timing Приёмник результата либо 0.
+ * @return 1, если скорость получается из текущей частоты APB1 без ошибки.
+ */
+uint8_t CanSensorStm32F1_CalcTiming(uint32_t bitrate,
+                                    CanSensorStm32F1_Timing *timing);
+
+/**
+ * @brief Запускает CAN1, настраивает выводы и один 32-битный фильтр FIFO 0.
+ *
+ * Фильтр сравнивает Extended ID по формуле `(id & filter_mask) ==
+ * (filter_id & filter_mask)` и отбрасывает Standard и Remote кадры.
+ */
+uint8_t CanSensorStm32F1_Start(CanSensorStm32F1_Port *port,
+                               uint32_t bitrate, uint32_t filter_id,
+                               uint32_t filter_mask, uint8_t loopback);
+
+/** Останавливает CAN1 программным сбросом. */
+void CanSensorStm32F1_Stop(CanSensorStm32F1_Port *port);
+
+/** Помещает data-кадр в свободный mailbox. Совместима с CanSensor_Io.send. */
+uint8_t CanSensorStm32F1_Send(void *context, const CanSensor_Frame *frame);
+
+/** Забирает один data-кадр из FIFO 0. Совместима с CanSensor_Io.receive. */
+uint8_t CanSensorStm32F1_Receive(void *context, CanSensor_Frame *frame);
+
+/** Собирает таблицу callback-функций для CanSensor_Init(). */
+CanSensor_Io CanSensorStm32F1_MakeIo(CanSensorStm32F1_Port *port);
+
+/**
+ * @brief Обслуживает завершение и тайм-аут передачи без прерываний.
+ * @param now_ms Монотонное время приложения, мс.
+ * @param timeout_ms Предел ожидания ACK; 0 отключает принудительную отмену.
+ */
+void CanSensorStm32F1_Task(CanSensorStm32F1_Port *port, uint32_t now_ms,
+                           uint32_t timeout_ms);
+
+/** Возвращает 1 при bus-off или error-passive. */
+uint8_t CanSensorStm32F1_BusError(const CanSensorStm32F1_Port *port);
+
+#endif /* CAN_SENSOR_STM32F1_H */
--- a/c/can-sensor/ports/stm32f1/can_sensor_stm32f1_config.f103.template.h
+++ b/c/can-sensor/ports/stm32f1/can_sensor_stm32f1_config.f103.template.h
@@ -0,0 +1,19 @@
+/**
+ * @file can_sensor_stm32f1_config.f103.template.h
+ * @brief Шаблон выводов CAN1 для STM32F103 без ремапа.
+ *
+ * Скопируйте файл в include-каталог приложения под именем
+ * can_sensor_stm32f1_config.h. Скорость и фильтр задаются при запуске порта.
+ */
+
+#ifndef CAN_SENSOR_STM32F1_CONFIG_H
+#define CAN_SENSOR_STM32F1_CONFIG_H
+
+#include "stm32f10x.h"
+
+#define CAN_SENSOR_STM32F1_GPIO       GPIOA
+#define CAN_SENSOR_STM32F1_GPIO_CLOCK RCC_APB2ENR_IOPAEN
+#define CAN_SENSOR_STM32F1_RX_PIN     11U
+#define CAN_SENSOR_STM32F1_TX_PIN     12U
+
+#endif /* CAN_SENSOR_STM32F1_CONFIG_H */
--- a/c/can-sensor/tests/test_can_sensor.c
+++ b/c/can-sensor/tests/test_can_sensor.c
@@ -0,0 +1,79 @@
+#include "can_sensor.h"
+
+#include <stdio.h>
+
+typedef struct {
+    CanSensor_Frame last_frame;
+    uint32_t send_count;
+    uint8_t accept;
+} FakeCan;
+
+static uint8_t fake_send(void *context, const CanSensor_Frame *frame)
+{
+    FakeCan *fake = (FakeCan *)context;
+
+    fake->send_count++;
+    fake->last_frame = *frame;
+    return fake->accept;
+}
+
+#define CHECK(condition)                                                        \
+    do {                                                                        \
+        if (!(condition)) {                                                      \
+            fprintf(stderr, "check failed at line %d: %s\n", __LINE__,         \
+                    #condition);                                                \
+            return 1;                                                           \
+        }                                                                       \
+    } while (0)
+
+int main(void)
+{
+    CanSensor link;
+    CanSensor_Config config;
+    CanSensor_Io io;
+    FakeCan fake = {0};
+
+    fake.accept = 1U;
+    io.send = fake_send;
+    io.receive = 0;
+    io.context = &fake;
+    CanSensor_ConfigDefault(&config);
+
+    CHECK(config.pulse_period_ms == 0U);
+    CHECK(CanSensor_Init(&link, &io, &config) != 0U);
+
+    /* Нулевой период означает выключенный PULSE при любых метках времени. */
+    CanSensor_Task(&link, 0U);
+    CanSensor_Task(&link, 0xFFFFFFFFUL);
+    CHECK(fake.send_count == 0U);
+
+    CanSensor_SetPulsePeriod(&link, 1000U);
+    CHECK(CanSensor_PulsePeriod(&link) == 1000U);
+    CanSensor_Task(&link, 500U);
+    CanSensor_Task(&link, 1499U);
+    CHECK(fake.send_count == 0U);
+    CanSensor_Task(&link, 1500U);
+    CHECK(fake.send_count == 1U);
+    CHECK(fake.last_frame.id == 0x1FFF0000UL);
+    CHECK(fake.last_frame.extended == 1U);
+    CHECK(fake.last_frame.length == 1U);
+    CHECK(fake.last_frame.data[0] == 1U);
+
+    /* После period=0 дальнейшие вызовы не отправляют heartbeat. */
+    CanSensor_SetPulsePeriod(&link, 0U);
+    CHECK(CanSensor_PulsePeriod(&link) == 0U);
+    CanSensor_Task(&link, 0xFFFFFFFFUL);
+    CHECK(fake.send_count == 1U);
+
+    /* Повторное включение начинает новый полный период. */
+    CanSensor_SetPulsePeriod(&link, 10U);
+    CanSensor_Task(&link, 2000U);
+    CanSensor_Task(&link, 2009U);
+    CHECK(fake.send_count == 1U);
+    CanSensor_Task(&link, 2010U);
+    CHECK(fake.send_count == 2U);
+    CHECK(fake.last_frame.data[0] == 2U);
+
+    puts("can_sensor pulse tests passed");
+    return 0;
+}
--- a/c/ds18b20/README.md
+++ b/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
--- a/c/ds18b20/include/onewire.h
+++ b/c/ds18b20/include/onewire.h
@@ -13,7 +13,7 @@
 *                   и OneWire_ReadBit.
 *
 * Чтобы перенести библиотеку на другой микроконтроллер, достаточно написать
- * эти пять функций - остальное собирается как есть.
+ * эти пять функций - остальное собирается как есть. ТЕСТ
 */

 #ifndef ONEWIRE_H
--- a/c/ds18b20/ports/stm32f1/onewire_config.f103.template.h
+++ b/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 и положите на
 * путь поиска заголовков. Библиотека сама этот файл не подставляет:
--- a/c/ds18b20/ports/stm32f1/onewire_stm32f1.c
+++ b/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"
--- a/c/ds18b20/ports/stm32f4/onewire_config.f407.template.h
+++ b/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 */
--- a/c/ds18b20/ports/stm32f4/onewire_stm32f4.c
+++ b/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;
+}
--- a/c/ds18b20/ports/stm32g4/onewire_config.g431.template.h
+++ b/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 */
--- a/c/ds18b20/ports/stm32g4/onewire_config.g474.template.h
+++ b/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 */
--- a/c/ds18b20/ports/stm32g4/onewire_stm32g4.c
+++ b/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;
+}
--- a/c/firmware-info/CMakeLists.txt
+++ b/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)
--- a/c/firmware-info/PORTING.md
+++ b/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-байтов в каждом логическом слове.
--- a/c/firmware-info/README.md
+++ b/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` без изменений.
--- a/c/firmware-info/include/firmware_info.h
+++ b/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
--- a/c/firmware-info/include/firmware_info_port.h
+++ b/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
--- a/c/firmware-info/ports/k1921vk028/firmware_info_config.template.h
+++ b/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
--- a/c/firmware-info/ports/stm32f1/firmware_info_config.template.h
+++ b/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
--- a/c/firmware-info/ports/stm32f4/firmware_info_config.template.h
+++ b/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
--- a/c/firmware-info/ports/stm32g4/firmware_info_config.template.h
+++ b/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
--- a/c/firmware-info/src/firmware_info.c
+++ b/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;
+}
--- a/c/firmware-info/src/firmware_info_port.c
+++ b/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);
+}
--- a/c/firmware-info/tests/test_firmware_info.c
+++ b/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;
+}
--- a/c/firmware-info/tools/make_build_id.ps1
+++ b/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"
--- a/c/parallel-nand/CMakeLists.txt
+++ b/c/parallel-nand/CMakeLists.txt
@@ -0,0 +1,26 @@
+cmake_minimum_required(VERSION 3.16)
+project(parallel_nand C)
+
+set(CMAKE_C_STANDARD 99)
+set(CMAKE_C_STANDARD_REQUIRED ON)
+
+add_library(parallel_nand
+    src/parallel_nand.c
+    src/parallel_nand_gas.c
+)
+target_include_directories(parallel_nand PUBLIC
+    include
+)
+
+add_library(parallel_nand_pcan_gas src/parallel_nand_pcan_gas.c)
+target_include_directories(parallel_nand_pcan_gas PUBLIC
+    include
+    ../set-protocol/include
+)
+target_link_libraries(parallel_nand_pcan_gas PUBLIC parallel_nand)
+
+add_executable(test_parallel_nand tests/test_parallel_nand.c)
+target_link_libraries(test_parallel_nand PRIVATE parallel_nand)
+
+enable_testing()
+add_test(NAME parallel_nand_core COMMAND test_parallel_nand)
--- a/c/parallel-nand/README.md
+++ b/c/parallel-nand/README.md
@@ -0,0 +1,88 @@
+# parallel-nand
+
+Переносимый C99-драйвер асинхронной parallel NAND x8 и окно управления через
+общее адресное пространство GAS. Первый профиль — Micron `MT29F1G08ABADA`:
+2048+64 байта, 64 страницы в блоке, 1024 блока.
+
+Подготовлены аппаратные порты:
+
+- `TMS320F2812` — XINTF Zone 6;
+- `STM32F407VET6` — аппаратный FSMC NAND Bank 2;
+- `STM32G474CEU6` — GPIO bit-bang для корпуса UFQFPN-48.
+
+Ядро не зависит от HAL и транспорта GUI. STM32 HAL используется только в
+конкретных портах. `parallel_nand_gas` реализует переносимую 16-битную карту
+GAS и компилируется в том числе TI C28x, где `char` имеет 16 бит.
+
+## Подключение
+
+В проект добавить:
+
+```text
+c/parallel-nand/src/parallel_nand.c
+c/parallel-nand/src/parallel_nand_gas.c
+```
+
+Пути заголовков:
+
+```text
+c/parallel-nand/include
+c/parallel-nand/ports/<нужный-порт>
+```
+
+И один аппаратный порт, например:
+
+```text
+c/parallel-nand/ports/stm32g474ce/parallel_nand_port_stm32g474ce.c
+```
+
+Минимальная инициализация:
+
+```c
+static parallel_nand_t nand;
+static parallel_nand_gas_t nand_gas;
+
+void memory_init(void)
+{
+    int rc = parallel_nand_init(&nand,
+        parallel_nand_port_stm32g474ce(),
+        &parallel_nand_mt29f1g08_geometry);
+    if (rc != PNAND_OK) {
+        /* Оставить диагностику доступной GUI и сообщить ошибку платы. */
+    }
+
+    parallel_nand_gas_init(&nand_gas, &nand, PNAND_GAS_DEFAULT_BASE);
+}
+```
+
+Диспетчер общего адресного пространства вызывает
+`parallel_nand_gas_read()`/`parallel_nand_gas_write()` для адресов
+`0xE000..0xE51F`. Для STM32 с `c/set-protocol/pcan_gas` дополнительно включить
+`src/parallel_nand_pcan_gas.c`, создать `pcan_gas_region_t` и вызвать
+`parallel_nand_pcan_gas_region_init()`. Этот адаптер намеренно не нужен TMS.
+Для полного дампа предпочтительны пакетные `READ_REGISTERS/WRITE_REGISTERS`,
+а classic CAN GAS оставлен для совместимости и коротких диагностических чтений.
+
+Доступ GUI и алгоритм полного дампа описаны в
+[docs/MEMORY_GAS.md](docs/MEMORY_GAS.md). Электрические соединения — в README
+соответствующего порта и [docs/EMPTY_BOARD_PINOUT.md](docs/EMPTY_BOARD_PINOUT.md).
+
+## Текущие границы
+
+- Реализовано безопасное чтение, RESET, READ ID, STATUS и bad-block marker.
+- PROGRAM/ERASE намеренно отсутствуют; ядро включает аппаратную защиту `WP#`.
+- ECC пока не исправляет данные. GUI получает физические main/OOB и должен
+  помечать дамп как raw.
+- В полном дампе bad-блоки не пропускаются: сохраняется физический порядок.
+- Для другой NAND нужно передать другую `parallel_nand_geometry_t` и проверить
+  команды/маркер по её datasheet.
+
+## Проверка первого запуска
+
+1. Запустить `parallel_nand_init()`.
+2. Через GAS проверить `0xE000 = 0x4E44`.
+3. Записать `2` в `0xE004` (`READ_ID`).
+4. Проверить `0xE00B = 0x002C`, `0xE00C = 0x00F1`.
+5. Записать номер страницы в `0xE005/0xE006`, затем `3` в `0xE004`.
+6. Дождаться `READY | PAGE_VALID` в `0xE002`.
+7. Прочитать main из `0xE100..0xE4FF`, OOB из `0xE500..0xE51F`.
--- a/c/parallel-nand/docs/EMPTY_BOARD_PINOUT.md
+++ b/c/parallel-nand/docs/EMPTY_BOARD_PINOUT.md
@@ -0,0 +1,81 @@
+# Подключение parallel NAND на пустой плате
+
+Документ рассчитан на асинхронную NAND x8 `MT29F1G08ABADA` 3,3 В в корпусе
+TSOP-48 (суффикс `WP`). На второй фотографии NAND — длинная микросхема справа
+с маркировкой `29F1G08ABADA`. Микросхема Micron `D9MDK` сверху — DDR2 SDRAM,
+не NAND. На первой фотографии `AM29LV800BT` — parallel NOR, а не NAND.
+
+Уточнение по ёмкости с фотографий:
+
+- `K6R4008V1D` — SRAM 4 Mbit (512 KiB), не Flash;
+- `AM29LV800BT` — parallel NOR 8 Mbit (1 MiB);
+- `MT29F1G08ABADA` — parallel NAND 1 Gbit, то есть 128 MiB main area.
+
+Поэтому текущий NAND-профиль рассчитан на 1-Gbit чип со второй платы. Для
+другой плотности меняется `parallel_nand_geometry_t`; GAS и GUI-команды
+остаются теми же.
+
+Не переносите номера выводов TSOP-48 на вариант `H4` VFBGA-63. Для BGA нужно
+использовать ball map конкретного полного part number.
+
+## TSOP-48, x8
+
+| NAND | Вывод | Назначение |
+|---|---:|---|
+| `R/B#` | 7 | open-drain Ready/Busy, подтяжка 4,7–10 кОм к 3,3 В |
+| `RE#` | 8 | строб чтения от МК |
+| `CE#` | 9 | выбор кристалла от МК |
+| `VCC` | 12, 37 | питание 3,3 В |
+| `VSS` | 13, 36 | земля |
+| `CLE` | 16 | фиксация команды |
+| `ALE` | 17 | фиксация адреса |
+| `WE#` | 18 | строб команды/адреса от МК |
+| `WP#` | 19 | для read-only 10 кОм на GND; для записи — GPIO и pull-down |
+| `I/O0` | 29 | двунаправленная шина, бит 0 |
+| `I/O1` | 30 | двунаправленная шина, бит 1 |
+| `I/O2` | 31 | двунаправленная шина, бит 2 |
+| `I/O3` | 32 | двунаправленная шина, бит 3 |
+| `I/O4` | 41 | двунаправленная шина, бит 4 |
+| `I/O5` | 42 | двунаправленная шина, бит 5 |
+| `I/O6` | 43 | двунаправленная шина, бит 6 |
+| `I/O7` | 44 | двунаправленная шина, бит 7 |
+| `VCC1` | 34, 39 | соединить с 3,3 В для совместимости корпуса/ONFI |
+| `VSS1` | 25, 48 | соединить с GND для совместимости корпуса/ONFI |
+| `DNU` | 38, 47 | оставить неподключёнными |
+| `NC` | остальные | не подключать |
+
+У каждого VCC/VCC1 поставить 100 нФ на ближайший VSS/VSS1; рядом с NAND —
+общий 1–4,7 мкФ. Сигналы не должны превышать питание NAND. Для трасс длиннее
+нескольких сантиметров предусмотреть последовательные резисторы 22–47 Ом у
+источника на `WE#`, `RE#`, `CLE`, `ALE` и при необходимости на данных.
+
+## Соединение с МК
+
+| NAND | TMS320F2812 | STM32F407VET6 | STM32G474CEU6 |
+|---|---|---|---|
+| `I/O0..7` | `XD0..XD7` | `PD14,PD15,PD0,PD1,PE7..PE10` | `PB0..PB7` |
+| `CLE` | `XA0` | `PD11/FSMC_A16` | `PA0` |
+| `ALE` | `XA1` | `PD12/FSMC_A17` | `PA1` |
+| `WE#` | `XWE` | `PD5/FSMC_NWE` | `PA2` |
+| `RE#` | `XRD` | `PD4/FSMC_NOE` | `PA3` |
+| `CE#` | `XZCS6AND7` | `PD7/FSMC_NE2` | `PA4` |
+| `WP#` | GND через 10 кОм | GND через 10 кОм | `PA5` и pull-down 10 кОм |
+| `R/B#` | `GPIOE0` | `PD6/FSMC_NWAIT` | `PA6` |
+
+Подробные номера выводов корпуса МК и ограничения находятся в README каждого
+каталога `ports/`. Перед изготовлением платы нужно сверить выбранный корпус и
+полный part number NAND с актуальным datasheet.
+
+## Первый запуск
+
+1. Не устанавливать NAND и проверить 3,3 В, отсутствие КЗ и уровни `CE#/WE#/RE#`.
+2. Установить NAND, оставить `WP#` в нуле и выполнить RESET `FFh`.
+3. Прочитать ID `90h`: ожидаемые первые байты для профиля — `2C F1`.
+4. Считать одну страницу два раза и сравнить main/OOB побайтно.
+5. Только после устойчивого чтения запускать полный дамп через GAS.
+
+## Источники для проверки footprint
+
+- [Micron: каталог SLC NAND](https://www.micron.com/products/storage/nand-flash/slc-nand/part-catalog)
+- [MT29F1G08ABADA: signal assignments и геометрия](https://helpdesk.trx.pl/pliki/SERWER/Micron-MT29F1G08ABADAWP-IT%20D-datasheet.pdf)
+- [Micron FBGA part decoder](https://in.micron.com/sales-support/design-tools/fbga-parts-decoder)
--- a/c/parallel-nand/docs/MEMORY_GAS.md
+++ b/c/parallel-nand/docs/MEMORY_GAS.md
@@ -0,0 +1,177 @@
+# Работа с parallel NAND через GAS
+
+## Архитектура
+
+Внешняя NAND значительно больше общего адресного пространства GAS. Например,
+`MT29F1G08ABADA` содержит 128 МиБ main area, а GAS имеет только 65536
+16-битных регистров. Поэтому NAND представлена не линейным диапазоном, а
+банковым окном одной физической страницы.
+
+```text
+SETGUI
+  │ GUI protocol v1: READ_REGISTERS / WRITE_REGISTERS
+  ▼
+карта GAS 0x0000..0xFFFF
+  │ 0xE000: управление, 0xE100: main, 0xE500: OOB
+  ▼
+parallel_nand_gas
+  ▼
+общее ядро parallel_nand
+  ├─ TMS320F2812: XINTF
+  ├─ STM32F407VE: FSMC
+  └─ STM32G474CE: GPIO
+```
+
+GUI работает одинаково со всеми МК. Тип процессора влияет только на выбранный
+файл из `ports/`.
+
+Встроенный проект должен направлять весь диапазон `0xE000..0xE51F` в
+`parallel_nand_gas_read()` и `parallel_nand_gas_write()`. Их аргументы имеют
+тип `unsigned int`: на C28x это нативное 16-битное слово, а на ARM функции
+явно оставляют только младшие 16 бит. Так карта и wire-формат совпадают без
+предположения, что C `char` всегда восьмибитный.
+
+Для STM32, использующего карту `pcan_gas`, готов адаптер:
+
+```c
+#include "parallel_nand_pcan_gas.h"
+
+static pcan_gas_region_t nand_region;
+parallel_nand_pcan_gas_region_init(&nand_region, &nand_gas);
+```
+
+Для TMS320F2812 переносимый обработчик вызывается прямо из существующего GAS
+диспетчера:
+
+```c
+if (address >= nand_gas.base &&
+    address < nand_gas.base + PNAND_GAS_REGION_REGS) {
+    return parallel_nand_gas_read(&nand_gas, address, value);
+}
+```
+
+Если тип результата диспетчера отличается, статусы `PNAND_GAS_OK`,
+`PNAND_GAS_NO_REG`, `PNAND_GAS_READ_ONLY` и `PNAND_GAS_REJECTED`
+преобразуются в его локальные статусы так же, как это сделано в
+`parallel_nand_pcan_gas.c`.
+
+## Транспорт до GUI
+
+Карта GAS не привязана к физическому каналу. Рекомендуемый путь для полного
+дампа — используемые SETGUI сообщения `WRITE_REGISTERS (0x0A)` и
+`READ_REGISTERS (0x09)`: они позволяют передавать крупные блоки поверх USB,
+UART, RS-485 или Ethernet. Адаптер `pcan_gas` нужен, когда теми же регистрами
+обмениваются по classic CAN; там один кадр несёт только четыре регистра, и
+полный 128-MiB дамп будет значительно медленнее.
+
+Устройство не должно собирать весь дамп в RAM. Буферизуется только одна
+страница. Из-за переносимости на C28x каждый octet хранится в `unsigned short`,
+поэтому статические буферы GAS занимают примерно 4,2 KiB RAM и на TMS, и на
+ARM.
+
+## Карта GAS
+
+Базовый адрес по умолчанию — `0xE000`. Его можно изменить при вызове
+`parallel_nand_gas_init()`; все смещения ниже останутся прежними.
+
+| Адрес | Доступ | Название | Значение |
+|---:|:---:|---|---|
+| `E000` | R | `SIGNATURE` | `0x4E44` (`ND`) |
+| `E001` | R | `VERSION` | версия окна, сейчас 1 |
+| `E002` | R | `STATUS` | состояние операции |
+| `E003` | R | `ERROR` | код `PNAND_*`, 0 = нет ошибки |
+| `E004` | W | `COMMAND` | команда окна |
+| `E005` | R/W | `PAGE_LO` | младшие 16 бит физической страницы |
+| `E006` | R/W | `PAGE_HI` | старшие 16 бит физической страницы |
+| `E007` | R | `PAGE_MAIN` | main bytes, для MT29 = 2048 |
+| `E008` | R | `PAGE_OOB` | OOB bytes, для MT29 = 64 |
+| `E009` | R | `PAGES_PER_BLOCK` | для MT29 = 64 |
+| `E00A` | R | `BLOCKS` | для MT29 = 1024 |
+| `E00B` | R | `MANUFACTURER_ID` | ожидается `0x2C` |
+| `E00C` | R | `DEVICE_ID` | ожидается `0xF1` |
+| `E00D` | R | `BAD_BLOCK` | 1 для физически плохого блока |
+| `E00E` | R | `GENERATION_LO` | счётчик загруженных страниц, low |
+| `E00F` | R | `GENERATION_HI` | счётчик загруженных страниц, high |
+| `E100..E4FF` | R | `PAGE_DATA` | 1024 регистра main, два байта LE |
+| `E500..E51F` | R | `PAGE_OOB` | 32 регистра OOB, два байта LE |
+
+Между управляющими регистрами и окнами данных есть зарезервированные адреса.
+Чтение блока через них не выполняется: каждый запрос должен начинаться внутри
+существующего участка.
+
+## STATUS
+
+| Бит | Маска | Смысл |
+|---:|---:|---|
+| 0 | `0x0001` | `READY` |
+| 1 | `0x0002` | `BUSY` |
+| 2 | `0x0004` | `PAGE_VALID` |
+| 3 | `0x0008` | `BAD_BLOCK` |
+| 15 | `0x8000` | `ERROR`, подробность в `E003` |
+
+GUI читает окно данных только при `READY=1`, `PAGE_VALID=1`, `ERROR=0`.
+
+## COMMAND
+
+| Значение | Команда | Результат |
+|---:|---|---|
+| 1 | `RESET` | сброс NAND и ожидание Ready |
+| 2 | `READ_ID` | обновляет `E00B/E00C` |
+| 3 | `READ_PAGE` | загружает main/OOB выбранной страницы |
+
+Запись номера страницы и запуск — две отдельные операции. Сначала GUI пишет
+`PAGE_LO/PAGE_HI`, затем записывает `READ_PAGE` в `COMMAND`. Нельзя отправлять
+один блок, начинающийся с `COMMAND`: команда выполнилась бы до обновления номера
+страницы.
+
+## Последовательность полного дампа
+
+1. Прочитать `E000..E00F`, проверить подпись, версию и геометрию.
+2. Выполнить `READ_ID`; для микросхемы с фотографии проверить `2C F1`.
+3. Рассчитать `page_count = PAGES_PER_BLOCK * BLOCKS`.
+4. Для каждой физической страницы от 0 до `page_count - 1`:
+   - записать номер страницы в `E005/E006`;
+   - записать `3` в `E004`;
+   - опрашивать `E002`, пока не установлен `READY`;
+   - проверить `ERROR`, `BAD_BLOCK` и изменение `GENERATION`;
+   - прочитать `E100..E4FF`;
+   - прочитать `E500..E51F`;
+   - сразу дописать данные и метаданные в файлы.
+5. Не пропускать bad-блоки: иначе файл потеряет соответствие физическим
+   страницам микросхемы.
+
+GUI protocol v1 допускает payload до 512 байт. Ответ `READ_REGISTERS` содержит
+четырёхбайтовый заголовок диапазона, поэтому за один запрос следует читать не
+более 254 GAS-регистров. Страница main читается пятью запросами: четыре раза по
+254 регистра и последний раз 8 регистров. OOB читается одним запросом на 32
+регистра.
+
+## Возобновление
+
+GUI хранит номер последней полностью записанной страницы. После разрыва связи
+он повторно проверяет подпись/ID/геометрию и продолжает со следующей страницы.
+Страница считается готовой только после записи main, OOB и записи её статуса в
+метаданные.
+
+Рекомендуемые выходные файлы:
+
+- `dump.bin` — 2048 байт main каждой физической страницы;
+- `dump.oob` — 64 байта OOB каждой физической страницы;
+- `dump.json` — ID, геометрия, bad-блоки, ошибки и последняя готовая страница.
+
+Для `MT29F1G08ABADA` размеры завершённого дампа: `dump.bin` = 134217728 байт,
+`dump.oob` = 4194304 байта.
+
+## ECC
+
+Текущая версия шаблона отдаёт raw main/OOB и не заявляет исправление ошибок.
+Статус bad-блока определяется по первому байту OOB первых двух страниц блока.
+Перед использованием дампа как рабочего образа нужно добавить ECC-политику для
+точного чипа и формата OOB. Само окно GAS при этом менять не требуется: можно
+добавить новые флаги состояния в свободные биты `STATUS`.
+
+## PROGRAM/ERASE
+
+Запись и стирание не включены намеренно. Они требуют отдельного разрешения,
+проверки ECC, защиты загрузочных блоков и двухфазного подтверждения через GAS.
+До добавления этих функций `WP#` удерживается активным аппаратным портом.
--- a/c/parallel-nand/include/parallel_nand.h
+++ b/c/parallel-nand/include/parallel_nand.h
@@ -0,0 +1,68 @@
+#ifndef PARALLEL_NAND_H
+#define PARALLEL_NAND_H
+
+#include "parallel_nand_port.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define PNAND_MT29F1G08_PAGE_MAIN       2048UL
+#define PNAND_MT29F1G08_PAGE_OOB          64UL
+#define PNAND_MT29F1G08_PAGES_PER_BLOCK   64UL
+#define PNAND_MT29F1G08_BLOCKS           1024UL
+#define PNAND_MT29F1G08_COLUMN_CYCLES       2U
+#define PNAND_MT29F1G08_ROW_CYCLES          2U
+#define PNAND_MT29F1G08_PAGE_TOTAL \
+    (PNAND_MT29F1G08_PAGE_MAIN + PNAND_MT29F1G08_PAGE_OOB)
+
+typedef enum {
+    PNAND_OK = 0,
+    PNAND_ERROR_ARGUMENT = -1,
+    PNAND_ERROR_PORT = -2,
+    PNAND_ERROR_TIMEOUT = -3,
+    PNAND_ERROR_RANGE = -4,
+    PNAND_ERROR_BUFFER = -5
+} parallel_nand_result_t;
+
+typedef struct {
+    unsigned long page_main_size;
+    unsigned long page_oob_size;
+    unsigned long pages_per_block;
+    unsigned long block_count;
+    unsigned int column_cycles;
+    unsigned int row_cycles;
+    unsigned long ready_timeout_us;
+} parallel_nand_geometry_t;
+
+typedef struct {
+    const parallel_nand_port_t *port;
+    parallel_nand_geometry_t geometry;
+} parallel_nand_t;
+
+extern const parallel_nand_geometry_t parallel_nand_mt29f1g08_geometry;
+
+int parallel_nand_init(parallel_nand_t *nand,
+                       const parallel_nand_port_t *port,
+                       const parallel_nand_geometry_t *geometry);
+int parallel_nand_reset(parallel_nand_t *nand);
+int parallel_nand_read_status(parallel_nand_t *nand, pnand_octet_t *status);
+int parallel_nand_read_id(parallel_nand_t *nand, pnand_octet_t address,
+                          pnand_octet_t *id, unsigned int count);
+int parallel_nand_read_page(parallel_nand_t *nand, unsigned long page,
+                            pnand_octet_t *main_data,
+                            unsigned long main_capacity,
+                            pnand_octet_t *oob,
+                            unsigned long oob_capacity);
+int parallel_nand_read_page_slice(parallel_nand_t *nand, unsigned long page,
+                                  unsigned long column, pnand_octet_t *out,
+                                  unsigned long count);
+int parallel_nand_is_bad_block(parallel_nand_t *nand, unsigned long block,
+                               int *is_bad);
+unsigned long parallel_nand_page_count(const parallel_nand_t *nand);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- a/c/parallel-nand/include/parallel_nand_gas.h
+++ b/c/parallel-nand/include/parallel_nand_gas.h
@@ -0,0 +1,84 @@
+#ifndef PARALLEL_NAND_GAS_H
+#define PARALLEL_NAND_GAS_H
+
+#include "parallel_nand.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define PNAND_GAS_DEFAULT_BASE       0xE000U
+#define PNAND_GAS_REGION_REGS        0x0520U
+#define PNAND_GAS_DATA_OFFSET        0x0100U
+#define PNAND_GAS_DATA_REGS          1024U
+#define PNAND_GAS_OOB_OFFSET         0x0500U
+#define PNAND_GAS_OOB_REGS             32U
+
+enum {
+    PNAND_GAS_REG_SIGNATURE = 0x0000,
+    PNAND_GAS_REG_VERSION = 0x0001,
+    PNAND_GAS_REG_STATUS = 0x0002,
+    PNAND_GAS_REG_ERROR = 0x0003,
+    PNAND_GAS_REG_COMMAND = 0x0004,
+    PNAND_GAS_REG_PAGE_LO = 0x0005,
+    PNAND_GAS_REG_PAGE_HI = 0x0006,
+    PNAND_GAS_REG_PAGE_MAIN = 0x0007,
+    PNAND_GAS_REG_PAGE_OOB = 0x0008,
+    PNAND_GAS_REG_PAGES_PER_BLOCK = 0x0009,
+    PNAND_GAS_REG_BLOCKS = 0x000A,
+    PNAND_GAS_REG_MANUFACTURER_ID = 0x000B,
+    PNAND_GAS_REG_DEVICE_ID = 0x000C,
+    PNAND_GAS_REG_BAD_BLOCK = 0x000D,
+    PNAND_GAS_REG_GENERATION_LO = 0x000E,
+    PNAND_GAS_REG_GENERATION_HI = 0x000F
+};
+
+enum {
+    PNAND_GAS_CMD_NONE = 0,
+    PNAND_GAS_CMD_RESET = 1,
+    PNAND_GAS_CMD_READ_ID = 2,
+    PNAND_GAS_CMD_READ_PAGE = 3
+};
+
+#define PNAND_GAS_STATUS_READY       0x0001U
+#define PNAND_GAS_STATUS_BUSY        0x0002U
+#define PNAND_GAS_STATUS_PAGE_VALID  0x0004U
+#define PNAND_GAS_STATUS_BAD_BLOCK   0x0008U
+#define PNAND_GAS_STATUS_ERROR       0x8000U
+
+typedef struct {
+    parallel_nand_t *nand;
+    unsigned int base;
+    unsigned int status;
+    int error;
+    unsigned long selected_page;
+    unsigned long generation;
+    unsigned long cached_block;
+    int cached_bad_block;
+    int block_cache_valid;
+    pnand_octet_t id[8];
+    pnand_octet_t main_data[PNAND_MT29F1G08_PAGE_MAIN];
+    pnand_octet_t oob[PNAND_MT29F1G08_PAGE_OOB];
+} parallel_nand_gas_t;
+
+void parallel_nand_gas_init(parallel_nand_gas_t *gas,
+                            parallel_nand_t *nand, unsigned int base);
+
+/* Portable GAS callbacks. Values and addresses are exactly 16 bits on wire. */
+typedef enum {
+    PNAND_GAS_OK = 0,
+    PNAND_GAS_NO_REG,
+    PNAND_GAS_READ_ONLY,
+    PNAND_GAS_REJECTED
+} parallel_nand_gas_result_t;
+
+parallel_nand_gas_result_t parallel_nand_gas_read(
+    parallel_nand_gas_t *gas, unsigned int address, unsigned int *value);
+parallel_nand_gas_result_t parallel_nand_gas_write(
+    parallel_nand_gas_t *gas, unsigned int address, unsigned int value);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- a/c/parallel-nand/include/parallel_nand_pcan_gas.h
+++ b/c/parallel-nand/include/parallel_nand_pcan_gas.h
@@ -0,0 +1,11 @@
+#ifndef PARALLEL_NAND_PCAN_GAS_H
+#define PARALLEL_NAND_PCAN_GAS_H
+
+#include "parallel_nand_gas.h"
+#include "pcan_gas.h"
+
+/* Adapter for targets where c/set-protocol pcan_gas is available. */
+void parallel_nand_pcan_gas_region_init(pcan_gas_region_t *region,
+                                         parallel_nand_gas_t *gas);
+
+#endif
--- a/c/parallel-nand/include/parallel_nand_port.h
+++ b/c/parallel-nand/include/parallel_nand_port.h
@@ -0,0 +1,28 @@
+#ifndef PARALLEL_NAND_PORT_H
+#define PARALLEL_NAND_PORT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Один octet хранится в целом типе: это важно для C28x с 16-битным char. */
+typedef unsigned short pnand_octet_t;
+
+typedef struct {
+    int  (*init)(void);
+    void (*select)(void);
+    void (*deselect)(void);
+    void (*write_command)(pnand_octet_t value);
+    void (*write_address)(pnand_octet_t value);
+    void (*write_data)(pnand_octet_t value);
+    pnand_octet_t (*read_data)(void);
+    int  (*is_ready)(void);
+    void (*set_write_protect)(int enabled);
+    void (*delay_us)(unsigned long us);
+} parallel_nand_port_t;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- a/c/parallel-nand/ports/stm32f407ve/README.md
+++ b/c/parallel-nand/ports/stm32f407ve/README.md
@@ -0,0 +1,26 @@
+# Порт STM32F407VET6
+
+Используется аппаратный FSMC NAND Bank 2, шина x8.
+
+| NAND | STM32F407VE | LQFP-100 |
+|---|---|---:|
+| `I/O0` | `PD14/FSMC_D0` | 61 |
+| `I/O1` | `PD15/FSMC_D1` | 62 |
+| `I/O2` | `PD0/FSMC_D2` | 81 |
+| `I/O3` | `PD1/FSMC_D3` | 82 |
+| `I/O4` | `PE7/FSMC_D4` | 38 |
+| `I/O5` | `PE8/FSMC_D5` | 39 |
+| `I/O6` | `PE9/FSMC_D6` | 40 |
+| `I/O7` | `PE10/FSMC_D7` | 41 |
+| `RE#` | `PD4/FSMC_NOE` | 85 |
+| `WE#` | `PD5/FSMC_NWE` | 86 |
+| `R/B#` | `PD6/FSMC_NWAIT` | 87 |
+| `CE#` | `PD7/FSMC_NE2` | 88 |
+| `CLE` | `PD11/FSMC_A16` | 58 |
+| `ALE` | `PD12/FSMC_A17` | 59 |
+
+Порт использует STM32Cube HAL. В `stm32f4xx_hal_conf.h` включить
+`HAL_NAND_MODULE_ENABLED`, добавить `stm32f4xx_hal_nand.c` и
+`stm32f4xx_ll_fsmc.c`, включить FSMC и не создавать второй
+`NAND_HandleTypeDef` для Bank 2. Начальные тайминги
+консервативны; финальные значения подтвердить осциллографом.
--- a/c/parallel-nand/ports/stm32f407ve/parallel_nand_port_stm32f407ve.c
+++ b/c/parallel-nand/ports/stm32f407ve/parallel_nand_port_stm32f407ve.c
@@ -0,0 +1,93 @@
+#include "parallel_nand_port_stm32f407ve.h"
+#include "stm32f4xx_hal.h"
+#include "stm32f4xx_hal_nand.h"
+
+#define PNAND_F407_BANK2_BASE  0x70000000UL
+#define PNAND_F407_CMD_AREA    (1UL << 16)
+#define PNAND_F407_ADDR_AREA   (1UL << 17)
+
+static NAND_HandleTypeDef hnand;
+
+static int f407_init(void)
+{
+    GPIO_InitTypeDef io;
+    FSMC_NAND_PCC_TimingTypeDef common;
+    FSMC_NAND_PCC_TimingTypeDef attribute;
+
+    __HAL_RCC_GPIOD_CLK_ENABLE();
+    __HAL_RCC_GPIOE_CLK_ENABLE();
+    __HAL_RCC_FSMC_CLK_ENABLE();
+
+    io.Mode = GPIO_MODE_AF_PP;
+    io.Pull = GPIO_NOPULL;
+    io.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
+    io.Alternate = GPIO_AF12_FSMC;
+    io.Pin = GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_4 | GPIO_PIN_5 |
+             GPIO_PIN_6 | GPIO_PIN_7 | GPIO_PIN_11 | GPIO_PIN_12 |
+             GPIO_PIN_14 | GPIO_PIN_15;
+    HAL_GPIO_Init(GPIOD, &io);
+    io.Pin = GPIO_PIN_7 | GPIO_PIN_8 | GPIO_PIN_9 | GPIO_PIN_10;
+    HAL_GPIO_Init(GPIOE, &io);
+
+    hnand.Instance = FSMC_NAND_DEVICE;
+    hnand.Init.NandBank = FSMC_NAND_BANK2;
+    hnand.Init.Waitfeature = FSMC_NAND_PCC_WAIT_FEATURE_DISABLE;
+    hnand.Init.MemoryDataWidth = FSMC_NAND_PCC_MEM_BUS_WIDTH_8;
+    hnand.Init.EccComputation = FSMC_NAND_ECC_DISABLE;
+    hnand.Init.ECCPageSize = FSMC_NAND_ECC_PAGE_SIZE_2048BYTE;
+    hnand.Init.TCLRSetupTime = 2U;
+    hnand.Init.TARSetupTime = 2U;
+
+    common.SetupTime = 2U;
+    common.WaitSetupTime = 5U;
+    common.HoldSetupTime = 3U;
+    common.HiZSetupTime = 2U;
+    attribute = common;
+    return HAL_NAND_Init(&hnand, &common, &attribute) == HAL_OK ? 0 : -1;
+}
+
+static void f407_select(void) { /* FSMC_NCE2 активируется доступом. */ }
+static void f407_deselect(void) { }
+static void f407_write_command(pnand_octet_t value)
+{
+    *(__IO uint8_t *)(PNAND_F407_BANK2_BASE | PNAND_F407_CMD_AREA) =
+        (uint8_t)value;
+}
+static void f407_write_address(pnand_octet_t value)
+{
+    *(__IO uint8_t *)(PNAND_F407_BANK2_BASE | PNAND_F407_ADDR_AREA) =
+        (uint8_t)value;
+}
+static void f407_write_data(pnand_octet_t value)
+{
+    *(__IO uint8_t *)PNAND_F407_BANK2_BASE = (uint8_t)value;
+}
+static pnand_octet_t f407_read_data(void)
+{
+    return *(__IO uint8_t *)PNAND_F407_BANK2_BASE;
+}
+static int f407_is_ready(void)
+{
+    return HAL_GPIO_ReadPin(GPIOD, GPIO_PIN_6) == GPIO_PIN_SET;
+}
+static void f407_set_wp(int enabled)
+{
+    /* WP# аппаратный в базовой схеме. */
+    (void)enabled;
+}
+static void f407_delay_us(unsigned long us)
+{
+    uint32_t cycles = (SystemCoreClock / 3000000UL) * (uint32_t)us;
+    while (cycles-- != 0U) __NOP();
+}
+
+static const parallel_nand_port_t f407_port = {
+    f407_init, f407_select, f407_deselect,
+    f407_write_command, f407_write_address, f407_write_data,
+    f407_read_data, f407_is_ready, f407_set_wp, f407_delay_us
+};
+
+const parallel_nand_port_t *parallel_nand_port_stm32f407ve(void)
+{
+    return &f407_port;
+}
--- a/c/parallel-nand/ports/stm32f407ve/parallel_nand_port_stm32f407ve.h
+++ b/c/parallel-nand/ports/stm32f407ve/parallel_nand_port_stm32f407ve.h
@@ -0,0 +1,8 @@
+#ifndef PARALLEL_NAND_PORT_STM32F407VE_H
+#define PARALLEL_NAND_PORT_STM32F407VE_H
+
+#include "parallel_nand_port.h"
+
+const parallel_nand_port_t *parallel_nand_port_stm32f407ve(void);
+
+#endif
--- a/c/parallel-nand/ports/stm32g474ce/README.md
+++ b/c/parallel-nand/ports/stm32g474ce/README.md
@@ -0,0 +1,21 @@
+# Порт STM32G474CEU6
+
+У UFQFPN-48 нет выведенного FSMC, поэтому используется GPIO bit-bang.
+
+| NAND | STM32G474CEU6 | UFQFPN-48 |
+|---|---|---:|
+| `I/O0..I/O7` | `PB0..PB7` | 17, 18, 19, 41, 42, 43, 44, 45 |
+| `CLE` | `PA0` | 8 |
+| `ALE` | `PA1` | 9 |
+| `WE#` | `PA2` | 10 |
+| `RE#` | `PA3` | 11 |
+| `CE#` | `PA4` | 12 |
+| `WP#` | `PA5` | 13 |
+| `R/B#` | `PA6` | 14 |
+
+`R/B#` требует внешней подтяжки 4,7–10 кОм к 3,3 В. Порт использует STM32Cube
+HAL только для инициализации, а циклы NAND выполняет прямым доступом к GPIO.
+
+Выбранные `PB3/PB4` нельзя одновременно использовать для trace/JTAG; SWD на
+`PA13/PA14` остаётся доступен. Если эти пины нужны проекту, измените таблицу и
+операции шины: текущая оптимизация рассчитана на непрерывные `PB0..PB7`.
--- a/c/parallel-nand/ports/stm32g474ce/parallel_nand_port_stm32g474ce.c
+++ b/c/parallel-nand/ports/stm32g474ce/parallel_nand_port_stm32g474ce.c
@@ -0,0 +1,134 @@
+#include "parallel_nand_port_stm32g474ce.h"
+#include "stm32g4xx_hal.h"
+
+/* Пустая плата STM32G474CEU6: PB0..PB7 образуют непрерывную x8 шину. */
+#define DATA_MASK 0x00FFU
+#define CLE_PIN GPIO_PIN_0
+#define ALE_PIN GPIO_PIN_1
+#define WE_PIN  GPIO_PIN_2
+#define RE_PIN  GPIO_PIN_3
+#define CE_PIN  GPIO_PIN_4
+#define WP_PIN  GPIO_PIN_5
+#define RB_PIN  GPIO_PIN_6
+
+static int data_is_output;
+
+static void data_input(void)
+{
+    if (data_is_output) {
+        GPIOB->MODER &= ~0x0000FFFFUL;
+        data_is_output = 0;
+    }
+}
+
+static void data_output(void)
+{
+    if (!data_is_output) {
+        GPIOB->MODER = (GPIOB->MODER & ~0x0000FFFFUL) | 0x00005555UL;
+        data_is_output = 1;
+    }
+}
+
+static void short_delay(void)
+{
+    __NOP(); __NOP(); __NOP(); __NOP();
+    __NOP(); __NOP(); __NOP(); __NOP();
+}
+
+static int g474_init(void)
+{
+    GPIO_InitTypeDef io;
+    __HAL_RCC_GPIOA_CLK_ENABLE();
+    __HAL_RCC_GPIOB_CLK_ENABLE();
+
+    io.Pin = DATA_MASK;
+    io.Mode = GPIO_MODE_OUTPUT_PP;
+    io.Pull = GPIO_NOPULL;
+    io.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
+    HAL_GPIO_Init(GPIOB, &io);
+    data_is_output = 1;
+    data_input();
+
+    /* Set inactive levels before enabling the pins as outputs. */
+    GPIOA->BSRR = WE_PIN | RE_PIN | CE_PIN |
+                  ((uint32_t)(CLE_PIN | ALE_PIN | WP_PIN) << 16);
+    io.Pin = CLE_PIN | ALE_PIN | WE_PIN | RE_PIN | CE_PIN | WP_PIN;
+    io.Mode = GPIO_MODE_OUTPUT_PP;
+    io.Pull = GPIO_NOPULL;
+    io.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
+    HAL_GPIO_Init(GPIOA, &io);
+    io.Pin = RB_PIN;
+    io.Mode = GPIO_MODE_INPUT;
+    io.Pull = GPIO_NOPULL;
+    HAL_GPIO_Init(GPIOA, &io);
+    return 0;
+}
+
+static void g474_select(void) { GPIOA->BSRR = (uint32_t)CE_PIN << 16; }
+static void g474_deselect(void) { GPIOA->BSRR = CE_PIN; }
+
+static void write_cycle(pnand_octet_t value)
+{
+    data_output();
+    GPIOB->BSRR = (uint32_t)DATA_MASK << 16;
+    GPIOB->BSRR = (uint32_t)value & DATA_MASK;
+    short_delay();
+    GPIOA->BSRR = (uint32_t)WE_PIN << 16;
+    short_delay();
+    GPIOA->BSRR = WE_PIN;
+    short_delay();
+}
+
+static void g474_write_command(pnand_octet_t value)
+{
+    GPIOA->BSRR = CLE_PIN | ((uint32_t)ALE_PIN << 16);
+    write_cycle(value);
+    GPIOA->BSRR = (uint32_t)CLE_PIN << 16;
+}
+
+static void g474_write_address(pnand_octet_t value)
+{
+    GPIOA->BSRR = ALE_PIN | ((uint32_t)CLE_PIN << 16);
+    write_cycle(value);
+    GPIOA->BSRR = (uint32_t)ALE_PIN << 16;
+}
+
+static void g474_write_data(pnand_octet_t value)
+{
+    GPIOA->BSRR = ((uint32_t)(CLE_PIN | ALE_PIN) << 16);
+    write_cycle(value);
+}
+
+static pnand_octet_t g474_read_data(void)
+{
+    pnand_octet_t value;
+    data_input();
+    GPIOA->BSRR = ((uint32_t)(CLE_PIN | ALE_PIN | RE_PIN) << 16);
+    short_delay();
+    value = (pnand_octet_t)(GPIOB->IDR & DATA_MASK);
+    GPIOA->BSRR = RE_PIN;
+    short_delay();
+    return value;
+}
+
+static int g474_is_ready(void) { return (GPIOA->IDR & RB_PIN) != 0U; }
+static void g474_set_wp(int enabled)
+{
+    GPIOA->BSRR = enabled ? ((uint32_t)WP_PIN << 16) : WP_PIN;
+}
+static void g474_delay_us(unsigned long us)
+{
+    uint32_t cycles = (SystemCoreClock / 3000000UL) * (uint32_t)us;
+    while (cycles-- != 0U) __NOP();
+}
+
+static const parallel_nand_port_t g474_port = {
+    g474_init, g474_select, g474_deselect,
+    g474_write_command, g474_write_address, g474_write_data,
+    g474_read_data, g474_is_ready, g474_set_wp, g474_delay_us
+};
+
+const parallel_nand_port_t *parallel_nand_port_stm32g474ce(void)
+{
+    return &g474_port;
+}
--- a/c/parallel-nand/ports/stm32g474ce/parallel_nand_port_stm32g474ce.h
+++ b/c/parallel-nand/ports/stm32g474ce/parallel_nand_port_stm32g474ce.h
@@ -0,0 +1,8 @@
+#ifndef PARALLEL_NAND_PORT_STM32G474CE_H
+#define PARALLEL_NAND_PORT_STM32G474CE_H
+
+#include "parallel_nand_port.h"
+
+const parallel_nand_port_t *parallel_nand_port_stm32g474ce(void);
+
+#endif
--- a/c/parallel-nand/ports/tms320f2812/README.md
+++ b/c/parallel-nand/ports/tms320f2812/README.md
@@ -0,0 +1,21 @@
+# Порт TMS320F2812
+
+Порт использует XINTF Zone 6:
+
+- `XD0..XD7` — NAND `I/O0..I/O7`;
+- `XA0` — `CLE`;
+- `XA1` — `ALE`;
+- `XWE` — `WE#`;
+- `XRD` — `RE#`;
+- `XZCS6AND7` — `CE#`;
+- `GPIOE0/XINT1` — `R/B#` с внешней подтяжкой 4,7–10 кОм.
+
+Адреса C28x задаются в 16-битных словах: data `0x100000`, command
+`0x100001`, address `0x100002`. Используется только младший байт XINTF.
+
+`WP#` в базовом варианте аппаратный: для режима только чтения соединить с GND
+через 10 кОм; если позже понадобится PROGRAM/ERASE, заменить на GPIO и реализовать
+`tms_set_wp()`.
+
+Задержка в порте приблизительная. После выбора частоты CPU проверить импульсы
+осциллографом и при необходимости изменить `PNAND_TMS_CPU_MHZ`.
--- a/c/parallel-nand/ports/tms320f2812/parallel_nand_port_tms320f2812.c
+++ b/c/parallel-nand/ports/tms320f2812/parallel_nand_port_tms320f2812.c
@@ -0,0 +1,65 @@
+#include "parallel_nand_port_tms320f2812.h"
+#include "DSP281x_Device.h"
+
+/* C28x addresses are 16-bit word addresses. XA0/XA1 drive CLE/ALE. */
+#define PNAND_TMS_DATA_REG (*(volatile unsigned int *)0x100000UL)
+#define PNAND_TMS_CMD_REG  (*(volatile unsigned int *)0x100001UL)
+#define PNAND_TMS_ADDR_REG (*(volatile unsigned int *)0x100002UL)
+
+#ifndef PNAND_TMS_CPU_MHZ
+#define PNAND_TMS_CPU_MHZ 150UL
+#endif
+
+static void tms_delay_us(unsigned long us)
+{
+    volatile unsigned long loops = us * (PNAND_TMS_CPU_MHZ / 5UL);
+    while (loops-- != 0UL) asm(" NOP");
+}
+
+static int tms_init(void)
+{
+    EALLOW;
+    GpioMuxRegs.GPEMUX.bit.XINT1_XBIO_GPIOE0 = 0;
+    GpioMuxRegs.GPEDIR.bit.GPIOE0 = 0;
+
+    XintfRegs.XINTCNF2.bit.XTIMCLK = 1;
+    XintfRegs.XINTCNF2.bit.WRBUFF = 0;
+    XintfRegs.XINTCNF2.bit.CLKOFF = 0;
+    XintfRegs.XINTCNF2.bit.CLKMODE = 1;
+    XintfRegs.XTIMING6.bit.XWRLEAD = 3;
+    XintfRegs.XTIMING6.bit.XWRACTIVE = 7;
+    XintfRegs.XTIMING6.bit.XWRTRAIL = 3;
+    XintfRegs.XTIMING6.bit.XRDLEAD = 3;
+    XintfRegs.XTIMING6.bit.XRDACTIVE = 7;
+    XintfRegs.XTIMING6.bit.XRDTRAIL = 3;
+    XintfRegs.XTIMING6.bit.USEREADY = 0;
+    XintfRegs.XTIMING6.bit.READYMODE = 0;
+    XintfRegs.XTIMING6.bit.XSIZE = 3;
+    EDIS;
+    asm(" RPT #7 || NOP");
+    return 0;
+}
+
+static void tms_select(void) { /* XZCS6AND7 формируется каждым доступом. */ }
+static void tms_deselect(void) { }
+static void tms_write_command(pnand_octet_t v) { PNAND_TMS_CMD_REG = v & 0xFFU; }
+static void tms_write_address(pnand_octet_t v) { PNAND_TMS_ADDR_REG = v & 0xFFU; }
+static void tms_write_data(pnand_octet_t v) { PNAND_TMS_DATA_REG = v & 0xFFU; }
+static pnand_octet_t tms_read_data(void) { return PNAND_TMS_DATA_REG & 0xFFU; }
+static int tms_is_ready(void) { return GpioDataRegs.GPEDAT.bit.GPIOE0 != 0; }
+static void tms_set_wp(int enabled)
+{
+    /* Шаблон платы фиксирует WP# аппаратно. См. README порта. */
+    (void)enabled;
+}
+
+static const parallel_nand_port_t tms_port = {
+    tms_init, tms_select, tms_deselect,
+    tms_write_command, tms_write_address, tms_write_data,
+    tms_read_data, tms_is_ready, tms_set_wp, tms_delay_us
+};
+
+const parallel_nand_port_t *parallel_nand_port_tms320f2812(void)
+{
+    return &tms_port;
+}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Andrey	27ef6fcfdf	Merge remote-tracking branch 'origin/codex/trend-display-scale' into HEAD	2026-09-05 11:43:08 +03:00
Andrey	235d5d81a2	Share PM67 upload protocol through C core	2026-09-05 11:37:03 +03:00
Andrey Kruchinkin	59f847e900	Добавить множитель и IQ в Python-тренды	2026-09-05 03:45:05 +03:00
Andrey Kruchinkin	286e454464	Добавить выпуск прошивок из Keil и CCS	2026-09-05 03:16:16 +03:00
Andrey Kruchinkin	e691dfc337	Добавить публикацию каталога прошивок	2026-09-05 03:05:17 +03:00
Andrey Kruchinkin	f5f15f6a04	Сохранить совместимость ABI графиков	2026-09-05 02:44:08 +03:00
Andrey Kruchinkin	be066a57eb	Дополнить общий контракт границ осей	2026-09-05 02:43:07 +03:00
Andrey Kruchinkin	b1f7b965f4	Расширить общие API графиков и GAS обмена	2026-09-05 02:37:11 +03:00
Andrey	78d3f6690b	Align Android parser statistics with C core	2026-09-04 21:10:02 +03:00
Andrey	6a82b309cc	Move PM35 protocol into shared C core	2026-09-04 21:06:40 +03:00
Andrey	2316a5a26a	Добавить Android API протокола ПМ35	2026-09-04 20:39:04 +03:00
Andrey	d44d57a7aa	Убрать лишнюю строку в Legacy CAN API	2026-09-04 19:17:27 +03:00
Andrey	b972b6f33c	Добавить канал TMS в каталог прошивок	2026-09-04 19:15:48 +03:00
Andrey	454baeed98	Добавить общий протокол Periph28335	2026-09-04 19:15:48 +03:00
Andrey	01ffc0e496	Добавить общий Python API старого CAN terminal	2026-09-04 19:15:47 +03:00
Andrey	3c4ac9963d	Добавить общий API старого CAN terminal	2026-09-04 19:15:47 +03:00
Andrey	d9eb7dd9ad	feat(plot): lock axes and calculate marker levels in dB	2026-09-04 19:15:47 +03:00
Andrey	f6787163dc	feat(plot): configure one or two marker pairs per axis	2026-09-04 19:15:47 +03:00
Andrey	5f8fc07f2a	Merge pull request 'Добавить общие графики и драйвер parallel NAND' (#3 ) from feature/shared-plot-and-parallel-nand into master Reviewed-on: #3	2026-09-04 12:39:12 +03:00
Andrey	c8565d868d	Убрать лишнюю строку в модели маркеров	2026-09-04 12:36:56 +03:00
Andrey	1523640414	Добавить общий Python-парсер каталога прошивок	2026-09-04 12:31:42 +03:00
Andrey	fa6f615e81	Добавить безопасный клиент каталога прошивок Android	2026-09-04 12:30:37 +03:00
Andrey	392817432b	Поддержать настройки трендов в Python 3.8	2026-09-04 12:23:07 +03:00
Andrey	20850b26df	Добавить переносимый драйвер parallel NAND	2026-09-04 12:22:21 +03:00
Andrey	e163d9ba55	Добавить общие графики, декодер KONOR и порт STM32 bxCAN	2026-09-04 12:22:17 +03:00
Andrey	af82687e42	Добавить переносимый планировщик PULSE	2026-09-01 20:54:58 +03:00
Andrey	e9ec078b38	Объединить SETProtocol v2 и общие кодеки (#1 ) Reviewed-on: #1	2026-09-01 20:43:49 +03:00
Andrey	43410c3f12	Merge origin/master into SETProtocol v2 integration branch	2026-09-01 20:41:07 +03:00
Andrey	076c51c083	fix(python): support library lookup on Python 3.8	2026-09-01 20:31:18 +03:00
Andrey	e9c5ec90b8	refactor(python): centralize ProtoCAN decoder	2026-09-01 12:00:53 +03:00
Andrey	00a0f944c4	refactor(python): centralize SETProtocol v2 codec	2026-09-01 11:56:24 +03:00
Andrey	9c0701ab9b	refactor(android): centralize Kotlin protocol codecs	2026-09-01 11:54:35 +03:00
Andrey	9b636a9f40	feat(setprotocol): define system payload schemas	2026-09-01 11:47:08 +03:00
Andrey	19becd7b8c	refactor: merge protocol cores as SETProtocol	2026-09-01 09:58:35 +03:00
Andrey	5504104cc5	feat(protocan): вынеси GUI-кадрирование в общий ABI	2026-08-31 21:02:23 +03:00
Andrey	e6bea52db0	fix(protocan): держи import library в build-каталоге	2026-08-31 20:58:52 +03:00
Andrey	92fc2ade58	docs(protocan): перенеси канонический протокол из SETCAN	2026-08-31 20:55:04 +03:00
Andrey	080b6900f5	feat(protocan): добавь JNI-разбор идентификатора	2026-08-31 20:50:40 +03:00
Andrey	68040a2803	fix(protocan): исправь вызов MSVC из host builder	2026-08-31 20:48:17 +03:00
Andrey	7fe76b3c3b	build(protocan): добавь host-сборку без CMake	2026-08-31 20:48:01 +03:00
Andrey	0f77a510e6	feat(protocan): открой разбор ID и статистику FFI	2026-08-31 20:46:52 +03:00
Andrey	7910a07f2f	feat(protocan): добавь общий ABI для GUI	2026-08-31 20:45:34 +03:00
Andrey	2fd51a1d7e	docs: move SETCAN documentation into templates	2026-08-31 19:30:54 +03:00
Andrey	de180750aa	feat(can-sensor): add STM32F1 bxCAN port	2026-08-31 18:50:52 +03:00
Andrey Kruchinkin	648457e587	protocan-boot: support single-slot targets	2026-08-31 01:06:16 +03:00
Andrey Kruchinkin	5f3a9879d5	Add C28x RS boot ports for F2812 and F28335	2026-08-30 15:30:08 +03:00
Andrey Kruchinkin	9ce32b56d4	Add reusable firmware info module	2026-08-30 07:01:59 +03:00
Andrey Kruchinkin	05863db2a2	docs: add Windows HTML build script	2026-08-30 06:12:50 +03:00
Andrey Kruchinkin	4b32cda46e	docs: add HTML library catalog	2026-08-30 03:44:36 +03:00
Andrey Kruchinkin	217073982f	feat(rs485-boot): add STM32F103 and G474 ports	2026-08-30 01:37:12 +03:00
Andrey Kruchinkin	94c991380b	docs(porting): опиши структуру проектов STM32	2026-08-30 01:13:43 +03:00
Andrey Kruchinkin	5a8724da6d	docs(protocan-boot): уточни границы блоков слота	2026-08-30 01:13:42 +03:00
Andrey Kruchinkin	d507b84a76	Обновить Python-декодер ProtoCAN Boot	2026-08-29 22:18:53 +03:00
Andrey Kruchinkin	d3bb634fb1	feat(protocan-boot): добавь прошивку приборов по CAN	2026-08-29 17:11:53 +03:00
Andrey	a1d2d05f42	тест	2026-08-26 21:01:51 +03:00
Andrey	1345766efb	Обновить can-sensor для SETCAN SETTINGS	2026-08-26 20:47:59 +03:00
Andrey	085eb3c8bd	feat: add unified SET protocol v2	2026-08-24 19:19:32 +03:00
Andrey Kruchinkin	033c7ab9e8	feat(ds18b20): порты 1-Wire для STM32G4 и STM32F4 Добавлены реализации низкоуровневой шины для STM32G431/G474 и STM32F407VET6 с шаблонами onewire_config.h под каждый камень. Логика повторяет порт STM32F1: открытый сток, задержки по DWT, запрет прерываний на один тайм-слот. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>	2026-08-23 13:14:23 +03:00