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

1033 行
28 KiB
Raw Blame 履歴 

  1. #include "modbus_rtu_slave.h"

  2. #include "ucos_ii.h"

  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. static MODBUS_HISTORY_ITEM ModbusHistory[16];

  28. static uint16_t ModbusHistoryWriteIndex;

  29. /**

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

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

  32.  */

  33. static uint8_t ModbusRxDmaBuffer[MODBUS_RTU_ADU_SIZE_MAX];

  34. static uint8_t ModbusRxFrame[MODBUS_RTU_ADU_SIZE_MAX];

  35. static uint8_t ModbusTxFrame[MODBUS_RTU_ADU_SIZE_MAX];

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

  37. static uint16_t ModbusRetainedSnapshot[MODBUS_RETAINED_D_COUNT];

  38. static volatile uint16_t ModbusRxFrameLength;

  39. static volatile uint8_t ModbusRxFrameReady;

  40. static volatile uint8_t ModbusTxBusy;

  41. static volatile uint32_t ModbusRxEventTick;

  42. static volatile uint32_t ModbusLastValidFrameTick;

  43. static volatile uint8_t ModbusHasReceivedValidFrame;

  44. 

  45. /**

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

  47.  * 占用 1250 字节

  48.  */

  49. static uint16_t ModbusHoldingRegisters[40000];

  50. 

  51. 

  52. #pragma location = ".ccmram"

  53. #pragma data_alignment = 4

  54. __root static uint16_t ModbusRegistersCcm[29999];

  55. 

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

  57. 

  58. volatile MODBUS_SLAVE_STATS ModbusSlaveStatistics;

  59. 

  60. /**

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

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

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

  64.  * @return CRC16 校验值

  65.  */

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

  67. {

  68.     uint16_t crc = 0xFFFFU;

  69.     uint16_t index;

  70.     uint8_t bit;

  71. 

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

  73.     {

  74.         crc ^= data[index];

  75. 

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

  77.         {

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

  79.             {

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

  81.             }

  82.             else

  83.             {

  84.                 crc >>= 1U;

  85.             }

  86.         }

  87.     }

  88. 

  89.     return crc;

  90. }

  91. 

  92. /**

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

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

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

  96.  */

  97. static uint16_t ModbusGetU16Be(const uint8_t *data)

  98. {

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

  100. }

  101. 

  102. /**

  103.  * @brief 提取一个 24 位无符号整数

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

  105.  * @return 转换后的 24 位无符号整数

  106.  */

  107. static uint32_t ModbusGetU24Be(const uint8_t *data)

  108. {

  109.     return (uint32_t)((uint32_t)data[0] << 16U|((uint16_t)data[1] << 8U) | data[2]);

  110. }

  111. 

  112. /**

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

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

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

  116.  */

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

  118. {

  119.     if (start >= MODBUS_MAP_ITEM_COUNT)

  120.     {

  121.         return 0U;

  122.     }

  123. 

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

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

  126. }

  127. 

  128. /**

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

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

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

  132.  */

  133. static uint8_t ModbusCoilGetUnchecked(uint16_t address)

  134. {

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

  136. 

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

  138. }

  139. 

  140. /**

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

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

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

  144.  */

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

  146. {

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

  148. 

  149.     if (state != 0U)

  150.     {

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

  152.     }

  153.     else

  154.     {

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

  156.     }

  157. }

  158. 

  159. /**

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

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

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

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

  164.  */

  165. static HAL_StatusTypeDef ModbusStartReceive(void)

  166. {

  167.     HAL_StatusTypeDef status;

  168. 

  169.     if (ModbusTxBusy != 0U)

  170.     {

  171.         return HAL_BUSY;

  172.     }

  173. 

  174.     status = HAL_UARTEx_ReceiveToIdle_DMA(ModbusUart,

  175.                                           ModbusRxDmaBuffer,

  176.                                           sizeof(ModbusRxDmaBuffer));

  177. 

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

  179.     {

  180.         /*

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

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

  183.          */

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

  185.     }

  186. 

  187.     return status;

  188. }

  189. 

  190. 

  191. 

  192. /**

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

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

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

  196.  */

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

  198. {

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

  200. 

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

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

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

  204. }

  205. 

  206. /**

  207.  * @brief 构造 Modbus 异常响应

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

  209.  * @param[in] exception 异常码

  210.  * @return 异常响应 ADU 长度

  211.  */

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

  213. {

  214.     ModbusTxFrame[0] = ModbusSlaveAddress;

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

  216.     ModbusTxFrame[2] = exception;

  217.     ModbusAppendCrc(ModbusTxFrame, 3U);

  218. 

  219.     return 5U;

  220. }

  221. 

  222. /**

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

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

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

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

  227.  */

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

  229. {

  230.    

  231.     uint16_t start;

  232.     uint16_t quantity;

  233.     uint16_t index;

  234.     uint8_t byteCount;

  235. 

  236.     if (requestLength != 8U)

  237.     {

  238.         ModbusSlaveStatistics.illegalValueCount++;

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

  240.     }

  241. 

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

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

  244. 

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

  246.     {

  247.         ModbusSlaveStatistics.illegalValueCount++;

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

  249.     }

  250. 

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

  252.     {

  253.         ModbusSlaveStatistics.illegalAddressCount++;

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

  255.     }

  256. 

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

  258.     ModbusTxFrame[0] = ModbusSlaveAddress;

  259.     ModbusTxFrame[1] = 0X01;

  260.     ModbusTxFrame[2] = byteCount;

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

  262. 

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

  264.     {

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

  266.         {

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

  268.                

  269.         }

  270.     }

  271. 

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

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

  274. }

  275. 

  276. /**

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

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

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

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

  281.  */

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

  283.     

  284. {

  285.     uint16_t start;

  286.     uint16_t quantity;

  287.     uint16_t index;

  288.     uint16_t value;

  289. 

  290.     if (requestLength != 8U)

  291.     {

  292.         ModbusSlaveStatistics.illegalValueCount++;

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

  294.     }

  295. 

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

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

  298. 

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

  300.     {

  301.         ModbusSlaveStatistics.illegalValueCount++;

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

  303.     }

  304.     

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

  306.     {

  307.         if ((start >= 20000U) &&

  308.         (start < 25000U) &&

  309.         (quantity > 0U) &&

  310.         (quantity <= (25000U - start)))goto tx;

  311.         ModbusSlaveStatistics.illegalAddressCount++;

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

  313.     }

  314.     tx:

  315.     ModbusTxFrame[0] = ModbusSlaveAddress;

  316.     ModbusTxFrame[1] = 0X03;

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

  318. 

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

  320.     {

  321.         uint16_t address = start + index;

  322.      /* D20000～D24999映射到D1、D3、D5……D9999 */

  323.         if (address >= 20000U)

  324.         {

  325.             address = (address - 20000U) * 2U + 1U;

  326.         }

  327.         value = ModbusHoldingRegisters[address];

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

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

  330.     }

  331. 

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

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

  334. 

  335. 

  336. 

  337. 

  338. }

  339. 

  340. /**

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

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

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

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

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

  346.  */

  347. static uint16_t ModbusProcessWriteSingleRegister(

  348.     const uint8_t *request,

  349.     uint16_t requestLength,

  350.     uint8_t isBroadcast)

  351. {

  352.     uint16_t address;

  353.     uint16_t value;

  354. 

  355.     if (requestLength != 8U)

  356.     {

  357.         ModbusSlaveStatistics.illegalValueCount++;

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

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

  360.     }

  361. 

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

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

  364. 

  365.     if (address >= MODBUS_MAP_ITEM_COUNT)

  366.     {

  367.         ModbusSlaveStatistics.illegalAddressCount++;

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

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

  370.     }

  371. 

  372.     ModbusHoldingRegisters[address] = value;

  373. 

  374.     if (isBroadcast != 0U)

  375.     {

  376.         return 0U;

  377.     }

  378. 

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

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

  381.     ModbusAppendCrc(ModbusTxFrame, 6U);

  382.     return 8U;

  383. }

  384. 

  385. /**

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

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

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

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

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

  391.  */

  392. static uint16_t ModbusProcessWriteSingleCoil(

  393.     const uint8_t *request,

  394.     uint16_t requestLength,

  395.     uint8_t isBroadcast)

  396. {

  397.     uint16_t address;

  398.     uint16_t value;

  399. 

  400.     if (requestLength != 8U)

  401.     {

  402.         ModbusSlaveStatistics.illegalValueCount++;

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

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

  405.     }

  406. 

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

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

  409. 

  410.     /*

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

  412.      * 其他数值属于非法数据值

  413.      */

  414.     if ((value != MODBUS_COIL_VALUE_ON)

  415.         && (value != MODBUS_COIL_VALUE_OFF))

  416.     {

  417.         ModbusSlaveStatistics.illegalValueCount++;

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

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

  420.     }

  421. 

  422.     if (address >= MODBUS_MAP_ITEM_COUNT)

  423.     {

  424.         ModbusSlaveStatistics.illegalAddressCount++;

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

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

  427.     }

  428. 

  429.     ModbusCoilSetUnchecked(

  430.         address,

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

  432. 

  433.     if (isBroadcast != 0U)

  434.     {

  435.         return 0U;

  436.     }

  437. 

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

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

  440.     ModbusAppendCrc(ModbusTxFrame, 6U);

  441.     return 8U;

  442. }

  443. 

  444. /**

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

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

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

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

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

  450.  */

  451. static uint16_t ModbusProcessWriteMultipleCoils(

  452.     const uint8_t *request,

  453.     uint16_t requestLength,

  454.     uint8_t isBroadcast)

  455. {

  456.     uint16_t start;

  457.     uint16_t quantity;

  458.     uint16_t index;

  459.     uint8_t byteCount;

  460.     uint8_t expectedByteCount;

  461. 

  462.     if (requestLength < 9U)

  463.     {

  464.         ModbusSlaveStatistics.illegalValueCount++;

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

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

  467.     }

  468. 

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

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

  471.     byteCount = request[6];

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

  473. 

  474.     if ((quantity == 0U)

  475.         || (quantity > MODBUS_WRITE_COILS_MAX)

  476.         || (byteCount != expectedByteCount)

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

  478.     {

  479.         ModbusSlaveStatistics.illegalValueCount++;

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

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

  482.     }

  483. 

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

  485.     {

  486.         ModbusSlaveStatistics.illegalAddressCount++;

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

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

  489.     }

  490. 

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

  492.     {

  493.         uint8_t state;

  494. 

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

  496.             >> (index & 0x0007U))

  497.             & 0x01U);

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

  499.     }

  500. 

  501.     if (isBroadcast != 0U)

  502.     {

  503.         return 0U;

  504.     }

  505. 

  506.     ModbusTxFrame[0] = ModbusSlaveAddress;

  507.     ModbusTxFrame[1] = 0X0F;

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

  509.     ModbusAppendCrc(ModbusTxFrame, 6U);

  510.     return 8U;

  511. }

  512. 

  513. /**

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

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

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

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

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

  519.  */

  520. static uint16_t ModbusProcessWriteMultipleRegisters(

  521.     const uint8_t *request,

  522.     uint16_t requestLength,

  523.     uint8_t isBroadcast)

  524. {

  525.     uint16_t start;

  526.     uint16_t quantity;

  527.     uint16_t index;

  528.     uint8_t byteCount;

  529. 

  530.     if (requestLength < 9U)

  531.     {

  532.         ModbusSlaveStatistics.illegalValueCount++;

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

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

  535.     }

  536. 

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

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

  539.     byteCount = request[6];

  540. 

  541.     if ((quantity == 0U)

  542.         || (quantity > MODBUS_WRITE_REGS_MAX)

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

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

  545.     {

  546.         ModbusSlaveStatistics.illegalValueCount++;

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

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

  549.     }

  550. 

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

  552.     {

  553.         ModbusSlaveStatistics.illegalAddressCount++;

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

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

  556.     }

  557. 

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

  559.     {

  560.         ModbusHoldingRegisters[start + index] =

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

  562.     }

  563. 

  564.     if (isBroadcast != 0U)

  565.     {

  566.         return 0U;

  567.     }

  568. 

  569.     ModbusTxFrame[0] = ModbusSlaveAddress;

  570.     ModbusTxFrame[1] = 0X10;

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

  572.     ModbusAppendCrc(ModbusTxFrame, 6U);

  573.     return 8U;

  574. }

  575. 

  576. 

  577. /**

  578.  * @brief 处理读取扩展地址保持寄存器功能码0x48

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

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

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

  582.  */

  583. static uint16_t ModbusProcessReadBigHolding(

  584.     const uint8_t *request,

  585.     uint16_t requestLength)

  586. {

  587.     uint32_t start;

  588.     uint32_t currentAddress;

  589.     uint16_t quantity;

  590.     uint16_t index;

  591.     uint16_t value;

  592. 

  593.     /* 请求帧：站号1 + 功能码1 + 地址3 + 数量2 + CRC2 */

  594.     if (requestLength != 9U)

  595.     {

  596.         ModbusSlaveStatistics.illegalValueCount++;

  597. 

  598.         return ModbusBuildException(

  599.             request[1],

  600.             MODBUS_EX_ILLEGAL_VALUE);

  601.     }

  602. 

  603.     /* 提取24位起始地址和16位寄存器数量 */

  604.     start = ModbusGetU24Be(&request[2]);

  605.     quantity = ModbusGetU16Be(&request[5]);

  606. 

  607.     /* 一次最多读取125个寄存器 */

  608.     if ((quantity == 0U) ||

  609.         (quantity > MODBUS_READ_REGS_MAX))

  610.     {

  611.         ModbusSlaveStatistics.illegalValueCount++;

  612. 

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

  614.             

  615.             

  616.     }

  617. 

  618.     /*

  619.      * 普通SRAM有40000个寄存器，CCMRAM有29999个寄存器，

  620.      * 总地址范围为0～69998

  621.      */

  622.     if ((start >= 69999UL) || ((uint32_t)quantity > (69999UL - start)))

  623.        

  624.     {

  625.         ModbusSlaveStatistics.illegalAddressCount++;

  626. 

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

  628.           

  629.             

  630.     }

  631. 

  632.     /* 组成正常响应帧头 */

  633.     ModbusTxFrame[0] = ModbusSlaveAddress;

  634.     ModbusTxFrame[1] = 0x48U;

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

  636. 

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

  638.     {

  639.         currentAddress = start + (uint32_t)index;

  640. 

  641.         /*

  642.          * 地址0～39999位于普通SRAM；

  643.          * 地址40000～69998位于CCMRAM

  644.          */

  645.         if (currentAddress < 40000UL)

  646.         {

  647.             value = ModbusHoldingRegisters[currentAddress];

  648.         }

  649.         else

  650.         {

  651.             value = ModbusRegistersCcm[currentAddress - 40000UL];

  652.                 

  653.         }

  654. 

  655.         /* 每个寄存器按照高字节、低字节装入响应帧 */

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

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

  658.            

  659.     }

  660.     /* 添加CRC */

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

  662.         

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

  664. }

  665. 

  666. /**

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

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

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

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

  671.  */

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

  673. {

  674.     uint16_t calculatedCrc;

  675.     uint16_t receivedCrc;

  676.     uint8_t isBroadcast;

  677. 

  678.     if (requestLength < 4U)

  679.     {

  680.         return 0U;

  681.     }

  682. 

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

  684.     receivedCrc =

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

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

  687. 

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

  689.     {

  690.         ModbusSlaveStatistics.crcErrorCount++;

  691.         return 0U;

  692.     }

  693. 

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

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

  696.     {

  697.         ModbusSlaveStatistics.ignoredAddressCount++;

  698.         return 0U;

  699.     }

  700. 

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

  702.     ModbusSlaveStatistics.validFrameCount++;

  703.     ModbusLastValidFrameTick = HAL_GetTick();

  704.     ModbusHasReceivedValidFrame = 1U;

  705. 

  706.     switch (request[1])

  707.     {

  708.         case 0X01U://读线圈

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

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

  711.                 ModbusProcessReadCoils(request, requestLength);

  712. 

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

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

  715.                 ModbusProcessReadHolding(request, requestLength);

  716. 

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

  718.             return ModbusProcessWriteSingleCoil(request,

  719.                                                 requestLength,

  720.                                                 isBroadcast);

  721. 

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

  723.             return ModbusProcessWriteSingleRegister(request,

  724.                                                     requestLength,

  725.                                                     isBroadcast);

  726. 

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

  728.             return ModbusProcessWriteMultipleCoils(request,

  729.                 requestLength,

  730.                 isBroadcast);

  731. 

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

  733.             return ModbusProcessWriteMultipleRegisters(request,

  734.                 requestLength,

  735.                 isBroadcast);

  736. 

  737.         case 0x48U://读大地址保持寄存器

  738.                return   ModbusProcessReadBigHolding(request, requestLength);

  739.         

  740.         default://未知功能码

  741.             ModbusSlaveStatistics.illegalFunctionCount++;

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

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

  744.     }

  745. }

  746. 

  747. HAL_StatusTypeDef ModbusSlaveInit(UART_HandleTypeDef *huart,

  748.     uint8_t slaveAddress)

  749. {

  750. 

  751.     ModbusUart = huart;

  752.     ModbusSlaveAddress = slaveAddress;

  753. 

  754.     ModbusHoldingRegisters[HMI_REG_DEVICE_ID] = 0xF407U;

  755. 

  756.     return ModbusStartReceive();

  757. }

  758. 

  759. void ModbusSlavePoll(void)

  760. {

  761.     uint16_t responseLength;

  762. 

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

  764.     {

  765.         return;

  766.     }

  767. 

  768. 

  769. 

  770.     responseLength = ModbusProcessRequest(ModbusRxFrame, ModbusRxFrameLength);

  771.     ModbusHistorySave(OSTimeGet() / 1000,ModbusRxFrame,

  772.                                     ModbusRxFrameLength,

  773.                                     ModbusTxFrame,

  774.                                     responseLength);    

  775.     

  776.     

  777. 

  778.     if (responseLength > 0U)

  779.     {

  780.         ModbusTxBusy = 1U;

  781. 

  782.         if (HAL_UART_Transmit_DMA(ModbusUart,

  783.                                   ModbusTxFrame,

  784.                                   responseLength) == HAL_OK)                                                               

  785.         {

  786.             ModbusSlaveStatistics.txFrameCount++;

  787.         }

  788.         else

  789.         {

  790.             ModbusTxBusy = 0U;

  791.             ModbusSlaveStatistics.uartErrorCount++;

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

  793.         }

  794.     }

  795.     else 

  796.     {

  797.          (void)ModbusStartReceive();

  798.     }

  799. 

  800.     /*

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

  802.      */

  803.     ModbusRxFrameReady = 0U;

  804. }

  805. 

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

  807. {

  808. 

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

  810. 

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

  812.     {

  813.         if (ModbusRxFrameReady == 0U)

  814.         {

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

  816.             ModbusRxFrameLength = size;

  817.             ModbusRxEventTick = HAL_GetTick();

  818.             ModbusRxFrameReady = 1U;

  819.         }

  820.         else

  821.         {

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

  823.             ModbusSlaveStatistics.droppedFrameCount++;

  824.         }

  825.     }

  826.     else

  827.     {

  828.         //长度异常帧

  829.         ModbusSlaveStatistics.droppedFrameCount++;

  830.         (void)ModbusStartReceive();

  831.     }

  832. }

  833. 

  834. void ModbusSlaveOnTxComplete(UART_HandleTypeDef *huart)

  835. {

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

  837.     {

  838.         return;

  839.     }

  840. 

  841.     ModbusTxBusy = 0U;

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

  843. }

  844. 

  845. void ModbusSlaveOnUartError(UART_HandleTypeDef *huart)

  846. {

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

  848.     {

  849.         return;

  850.     }

  851. 

  852.     ModbusSlaveStatistics.uartErrorCount++;

  853.     ModbusTxBusy = 0U;

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

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

  856. }

  857. 

  858. uint8_t ModbusSlaveSetHoldingRegister(uint16_t address, uint16_t value)

  859. {

  860.     if (address >= MODBUS_MAP_ITEM_COUNT)

  861.     {

  862.         return 0U;

  863.     }

  864. 

  865.     ModbusHoldingRegisters[address] = value;

  866.     return 1U;

  867. }

  868. 

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

  870. {

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

  872.     {

  873.         return 0U;

  874.     }

  875. 

  876.     *value = ModbusHoldingRegisters[address];

  877.     return 1U;

  878. }

  879. 

  880. uint8_t ModbusSlaveSetCoil(uint16_t address, uint8_t state)

  881. {

  882.     if (address >= MODBUS_MAP_ITEM_COUNT)

  883.     {

  884.         return 0U;

  885.     }

  886. 

  887.     ModbusCoilSetUnchecked(address, state);

  888.     return 1U;

  889. }

  890. 

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

  892. {

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

  894.     {

  895.         return 0U;

  896.     }

  897. 

  898.     *state = ModbusCoilGetUnchecked(address);

  899.     return 1U;

  900. }

  901. 

  902. uint8_t ModbusSlaveIsConnected(uint32_t timeoutMs)

  903. {

  904.     if (ModbusHasReceivedValidFrame == 0U)

  905.     {

  906.         return 0U;

  907.     }

  908. 

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

  910.         ? 1U

  911.         : 0U;

  912. }

  913. 

  914. //上电恢复函数

  915. void ModbusRetainedRegistersLoad(void)

  916. {

  917.     uint16_t index;

  918. 

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

  920.     {

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

  922.         {

  923.             ModbusHoldingRegisters[MODBUS_RETAINED_D_START + index] =             

  924.                 backupData->retainedD[index];

  925.         }

  926.     }

  927.     else

  928.     {

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

  930.         {

  931.             ModbusHoldingRegisters[

  932.                 MODBUS_RETAINED_D_START + index] = 0U;

  933. 

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

  935.         }

  936. 

  937.         /*

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

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

  940.          */

  941.         backupData->magic = MODBUS_BACKUP_MAGIC;

  942.     }

  943. }

  944. void ModbusRetainedRegistersPoll(void)

  945. {

  946.     uint16_t index;

  947.    // uint16_t address;

  948.     uint16_t value;

  949. 

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

  951.     {

  952.         value=ModbusHoldingRegisters[MODBUS_RETAINED_D_START +index];

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

  954.         {

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

  956.         }

  957. 

  958.         ModbusRetainedSnapshot[index] = value;

  959.     }

  960. 

  961. 

  962. 

  963. 

  964. }

  965. static void ModbusHistorySave(

  966.                             uint32_t tick,

  967.                             const uint8_t *request,

  968.                             uint16_t requestLength,

  969.                             const uint8_t *response,

  970.                             uint16_t responseLength)

  971. {

  972.     MODBUS_HISTORY_ITEM *item;

  973. 

  974.     if(requestLength > 256U)

  975.     {

  976.         requestLength = 256U;

  977.     }

  978. 

  979.     if(responseLength > 256U)

  980.     {

  981.         responseLength = 256U;

  982.     }

  983. 

  984.     item = &ModbusHistory[ModbusHistoryWriteIndex];

  985. 

  986.     item->tick = tick;

  987.     item->requestLength = requestLength;

  988.     item->responseLength = responseLength;

  989. 

  990.     (void)memcpy(

  991.         item->request,

  992.         request,

  993.         requestLength);

  994. 

  995.     if(responseLength > 0U)

  996.     {

  997.         (void)memcpy(

  998.             item->response,

  999.             response,

  1000.             responseLength);

  1001.     }

  1002. 

  1003.     ModbusHistoryWriteIndex++;

  1004. 

  1005.     if(ModbusHistoryWriteIndex >= 16U)

  1006.     {

  1007.         ModbusHistoryWriteIndex = 0U;

  1008.     }

  1009. }

  1010. void HistorySaveToRegisters(void)

  1011. {

  1012.     // (void)memcpy(

  1013.     // &ModbusHoldingRegisters[1000],

  1014.     // ModbusHistory,

  1015.     // sizeof(ModbusHistory));

  1016. 

  1017.     uint16_t index;

  1018. 

  1019.     if(ModbusHistoryWriteIndex == 0U)

  1020.     {

  1021.         index = 15U;

  1022.     }

  1023.     else

  1024.     {

  1025.         index = ModbusHistoryWriteIndex - 1U;

  1026.     }

  1027. 

  1028.     (void)memcpy(

  1029.         &ModbusHoldingRegisters[

  1030.             1000U + index * 260U],

  1031.         &ModbusHistory[index],

  1032.         sizeof(ModbusHistory[index]));

  1033. }