yuwenhao
/
Modbus-rtu
1
0
Forkuj 0
Kod Zgłoszenia 0 Oczekujące zmiany 0 Wydania 0 Wiki Aktywność
Nie możesz wybrać więcej, niż 25 tematów Tematy muszą się zaczynać od litery lub cyfry, mogą zawierać myślniki ('-') i mogą mieć do 35 znaków.
9 Commity
3 Gałęzie
138 MiB
 
 
 
 
 
 
Drzewo: 17f2578f93
Gałęzie Tagi
${ item.name }
Utwórz gałąź ${ searchTerm }
z '17f2578f93'
${ noResults }
Modbus-rtu/Modbus/Src/modbus_rtu_slave.c

825 wiersze
22 KiB
Czysty Wina Historia 

  1. /**

  2.  * @file modbus_rtu_slave.c

  3.  * @brief Modbus RTU 从站协议处理模块。

  4.  */

  5. 

  6. #include "modbus_rtu_slave.h"

  7. 

  8. #include <string.h>

  9. 

  10. /** @brief Modbus RTU 最大 ADU 长度，单位为字节。 */

  11. #define MODBUS_RTU_ADU_SIZE_MAX          (256U)

  12. 

  13. /**

  14.  * @brief 当前通信参数下使用的 RTU 帧间隔。

  15.  *

  16.  * 当前波特率为 115200 bit/s。Modbus 规范建议波特率高于

  17.  * 19200 bit/s 时采用固定 1.75 ms 帧间隔，此处向上取整为 2 ms。

  18.  */

  19. #define MODBUS_RTU_FRAME_GAP_MS          (2U)

  20. 

  21. #define MODBUS_BROADCAST_ADDRESS         (0U)

  22. 

  23. 

  24. 

  25. #define MODBUS_EX_ILLEGAL_FUNCTION       (0x01U)

  26. #define MODBUS_EX_ILLEGAL_ADDRESS        (0x02U)

  27. #define MODBUS_EX_ILLEGAL_VALUE          (0x03U)

  28. 

  29. #define MODBUS_READ_COILS_MAX            (2000U)

  30. #define MODBUS_READ_REGS_MAX             (125U)

  31. #define MODBUS_WRITE_COILS_MAX           (1968U)

  32. #define MODBUS_WRITE_REGS_MAX            (123U)

  33. 

  34. #define MODBUS_COIL_VALUE_ON             (0xFF00U)

  35. #define MODBUS_COIL_VALUE_OFF            (0x0000U)

  36. 

  37. static UART_HandleTypeDef *ModbusUart;

  38. static uint8_t ModbusSlaveAddress;

  39. 

  40. /**

  41.  * DMA 缓冲区只由 DMA 写入；帧缓冲区在接收回调中完成一次快照，

  42.  * 随后由任务解析，避免 DMA 重启后覆盖尚未处理的数据。

  43.  */

  44. static uint8_t ModbusRxDmaBuffer[MODBUS_RTU_ADU_SIZE_MAX];

  45. static uint8_t ModbusRxFrame[MODBUS_RTU_ADU_SIZE_MAX];

  46. static uint8_t ModbusTxFrame[MODBUS_RTU_ADU_SIZE_MAX];

  47. 

  48. static volatile uint16_t ModbusRxFrameLength;

  49. static volatile uint8_t ModbusRxFrameReady;

  50. static volatile uint8_t ModbusTxBusy;

  51. static volatile uint32_t ModbusRxEventTick;

  52. static volatile uint32_t ModbusLastValidFrameTick;

  53. static volatile uint8_t ModbusHasReceivedValidFrame;

  54. 

  55. /**

  56.  * 10000 个保持寄存器占用 20000 字节；10000 个线圈按位存储，

  57.  * 占用 1250 字节。

  58.  */

  59. static uint16_t ModbusHoldingRegisters[MODBUS_MAP_ITEM_COUNT];

  60. static uint8_t ModbusCoils[(MODBUS_MAP_ITEM_COUNT + 7U) / 8U];

  61. 

  62. volatile MODBUS_SLAVE_STATS ModbusSlaveStatistics;

  63. 

  64. /**

  65.  * @brief 计算 Modbus RTU CRC16 校验值。

  66.  * @param[in] data 待校验数据。

  67.  * @param[in] length 待校验数据长度。

  68.  * @return CRC16 校验值。

  69.  */

  70. static uint16_t ModbusCrc16(const uint8_t *data, uint16_t length)

  71. {

  72.     uint16_t crc = 0xFFFFU;

  73.     uint16_t index;

  74.     uint8_t bit;

  75. 

  76.     for (index = 0U; index < length; index++)

  77.     {

  78.         crc ^= data[index];

  79. 

  80.         for (bit = 0U; bit < 8U; bit++)

  81.         {

  82.             if ((crc & 0x0001U) != 0U)

  83.             {

  84.                 crc = (uint16_t)((crc >> 1U) ^ 0xA001U);

  85.             }

  86.             else

  87.             {

  88.                 crc >>= 1U;

  89.             }

  90.         }

  91.     }

  92. 

  93.     return crc;

  94. }

  95. 

  96. /**

  97.  * @brief 从网络字节序数据中读取一个 16 位无符号整数。

  98.  * @param[in] data 至少包含两个字节的数据地址。

  99.  * @return 转换后的 16 位无符号整数。

  100.  */

  101. static uint16_t ModbusGetU16Be(const uint8_t *data)

  102. {

  103.     return (uint16_t)(((uint16_t)data[0] << 8U) | data[1]);

  104. }

  105. 

  106. /**

  107.  * @brief 检查连续数据地址范围是否合法。

  108.  * @param[in] start 起始地址。

  109.  * @param[in] quantity 数据项数量。

  110.  * @retval 1 地址范围合法。

  111.  * @retval 0 地址范围非法。

  112.  */

  113. static uint8_t ModbusAddressRangeIsValid(uint16_t start, uint16_t quantity)

  114. {

  115.     if ((quantity == 0U) || (start >= MODBUS_MAP_ITEM_COUNT))

  116.     {

  117.         return 0U;

  118.     }

  119. 

  120.     /* 先做减法再比较，避免 start + quantity 发生 16 位溢出。 */

  121.     return (quantity <= (MODBUS_MAP_ITEM_COUNT - start)) ? 1U : 0U;

  122. }

  123. 

  124. /**

  125.  * @brief 读取已经确认地址合法的线圈。

  126.  * @param[in] address 线圈地址。

  127.  * @return 线圈状态，取值为 0 或 1。

  128.  */

  129. static uint8_t ModbusCoilGetUnchecked(uint16_t address)

  130. {

  131.     uint8_t mask = (uint8_t)(1U << (address & 0x0007U));

  132. 

  133.     return ((ModbusCoils[address >> 3U] & mask) != 0U) ? 1U : 0U;

  134. }

  135. 

  136. /**

  137.  * @brief 设置已经确认地址合法的线圈。

  138.  * @param[in] address 线圈地址。

  139.  * @param[in] state 0 表示复位，非 0 表示置位。

  140.  */

  141. static void ModbusCoilSetUnchecked(uint16_t address, uint8_t state)

  142. {

  143.     uint8_t mask = (uint8_t)(1U << (address & 0x0007U));

  144. 

  145.     if (state != 0U)

  146.     {

  147.         ModbusCoils[address >> 3U] |= mask;

  148.     }

  149.     else

  150.     {

  151.         ModbusCoils[address >> 3U] &= (uint8_t)(~mask);

  152.     }

  153. }

  154. 

  155. /**

  156.  * @brief 启动 USART DMA 空闲接收。

  157.  * @retval HAL_OK DMA 接收启动成功。

  158.  * @retval HAL_BUSY 串口未配置或发送尚未结束。

  159.  * @return 其他 HAL 状态表示 DMA 接收启动失败。

  160.  */

  161. static HAL_StatusTypeDef ModbusStartReceive(void)

  162. {

  163.     HAL_StatusTypeDef status;

  164. 

  165.     if (ModbusTxBusy != 0U)

  166.     {

  167.         return HAL_BUSY;

  168.     }

  169. 

  170.     status = HAL_UARTEx_ReceiveToIdle_DMA(ModbusUart,

  171.                                           ModbusRxDmaBuffer,

  172.                                           sizeof(ModbusRxDmaBuffer));

  173. 

  174.     if ((status == HAL_OK) && (ModbusUart->hdmarx != NULL))

  175.     {

  176.         /*

  177.          * 普通 Modbus 帧只应在 IDLE 或缓冲区满时交给应用。

  178.          * 关闭 DMA 半传输中断，避免长帧在一半位置被误认为完整帧。

  179.          */

  180.         __HAL_DMA_DISABLE_IT(ModbusUart->hdmarx, DMA_IT_HT);

  181.     }

  182. 

  183.     return status;

  184. }

  185. 

  186. /**

  187.  * @brief 停止当前 USART DMA 接收。

  188.  */

  189. static void ModbusStopReceive(void)

  190. {

  191.     if (ModbusUart != NULL)

  192.     {

  193.         (void)HAL_UART_AbortReceive(ModbusUart);

  194.     }

  195. }

  196. 

  197. /**

  198.  * @brief 在 RTU 帧末尾追加 CRC 低字节和高字节。

  199.  * @param[in,out] frame 待追加 CRC 的帧缓冲区。

  200.  * @param[in] payloadLength 不包含 CRC 的有效载荷长度。

  201.  */

  202. static void ModbusAppendCrc(uint8_t *frame, uint16_t payloadLength)

  203. {

  204.     uint16_t crc = ModbusCrc16(frame, payloadLength);

  205. 

  206.     /* Modbus RTU 在线路上传输 CRC 低字节在前、高字节在后。 */

  207.     frame[payloadLength] = (uint8_t)(crc & 0x00FFU);

  208.     frame[payloadLength + 1U] = (uint8_t)(crc >> 8U);

  209. }

  210. 

  211. /**

  212.  * @brief 构造 Modbus 异常响应。

  213.  * @param[in] function 请求功能码。

  214.  * @param[in] exception 异常码。

  215.  * @return 异常响应 ADU 长度。

  216.  */

  217. static uint16_t ModbusBuildException(uint8_t function, uint8_t exception)

  218. {

  219.     ModbusTxFrame[0] = ModbusSlaveAddress;

  220.     ModbusTxFrame[1] = (uint8_t)(function | 0x80U);

  221.     ModbusTxFrame[2] = exception;

  222.     ModbusAppendCrc(ModbusTxFrame, 3U);

  223. 

  224.     return 5U;

  225. }

  226. 

  227. /**

  228.  * @brief 处理读线圈功能码 0x01。

  229.  * @param[in] request RTU 请求帧。

  230.  * @param[in] requestLength 请求帧长度。

  231.  * @return 待发送响应长度，异常请求返回异常响应长度。

  232.  */

  233. static uint16_t ModbusProcessReadCoils(const uint8_t *request,

  234.     uint16_t requestLength)

  235. {

  236.     uint16_t start;

  237.     uint16_t quantity;

  238.     uint16_t index;

  239.     uint8_t byteCount;

  240. 

  241.     if (requestLength != 8U)

  242.     {

  243.         ModbusSlaveStatistics.illegalValueCount++;

  244.         return ModbusBuildException(request[1], MODBUS_EX_ILLEGAL_VALUE);

  245.     }

  246. 

  247.     start = ModbusGetU16Be(&request[2]);

  248.     quantity = ModbusGetU16Be(&request[4]);

  249. 

  250.     if ((quantity == 0U) || (quantity > MODBUS_READ_COILS_MAX))

  251.     {

  252.         ModbusSlaveStatistics.illegalValueCount++;

  253.         return ModbusBuildException(request[1], MODBUS_EX_ILLEGAL_VALUE);

  254.     }

  255. 

  256.     if (ModbusAddressRangeIsValid(start, quantity) == 0U)

  257.     {

  258.         ModbusSlaveStatistics.illegalAddressCount++;

  259.         return ModbusBuildException(request[1], MODBUS_EX_ILLEGAL_ADDRESS);

  260.     }

  261. 

  262.     byteCount = (uint8_t)((quantity + 7U) / 8U);

  263.     ModbusTxFrame[0] = ModbusSlaveAddress;

  264.     ModbusTxFrame[1] = 0X01;

  265.     ModbusTxFrame[2] = byteCount;

  266.     (void)memset(&ModbusTxFrame[3], 0, byteCount);

  267. 

  268.     /* Modbus 规定第一个线圈放在响应数据首字节的最低位。 */

  269.     for (index = 0U; index < quantity; index++)

  270.     {

  271.         if (ModbusCoilGetUnchecked((uint16_t)(start + index)) != 0U)

  272.         {

  273.             ModbusTxFrame[3U + (index >> 3U)] |=

  274.                 (uint8_t)(1U << (index & 0x0007U));

  275.         }

  276.     }

  277. 

  278.     ModbusAppendCrc(ModbusTxFrame, (uint16_t)(3U + byteCount));

  279.     return (uint16_t)(5U + byteCount);

  280. }

  281. 

  282. /**

  283.  * @brief 处理读保持寄存器功能码 0x03。

  284.  * @param[in] request RTU 请求帧。

  285.  * @param[in] requestLength 请求帧长度。

  286.  * @return 待发送响应长度，异常请求返回异常响应长度。

  287.  */

  288. static uint16_t ModbusProcessReadHolding(const uint8_t *request,

  289.     uint16_t requestLength)

  290. {

  291.     uint16_t start;

  292.     uint16_t quantity;

  293.     uint16_t index;

  294.     uint16_t value;

  295. 

  296.     if (requestLength != 8U)

  297.     {

  298.         ModbusSlaveStatistics.illegalValueCount++;

  299.         return ModbusBuildException(request[1], MODBUS_EX_ILLEGAL_VALUE);

  300.     }

  301. 

  302.     start = ModbusGetU16Be(&request[2]);

  303.     quantity = ModbusGetU16Be(&request[4]);

  304. 

  305.     if ((quantity == 0U) || (quantity > MODBUS_READ_REGS_MAX))

  306.     {

  307.         ModbusSlaveStatistics.illegalValueCount++;

  308.         return ModbusBuildException(request[1], MODBUS_EX_ILLEGAL_VALUE);

  309.     }

  310. 

  311.     if (ModbusAddressRangeIsValid(start, quantity) == 0U)

  312.     {

  313.         ModbusSlaveStatistics.illegalAddressCount++;

  314.         return ModbusBuildException(request[1], MODBUS_EX_ILLEGAL_ADDRESS);

  315.     }

  316. 

  317.     ModbusTxFrame[0] = ModbusSlaveAddress;

  318.     ModbusTxFrame[1] = 0X03;

  319.     ModbusTxFrame[2] = (uint8_t)(quantity * 2U);

  320. 

  321.     for (index = 0U; index < quantity; index++)

  322.     {

  323.         value = ModbusHoldingRegisters[start + index];

  324.         ModbusTxFrame[3U + index * 2U] = (uint8_t)(value >> 8U);

  325.         ModbusTxFrame[4U + index * 2U] = (uint8_t)(value & 0x00FFU);

  326.     }

  327. 

  328.     ModbusAppendCrc(ModbusTxFrame, (uint16_t)(3U + quantity * 2U));

  329.     return (uint16_t)(5U + quantity * 2U);

  330. }

  331. 

  332. /**

  333.  * @brief 处理写单个保持寄存器功能码 0x06。

  334.  * @param[in] request RTU 请求帧。

  335.  * @param[in] requestLength 请求帧长度。

  336.  * @param[in] isBroadcast 非 0 表示当前请求为广播。

  337.  * @return 单播响应长度；广播或无法响应时返回 0。

  338.  */

  339. static uint16_t ModbusProcessWriteSingleRegister(

  340.     const uint8_t *request,

  341.     uint16_t requestLength,

  342.     uint8_t isBroadcast)

  343. {

  344.     uint16_t address;

  345.     uint16_t value;

  346. 

  347.     if (requestLength != 8U)

  348.     {

  349.         ModbusSlaveStatistics.illegalValueCount++;

  350.         return (isBroadcast != 0U) ? 0U :

  351.             ModbusBuildException(request[1], MODBUS_EX_ILLEGAL_VALUE);

  352.     }

  353. 

  354.     address = ModbusGetU16Be(&request[2]);

  355.     value = ModbusGetU16Be(&request[4]);

  356. 

  357.     if (address >= MODBUS_MAP_ITEM_COUNT)

  358.     {

  359.         ModbusSlaveStatistics.illegalAddressCount++;

  360.         return (isBroadcast != 0U) ? 0U :

  361.             ModbusBuildException(request[1], MODBUS_EX_ILLEGAL_ADDRESS);

  362.     }

  363. 

  364.     ModbusHoldingRegisters[address] = value;

  365. 

  366.     if (isBroadcast != 0U)

  367.     {

  368.         return 0U;

  369.     }

  370. 

  371.     /* 0x06 的正常响应必须原样回显请求的前 6 个字节。 */

  372.     (void)memcpy(ModbusTxFrame, request, 6U);

  373.     ModbusAppendCrc(ModbusTxFrame, 6U);

  374.     return 8U;

  375. }

  376. 

  377. /**

  378.  * @brief 处理写单个线圈功能码 0x05。

  379.  * @param[in] request RTU 请求帧。

  380.  * @param[in] requestLength 请求帧长度。

  381.  * @param[in] isBroadcast 非 0 表示当前请求为广播。

  382.  * @return 单播响应长度；广播或无法响应时返回 0。

  383.  */

  384. static uint16_t ModbusProcessWriteSingleCoil(

  385.     const uint8_t *request,

  386.     uint16_t requestLength,

  387.     uint8_t isBroadcast)

  388. {

  389.     uint16_t address;

  390.     uint16_t value;

  391. 

  392.     if (requestLength != 8U)

  393.     {

  394.         ModbusSlaveStatistics.illegalValueCount++;

  395.         return (isBroadcast != 0U) ? 0U :

  396.             ModbusBuildException(request[1], MODBUS_EX_ILLEGAL_VALUE);

  397.     }

  398. 

  399.     address = ModbusGetU16Be(&request[2]);

  400.     value = ModbusGetU16Be(&request[4]);

  401. 

  402.     /*

  403.      * 0x05 只接受 0xFF00（线圈置位）和 0x0000（线圈复位）；

  404.      * 其他数值属于非法数据值。

  405.      */

  406.     if ((value != MODBUS_COIL_VALUE_ON)

  407.         && (value != MODBUS_COIL_VALUE_OFF))

  408.     {

  409.         ModbusSlaveStatistics.illegalValueCount++;

  410.         return (isBroadcast != 0U) ? 0U :

  411.             ModbusBuildException(request[1], MODBUS_EX_ILLEGAL_VALUE);

  412.     }

  413. 

  414.     if (address >= MODBUS_MAP_ITEM_COUNT)

  415.     {

  416.         ModbusSlaveStatistics.illegalAddressCount++;

  417.         return (isBroadcast != 0U) ? 0U :

  418.             ModbusBuildException(request[1], MODBUS_EX_ILLEGAL_ADDRESS);

  419.     }

  420. 

  421.     ModbusCoilSetUnchecked(

  422.         address,

  423.         (value == MODBUS_COIL_VALUE_ON) ? 1U : 0U);

  424. 

  425.     if (isBroadcast != 0U)

  426.     {

  427.         return 0U;

  428.     }

  429. 

  430.     /* 0x05 正常应答原样回显请求的前 6 个字节，再追加 CRC。 */

  431.     (void)memcpy(ModbusTxFrame, request, 6U);

  432.     ModbusAppendCrc(ModbusTxFrame, 6U);

  433.     return 8U;

  434. }

  435. 

  436. /**

  437.  * @brief 处理写多个线圈功能码 0x0F。

  438.  * @param[in] request RTU 请求帧。

  439.  * @param[in] requestLength 请求帧长度。

  440.  * @param[in] isBroadcast 非 0 表示当前请求为广播。

  441.  * @return 单播响应长度；广播或无法响应时返回 0。

  442.  */

  443. static uint16_t ModbusProcessWriteMultipleCoils(

  444.     const uint8_t *request,

  445.     uint16_t requestLength,

  446.     uint8_t isBroadcast)

  447. {

  448.     uint16_t start;

  449.     uint16_t quantity;

  450.     uint16_t index;

  451.     uint8_t byteCount;

  452.     uint8_t expectedByteCount;

  453. 

  454.     if (requestLength < 9U)

  455.     {

  456.         ModbusSlaveStatistics.illegalValueCount++;

  457.         return (isBroadcast != 0U) ? 0U :

  458.             ModbusBuildException(request[1], MODBUS_EX_ILLEGAL_VALUE);

  459.     }

  460. 

  461.     start = ModbusGetU16Be(&request[2]);

  462.     quantity = ModbusGetU16Be(&request[4]);

  463.     byteCount = request[6];

  464.     expectedByteCount = (uint8_t)((quantity + 7U) / 8U);

  465. 

  466.     if ((quantity == 0U)

  467.         || (quantity > MODBUS_WRITE_COILS_MAX)

  468.         || (byteCount != expectedByteCount)

  469.         || (requestLength != (uint16_t)(9U + byteCount)))

  470.     {

  471.         ModbusSlaveStatistics.illegalValueCount++;

  472.         return (isBroadcast != 0U) ? 0U :

  473.             ModbusBuildException(request[1], MODBUS_EX_ILLEGAL_VALUE);

  474.     }

  475. 

  476.     if (ModbusAddressRangeIsValid(start, quantity) == 0U)

  477.     {

  478.         ModbusSlaveStatistics.illegalAddressCount++;

  479.         return (isBroadcast != 0U) ? 0U :

  480.             ModbusBuildException(request[1], MODBUS_EX_ILLEGAL_ADDRESS);

  481.     }

  482. 

  483.     for (index = 0U; index < quantity; index++)

  484.     {

  485.         uint8_t state;

  486. 

  487.         state = (uint8_t)((request[7U + (index >> 3U)]

  488.             >> (index & 0x0007U))

  489.             & 0x01U);

  490.         ModbusCoilSetUnchecked((uint16_t)(start + index), state);

  491.     }

  492. 

  493.     if (isBroadcast != 0U)

  494.     {

  495.         return 0U;

  496.     }

  497. 

  498.     ModbusTxFrame[0] = ModbusSlaveAddress;

  499.     ModbusTxFrame[1] = 0X0F;

  500.     (void)memcpy(&ModbusTxFrame[2], &request[2], 4U);

  501.     ModbusAppendCrc(ModbusTxFrame, 6U);

  502.     return 8U;

  503. }

  504. 

  505. /**

  506.  * @brief 处理写多个保持寄存器功能码 0x10。

  507.  * @param[in] request RTU 请求帧。

  508.  * @param[in] requestLength 请求帧长度。

  509.  * @param[in] isBroadcast 非 0 表示当前请求为广播。

  510.  * @return 单播响应长度；广播或无法响应时返回 0。

  511.  */

  512. static uint16_t ModbusProcessWriteMultipleRegisters(

  513.     const uint8_t *request,

  514.     uint16_t requestLength,

  515.     uint8_t isBroadcast)

  516. {

  517.     uint16_t start;

  518.     uint16_t quantity;

  519.     uint16_t index;

  520.     uint8_t byteCount;

  521. 

  522.     if (requestLength < 9U)

  523.     {

  524.         ModbusSlaveStatistics.illegalValueCount++;

  525.         return (isBroadcast != 0U) ? 0U :

  526.             ModbusBuildException(request[1], MODBUS_EX_ILLEGAL_VALUE);

  527.     }

  528. 

  529.     start = ModbusGetU16Be(&request[2]);

  530.     quantity = ModbusGetU16Be(&request[4]);

  531.     byteCount = request[6];

  532. 

  533.     if ((quantity == 0U)

  534.         || (quantity > MODBUS_WRITE_REGS_MAX)

  535.         || (byteCount != (uint8_t)(quantity * 2U))

  536.         || (requestLength != (uint16_t)(9U + byteCount)))

  537.     {

  538.         ModbusSlaveStatistics.illegalValueCount++;

  539.         return (isBroadcast != 0U) ? 0U :

  540.             ModbusBuildException(request[1], MODBUS_EX_ILLEGAL_VALUE);

  541.     }

  542. 

  543.     if (ModbusAddressRangeIsValid(start, quantity) == 0U)

  544.     {

  545.         ModbusSlaveStatistics.illegalAddressCount++;

  546.         return (isBroadcast != 0U) ? 0U :

  547.             ModbusBuildException(request[1], MODBUS_EX_ILLEGAL_ADDRESS);

  548.     }

  549. 

  550.     for (index = 0U; index < quantity; index++)

  551.     {

  552.         ModbusHoldingRegisters[start + index] =

  553.             ModbusGetU16Be(&request[7U + index * 2U]);

  554.     }

  555. 

  556.     if (isBroadcast != 0U)

  557.     {

  558.         return 0U;

  559.     }

  560. 

  561.     ModbusTxFrame[0] = ModbusSlaveAddress;

  562.     ModbusTxFrame[1] = 0X10;

  563.     (void)memcpy(&ModbusTxFrame[2], &request[2], 4U);

  564.     ModbusAppendCrc(ModbusTxFrame, 6U);

  565.     return 8U;

  566. }

  567. 

  568. /**

  569.  * @brief 校验并分发一帧 Modbus RTU 请求。

  570.  * @param[in] request RTU 请求帧。

  571.  * @param[in] requestLength 请求帧长度。

  572.  * @return 待发送响应长度；无需响应时返回 0。

  573.  */

  574. static uint16_t ModbusProcessRequest(const uint8_t *request,

  575.     uint16_t requestLength)

  576. {

  577.     uint16_t calculatedCrc;

  578.     uint16_t receivedCrc;

  579.     uint8_t isBroadcast;

  580. 

  581.     if (requestLength < 4U)

  582.     {

  583.         return 0U;

  584.     }

  585. 

  586.     calculatedCrc = ModbusCrc16(request, (uint16_t)(requestLength - 2U));

  587.     receivedCrc =

  588.         (uint16_t)(request[requestLength - 2U]

  589.             | ((uint16_t)request[requestLength - 1U] << 8U));

  590. 

  591.     if (calculatedCrc != receivedCrc)

  592.     {

  593.         ModbusSlaveStatistics.crcErrorCount++;

  594.         return 0U;

  595.     }

  596. 

  597.     if ((request[0] != ModbusSlaveAddress)

  598.         && (request[0] != MODBUS_BROADCAST_ADDRESS))

  599.     {

  600.         ModbusSlaveStatistics.ignoredAddressCount++;

  601.         return 0U;

  602.     }

  603. 

  604.     isBroadcast = (request[0] == MODBUS_BROADCAST_ADDRESS) ? 1U : 0U;

  605.     ModbusSlaveStatistics.validFrameCount++;

  606.     ModbusLastValidFrameTick = HAL_GetTick();

  607.     ModbusHasReceivedValidFrame = 1U;

  608. 

  609.     switch (request[1])

  610.     {

  611.         case 0X01U://读线圈

  612.             // 广播请求不允许读取，从站不作响应。 

  613.             return (isBroadcast != 0U) ? 0U :

  614.                 ModbusProcessReadCoils(request, requestLength);

  615. 

  616.         case 0X03U://读保持寄存器

  617.             return (isBroadcast != 0U) ? 0U :

  618.                 ModbusProcessReadHolding(request, requestLength);

  619. 

  620.         case 0x05U://写单个线圈

  621.             return ModbusProcessWriteSingleCoil(request,

  622.                                                 requestLength,

  623.                                                 isBroadcast);

  624. 

  625.         case 0x06U://写单个保持寄存器

  626.             return ModbusProcessWriteSingleRegister(request,

  627.                                                     requestLength,

  628.                                                     isBroadcast);

  629. 

  630.         case 0x0FU://写多个线圈

  631.             return ModbusProcessWriteMultipleCoils(request,

  632.                 requestLength,

  633.                 isBroadcast);

  634. 

  635.         case 0x10U://写多个保持寄存器

  636.             return ModbusProcessWriteMultipleRegisters(request,

  637.                 requestLength,

  638.                 isBroadcast);

  639. 

  640.         default://未知功能码

  641.             ModbusSlaveStatistics.illegalFunctionCount++;

  642.             return (isBroadcast != 0U) ? 0U :

  643.                 ModbusBuildException(request[1], MODBUS_EX_ILLEGAL_FUNCTION);

  644.     }

  645. }

  646. 

  647. HAL_StatusTypeDef ModbusSlaveInit(UART_HandleTypeDef *huart,

  648.     uint8_t slaveAddress)

  649. {

  650. 

  651.     ModbusUart = huart;

  652.     ModbusSlaveAddress = slaveAddress;

  653. 

  654.     ModbusHoldingRegisters[HMI_REG_DEVICE_ID] = 0xF407U;

  655. 

  656.     return ModbusStartReceive();

  657. }

  658. 

  659. void ModbusSlavePoll(void)

  660. {

  661.     uint16_t responseLength;

  662. 

  663.     if ((ModbusRxFrameReady == 0U) || (ModbusTxBusy != 0U))

  664.     {

  665.         return;

  666.     }

  667. 

  668.     /*

  669.      * IDLE 事件在约 1 个字符静默后产生；再等待到 2 ms，

  670.      * 满足当前 115200 bit/s 下的 Modbus RTU 帧间隔要求。

  671.      */

  672.     // if ((HAL_GetTick() - ModbusRxEventTick) < MODBUS_RTU_FRAME_GAP_MS)

  673.     // {

  674.     //     return;

  675.     // }

  676. 

  677.     responseLength = ModbusProcessRequest(ModbusRxFrame, ModbusRxFrameLength);

  678.         

  679. 

  680.     if (responseLength > 0U)

  681.     {

  682.         /*

  683.          * 发送期间停止接收

  684.          * 

  685.          */

  686.         ModbusStopReceive();

  687.         ModbusTxBusy = 1U;

  688. 

  689.         if (HAL_UART_Transmit_DMA(ModbusUart,

  690.                                   ModbusTxFrame,

  691.                                   responseLength) == HAL_OK)                                                               

  692.         {

  693.             ModbusSlaveStatistics.txFrameCount++;

  694.         }

  695.         else

  696.         {

  697.             ModbusTxBusy = 0U;

  698.             ModbusSlaveStatistics.uartErrorCount++;

  699.             (void)ModbusStartReceive();//重启DMA接收

  700.         }

  701.     }

  702. 

  703.     /*

  704.      * 处理期间保持 ModbusRxFrameReady 为 1，使中断不会覆盖

  705.      * 当前帧；处理完成后再释放帧槽。

  706.      */

  707.     ModbusRxFrameReady = 0U;

  708. }

  709. 

  710. void ModbusSlaveOnRxEvent(UART_HandleTypeDef *huart, uint16_t size)

  711. {

  712.     if ((huart != ModbusUart) || (ModbusUart == NULL))

  713.     {

  714.         return;

  715.     }

  716. 

  717.     ModbusSlaveStatistics.rxEventCount++;//串口接收事件计数

  718. 

  719.     if ((size > 0U) && (size <= MODBUS_RTU_ADU_SIZE_MAX))

  720.     {

  721.         if (ModbusRxFrameReady == 0U)

  722.         {

  723.             (void)memcpy(ModbusRxFrame, ModbusRxDmaBuffer, size);

  724.             ModbusRxFrameLength = size;

  725.             ModbusRxEventTick = HAL_GetTick();

  726.             ModbusRxFrameReady = 1U;

  727.         }

  728.         else

  729.         {

  730.             /* 单帧槽尚未处理完成，丢弃新帧而不覆盖旧帧。 */

  731.             ModbusSlaveStatistics.droppedFrameCount++;

  732.         }

  733.     }

  734.     else

  735.     {

  736.         ModbusSlaveStatistics.droppedFrameCount++;

  737.     }

  738. 

  739.     /* DMA 普通模式在 IDLE 事件后停止，需要重新启动。 */

  740.     if (ModbusTxBusy == 0U)

  741.     {

  742.         (void)ModbusStartReceive();

  743.     }

  744. }

  745. 

  746. void ModbusSlaveOnTxComplete(UART_HandleTypeDef *huart)

  747. {

  748.     if ((huart != ModbusUart) || (ModbusUart == NULL))

  749.     {

  750.         return;

  751.     }

  752. 

  753.     ModbusTxBusy = 0U;

  754.     (void)ModbusStartReceive();//重启DMA接收

  755. }

  756. 

  757. void ModbusSlaveOnUartError(UART_HandleTypeDef *huart)

  758. {

  759.     if ((huart != ModbusUart) || (ModbusUart == NULL))

  760.     {

  761.         return;

  762.     }

  763. 

  764.     ModbusSlaveStatistics.uartErrorCount++;

  765.     ModbusTxBusy = 0U;

  766.     (void)HAL_UART_Abort(huart);//立即终止这个串口当前正在进行的发送和接收操作

  767.     (void)ModbusStartReceive();//重启DMA接收

  768. }

  769. 

  770. uint8_t ModbusSlaveSetHoldingRegister(uint16_t address, uint16_t value)

  771. {

  772.     if (address >= MODBUS_MAP_ITEM_COUNT)

  773.     {

  774.         return 0U;

  775.     }

  776. 

  777.     ModbusHoldingRegisters[address] = value;

  778.     return 1U;

  779. }

  780. 

  781. uint8_t ModbusSlaveGetHoldingRegister(uint16_t address, uint16_t *value)

  782. {

  783.     if ((address >= MODBUS_MAP_ITEM_COUNT) || (value == NULL))

  784.     {

  785.         return 0U;

  786.     }

  787. 

  788.     *value = ModbusHoldingRegisters[address];

  789.     return 1U;

  790. }

  791. 

  792. uint8_t ModbusSlaveSetCoil(uint16_t address, uint8_t state)

  793. {

  794.     if (address >= MODBUS_MAP_ITEM_COUNT)

  795.     {

  796.         return 0U;

  797.     }

  798. 

  799.     ModbusCoilSetUnchecked(address, state);

  800.     return 1U;

  801. }

  802. 

  803. uint8_t ModbusSlaveGetCoil(uint16_t address, uint8_t *state)

  804. {

  805.     if ((address >= MODBUS_MAP_ITEM_COUNT) || (state == NULL))

  806.     {

  807.         return 0U;

  808.     }

  809. 

  810.     *state = ModbusCoilGetUnchecked(address);

  811.     return 1U;

  812. }

  813. 

  814. uint8_t ModbusSlaveIsConnected(uint32_t timeoutMs)

  815. {

  816.     if (ModbusHasReceivedValidFrame == 0U)

  817.     {

  818.         return 0U;

  819.     }

  820. 

  821.     return ((HAL_GetTick() - ModbusLastValidFrameTick) <= timeoutMs)

  822.         ? 1U

  823.         : 0U;

  824. }