Инженер — это не профессия, а состояние души

Modbus RTU slave на STM32 — это разбор байтового потока на кадры, проверка CRC, обработка нескольких функций протокола и управление направлением передачи на RS-485. Статья опирается на приём через DMA с кольцевым буфером из предыдущей статьи серии и на схему RS-485-узла из серии про схемотехнику.

CRC-16 Modbus

Modbus RTU использует CRC-16 с полиномом 0xA007 (обратный порядок бит от 0x8005), начальное значение 0xFFFF. Побитовый расчёт — медленнее табличного, но нагляднее, и для кадров в несколько байт разница в скорости не критична:

static uint16_t Modbus_CRC16(const uint8_t *buf, uint16_t len)
{
    uint16_t crc = 0xFFFFU;
    for (uint16_t pos = 0; pos < len; pos++) {
        crc ^= buf[pos];
        for (uint8_t bit = 0; bit < 8; bit++) {
            if (crc & 0x0001U) {
                crc >>= 1;
                crc ^= 0xA001U;
            } else {
                crc >>= 1;
            }
        }
    }
    return crc;
}

CRC передаётся в кадре младшим байтом первым (little-endian), в отличие от самих данных регистров, которые в Modbus идут старшим байтом вперёд (big-endian) — это частый источник ошибок при ручной сборке кадра.

Обработка кадра

Кадр Modbus RTU: адрес slave (1 байт) + код функции (1 байт) + данные + CRC (2 байта). Разбор — проверка адреса, проверка CRC, затем ветвление по коду функции:

#define MODBUS_SLAVE_ADDR   0x01U
#define FUNC_READ_HOLDING    0x03U
#define FUNC_WRITE_SINGLE    0x06U
#define MODBUS_REG_COUNT     16U

static uint16_t holding_regs[MODBUS_REG_COUNT];

int Modbus_HandleFrame(const uint8_t *frame, uint16_t len)
{
    if (len < 4U) {
        return 0;
    }

    uint16_t crc_received = (uint16_t)(frame[len - 2] | (frame[len - 1] << 8));
    uint16_t crc_calc = Modbus_CRC16(frame, (uint16_t)(len - 2));
    if (crc_received != crc_calc) {
        return 0; /* битый кадр — молча игнорируем, не отвечаем */
    }

    if (frame[0] != MODBUS_SLAVE_ADDR) {
        return 0; /* не наш адрес */
    }

    uint8_t func = frame[1];
    uint8_t response[256];
    uint16_t resp_len;

    if (func == FUNC_READ_HOLDING) {
        uint16_t start_reg = (uint16_t)((frame[2] << 8) | frame[3]);
        uint16_t qty = (uint16_t)((frame[4] << 8) | frame[5]);

        if (start_reg + qty > MODBUS_REG_COUNT) {
            resp_len = Modbus_BuildErrorResponse(response, func, 0x02);
        } else {
            response[0] = MODBUS_SLAVE_ADDR;
            response[1] = func;
            response[2] = (uint8_t)(qty * 2U);
            for (uint16_t i = 0; i < qty; i++) {
                response[3 + i * 2] = (uint8_t)(holding_regs[start_reg + i] >> 8);
                response[4 + i * 2] = (uint8_t)(holding_regs[start_reg + i] & 0xFFU);
            }
            uint16_t crc = Modbus_CRC16(response, (uint16_t)(3 + qty * 2));
            response[3 + qty * 2] = (uint8_t)(crc & 0xFFU);
            response[4 + qty * 2] = (uint8_t)(crc >> 8);
            resp_len = (uint16_t)(5 + qty * 2);
        }
    } else if (func == FUNC_WRITE_SINGLE) {
        /* ... см. полный код ниже */
    } else {
        resp_len = Modbus_BuildErrorResponse(response, func, 0x01); /* Illegal Function */
    }

    UART_SendFrame(response, resp_len);
    return 1;
}

Важный момент — битый CRC и чужой адрес обрабатываются молча, без ответа. Это не недосмотр: по спецификации Modbus RTU slave не должен отвечать на кадры с неверной контрольной суммой (их мог исказить шум на линии) и не должен отвечать на кадры, адресованные другим устройствам на той же шине — ответ на чужой адрес вызвал бы коллизию на RS-485.

Функция 0x06 (Write Single Register) при успехе отвечает эхом исходного запроса целиком — так устроен протокол, это не ошибка копирования.

Управление направлением RS-485

RS-485-трансивер (см. статью про RS-485 в серии про схемотехнику) требует явного переключения между приёмом и передачей через вывод DE/RE — линия полудуплексная, и если transmit enable остаётся включённым постоянно, устройство никогда не услышит ответ других узлов:

static void RS485_SetDirection(GPIO_PinState dir)
{
    HAL_GPIO_WritePin(GPIOA, GPIO_PIN_1, dir);
}

static void UART_SendFrame(const uint8_t *data, uint16_t len)
{
    RS485_SetDirection(GPIO_PIN_SET);
    HAL_UART_Transmit(&huart1, (uint8_t *)data, len, 100);
    /* Дождаться реальной отправки надо по HAL_UART_TxCpltCallback,
     * а не паузой вслепую после HAL_UART_Transmit — здесь для
     * краткости примера упрощено, см. пояснение после кода. */
    RS485_SetDirection(GPIO_PIN_RESET);
}

HAL_UART_Transmit в блокирующем режиме возвращает управление, когда данные переданы из буфера в периферийный регистр UART — но это не гарантирует, что последний бит физически ушёл в линию. Переключение DE/RE обратно в приём сразу после возврата из HAL_UART_Transmit рискует обрезать конец кадра. Корректный подход — дождаться HAL_UART_TxCpltCallback перед переключением направления; в примере это упрощено ради компактности и явно помечено как место для доработки.

Откуда берутся кадры: граница с UART+DMA

Определение того, где заканчивается один кадр Modbus и начинается следующий, в этой статье не рассматривается отдельно — оно опирается на приём по IDLE line из статьи про UART+DMA: пауза на линии после последнего байта кадра (3.5 символа по спецификации Modbus RTU) создаёт событие IDLE, HAL передаёт накопленные байты в колбэк, и это естественная граница кадра для вызова Modbus_HandleFrame().

Итог

Modbus RTU slave на STM32 — это CRC-16, разбор нескольких функций протокола и аккуратное управление направлением RS-485, а не что-то принципиально сложное. Главные источники реальных багов — не сам протокол, а обвязка вокруг него: переключение DE/RE без ожидания реальной отправки, отсутствие проверки диапазона регистров, попытка ответить на чужой адрес или битый CRC. Код не проверен ни на плате, ни на стенде — перед использованием нужен реальный RS-485-узел для проверки таймингов DE/RE и поведения при коллизиях на шине.

← Все статьи раздела «Программирование»