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 и поведения при коллизиях на шине.