yuwenhao
/
Modbus-rtu
1
0
Форк 0
Код Проблеми 0 Запити на злиття 0 Релізи 0 Вікі Активність
Ви не можете вибрати більше 25 тем Теми мають розпочинатися з літери або цифри, можуть містити дефіси (-) і не повинні перевищувати 35 символів.
20 Коміти
3 Гілки
138 MiB
 
 
 
 
 
 
Дерево: 4c45d6e670
Гілки Теги
${ item.name }
Створити гілку ${ searchTerm }
з '4c45d6e670'
${ noResults }
Modbus-rtu/Modbus/Src/modbus_rtu_slave.c

1249 рядки
37 KiB
Неформатований Звинувачення Історія 

  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. static HAL_StatusTypeDef ModbusStartReceive(void);

  32. static MODBUS_HISTORY_ITEM ModbusHistory[16];

  33. static uint16_t ModbusHistoryWriteIndex;

  34. /*最近一次字节尾到字节头的间隔周期数*/

  35. static volatile uint32_t ModbusLastInterFrameGapCycles;

  36. /**

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

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

  39.  */

  40. static uint8_t ModbusRxDmaBuffer[MODBUS_RTU_ADU_SIZE_MAX];

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

  42. static uint8_t ModbusRxAssemblyBuffer[MODBUS_RTU_ADU_SIZE_MAX];

  43. static uint8_t ModbusRxFrame[MODBUS_RTU_ADU_SIZE_MAX];

  44. static uint8_t ModbusTxFrame[MODBUS_RTU_ADU_SIZE_MAX];

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

  46. static uint16_t ModbusRetainedSnapshot[MODBUS_RETAINED_D_COUNT];

  47. static volatile uint16_t ModbusRxFrameLength;

  48. static volatile uint8_t ModbusRxFrameReady;

  49. static volatile uint8_t ModbusTxBusy;

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

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

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

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

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

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

  56. static volatile uint32_t ModbusLastValidFrameTick;

  57. static volatile uint8_t ModbusHasReceivedValidFrame;

  58. static volatile MODBUS_BACKUP_DATA *ModbusBackupData =

  59.     (volatile MODBUS_BACKUP_DATA *)BKPSRAM_BASE;

  60. 

  61. /**

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

  63.  * 占用 1250 字节

  64.  */

  65. static uint16_t ModbusHoldingRegisters[40000];

  66. 

  67. #pragma location = ".ccmram"

  68. #pragma data_alignment = 4

  69. __root static uint16_t ModbusRegistersCcm[29999];

  70. 

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

  72. 

  73. volatile MODBUS_SLAVE_STATS ModbusSlaveStatistics;

  74. 

  75. /**

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

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

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

  79.  * @return CRC16 校验值

  80.  */

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

  82. {

  83.     uint16_t crc = 0xFFFFU;

  84.     uint16_t index;

  85.     uint8_t bit;

  86. 

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

  88.     {

  89.         crc ^= data[index];

  90. 

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

  92.         {

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

  94.             {

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

  96.             }

  97.             else

  98.             {

  99.                 crc >>= 1U;

  100.             }

  101.         }

  102.     }

  103. 

  104.     return crc;

  105. }

  106. 

  107. /**

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

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

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

  111.  */

  112. static uint16_t ModbusGetU16Be(const uint8_t *data)

  113. {

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

  115. }

  116. 

  117. /**

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

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

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

  121.  */

  122. static uint32_t ModbusGetU24Be(const uint8_t *data)

  123. {

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

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

  126. }

  127. 

  128. /**

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

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

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

  132.  */

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

  134. {

  135.     if (start >= MODBUS_MAP_ITEM_COUNT)

  136.     {

  137.         return 0U;

  138.     }

  139. 

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

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

  142. }

  143. 

  144. /**

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

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

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

  148.  */

  149. static uint8_t ModbusCoilGetUnchecked(uint16_t address)

  150. {

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

  152. 

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

  154. }

  155. 

  156. /**

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

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

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

  160.  */

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

  162. {

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

  164. 

  165.     if (state != 0U)

  166.     {

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

  168.     }

  169.     else

  170.     {

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

  172.     }

  173. }

  174. 

  175. /**

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

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

  178.  */

  179. static void ModbusRtuTimingInit(uint32_t baudRate)

  180. {

  181.     uint64_t coreClock;

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

  183.     CoreDebug->DEMCR |= CoreDebug_DEMCR_TRCENA_Msk;

  184.     DWT->CYCCNT = 0U;

  185.     DWT->CTRL |= DWT_CTRL_CYCCNTENA_Msk;

  186. 

  187.     coreClock = SystemCoreClock;

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

  189.     ModbusRtuCharCycles =

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

  191. 

  192.     if (baudRate > MODBUS_RTU_HIGH_BAUD_LIMIT)

  193.     {

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

  195.         ModbusRtuT15Cycles =

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

  197. 

  198.         ModbusRtuT35Cycles =

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

  200.     }

  201.     else

  202.     {

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

  204.         ModbusRtuT15Cycles =

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

  206.         ModbusRtuT35Cycles =

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

  208.     }

  209. }

  210. 

  211. /**

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

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

  214.  */

  215. static void ModbusRxAssemblyFinalize(void)

  216. {

  217.     if (ModbusRxAssemblyLength == 0U)

  218.     {

  219.         return;

  220.     }

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

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

  223.     {

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

  225.         (void)memcpy(ModbusRxFrame, ModbusRxAssemblyBuffer,

  226.                      ModbusRxAssemblyLength);

  227.         ModbusRxFrameLength = ModbusRxAssemblyLength;

  228.         ModbusRxFrameReady = 1U;

  229.     }

  230.     else

  231.     {

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

  233.         ModbusSlaveStatistics.droppedFrameCount++;

  234.     }

  235. 

  236.     ModbusRxAssemblyLength = 0U;

  237.     ModbusRxAssemblyInvalid = 0U;

  238. }

  239. 

  240. /**

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

  242.  */

  243. static void ModbusTryFinalizeReceive(void)

  244. {

  245.     uint32_t now;

  246. 

  247.     if (ModbusRxAssemblyLength == 0U)

  248.     {

  249.         return;

  250.     }

  251. 

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

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

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

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

  256.             < MODBUS_RTU_ADU_SIZE_MAX))

  257.     {

  258.         return;

  259.     }

  260. 

  261.     now = DWT->CYCCNT;

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

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

  264.     {

  265.         return;

  266.     }

  267. 

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

  269.     (void)HAL_UART_AbortReceive(ModbusUart);

  270. 

  271.     __disable_irq();

  272.     ModbusRxAssemblyFinalize();

  273.     __enable_irq();

  274. /* 无效帧被丢弃后，重新启动DMA接收。 */

  275.     if (ModbusRxFrameReady == 0U)

  276.     {

  277.         (void)ModbusStartReceive();

  278.     }

  279. 

  280. 

  281. }

  282. 

  283. /**

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

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

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

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

  288.  */

  289. static HAL_StatusTypeDef ModbusStartReceive(void)

  290. {

  291.     HAL_StatusTypeDef status;

  292. 

  293.     if (ModbusTxBusy != 0U)

  294.     {

  295.         return HAL_BUSY;

  296.     }

  297. 

  298.     status = HAL_UARTEx_ReceiveToIdle_DMA(ModbusUart, ModbusRxDmaBuffer,

  299.                                           sizeof(ModbusRxDmaBuffer));

  300. 

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

  302.     {

  303.         /*

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

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

  306.          */

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

  308.     }

  309. 

  310.     return status;

  311. }

  312. 

  313. /**

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

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

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

  317.  */

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

  319. {

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

  321. 

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

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

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

  325. }

  326. 

  327. /**

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

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

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

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

  332.  */

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

  334. {

  335.     ModbusTxFrame[0] = ModbusSlaveAddress;

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

  337.     ModbusTxFrame[2] = exception;

  338.     ModbusAppendCrc(ModbusTxFrame, 3U);

  339. 

  340.     return 5U;

  341. }

  342. 

  343. /**

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

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

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

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

  348.  */

  349. static uint16_t ModbusProcessReadCoils(const uint8_t *request,

  350.                                        uint16_t requestLength)

  351. {

  352. 

  353.     uint16_t start;

  354.     uint16_t quantity;

  355.     uint16_t index;

  356.     uint8_t byteCount;

  357. 

  358.     if (requestLength != 8U)

  359.     {

  360.         ModbusSlaveStatistics.illegalValueCount++;

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

  362.     }

  363. 

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

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

  366. 

  367.     if ((quantity == 0U)

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

  369.     {

  370.         ModbusSlaveStatistics.illegalValueCount++;

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

  372.     }

  373. 

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

  375.     {

  376.         ModbusSlaveStatistics.illegalAddressCount++;

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

  378.     }

  379. 

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

  381.     ModbusTxFrame[0] = ModbusSlaveAddress;

  382.     ModbusTxFrame[1] = 0X01;

  383.     ModbusTxFrame[2] = byteCount;

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

  385. 

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

  387.     {

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

  389.         {

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

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

  392.         }

  393.     }

  394. 

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

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

  397. }

  398. 

  399. /**

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

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

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

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

  404.  */

  405. static uint16_t ModbusProcessReadHolding(const uint8_t *request,

  406.                                          uint16_t requestLength)

  407. 

  408. {

  409.     uint16_t start;

  410.     uint16_t quantity;

  411.     uint16_t index;

  412.     uint16_t value;

  413. 

  414.     if (requestLength != 8U)

  415.     {

  416.         ModbusSlaveStatistics.illegalValueCount++;

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

  418.     }

  419. 

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

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

  422. 

  423.     if ((quantity == 0U)

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

  425.     {

  426.         ModbusSlaveStatistics.illegalValueCount++;

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

  428.     }

  429. 

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

  431.     {

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

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

  434.             goto tx;

  435.         ModbusSlaveStatistics.illegalAddressCount++;

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

  437.     }

  438. tx:

  439.     ModbusTxFrame[0] = ModbusSlaveAddress;

  440.     ModbusTxFrame[1] = 0X03;

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

  442. 

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

  444.     {

  445.         uint16_t address = start + index;

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

  447.         if (address >= 20000U)

  448.         {

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

  450.         }

  451.         value = ModbusHoldingRegisters[address];

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

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

  454.     }

  455. 

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

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

  458. }

  459. 

  460. /*

  461.  * 返回帧

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

  463.  *

  464.  *    01          从站地址

  465.  *    14          功能码

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

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

  468.  *    06          引用类型

  469.  *    12 34       第一个寄存器

  470.  *    56 78       第二个寄存器

  471.  */

  472. static uint16_t ModbusProcessFile(const uint8_t *request,

  473.                                   uint16_t requestLength)

  474. {

  475.     uint16_t fileNumber;

  476.     uint16_t recordNumber;

  477.     uint16_t quantity;

  478.     uint16_t index;

  479.     uint16_t value;

  480.     uint16_t *historyRegister;

  481.     if (requestLength != 12U)

  482.     {

  483.         ModbusSlaveStatistics.illegalValueCount++;

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

  485.     }

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

  487.     {

  488.         ModbusSlaveStatistics.illegalValueCount++;

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

  490.     }

  491. 

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

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

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

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

  496.     {

  497.         ModbusSlaveStatistics.illegalValueCount++;

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

  499.     }

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

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

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

  503.     {

  504.         ModbusSlaveStatistics.illegalAddressCount++;

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

  506.     }

  507.     ModbusTxFrame[0] = ModbusSlaveAddress;

  508.     ModbusTxFrame[1] = 0X14;

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

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

  511. 

  512.     ModbusTxFrame[4] = 0X06;

  513.     historyRegister = (uint16_t *)ModbusHistory;

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

  515.     {

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

  517. 

  518.         value = *(historyRegister + address);

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

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

  521.     }

  522. 

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

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

  525. }

  526. 

  527. /**

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

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

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

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

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

  533.  */

  534. static uint16_t ModbusProcessWriteSingleRegister(const uint8_t *request,

  535.                                                  uint16_t requestLength,

  536.                                                  uint8_t isBroadcast)

  537. {

  538.     uint16_t address;

  539.     uint16_t value;

  540. 

  541.     if (requestLength != 8U)

  542.     {

  543.         ModbusSlaveStatistics.illegalValueCount++;

  544.         return (isBroadcast != 0U) ? 0U: ModbusBuildException(request[1], MODBUS_EX_ILLEGAL_VALUE);

  545.                   

  546.                    

  547.     }

  548. 

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

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

  551. 

  552.     if (address >= MODBUS_MAP_ITEM_COUNT)

  553.     {

  554.         ModbusSlaveStatistics.illegalAddressCount++;

  555.         return (isBroadcast != 0U) ? 0U : ModbusBuildException(request[1], MODBUS_EX_ILLEGAL_ADDRESS);

  556.                                   

  557.                                          

  558.     }

  559. 

  560.     ModbusHoldingRegisters[address] = value;

  561. 

  562.     if (isBroadcast != 0U)

  563.     {

  564.         return 0U;

  565.     }

  566. 

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

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

  569.     ModbusAppendCrc(ModbusTxFrame, 6U);

  570.     return 8U;

  571. }

  572. 

  573. /**

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

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

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

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

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

  579.  */

  580. static uint16_t ModbusProcessWriteSingleCoil(const uint8_t *request,

  581.                                              uint16_t requestLength,

  582.                                              uint8_t isBroadcast)

  583. {

  584.     uint16_t address;

  585.     uint16_t value;

  586. 

  587.     if (requestLength != 8U)

  588.     {

  589.         ModbusSlaveStatistics.illegalValueCount++;

  590.         return (isBroadcast != 0U)? 0U : ModbusBuildException(request[1], MODBUS_EX_ILLEGAL_VALUE);

  591.                    

  592.                   

  593.     }

  594. 

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

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

  597. 

  598.     /*

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

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

  601.      */

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

  603.     {

  604.         ModbusSlaveStatistics.illegalValueCount++;

  605.         return (isBroadcast != 0U)? 0U : ModbusBuildException(request[1], MODBUS_EX_ILLEGAL_VALUE);

  606.                    

  607.                   

  608.     }

  609. 

  610.     if (address >= MODBUS_MAP_ITEM_COUNT)

  611.     {

  612.         ModbusSlaveStatistics.illegalAddressCount++;

  613.         return (isBroadcast != 0U) ? 0U: ModbusBuildException(request[1], MODBUS_EX_ILLEGAL_ADDRESS);

  614.                                    

  615.                                          

  616.     }

  617. 

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

  619. 

  620.     if (isBroadcast != 0U)

  621.     {

  622.         return 0U;

  623.     }

  624. 

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

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

  627.     ModbusAppendCrc(ModbusTxFrame, 6U);

  628.     return 8U;

  629. }

  630. 

  631. /**

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

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

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

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

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

  637.  */

  638. static uint16_t ModbusProcessWriteMultipleCoils(const uint8_t *request,

  639.                                                 uint16_t requestLength,

  640.                                                 uint8_t isBroadcast)

  641. {

  642.     uint16_t start;

  643.     uint16_t quantity;

  644.     uint16_t index;

  645.     uint8_t byteCount;

  646.     uint8_t expectedByteCount;

  647. 

  648.     if (requestLength < 9U)

  649.     {

  650.         ModbusSlaveStatistics.illegalValueCount++;

  651.         return (isBroadcast != 0U) ? 0U: ModbusBuildException(request[1], MODBUS_EX_ILLEGAL_VALUE);

  652.                   

  653.                    

  654.     }

  655. 

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

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

  658.     byteCount = request[6];

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

  660. 

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

  662.         || (byteCount != expectedByteCount)

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

  664.     {

  665.         ModbusSlaveStatistics.illegalValueCount++;

  666.         return (isBroadcast != 0U)? 0U : ModbusBuildException(request[1], MODBUS_EX_ILLEGAL_VALUE);

  667.                    

  668.                   

  669.     }

  670. 

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

  672.     {

  673.         ModbusSlaveStatistics.illegalAddressCount++;

  674.         return (isBroadcast != 0U) ? 0U: ModbusBuildException(request[1], MODBUS_EX_ILLEGAL_ADDRESS);

  675.                                    

  676.                                          

  677.     }

  678. 

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

  680.     {

  681.         uint8_t state;

  682. 

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

  684.                          

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

  686.     }

  687. 

  688.     if (isBroadcast != 0U)

  689.     {

  690.         return 0U;

  691.     }

  692. 

  693.     ModbusTxFrame[0] = ModbusSlaveAddress;

  694.     ModbusTxFrame[1] = 0X0F;

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

  696.     ModbusAppendCrc(ModbusTxFrame, 6U);

  697.     return 8U;

  698. }

  699. 

  700. /**

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

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

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

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

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

  706.  */

  707. static uint16_t ModbusProcessWriteMultipleRegisters(const uint8_t *request,

  708.                                                     uint16_t requestLength,

  709.                                                     uint8_t isBroadcast)

  710. {

  711.     uint16_t start;

  712.     uint16_t quantity;

  713.     uint16_t index;

  714.     uint8_t byteCount;

  715. 

  716.     if (requestLength < 9U)

  717.     {

  718.         ModbusSlaveStatistics.illegalValueCount++;

  719.         return (isBroadcast != 0U) ? 0U : ModbusBuildException(request[1], MODBUS_EX_ILLEGAL_VALUE);

  720.                   

  721.                   

  722.     }

  723. 

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

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

  726.     byteCount = request[6];

  727. 

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

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

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

  731.     {

  732.         ModbusSlaveStatistics.illegalValueCount++;

  733.         return (isBroadcast != 0U)  ? 0U : ModbusBuildException(request[1], MODBUS_EX_ILLEGAL_VALUE);

  734.                  

  735.                   

  736.     }

  737. 

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

  739.     {

  740.         ModbusSlaveStatistics.illegalAddressCount++;

  741.         return (isBroadcast != 0U) ? 0U : ModbusBuildException(request[1], MODBUS_EX_ILLEGAL_ADDRESS);

  742.                                   

  743.                                          

  744.     }

  745. 

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

  747.     {

  748.         ModbusHoldingRegisters[start + index] =

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

  750.     }

  751. 

  752.     if (isBroadcast != 0U)

  753.     {

  754.         return 0U;

  755.     }

  756. 

  757.     ModbusTxFrame[0] = ModbusSlaveAddress;

  758.     ModbusTxFrame[1] = 0X10;

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

  760.     ModbusAppendCrc(ModbusTxFrame, 6U);

  761.     return 8U;

  762. }

  763. 

  764. /**

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

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

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

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

  769.  */

  770. static uint16_t ModbusProcessReadBigHolding(const uint8_t *request,

  771.                                             uint16_t requestLength)

  772. {

  773.     uint32_t start;

  774.     uint32_t currentAddress;

  775.     uint16_t quantity;

  776.     uint16_t index;

  777.     uint16_t value;

  778. 

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

  780.     if (requestLength != 9U)

  781.     {

  782.         ModbusSlaveStatistics.illegalValueCount++;

  783. 

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

  785.     }

  786. 

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

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

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

  790. 

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

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

  793.     {

  794.         ModbusSlaveStatistics.illegalValueCount++;

  795. 

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

  797.     }

  798. 

  799.     /*

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

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

  802.      */

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

  804. 

  805.     {

  806.         ModbusSlaveStatistics.illegalAddressCount++;

  807. 

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

  809.     }

  810. 

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

  812.     ModbusTxFrame[0] = ModbusSlaveAddress;

  813.     ModbusTxFrame[1] = 0x48U;

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

  815. 

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

  817.     {

  818.         currentAddress = start + (uint32_t)index;

  819. 

  820.         /*

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

  822.          * 地址40000～69998位于CCMRAM

  823.          */

  824.         if (currentAddress < 40000UL)

  825.         {

  826.             value = ModbusHoldingRegisters[currentAddress];

  827.         }

  828.         else

  829.         {

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

  831.         }

  832. 

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

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

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

  836.     }

  837.     /* 添加CRC */

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

  839. 

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

  841. }

  842. 

  843. /**

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

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

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

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

  848.  */

  849. static uint16_t ModbusProcessRequest(const uint8_t *request,

  850.                                      uint16_t requestLength)

  851. {

  852.     uint16_t calculatedCrc;

  853.     uint16_t receivedCrc;

  854.     uint8_t isBroadcast;

  855. 

  856.     if (requestLength < 4U)

  857.     {

  858.         return 0U;

  859.     }

  860. 

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

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

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

  864. 

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

  866.     {

  867.         ModbusSlaveStatistics.crcErrorCount++;

  868.         return 0U;

  869.     }

  870. 

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

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

  873.     {

  874.         ModbusSlaveStatistics.ignoredAddressCount++;

  875.         return 0U;

  876.     }

  877. 

  878.     isBroadcast =

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

  880.     ModbusSlaveStatistics.validFrameCount++;

  881.     ModbusLastValidFrameTick = HAL_GetTick();

  882.     ModbusHasReceivedValidFrame = 1U;

  883. 

  884.     switch (request[1])

  885.     {

  886.         case 0X01U: // 读线圈

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

  888.             return (isBroadcast != 0U)

  889.                        ? 0U

  890.                        : ModbusProcessReadCoils(request, requestLength);

  891. 

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

  893.             return (isBroadcast != 0U)

  894.                        ? 0U

  895.                        : ModbusProcessReadHolding(request, requestLength);

  896.         case 0x14U:

  897.             return (isBroadcast != 0U)

  898.                        ? 0U

  899.                        : ModbusProcessFile(request, requestLength);

  900. 

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

  902.             return ModbusProcessWriteSingleCoil(request, requestLength,

  903.                                                 isBroadcast);

  904. 

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

  906.             return ModbusProcessWriteSingleRegister(request, requestLength,

  907.                                                     isBroadcast);

  908. 

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

  910.             return ModbusProcessWriteMultipleCoils(request, requestLength,

  911.                                                    isBroadcast);

  912. 

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

  914.             return ModbusProcessWriteMultipleRegisters(request, requestLength,

  915.                                                        isBroadcast);

  916. 

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

  918.             return (isBroadcast != 0U)

  919.                        ? 0U

  920.                        : ModbusProcessReadBigHolding(request, requestLength);

  921. 

  922.         default: // 未知功能码

  923.             ModbusSlaveStatistics.illegalFunctionCount++;

  924.             return (isBroadcast != 0U)

  925.                        ? 0U

  926.                        : ModbusBuildException(request[1],

  927.                                               MODBUS_EX_ILLEGAL_FUNCTION);

  928.     }

  929. }

  930. 

  931. HAL_StatusTypeDef ModbusSlaveInit(UART_HandleTypeDef *huart,

  932.                                   uint8_t slaveAddress)

  933. 

  934. {

  935. 

  936.     ModbusUart = huart;

  937.     ModbusSlaveAddress = slaveAddress;

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

  939.     ModbusRxAssemblyLength = 0U;

  940.     ModbusRxAssemblyInvalid = 0U;

  941.     ModbusRxFrameReady = 0U;

  942.     ModbusTxBusy = 0U;

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

  944. 

  945.     //ModbusHoldingRegisters[HMI_REG_DEVICE_ID] = 0xF407U;

  946. 

  947.     return ModbusStartReceive();

  948. }

  949. 

  950. void ModbusSlavePoll(void)

  951. {

  952.     uint16_t responseLength;

  953. 

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

  955.     ModbusTryFinalizeReceive();

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

  957.     {

  958.         return;

  959.     }

  960. 

  961.     responseLength = ModbusProcessRequest(ModbusRxFrame, ModbusRxFrameLength);

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

  963.                       ModbusTxFrame, responseLength);

  964. 

  965.     if (responseLength > 0U)

  966.     {

  967.         ModbusTxBusy = 1U;

  968. 

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

  970.             == HAL_OK)

  971.         {

  972.             ModbusSlaveStatistics.txFrameCount++;

  973.         }

  974.         else

  975.         {

  976.             ModbusTxBusy = 0U;

  977.             ModbusSlaveStatistics.uartErrorCount++;

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

  979.         }

  980.     }

  981.     else

  982.     {

  983.         (void)ModbusStartReceive();

  984.     }

  985. 

  986.     /*

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

  988.      */

  989.     ModbusRxFrameReady = 0U;

  990. }

  991. 

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

  993. {

  994.     HAL_UART_RxEventTypeTypeDef eventType;

  995.     uint32_t now;

  996.     uint32_t lastByteCycle;

  997.     uint32_t firstByteCycle;

  998.     uint32_t chunkCycles;

  999.     uint32_t interFrameGap;

  1000. 

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

  1002. 

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

  1004.     {

  1005.         return;

  1006.     }

  1007. 

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

  1009.     {

  1010.         now = DWT->CYCCNT;

  1011.         eventType = HAL_UARTEx_GetRxEventType(huart);

  1012. 

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

  1014.         lastByteCycle = now;

  1015.         if (eventType == HAL_UART_RXEVENT_IDLE)

  1016.         {

  1017.             lastByteCycle -= ModbusRtuCharCycles;

  1018.         }

  1019. 

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

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

  1022.         firstByteCycle = lastByteCycle - chunkCycles;

  1023. 

  1024.         if (ModbusRxAssemblyLength > 0U)

  1025.         {

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

  1027.             ModbusLastInterFrameGapCycles = interFrameGap;

  1028.             if (interFrameGap >= ModbusRtuT35Cycles)

  1029.             {

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

  1031.                 ModbusRxAssemblyFinalize();

  1032.             }

  1033.             else if (interFrameGap > ModbusRtuT15Cycles)

  1034.             {

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

  1036.                 ModbusRxAssemblyInvalid = 1U;

  1037.             }

  1038.             else

  1039.             {

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

  1041.             }

  1042.         }

  1043. 

  1044.         if (size

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

  1046.         {

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

  1048.                          ModbusRxDmaBuffer, size);

  1049.             ModbusRxAssemblyLength += size;

  1050.         }

  1051.         else

  1052.         {

  1053.             ModbusRxAssemblyInvalid = 1U;

  1054.         }

  1055. 

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

  1057.         ModbusRxLastByteCycle = lastByteCycle;

  1058.         (void)ModbusStartReceive();

  1059.     }

  1060.     else

  1061.     {

  1062.         // 长度异常帧

  1063.         ModbusSlaveStatistics.droppedFrameCount++;

  1064.         ModbusRxAssemblyLength = 0U;

  1065.         ModbusRxAssemblyInvalid = 0U;

  1066.         (void)ModbusStartReceive();

  1067.     }

  1068. }

  1069. 

  1070. void ModbusSlaveOnTxComplete(UART_HandleTypeDef *huart)

  1071. {

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

  1073.     {

  1074.         return;

  1075.     }

  1076. 

  1077.     ModbusTxBusy = 0U;

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

  1079. }

  1080. 

  1081. void ModbusSlaveOnUartError(UART_HandleTypeDef *huart)

  1082. {

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

  1084.     {

  1085.         return;

  1086.     }

  1087. 

  1088.     ModbusSlaveStatistics.uartErrorCount++;

  1089.     ModbusTxBusy = 0U;

  1090.     ModbusRxAssemblyLength = 0U;

  1091.     ModbusRxAssemblyInvalid = 0U;

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

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

  1094. }

  1095. 

  1096. uint8_t ModbusSlaveSetHoldingRegister(uint16_t address, uint16_t value)

  1097. {

  1098.     if (address >= MODBUS_MAP_ITEM_COUNT)

  1099.     {

  1100.         return 0U;

  1101.     }

  1102. 

  1103.     ModbusHoldingRegisters[address] = value;

  1104.     return 1U;

  1105. }

  1106. 

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

  1108. {

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

  1110.     {

  1111.         return 0U;

  1112.     }

  1113. 

  1114.     *value = ModbusHoldingRegisters[address];

  1115.     return 1U;

  1116. }

  1117. 

  1118. uint8_t ModbusSlaveSetCoil(uint16_t address, uint8_t state)

  1119. {

  1120.     if (address >= MODBUS_MAP_ITEM_COUNT)

  1121.     {

  1122.         return 0U;

  1123.     }

  1124. 

  1125.     ModbusCoilSetUnchecked(address, state);

  1126.     return 1U;

  1127. }

  1128. 

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

  1130. {

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

  1132.     {

  1133.         return 0U;

  1134.     }

  1135. 

  1136.     *state = ModbusCoilGetUnchecked(address);

  1137.     return 1U;

  1138. }

  1139. 

  1140. uint8_t ModbusSlaveIsConnected(uint32_t timeoutMs)

  1141. {

  1142.     if (ModbusHasReceivedValidFrame == 0U)

  1143.     {

  1144.         return 0U;

  1145.     }

  1146. 

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

  1148. }

  1149. 

  1150. // 上电恢复函数

  1151. void ModbusRetainedRegistersLoad(void)

  1152. {

  1153.     uint16_t index;

  1154. 

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

  1156.     {

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

  1158.         {

  1159.             ModbusHoldingRegisters[MODBUS_RETAINED_D_START + index] =

  1160.                 ModbusBackupData->retainedD[index];

  1161.         }

  1162.     }

  1163.     else

  1164.     {

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

  1166.         {

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

  1168. 

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

  1170.         }

  1171. 

  1172.         /*

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

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

  1175.          */

  1176.         ModbusBackupData->magic = MODBUS_BACKUP_MAGIC;

  1177.     }

  1178. }

  1179. void ModbusRetainedRegistersPoll(void)

  1180. {

  1181.     uint16_t index;

  1182.     uint16_t value;

  1183. 

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

  1185.     {

  1186.         value = ModbusHoldingRegisters[MODBUS_RETAINED_D_START + index];

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

  1188.         {

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

  1190.         }

  1191. 

  1192.         ModbusRetainedSnapshot[index] = value;

  1193.     }

  1194. }

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

  1196.                               uint16_t requestLength, const uint8_t *response,

  1197.                               uint16_t responseLength)

  1198. {

  1199.     MODBUS_HISTORY_ITEM *item;

  1200. 

  1201.     if (requestLength > 256U)

  1202.     {

  1203.         requestLength = 256U;

  1204.     }

  1205. 

  1206.     if (responseLength > 256U)

  1207.     {

  1208.         responseLength = 256U;

  1209.     }

  1210. 

  1211.     item = &ModbusHistory[ModbusHistoryWriteIndex];

  1212. 

  1213.     item->tick = tick;

  1214.     item->requestLength = requestLength;

  1215.     item->responseLength = responseLength;

  1216. 

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

  1218. 

  1219.     if (responseLength > 0U)

  1220.     {

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

  1222.     }

  1223. 

  1224.     ModbusHistoryWriteIndex++;

  1225. 

  1226.     if (ModbusHistoryWriteIndex >= 16U)

  1227.     {

  1228.         ModbusHistoryWriteIndex = 0U;

  1229.     }

  1230. }

  1231. void HistorySaveToRegisters(void)

  1232. {

  1233. 

  1234. 

  1235.     uint16_t index;

  1236. 

  1237.     if (ModbusHistoryWriteIndex == 0U)

  1238.     {

  1239.         index = 15U;

  1240.     }

  1241.     else

  1242.     {

  1243.         index = ModbusHistoryWriteIndex - 1U;

  1244.     }

  1245. 

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

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

  1248. }