yuwenhao
/
Modbus-rtu
1
0
派生 0
代码 工单 0 合并请求 0 版本发布 0 百科 动态
您最多选择25个主题 主题必须以字母或数字开头，可以包含连字符 (-)，并且长度不得超过35个字符
10 提交
3 分支
138 MiB
 
 
 
 
 
 
目录树: dc8b337b2e
分支列表 标签列表
${ item.name }
创建分支 ${ searchTerm }
从 'dc8b337b2e'
${ noResults }
Modbus-rtu/Modbus/Src/modbus_rtu_slave.c

797 行
22 KiB
原始文件 Blame 文件历史 

  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. #define MODBUS_EX_ILLEGAL_FUNCTION       (0x01U)

  24. #define MODBUS_EX_ILLEGAL_ADDRESS        (0x02U)

  25. #define MODBUS_EX_ILLEGAL_VALUE          (0x03U)

  26. 

  27. #define MODBUS_READ_COILS_MAX            (2000U)

  28. #define MODBUS_READ_REGS_MAX             (125U)

  29. #define MODBUS_WRITE_COILS_MAX           (1968U)

  30. #define MODBUS_WRITE_REGS_MAX            (123U)

  31. 

  32. #define MODBUS_COIL_VALUE_ON             (0xFF00U)

  33. #define MODBUS_COIL_VALUE_OFF            (0x0000U)

  34. 

  35. static UART_HandleTypeDef *ModbusUart;

  36. static uint8_t ModbusSlaveAddress;

  37. 

  38. /**

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

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

  41.  */

  42. static uint8_t ModbusRxDmaBuffer[MODBUS_RTU_ADU_SIZE_MAX];

  43. static uint8_t ModbusRxFrame[MODBUS_RTU_ADU_SIZE_MAX];

  44. static uint8_t ModbusTxFrame[MODBUS_RTU_ADU_SIZE_MAX];

  45. 

  46. static volatile uint16_t ModbusRxFrameLength;

  47. static volatile uint8_t ModbusRxFrameReady;

  48. static volatile uint8_t ModbusTxBusy;

  49. static volatile uint32_t ModbusRxEventTick;

  50. static volatile uint32_t ModbusLastValidFrameTick;

  51. static volatile uint8_t ModbusHasReceivedValidFrame;

  52. 

  53. /**

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

  55.  * 占用 1250 字节。

  56.  */

  57. static uint16_t ModbusHoldingRegisters[MODBUS_MAP_ITEM_COUNT];

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

  59. 

  60. volatile MODBUS_SLAVE_STATS ModbusSlaveStatistics;

  61. 

  62. /**

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

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

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

  66.  * @return CRC16 校验值。

  67.  */

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

  69. {

  70.     uint16_t crc = 0xFFFFU;

  71.     uint16_t index;

  72.     uint8_t bit;

  73. 

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

  75.     {

  76.         crc ^= data[index];

  77. 

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

  79.         {

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

  81.             {

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

  83.             }

  84.             else

  85.             {

  86.                 crc >>= 1U;

  87.             }

  88.         }

  89.     }

  90. 

  91.     return crc;

  92. }

  93. 

  94. /**

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

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

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

  98.  */

  99. static uint16_t ModbusGetU16Be(const uint8_t *data)

  100. {

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

  102. }

  103. 

  104. /**

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

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

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

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

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

  110.  */

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

  112. {

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

  114.     {

  115.         return 0U;

  116.     }

  117. 

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

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

  120. }

  121. 

  122. /**

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

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

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

  126.  */

  127. static uint8_t ModbusCoilGetUnchecked(uint16_t address)

  128. {

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

  130. 

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

  132. }

  133. 

  134. /**

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

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

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

  138.  */

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

  140. {

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

  142. 

  143.     if (state != 0U)

  144.     {

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

  146.     }

  147.     else

  148.     {

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

  150.     }

  151. }

  152. 

  153. /**

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

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

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

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

  158.  */

  159. static HAL_StatusTypeDef ModbusStartReceive(void)

  160. {

  161.     HAL_StatusTypeDef status;

  162. 

  163.     if (ModbusTxBusy != 0U)

  164.     {

  165.         return HAL_BUSY;

  166.     }

  167. 

  168.     status = HAL_UARTEx_ReceiveToIdle_DMA(ModbusUart,

  169.                                           ModbusRxDmaBuffer,

  170.                                           sizeof(ModbusRxDmaBuffer));

  171. 

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

  173.     {

  174.         /*

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

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

  177.          */

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

  179.     }

  180. 

  181.     return status;

  182. }

  183. 

  184. 

  185. 

  186. /**

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

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

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

  190.  */

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

  192. {

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

  194. 

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

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

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

  198. }

  199. 

  200. /**

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

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

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

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

  205.  */

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

  207. {

  208.     ModbusTxFrame[0] = ModbusSlaveAddress;

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

  210.     ModbusTxFrame[2] = exception;

  211.     ModbusAppendCrc(ModbusTxFrame, 3U);

  212. 

  213.     return 5U;

  214. }

  215. 

  216. /**

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

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

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

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

  221.  */

  222. static uint16_t ModbusProcessReadCoils(const uint8_t *request,

  223.     uint16_t requestLength)

  224. {

  225.     uint16_t start;

  226.     uint16_t quantity;

  227.     uint16_t index;

  228.     uint8_t byteCount;

  229. 

  230.     if (requestLength != 8U)

  231.     {

  232.         ModbusSlaveStatistics.illegalValueCount++;

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

  234.     }

  235. 

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

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

  238. 

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

  240.     {

  241.         ModbusSlaveStatistics.illegalValueCount++;

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

  243.     }

  244. 

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

  246.     {

  247.         ModbusSlaveStatistics.illegalAddressCount++;

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

  249.     }

  250. 

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

  252.     ModbusTxFrame[0] = ModbusSlaveAddress;

  253.     ModbusTxFrame[1] = 0X01;

  254.     ModbusTxFrame[2] = byteCount;

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

  256. 

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

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

  259.     {

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

  261.         {

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

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

  264.         }

  265.     }

  266. 

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

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

  269. }

  270. 

  271. /**

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

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

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

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

  276.  */

  277. static uint16_t ModbusProcessReadHolding(const uint8_t *request,

  278.     uint16_t requestLength)

  279. {

  280.     uint16_t start;

  281.     uint16_t quantity;

  282.     uint16_t index;

  283.     uint16_t value;

  284. 

  285.     if (requestLength != 8U)

  286.     {

  287.         ModbusSlaveStatistics.illegalValueCount++;

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

  289.     }

  290. 

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

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

  293. 

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

  295.     {

  296.         ModbusSlaveStatistics.illegalValueCount++;

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

  298.     }

  299. 

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

  301.     {

  302.         ModbusSlaveStatistics.illegalAddressCount++;

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

  304.     }

  305. 

  306.     ModbusTxFrame[0] = ModbusSlaveAddress;

  307.     ModbusTxFrame[1] = 0X03;

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

  309. 

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

  311.     {

  312.         value = ModbusHoldingRegisters[start + index];

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

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

  315.     }

  316. 

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

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

  319. }

  320. 

  321. /**

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

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

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

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

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

  327.  */

  328. static uint16_t ModbusProcessWriteSingleRegister(

  329.     const uint8_t *request,

  330.     uint16_t requestLength,

  331.     uint8_t isBroadcast)

  332. {

  333.     uint16_t address;

  334.     uint16_t value;

  335. 

  336.     if (requestLength != 8U)

  337.     {

  338.         ModbusSlaveStatistics.illegalValueCount++;

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

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

  341.     }

  342. 

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

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

  345. 

  346.     if (address >= MODBUS_MAP_ITEM_COUNT)

  347.     {

  348.         ModbusSlaveStatistics.illegalAddressCount++;

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

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

  351.     }

  352. 

  353.     ModbusHoldingRegisters[address] = value;

  354. 

  355.     if (isBroadcast != 0U)

  356.     {

  357.         return 0U;

  358.     }

  359. 

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

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

  362.     ModbusAppendCrc(ModbusTxFrame, 6U);

  363.     return 8U;

  364. }

  365. 

  366. /**

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

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

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

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

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

  372.  */

  373. static uint16_t ModbusProcessWriteSingleCoil(

  374.     const uint8_t *request,

  375.     uint16_t requestLength,

  376.     uint8_t isBroadcast)

  377. {

  378.     uint16_t address;

  379.     uint16_t value;

  380. 

  381.     if (requestLength != 8U)

  382.     {

  383.         ModbusSlaveStatistics.illegalValueCount++;

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

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

  386.     }

  387. 

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

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

  390. 

  391.     /*

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

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

  394.      */

  395.     if ((value != MODBUS_COIL_VALUE_ON)

  396.         && (value != MODBUS_COIL_VALUE_OFF))

  397.     {

  398.         ModbusSlaveStatistics.illegalValueCount++;

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

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

  401.     }

  402. 

  403.     if (address >= MODBUS_MAP_ITEM_COUNT)

  404.     {

  405.         ModbusSlaveStatistics.illegalAddressCount++;

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

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

  408.     }

  409. 

  410.     ModbusCoilSetUnchecked(

  411.         address,

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

  413. 

  414.     if (isBroadcast != 0U)

  415.     {

  416.         return 0U;

  417.     }

  418. 

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

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

  421.     ModbusAppendCrc(ModbusTxFrame, 6U);

  422.     return 8U;

  423. }

  424. 

  425. /**

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

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

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

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

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

  431.  */

  432. static uint16_t ModbusProcessWriteMultipleCoils(

  433.     const uint8_t *request,

  434.     uint16_t requestLength,

  435.     uint8_t isBroadcast)

  436. {

  437.     uint16_t start;

  438.     uint16_t quantity;

  439.     uint16_t index;

  440.     uint8_t byteCount;

  441.     uint8_t expectedByteCount;

  442. 

  443.     if (requestLength < 9U)

  444.     {

  445.         ModbusSlaveStatistics.illegalValueCount++;

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

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

  448.     }

  449. 

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

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

  452.     byteCount = request[6];

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

  454. 

  455.     if ((quantity == 0U)

  456.         || (quantity > MODBUS_WRITE_COILS_MAX)

  457.         || (byteCount != expectedByteCount)

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

  459.     {

  460.         ModbusSlaveStatistics.illegalValueCount++;

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

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

  463.     }

  464. 

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

  466.     {

  467.         ModbusSlaveStatistics.illegalAddressCount++;

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

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

  470.     }

  471. 

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

  473.     {

  474.         uint8_t state;

  475. 

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

  477.             >> (index & 0x0007U))

  478.             & 0x01U);

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

  480.     }

  481. 

  482.     if (isBroadcast != 0U)

  483.     {

  484.         return 0U;

  485.     }

  486. 

  487.     ModbusTxFrame[0] = ModbusSlaveAddress;

  488.     ModbusTxFrame[1] = 0X0F;

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

  490.     ModbusAppendCrc(ModbusTxFrame, 6U);

  491.     return 8U;

  492. }

  493. 

  494. /**

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

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

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

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

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

  500.  */

  501. static uint16_t ModbusProcessWriteMultipleRegisters(

  502.     const uint8_t *request,

  503.     uint16_t requestLength,

  504.     uint8_t isBroadcast)

  505. {

  506.     uint16_t start;

  507.     uint16_t quantity;

  508.     uint16_t index;

  509.     uint8_t byteCount;

  510. 

  511.     if (requestLength < 9U)

  512.     {

  513.         ModbusSlaveStatistics.illegalValueCount++;

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

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

  516.     }

  517. 

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

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

  520.     byteCount = request[6];

  521. 

  522.     if ((quantity == 0U)

  523.         || (quantity > MODBUS_WRITE_REGS_MAX)

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

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

  526.     {

  527.         ModbusSlaveStatistics.illegalValueCount++;

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

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

  530.     }

  531. 

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

  533.     {

  534.         ModbusSlaveStatistics.illegalAddressCount++;

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

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

  537.     }

  538. 

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

  540.     {

  541.         ModbusHoldingRegisters[start + index] =

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

  543.     }

  544. 

  545.     if (isBroadcast != 0U)

  546.     {

  547.         return 0U;

  548.     }

  549. 

  550.     ModbusTxFrame[0] = ModbusSlaveAddress;

  551.     ModbusTxFrame[1] = 0X10;

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

  553.     ModbusAppendCrc(ModbusTxFrame, 6U);

  554.     return 8U;

  555. }

  556. 

  557. /**

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

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

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

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

  562.  */

  563. static uint16_t ModbusProcessRequest(const uint8_t *request,

  564.     uint16_t requestLength)

  565. {

  566.     uint16_t calculatedCrc;

  567.     uint16_t receivedCrc;

  568.     uint8_t isBroadcast;

  569. 

  570.     if (requestLength < 4U)

  571.     {

  572.         return 0U;

  573.     }

  574. 

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

  576.     receivedCrc =

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

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

  579. 

  580.     if (calculatedCrc != receivedCrc)

  581.     {

  582.         ModbusSlaveStatistics.crcErrorCount++;

  583.         return 0U;

  584.     }

  585. 

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

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

  588.     {

  589.         ModbusSlaveStatistics.ignoredAddressCount++;

  590.         return 0U;

  591.     }

  592. 

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

  594.     ModbusSlaveStatistics.validFrameCount++;

  595.     ModbusLastValidFrameTick = HAL_GetTick();

  596.     ModbusHasReceivedValidFrame = 1U;

  597. 

  598.     switch (request[1])

  599.     {

  600.         case 0X01U://读线圈

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

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

  603.                 ModbusProcessReadCoils(request, requestLength);

  604. 

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

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

  607.                 ModbusProcessReadHolding(request, requestLength);

  608. 

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

  610.             return ModbusProcessWriteSingleCoil(request,

  611.                                                 requestLength,

  612.                                                 isBroadcast);

  613. 

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

  615.             return ModbusProcessWriteSingleRegister(request,

  616.                                                     requestLength,

  617.                                                     isBroadcast);

  618. 

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

  620.             return ModbusProcessWriteMultipleCoils(request,

  621.                 requestLength,

  622.                 isBroadcast);

  623. 

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

  625.             return ModbusProcessWriteMultipleRegisters(request,

  626.                 requestLength,

  627.                 isBroadcast);

  628. 

  629.         default://未知功能码

  630.             ModbusSlaveStatistics.illegalFunctionCount++;

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

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

  633.     }

  634. }

  635. 

  636. HAL_StatusTypeDef ModbusSlaveInit(UART_HandleTypeDef *huart,

  637.     uint8_t slaveAddress)

  638. {

  639. 

  640.     ModbusUart = huart;

  641.     ModbusSlaveAddress = slaveAddress;

  642. 

  643.     ModbusHoldingRegisters[HMI_REG_DEVICE_ID] = 0xF407U;

  644. 

  645.     return ModbusStartReceive();

  646. }

  647. 

  648. void ModbusSlavePoll(void)

  649. {

  650.     uint16_t responseLength;

  651. 

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

  653.     {

  654.         return;

  655.     }

  656. 

  657. 

  658. 

  659.     responseLength = ModbusProcessRequest(ModbusRxFrame, ModbusRxFrameLength);

  660.         

  661. 

  662.     if (responseLength > 0U)

  663.     {

  664.         ModbusTxBusy = 1U;

  665. 

  666.         if (HAL_UART_Transmit_DMA(ModbusUart,

  667.                                   ModbusTxFrame,

  668.                                   responseLength) == HAL_OK)                                                               

  669.         {

  670.             ModbusSlaveStatistics.txFrameCount++;

  671.         }

  672.         else

  673.         {

  674.             ModbusTxBusy = 0U;

  675.             ModbusSlaveStatistics.uartErrorCount++;

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

  677.         }

  678.     }

  679.     else 

  680.     {

  681.          (void)ModbusStartReceive();

  682.     }

  683. 

  684.     /*

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

  686.      */

  687.     ModbusRxFrameReady = 0U;

  688. }

  689. 

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

  691. {

  692. 

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

  694. 

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

  696.     {

  697.         if (ModbusRxFrameReady == 0U)

  698.         {

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

  700.             ModbusRxFrameLength = size;

  701.             ModbusRxEventTick = HAL_GetTick();

  702.             ModbusRxFrameReady = 1U;

  703.         }

  704.         else

  705.         {

  706.             //前一帧未处理完毕

  707.             ModbusSlaveStatistics.droppedFrameCount++;

  708.         }

  709.     }

  710.     else

  711.     {

  712.         //长度异常帧

  713.         ModbusSlaveStatistics.droppedFrameCount++;

  714.         (void)ModbusStartReceive();

  715.     }

  716. }

  717. 

  718. void ModbusSlaveOnTxComplete(UART_HandleTypeDef *huart)

  719. {

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

  721.     {

  722.         return;

  723.     }

  724. 

  725.     ModbusTxBusy = 0U;

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

  727. }

  728. 

  729. void ModbusSlaveOnUartError(UART_HandleTypeDef *huart)

  730. {

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

  732.     {

  733.         return;

  734.     }

  735. 

  736.     ModbusSlaveStatistics.uartErrorCount++;

  737.     ModbusTxBusy = 0U;

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

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

  740. }

  741. 

  742. uint8_t ModbusSlaveSetHoldingRegister(uint16_t address, uint16_t value)

  743. {

  744.     if (address >= MODBUS_MAP_ITEM_COUNT)

  745.     {

  746.         return 0U;

  747.     }

  748. 

  749.     ModbusHoldingRegisters[address] = value;

  750.     return 1U;

  751. }

  752. 

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

  754. {

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

  756.     {

  757.         return 0U;

  758.     }

  759. 

  760.     *value = ModbusHoldingRegisters[address];

  761.     return 1U;

  762. }

  763. 

  764. uint8_t ModbusSlaveSetCoil(uint16_t address, uint8_t state)

  765. {

  766.     if (address >= MODBUS_MAP_ITEM_COUNT)

  767.     {

  768.         return 0U;

  769.     }

  770. 

  771.     ModbusCoilSetUnchecked(address, state);

  772.     return 1U;

  773. }

  774. 

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

  776. {

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

  778.     {

  779.         return 0U;

  780.     }

  781. 

  782.     *state = ModbusCoilGetUnchecked(address);

  783.     return 1U;

  784. }

  785. 

  786. uint8_t ModbusSlaveIsConnected(uint32_t timeoutMs)

  787. {

  788.     if (ModbusHasReceivedValidFrame == 0U)

  789.     {

  790.         return 0U;

  791.     }

  792. 

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

  794.         ? 1U

  795.         : 0U;

  796. }