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ů.
14 Revize
3 Větve
138 MiB
 
 
 
 
 
 
Strom: cac11d26c2
Větve Značky
${ item.name }
Vytvořit větev ${ searchTerm }
z „cac11d26c2“
${ noResults }
Modbus-rtu/Modbus/Src/modbus_rtu_slave.c

944 řádky
26 KiB
Surový Blame Historie 

  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[40000];

  48. 

  49. 

  50. #pragma location = ".ccmram"

  51. #pragma data_alignment = 4

  52. __root static uint16_t ModbusRegistersCcm[29999];

  53. 

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

  55. 

  56. volatile MODBUS_SLAVE_STATS ModbusSlaveStatistics;

  57. 

  58. /**

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

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

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

  62.  * @return CRC16 校验值

  63.  */

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

  65. {

  66.     uint16_t crc = 0xFFFFU;

  67.     uint16_t index;

  68.     uint8_t bit;

  69. 

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

  71.     {

  72.         crc ^= data[index];

  73. 

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

  75.         {

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

  77.             {

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

  79.             }

  80.             else

  81.             {

  82.                 crc >>= 1U;

  83.             }

  84.         }

  85.     }

  86. 

  87.     return crc;

  88. }

  89. 

  90. /**

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

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

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

  94.  */

  95. static uint16_t ModbusGetU16Be(const uint8_t *data)

  96. {

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

  98. }

  99. 

  100. /**

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

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

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

  104.  */

  105. static uint32_t ModbusGetU24Be(const uint8_t *data)

  106. {

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

  108. }

  109. 

  110. /**

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

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

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

  114.  */

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

  116. {

  117.     if (start >= MODBUS_MAP_ITEM_COUNT)

  118.     {

  119.         return 0U;

  120.     }

  121. 

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

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

  124. }

  125. 

  126. /**

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

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

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

  130.  */

  131. static uint8_t ModbusCoilGetUnchecked(uint16_t address)

  132. {

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

  134. 

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

  136. }

  137. 

  138. /**

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

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

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

  142.  */

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

  144. {

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

  146. 

  147.     if (state != 0U)

  148.     {

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

  150.     }

  151.     else

  152.     {

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

  154.     }

  155. }

  156. 

  157. /**

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

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

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

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

  162.  */

  163. static HAL_StatusTypeDef ModbusStartReceive(void)

  164. {

  165.     HAL_StatusTypeDef status;

  166. 

  167.     if (ModbusTxBusy != 0U)

  168.     {

  169.         return HAL_BUSY;

  170.     }

  171. 

  172.     status = HAL_UARTEx_ReceiveToIdle_DMA(ModbusUart,

  173.                                           ModbusRxDmaBuffer,

  174.                                           sizeof(ModbusRxDmaBuffer));

  175. 

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

  177.     {

  178.         /*

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

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

  181.          */

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

  183.     }

  184. 

  185.     return status;

  186. }

  187. 

  188. 

  189. 

  190. /**

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

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

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

  194.  */

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

  196. {

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

  198. 

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

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

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

  202. }

  203. 

  204. /**

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

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

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

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

  209.  */

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

  211. {

  212.     ModbusTxFrame[0] = ModbusSlaveAddress;

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

  214.     ModbusTxFrame[2] = exception;

  215.     ModbusAppendCrc(ModbusTxFrame, 3U);

  216. 

  217.     return 5U;

  218. }

  219. 

  220. /**

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

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

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

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

  225.  */

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

  227. {

  228.    

  229.     uint16_t start;

  230.     uint16_t quantity;

  231.     uint16_t index;

  232.     uint8_t byteCount;

  233. 

  234.     if (requestLength != 8U)

  235.     {

  236.         ModbusSlaveStatistics.illegalValueCount++;

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

  238.     }

  239. 

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

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

  242. 

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

  244.     {

  245.         ModbusSlaveStatistics.illegalValueCount++;

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

  247.     }

  248. 

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

  250.     {

  251.         ModbusSlaveStatistics.illegalAddressCount++;

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

  253.     }

  254. 

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

  256.     ModbusTxFrame[0] = ModbusSlaveAddress;

  257.     ModbusTxFrame[1] = 0X01;

  258.     ModbusTxFrame[2] = byteCount;

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

  260. 

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

  262.     {

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

  264.         {

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

  266.                

  267.         }

  268.     }

  269. 

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

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

  272. }

  273. 

  274. /**

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

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

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

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

  279.  */

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

  281.     

  282. {

  283.     uint16_t start;

  284.     uint16_t quantity;

  285.     uint16_t index;

  286.     uint16_t value;

  287. 

  288.     if (requestLength != 8U)

  289.     {

  290.         ModbusSlaveStatistics.illegalValueCount++;

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

  292.     }

  293. 

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

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

  296. 

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

  298.     {

  299.         ModbusSlaveStatistics.illegalValueCount++;

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

  301.     }

  302. 

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

  304.     {

  305.         ModbusSlaveStatistics.illegalAddressCount++;

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

  307.     }

  308. 

  309.     ModbusTxFrame[0] = ModbusSlaveAddress;

  310.     ModbusTxFrame[1] = 0X03;

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

  312. 

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

  314.     {

  315.         value = ModbusHoldingRegisters[start + index];

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

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

  318.     }

  319. 

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

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

  322. }

  323. 

  324. /**

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

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

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

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

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

  330.  */

  331. static uint16_t ModbusProcessWriteSingleRegister(

  332.     const uint8_t *request,

  333.     uint16_t requestLength,

  334.     uint8_t isBroadcast)

  335. {

  336.     uint16_t address;

  337.     uint16_t value;

  338. 

  339.     if (requestLength != 8U)

  340.     {

  341.         ModbusSlaveStatistics.illegalValueCount++;

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

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

  344.     }

  345. 

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

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

  348. 

  349.     if (address >= MODBUS_MAP_ITEM_COUNT)

  350.     {

  351.         ModbusSlaveStatistics.illegalAddressCount++;

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

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

  354.     }

  355. 

  356.     ModbusHoldingRegisters[address] = value;

  357. 

  358.     if (isBroadcast != 0U)

  359.     {

  360.         return 0U;

  361.     }

  362. 

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

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

  365.     ModbusAppendCrc(ModbusTxFrame, 6U);

  366.     return 8U;

  367. }

  368. 

  369. /**

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

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

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

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

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

  375.  */

  376. static uint16_t ModbusProcessWriteSingleCoil(

  377.     const uint8_t *request,

  378.     uint16_t requestLength,

  379.     uint8_t isBroadcast)

  380. {

  381.     uint16_t address;

  382.     uint16_t value;

  383. 

  384.     if (requestLength != 8U)

  385.     {

  386.         ModbusSlaveStatistics.illegalValueCount++;

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

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

  389.     }

  390. 

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

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

  393. 

  394.     /*

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

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

  397.      */

  398.     if ((value != MODBUS_COIL_VALUE_ON)

  399.         && (value != MODBUS_COIL_VALUE_OFF))

  400.     {

  401.         ModbusSlaveStatistics.illegalValueCount++;

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

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

  404.     }

  405. 

  406.     if (address >= MODBUS_MAP_ITEM_COUNT)

  407.     {

  408.         ModbusSlaveStatistics.illegalAddressCount++;

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

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

  411.     }

  412. 

  413.     ModbusCoilSetUnchecked(

  414.         address,

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

  416. 

  417.     if (isBroadcast != 0U)

  418.     {

  419.         return 0U;

  420.     }

  421. 

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

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

  424.     ModbusAppendCrc(ModbusTxFrame, 6U);

  425.     return 8U;

  426. }

  427. 

  428. /**

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

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

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

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

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

  434.  */

  435. static uint16_t ModbusProcessWriteMultipleCoils(

  436.     const uint8_t *request,

  437.     uint16_t requestLength,

  438.     uint8_t isBroadcast)

  439. {

  440.     uint16_t start;

  441.     uint16_t quantity;

  442.     uint16_t index;

  443.     uint8_t byteCount;

  444.     uint8_t expectedByteCount;

  445. 

  446.     if (requestLength < 9U)

  447.     {

  448.         ModbusSlaveStatistics.illegalValueCount++;

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

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

  451.     }

  452. 

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

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

  455.     byteCount = request[6];

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

  457. 

  458.     if ((quantity == 0U)

  459.         || (quantity > MODBUS_WRITE_COILS_MAX)

  460.         || (byteCount != expectedByteCount)

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

  462.     {

  463.         ModbusSlaveStatistics.illegalValueCount++;

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

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

  466.     }

  467. 

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

  469.     {

  470.         ModbusSlaveStatistics.illegalAddressCount++;

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

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

  473.     }

  474. 

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

  476.     {

  477.         uint8_t state;

  478. 

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

  480.             >> (index & 0x0007U))

  481.             & 0x01U);

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

  483.     }

  484. 

  485.     if (isBroadcast != 0U)

  486.     {

  487.         return 0U;

  488.     }

  489. 

  490.     ModbusTxFrame[0] = ModbusSlaveAddress;

  491.     ModbusTxFrame[1] = 0X0F;

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

  493.     ModbusAppendCrc(ModbusTxFrame, 6U);

  494.     return 8U;

  495. }

  496. 

  497. /**

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

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

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

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

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

  503.  */

  504. static uint16_t ModbusProcessWriteMultipleRegisters(

  505.     const uint8_t *request,

  506.     uint16_t requestLength,

  507.     uint8_t isBroadcast)

  508. {

  509.     uint16_t start;

  510.     uint16_t quantity;

  511.     uint16_t index;

  512.     uint8_t byteCount;

  513. 

  514.     if (requestLength < 9U)

  515.     {

  516.         ModbusSlaveStatistics.illegalValueCount++;

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

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

  519.     }

  520. 

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

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

  523.     byteCount = request[6];

  524. 

  525.     if ((quantity == 0U)

  526.         || (quantity > MODBUS_WRITE_REGS_MAX)

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

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

  529.     {

  530.         ModbusSlaveStatistics.illegalValueCount++;

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

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

  533.     }

  534. 

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

  536.     {

  537.         ModbusSlaveStatistics.illegalAddressCount++;

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

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

  540.     }

  541. 

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

  543.     {

  544.         ModbusHoldingRegisters[start + index] =

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

  546.     }

  547. 

  548.     if (isBroadcast != 0U)

  549.     {

  550.         return 0U;

  551.     }

  552. 

  553.     ModbusTxFrame[0] = ModbusSlaveAddress;

  554.     ModbusTxFrame[1] = 0X10;

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

  556.     ModbusAppendCrc(ModbusTxFrame, 6U);

  557.     return 8U;

  558. }

  559. 

  560. 

  561. /**

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

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

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

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

  566.  */

  567. static uint16_t ModbusProcessReadBigHolding(

  568.     const uint8_t *request,

  569.     uint16_t requestLength)

  570. {

  571.     uint32_t start;

  572.     uint32_t currentAddress;

  573.     uint16_t quantity;

  574.     uint16_t index;

  575.     uint16_t value;

  576. 

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

  578.     if (requestLength != 9U)

  579.     {

  580.         ModbusSlaveStatistics.illegalValueCount++;

  581. 

  582.         return ModbusBuildException(

  583.             request[1],

  584.             MODBUS_EX_ILLEGAL_VALUE);

  585.     }

  586. 

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

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

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

  590. 

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

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

  593.         (quantity > MODBUS_READ_REGS_MAX))

  594.     {

  595.         ModbusSlaveStatistics.illegalValueCount++;

  596. 

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

  598.             

  599.             

  600.     }

  601. 

  602.     /*

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

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

  605.      */

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

  607.        

  608.     {

  609.         ModbusSlaveStatistics.illegalAddressCount++;

  610. 

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

  612.           

  613.             

  614.     }

  615. 

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

  617.     ModbusTxFrame[0] = ModbusSlaveAddress;

  618.     ModbusTxFrame[1] = 0x48U;

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

  620. 

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

  622.     {

  623.         currentAddress = start + (uint32_t)index;

  624. 

  625.         /*

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

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

  628.          */

  629.         if (currentAddress < 40000UL)

  630.         {

  631.             value = ModbusHoldingRegisters[currentAddress];

  632.         }

  633.         else

  634.         {

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

  636.                 

  637.         }

  638. 

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

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

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

  642.            

  643.     }

  644.     /* 添加CRC。 */

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

  646.         

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

  648. }

  649. 

  650. /**

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

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

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

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

  655.  */

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

  657. {

  658.     uint16_t calculatedCrc;

  659.     uint16_t receivedCrc;

  660.     uint8_t isBroadcast;

  661. 

  662.     if (requestLength < 4U)

  663.     {

  664.         return 0U;

  665.     }

  666. 

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

  668.     receivedCrc =

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

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

  671. 

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

  673.     {

  674.         ModbusSlaveStatistics.crcErrorCount++;

  675.         return 0U;

  676.     }

  677. 

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

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

  680.     {

  681.         ModbusSlaveStatistics.ignoredAddressCount++;

  682.         return 0U;

  683.     }

  684. 

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

  686.     ModbusSlaveStatistics.validFrameCount++;

  687.     ModbusLastValidFrameTick = HAL_GetTick();

  688.     ModbusHasReceivedValidFrame = 1U;

  689. 

  690.     switch (request[1])

  691.     {

  692.         case 0X01U://读线圈

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

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

  695.                 ModbusProcessReadCoils(request, requestLength);

  696. 

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

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

  699.                 ModbusProcessReadHolding(request, requestLength);

  700. 

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

  702.             return ModbusProcessWriteSingleCoil(request,

  703.                                                 requestLength,

  704.                                                 isBroadcast);

  705. 

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

  707.             return ModbusProcessWriteSingleRegister(request,

  708.                                                     requestLength,

  709.                                                     isBroadcast);

  710. 

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

  712.             return ModbusProcessWriteMultipleCoils(request,

  713.                 requestLength,

  714.                 isBroadcast);

  715. 

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

  717.             return ModbusProcessWriteMultipleRegisters(request,

  718.                 requestLength,

  719.                 isBroadcast);

  720. 

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

  722.                return   ModbusProcessReadBigHolding(request, requestLength);

  723.         

  724.         default://未知功能码

  725.             ModbusSlaveStatistics.illegalFunctionCount++;

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

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

  728.     }

  729. }

  730. 

  731. HAL_StatusTypeDef ModbusSlaveInit(UART_HandleTypeDef *huart,

  732.     uint8_t slaveAddress)

  733. {

  734. 

  735.     ModbusUart = huart;

  736.     ModbusSlaveAddress = slaveAddress;

  737. 

  738.     ModbusHoldingRegisters[HMI_REG_DEVICE_ID] = 0xF407U;

  739. 

  740.     return ModbusStartReceive();

  741. }

  742. 

  743. void ModbusSlavePoll(void)

  744. {

  745.     uint16_t responseLength;

  746. 

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

  748.     {

  749.         return;

  750.     }

  751. 

  752. 

  753. 

  754.     responseLength = ModbusProcessRequest(ModbusRxFrame, ModbusRxFrameLength);

  755.         

  756. 

  757.     if (responseLength > 0U)

  758.     {

  759.         ModbusTxBusy = 1U;

  760. 

  761.         if (HAL_UART_Transmit_DMA(ModbusUart,

  762.                                   ModbusTxFrame,

  763.                                   responseLength) == HAL_OK)                                                               

  764.         {

  765.             ModbusSlaveStatistics.txFrameCount++;

  766.         }

  767.         else

  768.         {

  769.             ModbusTxBusy = 0U;

  770.             ModbusSlaveStatistics.uartErrorCount++;

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

  772.         }

  773.     }

  774.     else 

  775.     {

  776.          (void)ModbusStartReceive();

  777.     }

  778. 

  779.     /*

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

  781.      */

  782.     ModbusRxFrameReady = 0U;

  783. }

  784. 

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

  786. {

  787. 

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

  789. 

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

  791.     {

  792.         if (ModbusRxFrameReady == 0U)

  793.         {

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

  795.             ModbusRxFrameLength = size;

  796.             ModbusRxEventTick = HAL_GetTick();

  797.             ModbusRxFrameReady = 1U;

  798.         }

  799.         else

  800.         {

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

  802.             ModbusSlaveStatistics.droppedFrameCount++;

  803.         }

  804.     }

  805.     else

  806.     {

  807.         //长度异常帧

  808.         ModbusSlaveStatistics.droppedFrameCount++;

  809.         (void)ModbusStartReceive();

  810.     }

  811. }

  812. 

  813. void ModbusSlaveOnTxComplete(UART_HandleTypeDef *huart)

  814. {

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

  816.     {

  817.         return;

  818.     }

  819. 

  820.     ModbusTxBusy = 0U;

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

  822. }

  823. 

  824. void ModbusSlaveOnUartError(UART_HandleTypeDef *huart)

  825. {

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

  827.     {

  828.         return;

  829.     }

  830. 

  831.     ModbusSlaveStatistics.uartErrorCount++;

  832.     ModbusTxBusy = 0U;

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

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

  835. }

  836. 

  837. uint8_t ModbusSlaveSetHoldingRegister(uint16_t address, uint16_t value)

  838. {

  839.     if (address >= MODBUS_MAP_ITEM_COUNT)

  840.     {

  841.         return 0U;

  842.     }

  843. 

  844.     ModbusHoldingRegisters[address] = value;

  845.     return 1U;

  846. }

  847. 

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

  849. {

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

  851.     {

  852.         return 0U;

  853.     }

  854. 

  855.     *value = ModbusHoldingRegisters[address];

  856.     return 1U;

  857. }

  858. 

  859. uint8_t ModbusSlaveSetCoil(uint16_t address, uint8_t state)

  860. {

  861.     if (address >= MODBUS_MAP_ITEM_COUNT)

  862.     {

  863.         return 0U;

  864.     }

  865. 

  866.     ModbusCoilSetUnchecked(address, state);

  867.     return 1U;

  868. }

  869. 

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

  871. {

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

  873.     {

  874.         return 0U;

  875.     }

  876. 

  877.     *state = ModbusCoilGetUnchecked(address);

  878.     return 1U;

  879. }

  880. 

  881. uint8_t ModbusSlaveIsConnected(uint32_t timeoutMs)

  882. {

  883.     if (ModbusHasReceivedValidFrame == 0U)

  884.     {

  885.         return 0U;

  886.     }

  887. 

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

  889.         ? 1U

  890.         : 0U;

  891. }

  892. 

  893. //上电恢复函数

  894. void ModbusRetainedRegistersLoad(void)

  895. {

  896.     uint16_t index;

  897. 

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

  899.     {

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

  901.         {

  902.             ModbusHoldingRegisters[MODBUS_RETAINED_D_START + index] =             

  903.                 backupData->retainedD[index];

  904.         }

  905.     }

  906.     else

  907.     {

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

  909.         {

  910.             ModbusHoldingRegisters[

  911.                 MODBUS_RETAINED_D_START + index] = 0U;

  912. 

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

  914.         }

  915. 

  916.         /*

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

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

  919.          */

  920.         backupData->magic = MODBUS_BACKUP_MAGIC;

  921.     }

  922. }

  923. void ModbusRetainedRegistersPoll(void)

  924. {

  925.     uint16_t index;

  926.    // uint16_t address;

  927.     uint16_t value;

  928. 

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

  930.     {

  931.         value=ModbusHoldingRegisters[MODBUS_RETAINED_D_START +index];

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

  933.         {

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

  935.         }

  936. 

  937.         ModbusRetainedSnapshot[index] = value;

  938.     }

  939. 

  940. 

  941. 

  942. 

  943. }