yuwenhao
/
Modbus-rtu
1
0
フォーク 0
コード 課題 0 プルリクエスト 0 リリース 0 Wiki アクティビティ
選択できるのは25トピックまでです。 トピックは、先頭が英数字で、英数字とダッシュ('-')を使用した35文字以内のものにしてください。
12 コミット
3 ブランチ
138 MiB
 
 
 
 
 
 
ツリー: a338c8cfa3
ブランチ タグ
${ item.name }
ブランチ ${ searchTerm } を作成
'a338c8cfa3' から
${ noResults }
Modbus-rtu/Modbus/Src/modbus_rtu_slave.c

835 行
23 KiB
Raw Blame 履歴 

  1. #include "modbus_rtu_slave.h"

  2. 

  3. #include <string.h>

  4. 

  5. #define MODBUS_RTU_ADU_SIZE_MAX          (256U)//Modbus RTU 最大 ADU 长度，单位为字节

  6. 

  7. 

  8. #define MODBUS_RTU_FRAME_GAP_MS          (2U)

  9. 

  10. #define MODBUS_BROADCAST_ADDRESS         (0U)//广播地址

  11. 

  12. #define MODBUS_EX_ILLEGAL_FUNCTION       (0x01U)//非法功能码的异常码

  13. #define MODBUS_EX_ILLEGAL_ADDRESS        (0x02U)//非法地址的异常码

  14. #define MODBUS_EX_ILLEGAL_VALUE          (0x03U)//非法数据的异常码

  15. 

  16. #define MODBUS_READ_COILS_MAX            (2000U)//一次ADU最大线圈读取数量

  17. #define MODBUS_READ_REGS_MAX             (125U) //一次ADU最大寄存器读取数量

  18. #define MODBUS_WRITE_COILS_MAX           (1968U)//一次ADU最大线圈写入数量

  19. #define MODBUS_WRITE_REGS_MAX            (123U) //一次ADU最大寄存器写入数量

  20. 

  21. #define MODBUS_COIL_VALUE_ON             (0xFF00U)

  22. #define MODBUS_COIL_VALUE_OFF            (0x0000U)

  23. 

  24. static UART_HandleTypeDef *ModbusUart;

  25. static uint8_t ModbusSlaveAddress;

  26. 

  27. /**

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

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

  30.  */

  31. static uint8_t ModbusRxDmaBuffer[MODBUS_RTU_ADU_SIZE_MAX];

  32. static uint8_t ModbusRxFrame[MODBUS_RTU_ADU_SIZE_MAX];

  33. static uint8_t ModbusTxFrame[MODBUS_RTU_ADU_SIZE_MAX];

  34. /* D100～D120 上一次已保存的值，用于检测数据是否变化 */

  35. static uint16_t ModbusRetainedSnapshot[MODBUS_RETAINED_D_COUNT];

  36. static volatile uint16_t ModbusRxFrameLength;

  37. static volatile uint8_t ModbusRxFrameReady;

  38. static volatile uint8_t ModbusTxBusy;

  39. static volatile uint32_t ModbusRxEventTick;

  40. static volatile uint32_t ModbusLastValidFrameTick;

  41. static volatile uint8_t ModbusHasReceivedValidFrame;

  42. 

  43. /**

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

  45.  * 占用 1250 字节

  46.  */

  47. static uint16_t ModbusHoldingRegisters[MODBUS_MAP_ITEM_COUNT];

  48. 

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

  50. 

  51. volatile MODBUS_SLAVE_STATS ModbusSlaveStatistics;

  52. 

  53. /**

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

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

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

  57.  * @return CRC16 校验值

  58.  */

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

  60. {

  61.     uint16_t crc = 0xFFFFU;

  62.     uint16_t index;

  63.     uint8_t bit;

  64. 

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

  66.     {

  67.         crc ^= data[index];

  68. 

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

  70.         {

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

  72.             {

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

  74.             }

  75.             else

  76.             {

  77.                 crc >>= 1U;

  78.             }

  79.         }

  80.     }

  81. 

  82.     return crc;

  83. }

  84. 

  85. /**

  86.  * @brief 提取一个 16 位无符号整数

  87.  * @param[in] data 两个字节的数据地址

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

  89.  */

  90. static uint16_t ModbusGetU16Be(const uint8_t *data)

  91. {

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

  93. }

  94. 

  95. /**

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

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

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

  99.  */

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

  101. {

  102.     if (start >= MODBUS_MAP_ITEM_COUNT)

  103.     {

  104.         return 0U;

  105.     }

  106. 

  107.     // 先做减法再比较，避免溢出

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

  109. }

  110. 

  111. /**

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

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

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

  115.  */

  116. static uint8_t ModbusCoilGetUnchecked(uint16_t address)

  117. {

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

  119. 

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

  121. }

  122. 

  123. /**

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

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

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

  127.  */

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

  129. {

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

  131. 

  132.     if (state != 0U)

  133.     {

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

  135.     }

  136.     else

  137.     {

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

  139.     }

  140. }

  141. 

  142. /**

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

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

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

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

  147.  */

  148. static HAL_StatusTypeDef ModbusStartReceive(void)

  149. {

  150.     HAL_StatusTypeDef status;

  151. 

  152.     if (ModbusTxBusy != 0U)

  153.     {

  154.         return HAL_BUSY;

  155.     }

  156. 

  157.     status = HAL_UARTEx_ReceiveToIdle_DMA(ModbusUart,

  158.                                           ModbusRxDmaBuffer,

  159.                                           sizeof(ModbusRxDmaBuffer));

  160. 

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

  162.     {

  163.         /*

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

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

  166.          */

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

  168.     }

  169. 

  170.     return status;

  171. }

  172. 

  173. 

  174. 

  175. /**

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

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

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

  179.  */

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

  181. {

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

  183. 

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

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

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

  187. }

  188. 

  189. /**

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

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

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

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

  194.  */

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

  196. {

  197.     ModbusTxFrame[0] = ModbusSlaveAddress;

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

  199.     ModbusTxFrame[2] = exception;

  200.     ModbusAppendCrc(ModbusTxFrame, 3U);

  201. 

  202.     return 5U;

  203. }

  204. 

  205. /**

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

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

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

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

  210.  */

  211. static uint16_t ModbusProcessReadCoils(const uint8_t *request, uint16_t requestLength)

  212. {

  213.    

  214.     uint16_t start;

  215.     uint16_t quantity;

  216.     uint16_t index;

  217.     uint8_t byteCount;

  218. 

  219.     if (requestLength != 8U)

  220.     {

  221.         ModbusSlaveStatistics.illegalValueCount++;

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

  223.     }

  224. 

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

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

  227. 

  228.     if ((quantity == 0U) || (quantity > MODBUS_READ_COILS_MAX))//数量0或者数量大于最大值

  229.     {

  230.         ModbusSlaveStatistics.illegalValueCount++;

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

  232.     }

  233. 

  234.     if (ModbusAddressRangeIsValid(start, quantity) == 0U)//地址检查

  235.     {

  236.         ModbusSlaveStatistics.illegalAddressCount++;

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

  238.     }

  239. 

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

  241.     ModbusTxFrame[0] = ModbusSlaveAddress;

  242.     ModbusTxFrame[1] = 0X01;

  243.     ModbusTxFrame[2] = byteCount;

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

  245. 

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

  247.     {

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

  249.         {

  250.             ModbusTxFrame[3U + (index >> 3U)] |= (uint8_t)(1U << (index & 0x0007U));

  251.                

  252.         }

  253.     }

  254. 

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

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

  257. }

  258. 

  259. /**

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

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

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

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

  264.  */

  265. static uint16_t ModbusProcessReadHolding(const uint8_t *request,uint16_t requestLength)

  266.     

  267. {

  268.     uint16_t start;

  269.     uint16_t quantity;

  270.     uint16_t index;

  271.     uint16_t value;

  272. 

  273.     if (requestLength != 8U)

  274.     {

  275.         ModbusSlaveStatistics.illegalValueCount++;

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

  277.     }

  278. 

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

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

  281. 

  282.     if ((quantity == 0U) || (quantity > MODBUS_READ_REGS_MAX))//数量0或者数量大于最大值

  283.     {

  284.         ModbusSlaveStatistics.illegalValueCount++;

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

  286.     }

  287. 

  288.     if (ModbusAddressRangeIsValid(start, quantity) == 0U)//地址检查

  289.     {

  290.         ModbusSlaveStatistics.illegalAddressCount++;

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

  292.     }

  293. 

  294.     ModbusTxFrame[0] = ModbusSlaveAddress;

  295.     ModbusTxFrame[1] = 0X03;

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

  297. 

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

  299.     {

  300.         value = ModbusHoldingRegisters[start + index];

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

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

  303.     }

  304. 

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

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

  307. }

  308. 

  309. /**

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

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

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

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

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

  315.  */

  316. static uint16_t ModbusProcessWriteSingleRegister(

  317.     const uint8_t *request,

  318.     uint16_t requestLength,

  319.     uint8_t isBroadcast)

  320. {

  321.     uint16_t address;

  322.     uint16_t value;

  323. 

  324.     if (requestLength != 8U)

  325.     {

  326.         ModbusSlaveStatistics.illegalValueCount++;

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

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

  329.     }

  330. 

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

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

  333. 

  334.     if (address >= MODBUS_MAP_ITEM_COUNT)

  335.     {

  336.         ModbusSlaveStatistics.illegalAddressCount++;

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

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

  339.     }

  340. 

  341.     ModbusHoldingRegisters[address] = value;

  342. 

  343.     if (isBroadcast != 0U)

  344.     {

  345.         return 0U;

  346.     }

  347. 

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

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

  350.     ModbusAppendCrc(ModbusTxFrame, 6U);

  351.     return 8U;

  352. }

  353. 

  354. /**

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

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

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

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

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

  360.  */

  361. static uint16_t ModbusProcessWriteSingleCoil(

  362.     const uint8_t *request,

  363.     uint16_t requestLength,

  364.     uint8_t isBroadcast)

  365. {

  366.     uint16_t address;

  367.     uint16_t value;

  368. 

  369.     if (requestLength != 8U)

  370.     {

  371.         ModbusSlaveStatistics.illegalValueCount++;

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

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

  374.     }

  375. 

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

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

  378. 

  379.     /*

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

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

  382.      */

  383.     if ((value != MODBUS_COIL_VALUE_ON)

  384.         && (value != MODBUS_COIL_VALUE_OFF))

  385.     {

  386.         ModbusSlaveStatistics.illegalValueCount++;

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

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

  389.     }

  390. 

  391.     if (address >= MODBUS_MAP_ITEM_COUNT)

  392.     {

  393.         ModbusSlaveStatistics.illegalAddressCount++;

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

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

  396.     }

  397. 

  398.     ModbusCoilSetUnchecked(

  399.         address,

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

  401. 

  402.     if (isBroadcast != 0U)

  403.     {

  404.         return 0U;

  405.     }

  406. 

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

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

  409.     ModbusAppendCrc(ModbusTxFrame, 6U);

  410.     return 8U;

  411. }

  412. 

  413. /**

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

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

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

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

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

  419.  */

  420. static uint16_t ModbusProcessWriteMultipleCoils(

  421.     const uint8_t *request,

  422.     uint16_t requestLength,

  423.     uint8_t isBroadcast)

  424. {

  425.     uint16_t start;

  426.     uint16_t quantity;

  427.     uint16_t index;

  428.     uint8_t byteCount;

  429.     uint8_t expectedByteCount;

  430. 

  431.     if (requestLength < 9U)

  432.     {

  433.         ModbusSlaveStatistics.illegalValueCount++;

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

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

  436.     }

  437. 

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

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

  440.     byteCount = request[6];

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

  442. 

  443.     if ((quantity == 0U)

  444.         || (quantity > MODBUS_WRITE_COILS_MAX)

  445.         || (byteCount != expectedByteCount)

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

  447.     {

  448.         ModbusSlaveStatistics.illegalValueCount++;

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

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

  451.     }

  452. 

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

  454.     {

  455.         ModbusSlaveStatistics.illegalAddressCount++;

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

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

  458.     }

  459. 

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

  461.     {

  462.         uint8_t state;

  463. 

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

  465.             >> (index & 0x0007U))

  466.             & 0x01U);

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

  468.     }

  469. 

  470.     if (isBroadcast != 0U)

  471.     {

  472.         return 0U;

  473.     }

  474. 

  475.     ModbusTxFrame[0] = ModbusSlaveAddress;

  476.     ModbusTxFrame[1] = 0X0F;

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

  478.     ModbusAppendCrc(ModbusTxFrame, 6U);

  479.     return 8U;

  480. }

  481. 

  482. /**

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

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

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

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

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

  488.  */

  489. static uint16_t ModbusProcessWriteMultipleRegisters(

  490.     const uint8_t *request,

  491.     uint16_t requestLength,

  492.     uint8_t isBroadcast)

  493. {

  494.     uint16_t start;

  495.     uint16_t quantity;

  496.     uint16_t index;

  497.     uint8_t byteCount;

  498. 

  499.     if (requestLength < 9U)

  500.     {

  501.         ModbusSlaveStatistics.illegalValueCount++;

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

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

  504.     }

  505. 

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

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

  508.     byteCount = request[6];

  509. 

  510.     if ((quantity == 0U)

  511.         || (quantity > MODBUS_WRITE_REGS_MAX)

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

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

  514.     {

  515.         ModbusSlaveStatistics.illegalValueCount++;

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

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

  518.     }

  519. 

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

  521.     {

  522.         ModbusSlaveStatistics.illegalAddressCount++;

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

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

  525.     }

  526. 

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

  528.     {

  529.         ModbusHoldingRegisters[start + index] =

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

  531.     }

  532. 

  533.     if (isBroadcast != 0U)

  534.     {

  535.         return 0U;

  536.     }

  537. 

  538.     ModbusTxFrame[0] = ModbusSlaveAddress;

  539.     ModbusTxFrame[1] = 0X10;

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

  541.     ModbusAppendCrc(ModbusTxFrame, 6U);

  542.     return 8U;

  543. }

  544. 

  545. /**

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

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

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

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

  550.  */

  551. static uint16_t ModbusProcessRequest(const uint8_t *request,uint16_t requestLength)

  552. {

  553.     uint16_t calculatedCrc;

  554.     uint16_t receivedCrc;

  555.     uint8_t isBroadcast;

  556. 

  557.     if (requestLength < 4U)

  558.     {

  559.         return 0U;

  560.     }

  561. 

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

  563.     receivedCrc =

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

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

  566. 

  567.     if (calculatedCrc != receivedCrc)//CRC校验

  568.     {

  569.         ModbusSlaveStatistics.crcErrorCount++;

  570.         return 0U;

  571.     }

  572. 

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

  574.         && (request[0] != MODBUS_BROADCAST_ADDRESS))//非法从站地址

  575.     {

  576.         ModbusSlaveStatistics.ignoredAddressCount++;

  577.         return 0U;

  578.     }

  579. 

  580.     isBroadcast = (request[0] == MODBUS_BROADCAST_ADDRESS) ? 1U : 0U;//是否广播请求

  581.     ModbusSlaveStatistics.validFrameCount++;

  582.     ModbusLastValidFrameTick = HAL_GetTick();

  583.     ModbusHasReceivedValidFrame = 1U;

  584. 

  585.     switch (request[1])

  586.     {

  587.         case 0X01U://读线圈

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

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

  590.                 ModbusProcessReadCoils(request, requestLength);

  591. 

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

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

  594.                 ModbusProcessReadHolding(request, requestLength);

  595. 

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

  597.             return ModbusProcessWriteSingleCoil(request,

  598.                                                 requestLength,

  599.                                                 isBroadcast);

  600. 

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

  602.             return ModbusProcessWriteSingleRegister(request,

  603.                                                     requestLength,

  604.                                                     isBroadcast);

  605. 

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

  607.             return ModbusProcessWriteMultipleCoils(request,

  608.                 requestLength,

  609.                 isBroadcast);

  610. 

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

  612.             return ModbusProcessWriteMultipleRegisters(request,

  613.                 requestLength,

  614.                 isBroadcast);

  615.         

  616.         default://未知功能码

  617.             ModbusSlaveStatistics.illegalFunctionCount++;

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

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

  620.     }

  621. }

  622. 

  623. HAL_StatusTypeDef ModbusSlaveInit(UART_HandleTypeDef *huart,

  624.     uint8_t slaveAddress)

  625. {

  626. 

  627.     ModbusUart = huart;

  628.     ModbusSlaveAddress = slaveAddress;

  629. 

  630.     ModbusHoldingRegisters[HMI_REG_DEVICE_ID] = 0xF407U;

  631. 

  632.     return ModbusStartReceive();

  633. }

  634. 

  635. void ModbusSlavePoll(void)

  636. {

  637.     uint16_t responseLength;

  638. 

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

  640.     {

  641.         return;

  642.     }

  643. 

  644. 

  645. 

  646.     responseLength = ModbusProcessRequest(ModbusRxFrame, ModbusRxFrameLength);

  647.         

  648. 

  649.     if (responseLength > 0U)

  650.     {

  651.         ModbusTxBusy = 1U;

  652. 

  653.         if (HAL_UART_Transmit_DMA(ModbusUart,

  654.                                   ModbusTxFrame,

  655.                                   responseLength) == HAL_OK)                                                               

  656.         {

  657.             ModbusSlaveStatistics.txFrameCount++;

  658.         }

  659.         else

  660.         {

  661.             ModbusTxBusy = 0U;

  662.             ModbusSlaveStatistics.uartErrorCount++;

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

  664.         }

  665.     }

  666.     else 

  667.     {

  668.          (void)ModbusStartReceive();

  669.     }

  670. 

  671.     /*

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

  673.      */

  674.     ModbusRxFrameReady = 0U;

  675. }

  676. 

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

  678. {

  679. 

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

  681. 

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

  683.     {

  684.         if (ModbusRxFrameReady == 0U)

  685.         {

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

  687.             ModbusRxFrameLength = size;

  688.             ModbusRxEventTick = HAL_GetTick();

  689.             ModbusRxFrameReady = 1U;

  690.         }

  691.         else

  692.         {

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

  694.             ModbusSlaveStatistics.droppedFrameCount++;

  695.         }

  696.     }

  697.     else

  698.     {

  699.         //长度异常帧

  700.         ModbusSlaveStatistics.droppedFrameCount++;

  701.         (void)ModbusStartReceive();

  702.     }

  703. }

  704. 

  705. void ModbusSlaveOnTxComplete(UART_HandleTypeDef *huart)

  706. {

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

  708.     {

  709.         return;

  710.     }

  711. 

  712.     ModbusTxBusy = 0U;

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

  714. }

  715. 

  716. void ModbusSlaveOnUartError(UART_HandleTypeDef *huart)

  717. {

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

  719.     {

  720.         return;

  721.     }

  722. 

  723.     ModbusSlaveStatistics.uartErrorCount++;

  724.     ModbusTxBusy = 0U;

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

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

  727. }

  728. 

  729. uint8_t ModbusSlaveSetHoldingRegister(uint16_t address, uint16_t value)

  730. {

  731.     if (address >= MODBUS_MAP_ITEM_COUNT)

  732.     {

  733.         return 0U;

  734.     }

  735. 

  736.     ModbusHoldingRegisters[address] = value;

  737.     return 1U;

  738. }

  739. 

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

  741. {

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

  743.     {

  744.         return 0U;

  745.     }

  746. 

  747.     *value = ModbusHoldingRegisters[address];

  748.     return 1U;

  749. }

  750. 

  751. uint8_t ModbusSlaveSetCoil(uint16_t address, uint8_t state)

  752. {

  753.     if (address >= MODBUS_MAP_ITEM_COUNT)

  754.     {

  755.         return 0U;

  756.     }

  757. 

  758.     ModbusCoilSetUnchecked(address, state);

  759.     return 1U;

  760. }

  761. 

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

  763. {

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

  765.     {

  766.         return 0U;

  767.     }

  768. 

  769.     *state = ModbusCoilGetUnchecked(address);

  770.     return 1U;

  771. }

  772. 

  773. uint8_t ModbusSlaveIsConnected(uint32_t timeoutMs)

  774. {

  775.     if (ModbusHasReceivedValidFrame == 0U)

  776.     {

  777.         return 0U;

  778.     }

  779. 

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

  781.         ? 1U

  782.         : 0U;

  783. }

  784. 

  785. //上电恢复函数

  786. void ModbusRetainedRegistersLoad(void)

  787. {

  788.     uint16_t index;

  789. 

  790.     if (backupData->magic == MODBUS_BACKUP_MAGIC)

  791.     {

  792.         for (index = 0U; index < MODBUS_RETAINED_D_COUNT;index++)                         

  793.         {

  794.             ModbusHoldingRegisters[MODBUS_RETAINED_D_START + index] =             

  795.                 backupData->retainedD[index];

  796.         }

  797.     }

  798.     else

  799.     {

  800.         for (index = 0U;index < MODBUS_RETAINED_D_COUNT;index++)                     

  801.         {

  802.             ModbusHoldingRegisters[

  803.                 MODBUS_RETAINED_D_START + index] = 0U;

  804. 

  805.             backupData->retainedD[index] = 0U;

  806.         }

  807. 

  808.         /*

  809.          * 数据初始化完成后最后写magic，避免初始化中途断电

  810.          * 却把不完整数据标记成有效。

  811.          */

  812.         backupData->magic = MODBUS_BACKUP_MAGIC;

  813.     }

  814. }

  815. void ModbusRetainedRegistersPoll(void)

  816. {

  817.     uint16_t index;

  818.    // uint16_t address;

  819.     uint16_t value;

  820. 

  821.     for(index=0;index<MODBUS_RETAINED_D_COUNT;index++)

  822.     {

  823.         value=ModbusHoldingRegisters[MODBUS_RETAINED_D_START +index];

  824.         if(value != ModbusRetainedSnapshot[index])

  825.         {

  826.             backupData->retainedD[index]=value;

  827.         }

  828. 

  829.         ModbusRetainedSnapshot[index] = value;

  830.     }

  831. 

  832. 

  833. 

  834. 

  835. }