feat(can-sensor): add STM32F1 bxCAN port

README.md

@@ -28,7 +28,7 @@ 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/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/protocan-transport`](c/protocan-transport) | транспорт ProtoCAN: кадр, канал, CRC, общее адресное пространство, каталог GUI | `stdint.h` | запись в поток и запрос свободного места — **порт STM32F4 в комплекте** |
 | [`c/protocan-boot`](c/protocan-boot) | адресная прошивка по ProtoCAN: A/B-слоты, сессия, CRC32, verify и rollback-контракт | C99 | CAN TX, erase/write Flash, boot metadata, проверка образа и reboot |

c/can-sensor/README.md

@@ -20,6 +20,7 @@
 | Файл | Что делает | Зависимости |
 |---|---|---|
 | `can_sensor.h`, `can_sensor.c` | сборка и разбор SETTINGS, повторы передачи, счётчики обмена | `stdint.h` |
+| `ports/stm32f1/` | опросный порт CAN1: GPIO, BTR, фильтр, mailbox/FIFO, тайм-аут ACK | CMSIS `stm32f10x.h` |
 
 `ZZ` — номер сборки, `YY` — позиция. Нулевой ROM с DLC=8 очищает локацию.
 
@@ -47,6 +48,30 @@ CanSensor_Message message;
 if (CanSensor_Poll(&link, &message)) { /* принят идентификатор */ }
 ```
 
+## Порт 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):

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);
+}

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 */

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 */

c/protocan-boot/README.md

@@ -2,7 +2,7 @@
 
 `protocan-boot` — переносимое C99-ядро адресной прошивки приборов по classic
 CAN 2.0B и 29-битному ProtoCAN ID. Оно реализует сессию обновления, два
-логических слота по 512 КиБ, последовательную запись 8-байтовых блоков,
+логических слота по 512 КиБ либо single-slot обновление, последовательную запись 8-байтовых блоков,
 CRC32, проверку совместимости, продолжение по номеру следующего блока и
 безопасный выбор неактивного слота.
 
@@ -10,6 +10,11 @@ CRC32, проверку совместимости, продолжение по
 linker script, обработчиков прерываний, криптографии и перехода в приложение.
 Эти операции предоставляет проект через таблицу callbacks.
 
