yuwenhao
/
Modbus-rtu
1
0
Rozštěpit 0
Zdrojový kód Úkoly 0 Požadavky na natažení 0 Vydání 0 Wiki Aktivita
Nelze vybrat více než 25 témat Téma musí začínat písmenem nebo číslem, může obsahovat pomlčky („-“) a může být dlouhé až 35 znaků.
15 Revize
3 Větve
138 MiB
 
 
 
 
 
 
Strom: 63abe443c0
Větve Značky
${ item.name }
Vytvořit větev ${ searchTerm }
z „63abe443c0“
${ noResults }
Modbus-rtu/Modbus/Src/modbus_rtu_slave.c

1019 řádky
28 KiB
Surový Blame Historie 

  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.         ModbusSlaveStatistics.illegalAddressCount++;

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

  309.     }

  310. 

  311.     ModbusTxFrame[0] = ModbusSlaveAddress;

  312.     ModbusTxFrame[1] = 0X03;

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

  314. 

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

  316.     {

  317.         value = ModbusHoldingRegisters[start + index];

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

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

  320.     }

  321. 

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

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

  324. }

  325. 

  326. /**

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

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

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

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

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

  332.  */

  333. static uint16_t ModbusProcessWriteSingleRegister(

  334.     const uint8_t *request,

  335.     uint16_t requestLength,

  336.     uint8_t isBroadcast)

  337. {

  338.     uint16_t address;

  339.     uint16_t value;

  340. 

  341.     if (requestLength != 8U)

  342.     {

  343.         ModbusSlaveStatistics.illegalValueCount++;

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

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

  346.     }

  347. 

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

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

  350. 

  351.     if (address >= MODBUS_MAP_ITEM_COUNT)

  352.     {

  353.         ModbusSlaveStatistics.illegalAddressCount++;

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

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

  356.     }

  357. 

  358.     ModbusHoldingRegisters[address] = value;

  359. 

  360.     if (isBroadcast != 0U)

  361.     {

  362.         return 0U;

  363.     }

  364. 

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

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

  367.     ModbusAppendCrc(ModbusTxFrame, 6U);

  368.     return 8U;

  369. }

  370. 

  371. /**

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

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

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

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

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

  377.  */

  378. static uint16_t ModbusProcessWriteSingleCoil(

  379.     const uint8_t *request,

  380.     uint16_t requestLength,

  381.     uint8_t isBroadcast)

  382. {

  383.     uint16_t address;

  384.     uint16_t value;

  385. 

  386.     if (requestLength != 8U)

  387.     {

  388.         ModbusSlaveStatistics.illegalValueCount++;

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

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

  391.     }

  392. 

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

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

  395. 

  396.     /*

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

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

  399.      */

  400.     if ((value != MODBUS_COIL_VALUE_ON)

  401.         && (value != MODBUS_COIL_VALUE_OFF))

  402.     {

  403.         ModbusSlaveStatistics.illegalValueCount++;

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

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

  406.     }

  407. 

  408.     if (address >= MODBUS_MAP_ITEM_COUNT)

  409.     {

  410.         ModbusSlaveStatistics.illegalAddressCount++;

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

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

  413.     }

  414. 

  415.     ModbusCoilSetUnchecked(

  416.         address,

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

  418. 

  419.     if (isBroadcast != 0U)

  420.     {

  421.         return 0U;

  422.     }

  423. 

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

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

  426.     ModbusAppendCrc(ModbusTxFrame, 6U);

  427.     return 8U;

  428. }

  429. 

  430. /**

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

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

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

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

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

  436.  */

  437. static uint16_t ModbusProcessWriteMultipleCoils(

  438.     const uint8_t *request,

  439.     uint16_t requestLength,

  440.     uint8_t isBroadcast)

  441. {

  442.     uint16_t start;

  443.     uint16_t quantity;

  444.     uint16_t index;

  445.     uint8_t byteCount;

  446.     uint8_t expectedByteCount;

  447. 

  448.     if (requestLength < 9U)

  449.     {

  450.         ModbusSlaveStatistics.illegalValueCount++;

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

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

  453.     }

  454. 

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

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

  457.     byteCount = request[6];

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

  459. 

  460.     if ((quantity == 0U)

  461.         || (quantity > MODBUS_WRITE_COILS_MAX)

  462.         || (byteCount != expectedByteCount)

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

  464.     {

  465.         ModbusSlaveStatistics.illegalValueCount++;

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

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

  468.     }

  469. 

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

  471.     {

  472.         ModbusSlaveStatistics.illegalAddressCount++;

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

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

  475.     }

  476. 

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

  478.     {

  479.         uint8_t state;

  480. 

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

  482.             >> (index & 0x0007U))

  483.             & 0x01U);

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

  485.     }

  486. 

  487.     if (isBroadcast != 0U)

  488.     {

  489.         return 0U;

  490.     }

  491. 

  492.     ModbusTxFrame[0] = ModbusSlaveAddress;

  493.     ModbusTxFrame[1] = 0X0F;

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

  495.     ModbusAppendCrc(ModbusTxFrame, 6U);

  496.     return 8U;

  497. }

  498. 

  499. /**

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

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

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

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

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

  505.  */

  506. static uint16_t ModbusProcessWriteMultipleRegisters(

  507.     const uint8_t *request,

  508.     uint16_t requestLength,

  509.     uint8_t isBroadcast)

  510. {

  511.     uint16_t start;

  512.     uint16_t quantity;

  513.     uint16_t index;

  514.     uint8_t byteCount;

  515. 

  516.     if (requestLength < 9U)

  517.     {

  518.         ModbusSlaveStatistics.illegalValueCount++;

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

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

  521.     }

  522. 

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

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

  525.     byteCount = request[6];

  526. 

  527.     if ((quantity == 0U)

  528.         || (quantity > MODBUS_WRITE_REGS_MAX)

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

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

  531.     {

  532.         ModbusSlaveStatistics.illegalValueCount++;

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

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

  535.     }

  536. 

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

  538.     {

  539.         ModbusSlaveStatistics.illegalAddressCount++;

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

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

  542.     }

  543. 

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

  545.     {

  546.         ModbusHoldingRegisters[start + index] =

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

  548.     }

  549. 

  550.     if (isBroadcast != 0U)

  551.     {

  552.         return 0U;

  553.     }

  554. 

  555.     ModbusTxFrame[0] = ModbusSlaveAddress;

  556.     ModbusTxFrame[1] = 0X10;

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

  558.     ModbusAppendCrc(ModbusTxFrame, 6U);

  559.     return 8U;

  560. }

  561. 

  562. 

  563. /**

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

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

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

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

  568.  */

  569. static uint16_t ModbusProcessReadBigHolding(

  570.     const uint8_t *request,

  571.     uint16_t requestLength)

  572. {

  573.     uint32_t start;

  574.     uint32_t currentAddress;

  575.     uint16_t quantity;

  576.     uint16_t index;

  577.     uint16_t value;

  578. 

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

  580.     if (requestLength != 9U)

  581.     {

  582.         ModbusSlaveStatistics.illegalValueCount++;

  583. 

  584.         return ModbusBuildException(

  585.             request[1],

  586.             MODBUS_EX_ILLEGAL_VALUE);

  587.     }

  588. 

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

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

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

  592. 

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

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

  595.         (quantity > MODBUS_READ_REGS_MAX))

  596.     {

  597.         ModbusSlaveStatistics.illegalValueCount++;

  598. 

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

  600.             

  601.             

  602.     }

  603. 

  604.     /*

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

  606.      * 总地址范围为0～69998。

  607.      */

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

  609.        

  610.     {

  611.         ModbusSlaveStatistics.illegalAddressCount++;

  612. 

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

  614.           

  615.             

  616.     }

  617. 

  618.     /* 组成正常响应帧头。 */

  619.     ModbusTxFrame[0] = ModbusSlaveAddress;

  620.     ModbusTxFrame[1] = 0x48U;

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

  622. 

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

  624.     {

  625.         currentAddress = start + (uint32_t)index;

  626. 

  627.         /*

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

  629.          * 地址40000～69998位于CCMRAM。

  630.          */

  631.         if (currentAddress < 40000UL)

  632.         {

  633.             value = ModbusHoldingRegisters[currentAddress];

  634.         }

  635.         else

  636.         {

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

  638.                 

  639.         }

  640. 

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

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

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

  644.            

  645.     }

  646.     /* 添加CRC。 */

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

  648.         

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

  650. }

  651. 

  652. /**

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

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

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

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

  657.  */

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

  659. {

  660.     uint16_t calculatedCrc;

  661.     uint16_t receivedCrc;

  662.     uint8_t isBroadcast;

  663. 

  664.     if (requestLength < 4U)

  665.     {

  666.         return 0U;

  667.     }

  668. 

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

  670.     receivedCrc =

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

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

  673. 

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

  675.     {

  676.         ModbusSlaveStatistics.crcErrorCount++;

  677.         return 0U;

  678.     }

  679. 

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

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

  682.     {

  683.         ModbusSlaveStatistics.ignoredAddressCount++;

  684.         return 0U;

  685.     }

  686. 

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

  688.     ModbusSlaveStatistics.validFrameCount++;

  689.     ModbusLastValidFrameTick = HAL_GetTick();

  690.     ModbusHasReceivedValidFrame = 1U;

  691. 

  692.     switch (request[1])

  693.     {

  694.         case 0X01U://读线圈

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

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

  697.                 ModbusProcessReadCoils(request, requestLength);

  698. 

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

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

  701.                 ModbusProcessReadHolding(request, requestLength);

  702. 

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

  704.             return ModbusProcessWriteSingleCoil(request,

  705.                                                 requestLength,

  706.                                                 isBroadcast);

  707. 

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

  709.             return ModbusProcessWriteSingleRegister(request,

  710.                                                     requestLength,

  711.                                                     isBroadcast);

  712. 

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

  714.             return ModbusProcessWriteMultipleCoils(request,

  715.                 requestLength,

  716.                 isBroadcast);

  717. 

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

  719.             return ModbusProcessWriteMultipleRegisters(request,

  720.                 requestLength,

  721.                 isBroadcast);

  722. 

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

  724.                return   ModbusProcessReadBigHolding(request, requestLength);

  725.         

  726.         default://未知功能码

  727.             ModbusSlaveStatistics.illegalFunctionCount++;

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

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

  730.     }

  731. }

  732. 

  733. HAL_StatusTypeDef ModbusSlaveInit(UART_HandleTypeDef *huart,

  734.     uint8_t slaveAddress)

  735. {

  736. 

  737.     ModbusUart = huart;

  738.     ModbusSlaveAddress = slaveAddress;

  739. 

  740.     ModbusHoldingRegisters[HMI_REG_DEVICE_ID] = 0xF407U;

  741. 

  742.     return ModbusStartReceive();

  743. }

  744. 

  745. void ModbusSlavePoll(void)

  746. {

  747.     uint16_t responseLength;

  748. 

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

  750.     {

  751.         return;

  752.     }

  753. 

  754. 

  755. 

  756.     responseLength = ModbusProcessRequest(ModbusRxFrame, ModbusRxFrameLength);

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

  758.                                     ModbusRxFrameLength,

  759.                                     ModbusTxFrame,

  760.                                     responseLength);    

  761.     

  762.     

  763. 

  764.     if (responseLength > 0U)

  765.     {

  766.         ModbusTxBusy = 1U;

  767. 

  768.         if (HAL_UART_Transmit_DMA(ModbusUart,

  769.                                   ModbusTxFrame,

  770.                                   responseLength) == HAL_OK)                                                               

  771.         {

  772.             ModbusSlaveStatistics.txFrameCount++;

  773.         }

  774.         else

  775.         {

  776.             ModbusTxBusy = 0U;

  777.             ModbusSlaveStatistics.uartErrorCount++;

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

  779.         }

  780.     }

  781.     else 

  782.     {

  783.          (void)ModbusStartReceive();

  784.     }

  785. 

  786.     /*

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

  788.      */

  789.     ModbusRxFrameReady = 0U;

  790. }

  791. 

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

  793. {

  794. 

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

  796. 

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

  798.     {

  799.         if (ModbusRxFrameReady == 0U)

  800.         {

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

  802.             ModbusRxFrameLength = size;

  803.             ModbusRxEventTick = HAL_GetTick();

  804.             ModbusRxFrameReady = 1U;

  805.         }

  806.         else

  807.         {

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

  809.             ModbusSlaveStatistics.droppedFrameCount++;

  810.         }

  811.     }

  812.     else

  813.     {

  814.         //长度异常帧

  815.         ModbusSlaveStatistics.droppedFrameCount++;

  816.         (void)ModbusStartReceive();

  817.     }

  818. }

  819. 

  820. void ModbusSlaveOnTxComplete(UART_HandleTypeDef *huart)

  821. {

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

  823.     {

  824.         return;

  825.     }

  826. 

  827.     ModbusTxBusy = 0U;

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

  829. }

  830. 

  831. void ModbusSlaveOnUartError(UART_HandleTypeDef *huart)

  832. {

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

  834.     {

  835.         return;

  836.     }

  837. 

  838.     ModbusSlaveStatistics.uartErrorCount++;

  839.     ModbusTxBusy = 0U;

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

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

  842. }

  843. 

  844. uint8_t ModbusSlaveSetHoldingRegister(uint16_t address, uint16_t value)

  845. {

  846.     if (address >= MODBUS_MAP_ITEM_COUNT)

  847.     {

  848.         return 0U;

  849.     }

  850. 

  851.     ModbusHoldingRegisters[address] = value;

  852.     return 1U;

  853. }

  854. 

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

  856. {

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

  858.     {

  859.         return 0U;

  860.     }

  861. 

  862.     *value = ModbusHoldingRegisters[address];

  863.     return 1U;

  864. }

  865. 

  866. uint8_t ModbusSlaveSetCoil(uint16_t address, uint8_t state)

  867. {

  868.     if (address >= MODBUS_MAP_ITEM_COUNT)

  869.     {

  870.         return 0U;

  871.     }

  872. 

  873.     ModbusCoilSetUnchecked(address, state);

  874.     return 1U;

  875. }

  876. 

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

  878. {

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

  880.     {

  881.         return 0U;

  882.     }

  883. 

  884.     *state = ModbusCoilGetUnchecked(address);

  885.     return 1U;

  886. }

  887. 

  888. uint8_t ModbusSlaveIsConnected(uint32_t timeoutMs)

  889. {

  890.     if (ModbusHasReceivedValidFrame == 0U)

  891.     {

  892.         return 0U;

  893.     }

  894. 

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

  896.         ? 1U

  897.         : 0U;

  898. }

  899. 

  900. //上电恢复函数

  901. void ModbusRetainedRegistersLoad(void)

  902. {

  903.     uint16_t index;

  904. 

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

  906.     {

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

  908.         {

  909.             ModbusHoldingRegisters[MODBUS_RETAINED_D_START + index] =             

  910.                 backupData->retainedD[index];

  911.         }

  912.     }

  913.     else

  914.     {

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

  916.         {

  917.             ModbusHoldingRegisters[

  918.                 MODBUS_RETAINED_D_START + index] = 0U;

  919. 

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

  921.         }

  922. 

  923.         /*

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

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

  926.          */

  927.         backupData->magic = MODBUS_BACKUP_MAGIC;

  928.     }

  929. }

  930. void ModbusRetainedRegistersPoll(void)

  931. {

  932.     uint16_t index;

  933.    // uint16_t address;

  934.     uint16_t value;

  935. 

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

  937.     {

  938.         value=ModbusHoldingRegisters[MODBUS_RETAINED_D_START +index];

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

  940.         {

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

  942.         }

  943. 

  944.         ModbusRetainedSnapshot[index] = value;

  945.     }

  946. 

  947. 

  948. 

  949. 

  950. }

  951. static void ModbusHistorySave(

  952.                             uint32_t tick,

  953.                             const uint8_t *request,

  954.                             uint16_t requestLength,

  955.                             const uint8_t *response,

  956.                             uint16_t responseLength)

  957. {

  958.     MODBUS_HISTORY_ITEM *item;

  959. 

  960.     if(requestLength > 256U)

  961.     {

  962.         requestLength = 256U;

  963.     }

  964. 

  965.     if(responseLength > 256U)

  966.     {

  967.         responseLength = 256U;

  968.     }

  969. 

  970.     item = &ModbusHistory[ModbusHistoryWriteIndex];

  971. 

  972.     item->tick = tick;

  973.     item->requestLength = requestLength;

  974.     item->responseLength = responseLength;

  975. 

  976.     (void)memcpy(

  977.         item->request,

  978.         request,

  979.         requestLength);

  980. 

  981.     if(responseLength > 0U)

  982.     {

  983.         (void)memcpy(

  984.             item->response,

  985.             response,

  986.             responseLength);

  987.     }

  988. 

  989.     ModbusHistoryWriteIndex++;

  990. 

  991.     if(ModbusHistoryWriteIndex >= 16U)

  992.     {

  993.         ModbusHistoryWriteIndex = 0U;

  994.     }

  995. }

  996. void HistorySaveToRegisters(void)

  997. {

  998.     // (void)memcpy(

  999.     // &ModbusHoldingRegisters[1000],

  1000.     // ModbusHistory,

  1001.     // sizeof(ModbusHistory));

  1002. 

  1003.     uint16_t index;

  1004. 

  1005.     if(ModbusHistoryWriteIndex == 0U)

  1006.     {

  1007.         index = 15U;

  1008.     }

  1009.     else

  1010.     {

  1011.         index = ModbusHistoryWriteIndex - 1U;

  1012.     }

  1013. 

  1014.     (void)memcpy(

  1015.         &ModbusHoldingRegisters[

  1016.             1000U + index * 260U],

  1017.         &ModbusHistory[index],

  1018.         sizeof(ModbusHistory[index]));

  1019. }