yuwenhao
/
Modbus-rtu
1
0
Bifurcation 0
Code Tickets 0 Demandes d'ajout 0 Versions 0 Wiki Activité
Vous ne pouvez pas sélectionner plus de 25 sujets Les noms de sujets doivent commencer par une lettre ou un nombre, peuvent contenir des tirets ('-') et peuvent comporter jusqu'à 35 caractères.
19 Révisions
3 Branches
138 MiB
 
 
 
 
 
 
Aborescence: e9adda50f6
Branches Tags
${ item.name }
Créer la branche ${ searchTerm }
de 'e9adda50f6'
${ noResults }
Modbus-rtu/Modbus/Src/modbus_rtu_slave.c

1238 lignes
37 KiB
Brut Annotations Historique 

  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. #define MODBUS_RTU_T15_US (750UL)       /* 高波特率下固定T1.5时间，单位us */

  8. #define MODBUS_RTU_T35_US (1750UL)      /* 高波特率下固定T3.5时间，单位us */

  9. #define MODBUS_RTU_BITS_PER_CHAR (11UL) /* 8E1包含11个传输位 */

  10. #define MODBUS_RTU_HIGH_BAUD_LIMIT (19200UL) /* 高低波特率计算方式的分界值 */

  11. 

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

  13. 

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

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

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

  17. 

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

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

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

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

  22. 

  23. #define MODBUS_COIL_VALUE_ON (0xFF00U)

  24. #define MODBUS_COIL_VALUE_OFF (0x0000U)

  25. 

  26. static UART_HandleTypeDef *ModbusUart;

  27. static uint8_t ModbusSlaveAddress;

  28. static void ModbusHistorySave(uint32_t tick, const uint8_t *request,

  29.                               uint16_t requestLength, const uint8_t *response,

  30.                               uint16_t responseLength);

  31. 

  32. static MODBUS_HISTORY_ITEM ModbusHistory[16];

  33. static uint16_t ModbusHistoryWriteIndex;

  34. /**

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

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

  37.  */

  38. static uint8_t ModbusRxDmaBuffer[MODBUS_RTU_ADU_SIZE_MAX];

  39. /* 保存被UART IDLE事件分开的DMA片段，达到T3.5后再提交解析 */

  40. static uint8_t ModbusRxAssemblyBuffer[MODBUS_RTU_ADU_SIZE_MAX];

  41. static uint8_t ModbusRxFrame[MODBUS_RTU_ADU_SIZE_MAX];

  42. static uint8_t ModbusTxFrame[MODBUS_RTU_ADU_SIZE_MAX];

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

  44. static uint16_t ModbusRetainedSnapshot[MODBUS_RETAINED_D_COUNT];

  45. static volatile uint16_t ModbusRxFrameLength;

  46. static volatile uint8_t ModbusRxFrameReady;

  47. static volatile uint8_t ModbusTxBusy;

  48. static volatile uint16_t ModbusRxAssemblyLength; /* 当前拼帧长度 */

  49. static volatile uint8_t ModbusRxAssemblyInvalid; /* 帧内间隔超过T1.5时置1 */

  50. static volatile uint32_t ModbusRxLastByteCycle;  /* 上一片段末字节结束时刻 */

  51. static uint32_t ModbusRtuT15Cycles;              /* T1.5对应的CPU周期数 */

  52. static uint32_t ModbusRtuT35Cycles;              /* T3.5对应的CPU周期数 */

  53. static uint32_t ModbusRtuCharCycles; /* 一个UART字符对应的CPU周期数 */

  54. static volatile uint32_t ModbusLastValidFrameTick;

  55. static volatile uint8_t ModbusHasReceivedValidFrame;

  56. static volatile MODBUS_BACKUP_DATA *ModbusBackupData =

  57.     (volatile MODBUS_BACKUP_DATA *)BKPSRAM_BASE;

  58. 

  59. /**

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

  61.  * 占用 1250 字节

  62.  */

  63. static uint16_t ModbusHoldingRegisters[40000];

  64. 

  65. #pragma location = ".ccmram"

  66. #pragma data_alignment = 4

  67. __root static uint16_t ModbusRegistersCcm[29999];

  68. 

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

  70. 

  71. volatile MODBUS_SLAVE_STATS ModbusSlaveStatistics;

  72. 

  73. /**

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

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

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

  77.  * @return CRC16 校验值

  78.  */

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

  80. {

  81.     uint16_t crc = 0xFFFFU;

  82.     uint16_t index;

  83.     uint8_t bit;

  84. 

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

  86.     {

  87.         crc ^= data[index];

  88. 

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

  90.         {

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

  92.             {

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

  94.             }

  95.             else

  96.             {

  97.                 crc >>= 1U;

  98.             }

  99.         }

  100.     }

  101. 

  102.     return crc;

  103. }

  104. 

  105. /**

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

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

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

  109.  */

  110. static uint16_t ModbusGetU16Be(const uint8_t *data)

  111. {

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

  113. }

  114. 

  115. /**

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

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

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

  119.  */

  120. static uint32_t ModbusGetU24Be(const uint8_t *data)

  121. {

  122.     return (uint32_t)(((uint32_t)data[0] << 16U) | ((uint32_t)data[1] << 8U)

  123.                       | (uint32_t)data[2]);

  124. }

  125. 

  126. /**

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

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

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

  130.  */

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

  132. {

  133.     if (start >= MODBUS_MAP_ITEM_COUNT)

  134.     {

  135.         return 0U;

  136.     }

  137. 

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

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

  140. }

  141. 

  142. /**

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

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

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

  146.  */

  147. static uint8_t ModbusCoilGetUnchecked(uint16_t address)

  148. {

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

  150. 

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

  152. }

  153. 

  154. /**

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

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

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

  158.  */

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

  160. {

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

  162. 

  163.     if (state != 0U)

  164.     {

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

  166.     }

  167.     else

  168.     {

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

  170.     }

  171. }

  172. 

  173. /**

  174.  * @brief 初始化用于RTU帧间隔测量的DWT周期计数器

  175.  * @param[in] baudRate 当前串口波特率

  176.  */

  177. static void ModbusRtuTimingInit(uint32_t baudRate)

  178. {

  179.     uint64_t coreClock;

  180.     /* 开启DWT周期计数器，CYCCNT每经过一个CPU时钟周期自动加1 */

  181.     CoreDebug->DEMCR |= CoreDebug_DEMCR_TRCENA_Msk;

  182.     DWT->CYCCNT = 0U;

  183.     DWT->CTRL |= DWT_CTRL_CYCCNTENA_Msk;

  184. 

  185.     coreClock = SystemCoreClock;

  186.     /* 一个字符周期数=CPU频率*每字符位数/波特率 */

  187.     ModbusRtuCharCycles =

  188.         (uint32_t)((coreClock * MODBUS_RTU_BITS_PER_CHAR) / baudRate);

  189. 

  190.     if (baudRate > MODBUS_RTU_HIGH_BAUD_LIMIT)

  191.     {

  192.         /* 高波特率使用固定750us和1750us，999999用于向上取整 */

  193.         ModbusRtuT15Cycles =

  194.             (uint32_t)((coreClock * MODBUS_RTU_T15_US + 999999UL) / 1000000UL);

  195. 

  196.         ModbusRtuT35Cycles =

  197.             (uint32_t)((coreClock * MODBUS_RTU_T35_US + 999999UL) / 1000000UL);

  198.     }

  199.     else

  200.     {

  201.         /* 低波特率按照1.5个字符时间和3.5个字符时间计算 */

  202.         ModbusRtuT15Cycles =

  203.             (uint32_t)(((uint64_t)ModbusRtuCharCycles * 3UL + 1UL) / 2UL);

  204.         ModbusRtuT35Cycles =

  205.             (uint32_t)(((uint64_t)ModbusRtuCharCycles * 7UL + 1UL) / 2UL);

  206.     }

  207. }

  208. 

  209. /**

  210.  * @brief 结束当前RTU接收组帧

  211.  * @note 调用本函数时必须保证不会与串口接收中断并发执行

  212.  */

  213. static void ModbusRxAssemblyFinalize(void)

  214. {

  215.     if (ModbusRxAssemblyLength == 0U)

  216.     {

  217.         return;

  218.     }

  219.     /*拼帧区是否有数据*/

  220.     if ((ModbusRxAssemblyInvalid == 0U) && (ModbusRxFrameReady == 0U))

  221.     {

  222.         /* 当前帧未违反T1.5且解析缓冲区空闲时提交完整帧 */

  223.         (void)memcpy(ModbusRxFrame, ModbusRxAssemblyBuffer,

  224.                      ModbusRxAssemblyLength);

  225.         ModbusRxFrameLength = ModbusRxAssemblyLength;

  226.         ModbusRxFrameReady = 1U;

  227.     }

  228.     else

  229.     {

  230.         /* T1.5无效帧或上一帧尚未处理完成时丢弃 */

  231.         ModbusSlaveStatistics.droppedFrameCount++;

  232.     }

  233. 

  234.     ModbusRxAssemblyLength = 0U;

  235.     ModbusRxAssemblyInvalid = 0U;

  236. }

  237. 

  238. /**

  239.  * @brief 静默时间达到T3.5后，将接收数据交给协议解析任务

  240.  */

  241. static void ModbusTryFinalizeReceive(void)

  242. {

  243.     uint32_t now;

  244. 

  245.     if (ModbusRxAssemblyLength == 0U)

  246.     {

  247.         return;

  248.     }

  249. 

  250.     /* DMA缓冲区出现新数据时，说明串口仍在接收当前片段 */

  251.     if ((ModbusUart->hdmarx != NULL) && /*串口DMA使能*/

  252.         ((ModbusUart->Instance->CR3 & USART_CR3_DMAR) != 0U)

  253.         && (__HAL_DMA_GET_COUNTER(ModbusUart->hdmarx)

  254.             < MODBUS_RTU_ADU_SIZE_MAX))

  255.     {

  256.         return;

  257.     }

  258. 

  259.     now = DWT->CYCCNT;

  260.     /* 从末字节结束时刻开始计算静默时间，未达到T3.5时继续等待 */

  261.     if ((uint32_t)(now - ModbusRxLastByteCycle) < ModbusRtuT35Cycles)

  262.     {

  263.         return;

  264.     }

  265. 

  266.     /* 静默达到T3.5，当前RTU帧结束，发送响应前停止接收DMA */

  267.     (void)HAL_UART_AbortReceive(ModbusUart);

  268. 

  269.     __disable_irq();

  270.     ModbusRxAssemblyFinalize();

  271.     __enable_irq();

  272. }

  273. 

  274. /**

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

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

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

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

  279.  */

  280. static HAL_StatusTypeDef ModbusStartReceive(void)

  281. {

  282.     HAL_StatusTypeDef status;

  283. 

  284.     if (ModbusTxBusy != 0U)

  285.     {

  286.         return HAL_BUSY;

  287.     }

  288. 

  289.     status = HAL_UARTEx_ReceiveToIdle_DMA(ModbusUart, ModbusRxDmaBuffer,

  290.                                           sizeof(ModbusRxDmaBuffer));

  291. 

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

  293.     {

  294.         /*

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

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

  297.          */

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

  299.     }

  300. 

  301.     return status;

  302. }

  303. 

  304. /**

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

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

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

  308.  */

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

  310. {

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

  312. 

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

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

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

  316. }

  317. 

  318. /**

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

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

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

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

  323.  */

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

  325. {

  326.     ModbusTxFrame[0] = ModbusSlaveAddress;

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

  328.     ModbusTxFrame[2] = exception;

  329.     ModbusAppendCrc(ModbusTxFrame, 3U);

  330. 

  331.     return 5U;

  332. }

  333. 

  334. /**

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

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

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

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

  339.  */

  340. static uint16_t ModbusProcessReadCoils(const uint8_t *request,

  341.                                        uint16_t requestLength)

  342. {

  343. 

  344.     uint16_t start;

  345.     uint16_t quantity;

  346.     uint16_t index;

  347.     uint8_t byteCount;

  348. 

  349.     if (requestLength != 8U)

  350.     {

  351.         ModbusSlaveStatistics.illegalValueCount++;

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

  353.     }

  354. 

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

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

  357. 

  358.     if ((quantity == 0U)

  359.         || (quantity > MODBUS_READ_COILS_MAX)) // 数量0或者数量大于最大值

  360.     {

  361.         ModbusSlaveStatistics.illegalValueCount++;

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

  363.     }

  364. 

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

  366.     {

  367.         ModbusSlaveStatistics.illegalAddressCount++;

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

  369.     }

  370. 

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

  372.     ModbusTxFrame[0] = ModbusSlaveAddress;

  373.     ModbusTxFrame[1] = 0X01;

  374.     ModbusTxFrame[2] = byteCount;

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

  376. 

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

  378.     {

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

  380.         {

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

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

  383.         }

  384.     }

  385. 

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

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

  388. }

  389. 

  390. /**

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

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

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

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

  395.  */

  396. static uint16_t ModbusProcessReadHolding(const uint8_t *request,

  397.                                          uint16_t requestLength)

  398. 

  399. {

  400.     uint16_t start;

  401.     uint16_t quantity;

  402.     uint16_t index;

  403.     uint16_t value;

  404. 

  405.     if (requestLength != 8U)

  406.     {

  407.         ModbusSlaveStatistics.illegalValueCount++;

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

  409.     }

  410. 

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

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

  413. 

  414.     if ((quantity == 0U)

  415.         || (quantity > MODBUS_READ_REGS_MAX)) // 数量0或者数量大于最大值

  416.     {

  417.         ModbusSlaveStatistics.illegalValueCount++;

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

  419.     }

  420. 

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

  422.     {

  423.         if ((start >= 20000U) && (start < 25000U) && (quantity > 0U)

  424.             && (quantity <= (25000U - start)))

  425.             goto tx;

  426.         ModbusSlaveStatistics.illegalAddressCount++;

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

  428.     }

  429. tx:

  430.     ModbusTxFrame[0] = ModbusSlaveAddress;

  431.     ModbusTxFrame[1] = 0X03;

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

  433. 

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

  435.     {

  436.         uint16_t address = start + index;

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

  438.         if (address >= 20000U)

  439.         {

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

  441.         }

  442.         value = ModbusHoldingRegisters[address];

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

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

  445.     }

  446. 

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

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

  449. }

  450. 

  451. /*

  452.  * 返回帧

  453.  *从站地址 | 14 | 总字节数 | 子响应长度 | 06 | 寄存器数据 | CRC

  454.  *

  455.  *    01          从站地址

  456.  *    14          功能码

  457.  *    06          后续响应数据共6字节

  458.  *    05          当前子响应长度，共5字节

  459.  *    06          引用类型

  460.  *    12 34       第一个寄存器

  461.  *    56 78       第二个寄存器

  462.  */

  463. static uint16_t ModbusProcessFile(const uint8_t *request,

  464.                                   uint16_t requestLength)

  465. {

  466.     uint16_t fileNumber;

  467.     uint16_t recordNumber;

  468.     uint16_t quantity;

  469.     uint16_t index;

  470.     uint16_t value;

  471.     uint16_t *historyRegister;

  472.     if (requestLength != 12U)

  473.     {

  474.         ModbusSlaveStatistics.illegalValueCount++;

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

  476.     }

  477.     if ((request[2] != 7U) || (request[3] != 0x06U))

  478.     {

  479.         ModbusSlaveStatistics.illegalValueCount++;

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

  481.     }

  482. 

  483.     quantity = ModbusGetU16Be(&request[8]);

  484.     fileNumber = ModbusGetU16Be(&request[4]);

  485.     recordNumber = ModbusGetU16Be(&request[6]);

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

  487.     {

  488.         ModbusSlaveStatistics.illegalValueCount++;

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

  490.     }

  491.     /* 检查文件号、记录号和读取范围 */

  492.     if ((fileNumber > 15U) || (recordNumber >= 260U)

  493.         || (((uint32_t)recordNumber + quantity) > 260UL))

  494.     {

  495.         ModbusSlaveStatistics.illegalAddressCount++;

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

  497.     }

  498.     ModbusTxFrame[0] = ModbusSlaveAddress;

  499.     ModbusTxFrame[1] = 0X14;

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

  501.     ModbusTxFrame[3] = (uint8_t)(1U + quantity * 2U);

  502. 

  503.     ModbusTxFrame[4] = 0X06;

  504.     historyRegister = (uint16_t *)ModbusHistory;

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

  506.     {

  507.         uint16_t address = fileNumber * 260 + recordNumber + index;

  508. 

  509.         value = *(historyRegister + address);

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

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

  512.     }

  513. 

  514.     ModbusAppendCrc(ModbusTxFrame, (uint16_t)(5U + quantity * 2U));

  515.     return (uint16_t)(7U + quantity * 2U);

  516. }

  517. 

  518. /**

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

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

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

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

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

  524.  */

  525. static uint16_t ModbusProcessWriteSingleRegister(const uint8_t *request,

  526.                                                  uint16_t requestLength,

  527.                                                  uint8_t isBroadcast)

  528. {

  529.     uint16_t address;

  530.     uint16_t value;

  531. 

  532.     if (requestLength != 8U)

  533.     {

  534.         ModbusSlaveStatistics.illegalValueCount++;

  535.         return (isBroadcast != 0U)

  536.                    ? 0U

  537.                    : ModbusBuildException(request[1], MODBUS_EX_ILLEGAL_VALUE);

  538.     }

  539. 

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

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

  542. 

  543.     if (address >= MODBUS_MAP_ITEM_COUNT)

  544.     {

  545.         ModbusSlaveStatistics.illegalAddressCount++;

  546.         return (isBroadcast != 0U) ? 0U

  547.                                    : ModbusBuildException(

  548.                                          request[1], MODBUS_EX_ILLEGAL_ADDRESS);

  549.     }

  550. 

  551.     ModbusHoldingRegisters[address] = value;

  552. 

  553.     if (isBroadcast != 0U)

  554.     {

  555.         return 0U;

  556.     }

  557. 

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

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

  560.     ModbusAppendCrc(ModbusTxFrame, 6U);

  561.     return 8U;

  562. }

  563. 

  564. /**

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

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

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

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

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

  570.  */

  571. static uint16_t ModbusProcessWriteSingleCoil(const uint8_t *request,

  572.                                              uint16_t requestLength,

  573.                                              uint8_t isBroadcast)

  574. {

  575.     uint16_t address;

  576.     uint16_t value;

  577. 

  578.     if (requestLength != 8U)

  579.     {

  580.         ModbusSlaveStatistics.illegalValueCount++;

  581.         return (isBroadcast != 0U)

  582.                    ? 0U

  583.                    : ModbusBuildException(request[1], MODBUS_EX_ILLEGAL_VALUE);

  584.     }

  585. 

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

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

  588. 

  589.     /*

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

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

  592.      */

  593.     if ((value != MODBUS_COIL_VALUE_ON) && (value != MODBUS_COIL_VALUE_OFF))

  594.     {

  595.         ModbusSlaveStatistics.illegalValueCount++;

  596.         return (isBroadcast != 0U)

  597.                    ? 0U

  598.                    : ModbusBuildException(request[1], MODBUS_EX_ILLEGAL_VALUE);

  599.     }

  600. 

  601.     if (address >= MODBUS_MAP_ITEM_COUNT)

  602.     {

  603.         ModbusSlaveStatistics.illegalAddressCount++;

  604.         return (isBroadcast != 0U) ? 0U

  605.                                    : ModbusBuildException(

  606.                                          request[1], MODBUS_EX_ILLEGAL_ADDRESS);

  607.     }

  608. 

  609.     ModbusCoilSetUnchecked(address, (value == MODBUS_COIL_VALUE_ON) ? 1U : 0U);

  610. 

  611.     if (isBroadcast != 0U)

  612.     {

  613.         return 0U;

  614.     }

  615. 

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

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

  618.     ModbusAppendCrc(ModbusTxFrame, 6U);

  619.     return 8U;

  620. }

  621. 

  622. /**

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

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

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

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

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

  628.  */

  629. static uint16_t ModbusProcessWriteMultipleCoils(const uint8_t *request,

  630.                                                 uint16_t requestLength,

  631.                                                 uint8_t isBroadcast)

  632. {

  633.     uint16_t start;

  634.     uint16_t quantity;

  635.     uint16_t index;

  636.     uint8_t byteCount;

  637.     uint8_t expectedByteCount;

  638. 

  639.     if (requestLength < 9U)

  640.     {

  641.         ModbusSlaveStatistics.illegalValueCount++;

  642.         return (isBroadcast != 0U)

  643.                    ? 0U

  644.                    : ModbusBuildException(request[1], MODBUS_EX_ILLEGAL_VALUE);

  645.     }

  646. 

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

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

  649.     byteCount = request[6];

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

  651. 

  652.     if ((quantity == 0U) || (quantity > MODBUS_WRITE_COILS_MAX)

  653.         || (byteCount != expectedByteCount)

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

  655.     {

  656.         ModbusSlaveStatistics.illegalValueCount++;

  657.         return (isBroadcast != 0U)

  658.                    ? 0U

  659.                    : ModbusBuildException(request[1], MODBUS_EX_ILLEGAL_VALUE);

  660.     }

  661. 

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

  663.     {

  664.         ModbusSlaveStatistics.illegalAddressCount++;

  665.         return (isBroadcast != 0U) ? 0U

  666.                                    : ModbusBuildException(

  667.                                          request[1], MODBUS_EX_ILLEGAL_ADDRESS);

  668.     }

  669. 

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

  671.     {

  672.         uint8_t state;

  673. 

  674.         state = (uint8_t)((request[7U + (index >> 3U)] >> (index & 0x0007U))

  675.                           & 0x01U);

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

  677.     }

  678. 

  679.     if (isBroadcast != 0U)

  680.     {

  681.         return 0U;

  682.     }

  683. 

  684.     ModbusTxFrame[0] = ModbusSlaveAddress;

  685.     ModbusTxFrame[1] = 0X0F;

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

  687.     ModbusAppendCrc(ModbusTxFrame, 6U);

  688.     return 8U;

  689. }

  690. 

  691. /**

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

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

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

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

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

  697.  */

  698. static uint16_t ModbusProcessWriteMultipleRegisters(const uint8_t *request,

  699.                                                     uint16_t requestLength,

  700.                                                     uint8_t isBroadcast)

  701. {

  702.     uint16_t start;

  703.     uint16_t quantity;

  704.     uint16_t index;

  705.     uint8_t byteCount;

  706. 

  707.     if (requestLength < 9U)

  708.     {

  709.         ModbusSlaveStatistics.illegalValueCount++;

  710.         return (isBroadcast != 0U)

  711.                    ? 0U

  712.                    : ModbusBuildException(request[1], MODBUS_EX_ILLEGAL_VALUE);

  713.     }

  714. 

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

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

  717.     byteCount = request[6];

  718. 

  719.     if ((quantity == 0U) || (quantity > MODBUS_WRITE_REGS_MAX)

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

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

  722.     {

  723.         ModbusSlaveStatistics.illegalValueCount++;

  724.         return (isBroadcast != 0U)

  725.                    ? 0U

  726.                    : ModbusBuildException(request[1], MODBUS_EX_ILLEGAL_VALUE);

  727.     }

  728. 

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

  730.     {

  731.         ModbusSlaveStatistics.illegalAddressCount++;

  732.         return (isBroadcast != 0U) ? 0U

  733.                                    : ModbusBuildException(

  734.                                          request[1], MODBUS_EX_ILLEGAL_ADDRESS);

  735.     }

  736. 

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

  738.     {

  739.         ModbusHoldingRegisters[start + index] =

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

  741.     }

  742. 

  743.     if (isBroadcast != 0U)

  744.     {

  745.         return 0U;

  746.     }

  747. 

  748.     ModbusTxFrame[0] = ModbusSlaveAddress;

  749.     ModbusTxFrame[1] = 0X10;

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

  751.     ModbusAppendCrc(ModbusTxFrame, 6U);

  752.     return 8U;

  753. }

  754. 

  755. /**

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

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

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

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

  760.  */

  761. static uint16_t ModbusProcessReadBigHolding(const uint8_t *request,

  762.                                             uint16_t requestLength)

  763. {

  764.     uint32_t start;

  765.     uint32_t currentAddress;

  766.     uint16_t quantity;

  767.     uint16_t index;

  768.     uint16_t value;

  769. 

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

  771.     if (requestLength != 9U)

  772.     {

  773.         ModbusSlaveStatistics.illegalValueCount++;

  774. 

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

  776.     }

  777. 

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

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

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

  781. 

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

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

  784.     {

  785.         ModbusSlaveStatistics.illegalValueCount++;

  786. 

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

  788.     }

  789. 

  790.     /*

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

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

  793.      */

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

  795. 

  796.     {

  797.         ModbusSlaveStatistics.illegalAddressCount++;

  798. 

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

  800.     }

  801. 

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

  803.     ModbusTxFrame[0] = ModbusSlaveAddress;

  804.     ModbusTxFrame[1] = 0x48U;

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

  806. 

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

  808.     {

  809.         currentAddress = start + (uint32_t)index;

  810. 

  811.         /*

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

  813.          * 地址40000～69998位于CCMRAM

  814.          */

  815.         if (currentAddress < 40000UL)

  816.         {

  817.             value = ModbusHoldingRegisters[currentAddress];

  818.         }

  819.         else

  820.         {

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

  822.         }

  823. 

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

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

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

  827.     }

  828.     /* 添加CRC */

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

  830. 

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

  832. }

  833. 

  834. /**

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

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

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

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

  839.  */

  840. static uint16_t ModbusProcessRequest(const uint8_t *request,

  841.                                      uint16_t requestLength)

  842. {

  843.     uint16_t calculatedCrc;

  844.     uint16_t receivedCrc;

  845.     uint8_t isBroadcast;

  846. 

  847.     if (requestLength < 4U)

  848.     {

  849.         return 0U;

  850.     }

  851. 

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

  853.     receivedCrc = (uint16_t)(request[requestLength - 2U]

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

  855. 

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

  857.     {

  858.         ModbusSlaveStatistics.crcErrorCount++;

  859.         return 0U;

  860.     }

  861. 

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

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

  864.     {

  865.         ModbusSlaveStatistics.ignoredAddressCount++;

  866.         return 0U;

  867.     }

  868. 

  869.     isBroadcast =

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

  871.     ModbusSlaveStatistics.validFrameCount++;

  872.     ModbusLastValidFrameTick = HAL_GetTick();

  873.     ModbusHasReceivedValidFrame = 1U;

  874. 

  875.     switch (request[1])

  876.     {

  877.         case 0X01U: // 读线圈

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

  879.             return (isBroadcast != 0U)

  880.                        ? 0U

  881.                        : ModbusProcessReadCoils(request, requestLength);

  882. 

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

  884.             return (isBroadcast != 0U)

  885.                        ? 0U

  886.                        : ModbusProcessReadHolding(request, requestLength);

  887.         case 0x14U:

  888.             return (isBroadcast != 0U)

  889.                        ? 0U

  890.                        : ModbusProcessFile(request, requestLength);

  891. 

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

  893.             return ModbusProcessWriteSingleCoil(request, requestLength,

  894.                                                 isBroadcast);

  895. 

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

  897.             return ModbusProcessWriteSingleRegister(request, requestLength,

  898.                                                     isBroadcast);

  899. 

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

  901.             return ModbusProcessWriteMultipleCoils(request, requestLength,

  902.                                                    isBroadcast);

  903. 

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

  905.             return ModbusProcessWriteMultipleRegisters(request, requestLength,

  906.                                                        isBroadcast);

  907. 

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

  909.             return ModbusProcessReadBigHolding(request, requestLength);

  910. 

  911.         default: // 未知功能码

  912.             ModbusSlaveStatistics.illegalFunctionCount++;

  913.             return (isBroadcast != 0U)

  914.                        ? 0U

  915.                        : ModbusBuildException(request[1],

  916.                                               MODBUS_EX_ILLEGAL_FUNCTION);

  917.     }

  918. }

  919. 

  920. HAL_StatusTypeDef ModbusSlaveInit(UART_HandleTypeDef *huart,

  921.                                   uint8_t slaveAddress)

  922. 

  923. {

  924. 

  925.     ModbusUart = huart;

  926.     ModbusSlaveAddress = slaveAddress;

  927.     /* 清空拼帧状态并根据当前波特率初始化T1.5和T3.5 */

  928.     ModbusRxAssemblyLength = 0U;

  929.     ModbusRxAssemblyInvalid = 0U;

  930.     ModbusRxFrameReady = 0U;

  931.     ModbusTxBusy = 0U;

  932.     ModbusRtuTimingInit(huart->Init.BaudRate);

  933. 

  934.     ModbusHoldingRegisters[HMI_REG_DEVICE_ID] = 0xF407U;

  935. 

  936.     return ModbusStartReceive();

  937. }

  938. 

  939. void ModbusSlavePoll(void)

  940. {

  941.     uint16_t responseLength;

  942. 

  943.     /* 检查末字节后的静默时间是否已经达到T3.5 */

  944.     ModbusTryFinalizeReceive();

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

  946.     {

  947.         return;

  948.     }

  949. 

  950.     responseLength = ModbusProcessRequest(ModbusRxFrame, ModbusRxFrameLength);

  951.     ModbusHistorySave(OSTimeGet() / 1000, ModbusRxFrame, ModbusRxFrameLength,

  952.                       ModbusTxFrame, responseLength);

  953. 

  954.     if (responseLength > 0U)

  955.     {

  956.         ModbusTxBusy = 1U;

  957. 

  958.         if (HAL_UART_Transmit_DMA(ModbusUart, ModbusTxFrame, responseLength)

  959.             == HAL_OK)

  960.         {

  961.             ModbusSlaveStatistics.txFrameCount++;

  962.         }

  963.         else

  964.         {

  965.             ModbusTxBusy = 0U;

  966.             ModbusSlaveStatistics.uartErrorCount++;

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

  968.         }

  969.     }

  970.     else

  971.     {

  972.         (void)ModbusStartReceive();

  973.     }

  974. 

  975.     /*

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

  977.      */

  978.     ModbusRxFrameReady = 0U;

  979. }

  980. 

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

  982. {

  983.     HAL_UART_RxEventTypeTypeDef eventType;

  984.     uint32_t now;

  985.     uint32_t lastByteCycle;

  986.     uint32_t firstByteCycle;

  987.     uint32_t chunkCycles;

  988.     uint32_t interFrameGap;

  989. 

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

  991. 

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

  993.     {

  994.         return;

  995.     }

  996. 

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

  998.     {

  999.         now = DWT->CYCCNT;

  1000.         eventType = HAL_UARTEx_GetRxEventType(huart);

  1001. 

  1002.         /* IDLE事件比末字节结束晚约一个字符时间，减去字符时间得到末字节时刻 */

  1003.         lastByteCycle = now;

  1004.         if (eventType == HAL_UART_RXEVENT_IDLE)

  1005.         {

  1006.             lastByteCycle -= ModbusRtuCharCycles;

  1007.         }

  1008. 

  1009.         /* 根据本次接收字节数反推DMA片段首字节的开始时刻 */

  1010.         chunkCycles = (uint32_t)((uint64_t)size * ModbusRtuCharCycles);

  1011.         firstByteCycle = lastByteCycle - chunkCycles;

  1012. 

  1013.         if (ModbusRxAssemblyLength > 0U)

  1014.         {

  1015.             interFrameGap = (uint32_t)(firstByteCycle - ModbusRxLastByteCycle);

  1016. 

  1017.             if (interFrameGap >= ModbusRtuT35Cycles)

  1018.             {

  1019.                 /* 间隔达到T3.5，结束上一帧，本片段作为新帧开始 */

  1020.                 ModbusRxAssemblyFinalize();

  1021.             }

  1022.             else if (interFrameGap > ModbusRtuT15Cycles)

  1023.             {

  1024.                 /* 帧内静默超过T1.5但不足T3.5，标记整帧无效 */

  1025.                 ModbusRxAssemblyInvalid = 1U;

  1026.             }

  1027.             else

  1028.             {

  1029.                 /* 间隔不超过T1.5，当前片段继续拼入同一帧 */

  1030.             }

  1031.         }

  1032. 

  1033.         if (size

  1034.             <= (uint16_t)(MODBUS_RTU_ADU_SIZE_MAX - ModbusRxAssemblyLength))

  1035.         {

  1036.             (void)memcpy(&ModbusRxAssemblyBuffer[ModbusRxAssemblyLength],

  1037.                          ModbusRxDmaBuffer, size);

  1038.             ModbusRxAssemblyLength += size;

  1039.         }

  1040.         else

  1041.         {

  1042.             ModbusRxAssemblyInvalid = 1U;

  1043.         }

  1044. 

  1045.         /* 保存末字节时刻并立即重启DMA，继续等待可能的后续片段 */

  1046.         ModbusRxLastByteCycle = lastByteCycle;

  1047.         (void)ModbusStartReceive();

  1048.     }

  1049.     else

  1050.     {

  1051.         // 长度异常帧

  1052.         ModbusSlaveStatistics.droppedFrameCount++;

  1053.         ModbusRxAssemblyLength = 0U;

  1054.         ModbusRxAssemblyInvalid = 0U;

  1055.         (void)ModbusStartReceive();

  1056.     }

  1057. }

  1058. 

  1059. void ModbusSlaveOnTxComplete(UART_HandleTypeDef *huart)

  1060. {

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

  1062.     {

  1063.         return;

  1064.     }

  1065. 

  1066.     ModbusTxBusy = 0U;

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

  1068. }

  1069. 

  1070. void ModbusSlaveOnUartError(UART_HandleTypeDef *huart)

  1071. {

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

  1073.     {

  1074.         return;

  1075.     }

  1076. 

  1077.     ModbusSlaveStatistics.uartErrorCount++;

  1078.     ModbusTxBusy = 0U;

  1079.     ModbusRxAssemblyLength = 0U;

  1080.     ModbusRxAssemblyInvalid = 0U;

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

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

  1083. }

  1084. 

  1085. uint8_t ModbusSlaveSetHoldingRegister(uint16_t address, uint16_t value)

  1086. {

  1087.     if (address >= MODBUS_MAP_ITEM_COUNT)

  1088.     {

  1089.         return 0U;

  1090.     }

  1091. 

  1092.     ModbusHoldingRegisters[address] = value;

  1093.     return 1U;

  1094. }

  1095. 

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

  1097. {

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

  1099.     {

  1100.         return 0U;

  1101.     }

  1102. 

  1103.     *value = ModbusHoldingRegisters[address];

  1104.     return 1U;

  1105. }

  1106. 

  1107. uint8_t ModbusSlaveSetCoil(uint16_t address, uint8_t state)

  1108. {

  1109.     if (address >= MODBUS_MAP_ITEM_COUNT)

  1110.     {

  1111.         return 0U;

  1112.     }

  1113. 

  1114.     ModbusCoilSetUnchecked(address, state);

  1115.     return 1U;

  1116. }

  1117. 

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

  1119. {

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

  1121.     {

  1122.         return 0U;

  1123.     }

  1124. 

  1125.     *state = ModbusCoilGetUnchecked(address);

  1126.     return 1U;

  1127. }

  1128. 

  1129. uint8_t ModbusSlaveIsConnected(uint32_t timeoutMs)

  1130. {

  1131.     if (ModbusHasReceivedValidFrame == 0U)

  1132.     {

  1133.         return 0U;

  1134.     }

  1135. 

  1136.     return ((HAL_GetTick() - ModbusLastValidFrameTick) <= timeoutMs) ? 1U : 0U;

  1137. }

  1138. 

  1139. // 上电恢复函数

  1140. void ModbusRetainedRegistersLoad(void)

  1141. {

  1142.     uint16_t index;

  1143. 

  1144.     if (ModbusBackupData->magic == MODBUS_BACKUP_MAGIC)

  1145.     {

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

  1147.         {

  1148.             ModbusHoldingRegisters[MODBUS_RETAINED_D_START + index] =

  1149.                 ModbusBackupData->retainedD[index];

  1150.         }

  1151.     }

  1152.     else

  1153.     {

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

  1155.         {

  1156.             ModbusHoldingRegisters[MODBUS_RETAINED_D_START + index] = 0U;

  1157. 

  1158.             ModbusBackupData->retainedD[index] = 0U;

  1159.         }

  1160. 

  1161.         /*

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

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

  1164.          */

  1165.         ModbusBackupData->magic = MODBUS_BACKUP_MAGIC;

  1166.     }

  1167. }

  1168. void ModbusRetainedRegistersPoll(void)

  1169. {

  1170.     uint16_t index;

  1171.     uint16_t value;

  1172. 

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

  1174.     {

  1175.         value = ModbusHoldingRegisters[MODBUS_RETAINED_D_START + index];

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

  1177.         {

  1178.             ModbusBackupData->retainedD[index] = value;

  1179.         }

  1180. 

  1181.         ModbusRetainedSnapshot[index] = value;

  1182.     }

  1183. }

  1184. static void ModbusHistorySave(uint32_t tick, const uint8_t *request,

  1185.                               uint16_t requestLength, const uint8_t *response,

  1186.                               uint16_t responseLength)

  1187. {

  1188.     MODBUS_HISTORY_ITEM *item;

  1189. 

  1190.     if (requestLength > 256U)

  1191.     {

  1192.         requestLength = 256U;

  1193.     }

  1194. 

  1195.     if (responseLength > 256U)

  1196.     {

  1197.         responseLength = 256U;

  1198.     }

  1199. 

  1200.     item = &ModbusHistory[ModbusHistoryWriteIndex];

  1201. 

  1202.     item->tick = tick;

  1203.     item->requestLength = requestLength;

  1204.     item->responseLength = responseLength;

  1205. 

  1206.     (void)memcpy(item->request, request, requestLength);

  1207. 

  1208.     if (responseLength > 0U)

  1209.     {

  1210.         (void)memcpy(item->response, response, responseLength);

  1211.     }

  1212. 

  1213.     ModbusHistoryWriteIndex++;

  1214. 

  1215.     if (ModbusHistoryWriteIndex >= 16U)

  1216.     {

  1217.         ModbusHistoryWriteIndex = 0U;

  1218.     }

  1219. }

  1220. void HistorySaveToRegisters(void)

  1221. {

  1222. 

  1223. 

  1224.     uint16_t index;

  1225. 

  1226.     if (ModbusHistoryWriteIndex == 0U)

  1227.     {

  1228.         index = 15U;

  1229.     }

  1230.     else

  1231.     {

  1232.         index = ModbusHistoryWriteIndex - 1U;

  1233.     }

  1234. 

  1235.     (void)memcpy(&ModbusHoldingRegisters[1000U + index * 260U],

  1236.                  &ModbusHistory[index], sizeof(ModbusHistory[index]));

  1237. }