+Для STM32G474VET6 из `candleLight_fw` задаются `slot_count = 1` и
+`max_image_size = 480 * 1024`. В этом режиме запись идёт в единственную
+область приложения, callback `set_pending_slot` не требуется, а аппаратный
+rollback недоступен. Значение `slot_count = 0` сохраняет прежний A/B-режим.
+
 ## Слои
 
 ```text

c/protocan-boot/include/pcan_boot.h

@@ -79,6 +79,10 @@ typedef struct {
     uint8_t hardware_revision;
     uint32_t firmware_version;
     uint8_t active_slot;
+    /** 1 for an in-place/single-slot target, 2 for A/B. Zero keeps legacy A/B. */
+    uint8_t slot_count;
+    /** Writable image capacity. Zero uses PCAN_BOOT_SLOT_SIZE. */
+    uint32_t max_image_size;
     uint8_t ack_window; /**< 1 — ACK каждого блока, 16 — ACK каждых 16 блоков. */
 } pcan_boot_config_t;
 

c/protocan-boot/src/pcan_boot.c

@@ -115,17 +115,27 @@ void pcan_boot_abort(pcan_boot_t *boot)
 bool pcan_boot_init(pcan_boot_t *boot, const pcan_boot_config_t *config,
                     const pcan_boot_port_t *port, void *port_user)
 {
+    uint8_t slot_count;
     if ((boot == NULL) || (config == NULL) || (port == NULL)
             || (config->device_type > 7U) || (config->device_id > 15U)
             || (config->active_slot > 1U)
             || (port->send == NULL) || (port->erase_slot == NULL)
-            || (port->write_slot == NULL) || (port->set_pending_slot == NULL)) {
+            || (port->write_slot == NULL)) {
+        return false;
+    }
+    slot_count = config->slot_count == 0U ? 2U : config->slot_count;
+    if ((slot_count > 2U) || (config->active_slot >= slot_count)
+            || ((slot_count == 2U) && (port->set_pending_slot == NULL))) {
         return false;
     }
     (void)memset(boot, 0, sizeof(*boot));
     boot->config = *config;
     boot->port = *port;
     boot->port_user = port_user;
+    boot->config.slot_count = slot_count;
+    if (boot->config.max_image_size == 0U) {
+        boot->config.max_image_size = PCAN_BOOT_SLOT_SIZE;
+    }
     if (boot->config.ack_window == 0U) {
         boot->config.ack_window = 1U;
     }
@@ -140,7 +150,7 @@ static bool metadata_complete(pcan_boot_t *boot, uint8_t command)
         return send_status(boot, command, PCAN_BOOT_STATUS_OK);
     }
     if ((boot->manifest.image_size == 0U)
-            || (boot->manifest.image_size > PCAN_BOOT_SLOT_SIZE)) {
+            || (boot->manifest.image_size > boot->config.max_image_size)) {
         boot->state = PCAN_BOOT_STATE_FAILED;
         return send_status(boot, command, PCAN_BOOT_STATUS_INVALID_SIZE);
     }
@@ -155,7 +165,9 @@ static bool metadata_complete(pcan_boot_t *boot, uint8_t command)
         boot->state = PCAN_BOOT_STATE_FAILED;
         return send_status(boot, command, PCAN_BOOT_STATUS_SIGNATURE_ERROR);
     }
-    boot->target_slot = (uint8_t)(boot->config.active_slot ^ 1U);
+    boot->target_slot = boot->config.slot_count == 1U
+                      ? boot->config.active_slot
+                      : (uint8_t)(boot->config.active_slot ^ 1U);
     boot->state = PCAN_BOOT_STATE_READY_TO_ERASE;
     return send_status(boot, command, PCAN_BOOT_STATUS_OK);
 }
@@ -239,7 +251,8 @@ static bool process_control(pcan_boot_t *boot, uint16_t body,
         if (boot->state != PCAN_BOOT_STATE_VERIFIED) {
             return send_status(boot, command, PCAN_BOOT_STATUS_INVALID_STATE);
         }
-        if (!boot->port.set_pending_slot(boot->port_user, boot->target_slot,
+        if ((boot->config.slot_count == 2U)
+                && !boot->port.set_pending_slot(boot->port_user, boot->target_slot,
                                                 &boot->manifest)) {
             return send_status(boot, command, PCAN_BOOT_STATUS_FLASH_ERROR);
         }

c/protocan-boot/tests/test_pcan_boot.c

@@ -255,6 +255,44 @@ static void test_rejects_wrong_session_and_compatibility(void)
     assert(boot.state == PCAN_BOOT_STATE_FAILED);
 }
 
+static void test_single_slot_update(void)
+{
+    static const uint8_t image[8] = { 1U, 2U, 3U, 4U, 5U, 6U, 7U, 8U };
+    pcan_boot_t boot;
+    fake_t fake;
+    pcan_boot_config_t config;
+    pcan_boot_port_t port;
+
+    (void)memset(&fake, 0, sizeof(fake));
+    (void)memset(&config, 0, sizeof(config));
+    (void)memset(&port, 0, sizeof(port));
+    fake.pending_slot = PCAN_BOOT_SLOT_NONE;
+    fake.authorized = true;
+    fake.verified = true;
+    config.device_type = 3U;
+    config.device_id = 5U;
+    config.product_type = 0x1234U;
+    config.hardware_revision = 2U;
+    config.slot_count = 1U;
+    config.max_image_size = sizeof(fake.flash[0]);
+    config.ack_window = 16U;
+    port.send = fake_send;
+    port.erase_slot = fake_erase;
+    port.write_slot = fake_write;
+    port.authorize = fake_authorize;
+    port.verify_image = fake_verify;
+    port.reboot = fake_reboot;
+    assert(pcan_boot_init(&boot, &config, &port, &fake));
+    begin_update(&boot, image, sizeof(image));
+    assert(boot.target_slot == 0U);
+    assert(command(&boot, 7U, PCAN_BOOT_CMD_ERASE, NULL, 0U));
+    assert(pcan_boot_process(&boot, request_id(PCAN_BOOT_MSG_DATA_A, 0U), image, 8U));
+    assert(command(&boot, 7U, PCAN_BOOT_CMD_VERIFY, NULL, 0U));
+    assert(command(&boot, 7U, PCAN_BOOT_CMD_COMMIT, NULL, 0U));
+    assert(fake.pending_slot == PCAN_BOOT_SLOT_NONE);
+    assert(memcmp(fake.flash[0], image, sizeof(image)) == 0);
+}
+
 int main(void)
 {
     test_id_layout();
@@ -262,6 +300,7 @@ int main(void)
     test_complete_update();
     test_rejects_wrong_address_and_sequence();
     test_rejects_wrong_session_and_compatibility();
+    test_single_slot_update();
     puts("pcan_boot tests: OK");
     return 0;
 }