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

1366 行
44 KiB
Raw Blame 履歴 

  1. #include "modbus_rtu_slave.h"

  2. #include "modbus_data_store.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 HAL_StatusTypeDef ModbusStartReceive(void);

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

  30. static volatile uint32_t ModbusLastInterFrameGapCycles;

  31. /**

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

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

  34.  */

  35. static uint8_t ModbusRxDmaBuffer[MODBUS_RTU_ADU_SIZE_MAX];

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

  37. static uint8_t ModbusRxAssemblyBuffer[MODBUS_RTU_ADU_SIZE_MAX];

  38. static uint8_t ModbusRxFrame[MODBUS_RTU_ADU_SIZE_MAX];

  39. static uint8_t ModbusTxFrame[MODBUS_RTU_ADU_SIZE_MAX];

  40. static uint16_t ModbusWriteRegisterScratch[MODBUS_WRITE_REGS_MAX];

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

  42. static uint16_t ModbusRetainedSnapshot[MODBUS_RETAINED_D_COUNT];

  43. static volatile uint16_t ModbusRxFrameLength;

  44. static volatile uint8_t ModbusRxFrameReady;

  45. static volatile uint8_t ModbusTxBusy;

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

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

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

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

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

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

  52. static volatile uint32_t ModbusLastValidFrameTick;

  53. static volatile uint8_t ModbusHasReceivedValidFrame;

  54. static volatile uint32_t ModbusReceiveRestartAttemptCount;

  55. static volatile uint32_t ModbusReceiveRestartFailureCount;

  56. static volatile uint32_t ModbusNextReceiveRetryTick;

  57. static volatile uint32_t ModbusLastUartErrorCode;

  58. static volatile uint8_t ModbusLastReceiveStartStatus = (uint8_t)HAL_ERROR;

  59. static volatile MODBUS_BACKUP_DATA *ModbusBackupData =

  60.     (volatile MODBUS_BACKUP_DATA *)BKPSRAM_BASE;

  61. 

  62. /* Word and bit images are owned by modbus_data_store.c.  Standard Modbus

  63.  * coils are the protocol view of the PLC M device space. */

  64. 

  65. volatile MODBUS_SLAVE_STATS ModbusSlaveStatistics;

  66. 

  67. /**

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

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

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

  71.  * @return CRC16 校验值

  72.  */

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

  74. {

  75.     uint16_t crc = 0xFFFFU;

  76.     uint16_t index;

  77.     uint8_t bit;

  78. 

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

  80.     {

  81.         crc ^= data[index];

  82. 

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

  84.         {

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

  86.             {

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

  88.             }

  89.             else

  90.             {

  91.                 crc >>= 1U;

  92.             }

  93.         }

  94.     }

  95. 

  96.     return crc;

  97. }

  98. 

  99. /**

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

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

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

  103.  */

  104. static uint16_t ModbusGetU16Be(const uint8_t *data)

  105. {

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

  107. }

  108. 

  109. /**

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

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

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

  113.  */

  114. static uint32_t ModbusGetU24Be(const uint8_t *data)

  115. {

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

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

  118. }

  119. 

  120. /**

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

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

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

  124.  */

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

  126. {

  127.     if (start >= MODBUS_MAP_ITEM_COUNT)

  128.     {

  129.         return 0U;

  130.     }

  131. 

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

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

  134. }

  135. 

  136. /**

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

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

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

  140.  */

  141. static uint8_t ModbusCoilGetUnchecked(uint16_t address)

  142. {

  143.     uint8_t value = 0U;

  144. 

  145.     (void)ModbusDataReadBit(MODBUS_BIT_DEVICE_M, address, &value);

  146.     return value;

  147. }

  148. 

  149. /**

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

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

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

  153.  */

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

  155. {

  156.     (void)ModbusDataWriteBit(MODBUS_BIT_DEVICE_M, address, state);

  157. }

  158. 

  159. /**

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

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

  162.  */

  163. static void ModbusRtuTimingInit(uint32_t baudRate)

  164. {

  165.     uint64_t coreClock;

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

  167.     CoreDebug->DEMCR |= CoreDebug_DEMCR_TRCENA_Msk;

  168.     DWT->CYCCNT = 0U;

  169.     DWT->CTRL |= DWT_CTRL_CYCCNTENA_Msk;

  170. 

  171.     coreClock = SystemCoreClock;

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

  173.     ModbusRtuCharCycles =

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

  175. 

  176.     if (baudRate > MODBUS_RTU_HIGH_BAUD_LIMIT)

  177.     {

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

  179.         ModbusRtuT15Cycles =

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

  181. 

  182.         ModbusRtuT35Cycles =

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

  184.     }

  185.     else

  186.     {

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

  188.         ModbusRtuT15Cycles =

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

  190.         ModbusRtuT35Cycles =

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

  192.     }

  193. }

  194. 

  195. /**

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

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

  198.  */

  199. static void ModbusRxAssemblyFinalize(void)

  200. {

  201.     if (ModbusRxAssemblyLength == 0U)

  202.     {

  203.         return;

  204.     }

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

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

  207.     {

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

  209.         (void)memcpy(ModbusRxFrame, ModbusRxAssemblyBuffer,

  210.                      ModbusRxAssemblyLength);

  211.         ModbusRxFrameLength = ModbusRxAssemblyLength;

  212.         ModbusRxFrameReady = 1U;

  213.     }

  214.     else

  215.     {

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

  217.         ModbusSlaveStatistics.droppedFrameCount++;

  218.     }

  219. 

  220.     ModbusRxAssemblyLength = 0U;

  221.     ModbusRxAssemblyInvalid = 0U;

  222. }

  223. 

  224. /**

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

  226.  */

  227. static void ModbusTryFinalizeReceive(void)

  228. {

  229.     uint32_t now;

  230. 

  231.     if (ModbusRxAssemblyLength == 0U)

  232.     {

  233.         return;

  234.     }

  235. 

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

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

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

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

  240.             < MODBUS_RTU_ADU_SIZE_MAX))

  241.     {

  242.         return;

  243.     }

  244. 

  245.     now = DWT->CYCCNT;

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

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

  248.     {

  249.         return;

  250.     }

  251. 

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

  253.     (void)HAL_UART_AbortReceive(ModbusUart);

  254. 

  255.     /* HAL_UART_AbortReceive has already stopped DMA/IDLE callbacks.  The

  256.      * finalize routine may copy a full RTU ADU, so it must not globally mask

  257.      * the 100 kHz motion interrupts around that memcpy. */

  258.     ModbusRxAssemblyFinalize();

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

  260.     if (ModbusRxFrameReady == 0U)

  261.     {

  262.         (void)ModbusStartReceive();

  263.     }

  264. 

  265. 

  266. }

  267. 

  268. /**

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

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

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

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

  273.  */

  274. static HAL_StatusTypeDef ModbusStartReceive(void)

  275. {

  276.     HAL_StatusTypeDef status;

  277. 

  278.     ModbusReceiveRestartAttemptCount++;

  279. 

  280.     if (ModbusUart == NULL)

  281.     {

  282.         status = HAL_ERROR;

  283.         ModbusReceiveRestartFailureCount++;

  284.         ModbusLastReceiveStartStatus = (uint8_t)status;

  285.         return status;

  286.     }

  287. 

  288.     if (ModbusTxBusy != 0U)

  289.     {

  290.         status = HAL_BUSY;

  291.         ModbusReceiveRestartFailureCount++;

  292.         ModbusLastReceiveStartStatus = (uint8_t)status;

  293.         return status;

  294.     }

  295. 

  296.     status = HAL_UARTEx_ReceiveToIdle_DMA(ModbusUart, ModbusRxDmaBuffer,

  297.                                           sizeof(ModbusRxDmaBuffer));

  298. 

  299.     /* A duplicate start request can race with an already healthy DMA receiver.

  300.      * Treat that specific HAL_BUSY case as operational, not as a recovery

  301.      * failure; all other HAL_BUSY/HAL_ERROR results remain visible. */

  302.     if ((status == HAL_BUSY)

  303.         && (ModbusUart->RxState == HAL_UART_STATE_BUSY_RX)

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

  305.     {

  306.         status = HAL_OK;

  307.     }

  308. 

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

  310.     {

  311.         /*

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

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

  314.          */

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

  316.     }

  317. 

  318.     if (status != HAL_OK)

  319.     {

  320.         ModbusReceiveRestartFailureCount++;

  321.         ModbusLastUartErrorCode = ModbusUart->ErrorCode;

  322.         ModbusNextReceiveRetryTick = HAL_GetTick() + 10UL;

  323.     }

  324.     else

  325.     {

  326.         ModbusNextReceiveRetryTick = 0UL;

  327.     }

  328.     ModbusLastReceiveStartStatus = (uint8_t)status;

  329. 

  330.     return status;

  331. }

  332. 

  333. /**

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

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

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

  337.  */

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

  339. {

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

  341. 

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

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

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

  345. }

  346. 

  347. /**

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

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

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

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

  352.  */

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

  354. {

  355.     ModbusTxFrame[0] = ModbusSlaveAddress;

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

  357.     ModbusTxFrame[2] = exception;

  358.     ModbusAppendCrc(ModbusTxFrame, 3U);

  359. 

  360.     return 5U;

  361. }

  362. 

  363. /**

  364.  * @brief Build a bounded, read-only runtime diagnostic response (function 0x47).

  365.  *

  366.  * The request is: function, start word (BE), quantity (BE). Multi-word

  367.  * 32-bit values use low word first, matching the PLSR diagnostic window.

  368.  */

  369. static uint16_t ModbusProcessRuntimeDiagnostics(const uint8_t *request,

  370.                                                 uint16_t requestLength)

  371. {

  372.     MODBUS_SLAVE_RUNTIME_DIAGNOSTICS diagnostics;

  373.     uint16_t words[MODBUS_RUNTIME_DIAGNOSTICS_WORDS];

  374.     uint32_t flags = 0U;

  375.     uint32_t stats[10];

  376.     uint16_t start;

  377.     uint16_t quantity;

  378.     uint16_t index;

  379.     uint16_t responseLength;

  380. 

  381.     if (requestLength != 8U)

  382.     {

  383.         ModbusSlaveStatistics.illegalValueCount++;

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

  385.     }

  386. 

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

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

  389.     if ((quantity == 0U)

  390.         || (start >= MODBUS_RUNTIME_DIAGNOSTICS_WORDS)

  391.         || (quantity > (MODBUS_RUNTIME_DIAGNOSTICS_WORDS - start)))

  392.     {

  393.         ModbusSlaveStatistics.illegalAddressCount++;

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

  395.     }

  396. 

  397.     (void)ModbusSlaveGetRuntimeDiagnostics(MODBUS_CONNECTION_TIMEOUT_MS,

  398.                                            &diagnostics);

  399.     if (diagnostics.initialized != 0U)

  400.     {

  401.         flags |= MODBUS_RUNTIME_FLAG_INITIALIZED;

  402.     }

  403.     if (diagnostics.hasReceivedValidFrame != 0U)

  404.     {

  405.         flags |= MODBUS_RUNTIME_FLAG_VALID_FRAME_SEEN;

  406.     }

  407.     if (diagnostics.connected != 0U)

  408.     {

  409.         flags |= MODBUS_RUNTIME_FLAG_CONNECTED;

  410.     }

  411.     if (diagnostics.txBusy != 0U)

  412.     {

  413.         flags |= MODBUS_RUNTIME_FLAG_TX_BUSY;

  414.     }

  415.     if (diagnostics.rxFrameReady != 0U)

  416.     {

  417.         flags |= MODBUS_RUNTIME_FLAG_RX_FRAME_READY;

  418.     }

  419.     if (diagnostics.rxAssemblyInvalid != 0U)

  420.     {

  421.         flags |= MODBUS_RUNTIME_FLAG_RX_ASSEMBLY_INVALID;

  422.     }

  423.     if (diagnostics.lastReceiveStartStatus == (uint8_t)HAL_OK)

  424.     {

  425.         flags |= MODBUS_RUNTIME_FLAG_RX_RESTART_OK;

  426.     }

  427. 

  428.     words[0] = MODBUS_RUNTIME_DIAGNOSTICS_SIGNATURE;

  429.     words[1] = MODBUS_RUNTIME_DIAGNOSTICS_VERSION;

  430.     words[2] = MODBUS_RUNTIME_DIAGNOSTICS_WORDS;

  431.     words[3] = (uint16_t)flags;

  432.     words[4] = (uint16_t)diagnostics.currentTick;

  433.     words[5] = (uint16_t)(diagnostics.currentTick >> 16U);

  434.     words[6] = (uint16_t)diagnostics.lastValidFrameTick;

  435.     words[7] = (uint16_t)(diagnostics.lastValidFrameTick >> 16U);

  436.     words[8] = (uint16_t)diagnostics.lastInterFrameGapCycles;

  437.     words[9] = (uint16_t)(diagnostics.lastInterFrameGapCycles >> 16U);

  438.     words[10] = (uint16_t)diagnostics.receiveRestartAttemptCount;

  439.     words[11] = (uint16_t)(diagnostics.receiveRestartAttemptCount >> 16U);

  440.     words[12] = (uint16_t)diagnostics.receiveRestartFailureCount;

  441.     words[13] = (uint16_t)(diagnostics.receiveRestartFailureCount >> 16U);

  442.     words[14] = (uint16_t)diagnostics.lastUartErrorCode;

  443.     words[15] = (uint16_t)(diagnostics.lastUartErrorCode >> 16U);

  444.     words[16] = diagnostics.lastReceiveStartStatus;

  445.     words[17] = diagnostics.rxAssemblyLength;

  446.     words[18] = diagnostics.rxFrameLength;

  447.     words[19] = MODBUS_CONNECTION_TIMEOUT_MS;

  448. 

  449.     stats[0] = diagnostics.statistics.rxEventCount;

  450.     stats[1] = diagnostics.statistics.validFrameCount;

  451.     stats[2] = diagnostics.statistics.txFrameCount;

  452.     stats[3] = diagnostics.statistics.crcErrorCount;

  453.     stats[4] = diagnostics.statistics.ignoredAddressCount;

  454.     stats[5] = diagnostics.statistics.illegalFunctionCount;

  455.     stats[6] = diagnostics.statistics.illegalAddressCount;

  456.     stats[7] = diagnostics.statistics.illegalValueCount;

  457.     stats[8] = diagnostics.statistics.droppedFrameCount;

  458.     stats[9] = diagnostics.statistics.uartErrorCount;

  459.     for (index = 0U; index < 10U; index++)

  460.     {

  461.         words[20U + (index * 2U)] = (uint16_t)stats[index];

  462.         words[21U + (index * 2U)] = (uint16_t)(stats[index] >> 16U);

  463.     }

  464. 

  465.     ModbusTxFrame[0] = ModbusSlaveAddress;

  466.     ModbusTxFrame[1] = MODBUS_RUNTIME_DIAGNOSTICS_FUNCTION;

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

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

  469.     {

  470.         uint16_t value = words[start + index];

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

  472.         ModbusTxFrame[4U + (index * 2U)] = (uint8_t)value;

  473.     }

  474.     responseLength = (uint16_t)(3U + (quantity * 2U));

  475.     ModbusAppendCrc(ModbusTxFrame, responseLength);

  476.     return (uint16_t)(responseLength + 2U);

  477. }

  478. 

  479. /**

  480.  * @brief Process read coils (0x01) or discrete inputs (0x02).

  481.  * @param[in] request RTU request frame.

  482.  * @param[in] requestLength Request frame length.

  483.  * @param[in] functionCode Function code echoed in the response.

  484.  * @param[in] device Backing PLC bit-device image.

  485.  * @return Response ADU length, including an exception response when invalid.

  486.  */

  487. static uint16_t ModbusProcessReadBits(const uint8_t *request,

  488.                                       uint16_t requestLength,

  489.                                       uint8_t functionCode,

  490.                                       MODBUS_BIT_DEVICE device)

  491. {

  492. 

  493.     uint16_t start;

  494.     uint16_t quantity;

  495.     uint16_t index;

  496.     uint8_t byteCount;

  497. 

  498.     if (requestLength != 8U)

  499.     {

  500.         ModbusSlaveStatistics.illegalValueCount++;

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

  502.     }

  503. 

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

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

  506. 

  507.     if ((quantity == 0U)

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

  509.     {

  510.         ModbusSlaveStatistics.illegalValueCount++;

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

  512.     }

  513. 

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

  515.     {

  516.         ModbusSlaveStatistics.illegalAddressCount++;

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

  518.     }

  519. 

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

  521.     ModbusTxFrame[0] = ModbusSlaveAddress;

  522.     ModbusTxFrame[1] = functionCode;

  523.     ModbusTxFrame[2] = byteCount;

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

  525. 

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

  527.     {

  528.         uint8_t value = 0U;

  529. 

  530.         if ((ModbusDataReadBit(device,

  531.                                (uint32_t)start + index,

  532.                                &value) != 0U)

  533.             && (value != 0U))

  534.         {

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

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

  537.         }

  538.     }

  539. 

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

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

  542. }

  543. 

  544. /**

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

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

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

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

  549.  */

  550. static uint16_t ModbusProcessReadHolding(const uint8_t *request,

  551.                                          uint16_t requestLength)

  552. 

  553. {

  554.     uint16_t start;

  555.     uint16_t quantity;

  556.     uint16_t index;

  557.     uint16_t value;

  558. 

  559.     if (requestLength != 8U)

  560.     {

  561.         ModbusSlaveStatistics.illegalValueCount++;

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

  563.     }

  564. 

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

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

  567. 

  568.     if ((quantity == 0U)

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

  570.     {

  571.         ModbusSlaveStatistics.illegalValueCount++;

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

  573.     }

  574. 

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

  576.     {

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

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

  579.             goto tx;

  580.         ModbusSlaveStatistics.illegalAddressCount++;

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

  582.     }

  583. tx:

  584.     ModbusTxFrame[0] = ModbusSlaveAddress;

  585.     ModbusTxFrame[1] = 0X03;

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

  587. 

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

  589.     {

  590.         uint16_t address = start + index;

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

  592.         if (address >= 20000U)

  593.         {

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

  595.         }

  596.         if (ModbusDataReadWord(MODBUS_DATA_DEVICE_D, address, &value) == 0U)

  597.         {

  598.             ModbusSlaveStatistics.illegalAddressCount++;

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

  600.         }

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

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

  603.     }

  604. 

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

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

  607. }

  608. 

  609. /**

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

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

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

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

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

  615.  */

  616. static uint16_t ModbusProcessWriteSingleRegister(const uint8_t *request,

  617.                                                  uint16_t requestLength,

  618.                                                  uint8_t isBroadcast)

  619. {

  620.     uint16_t address;

  621.     uint16_t value;

  622. 

  623.     if (requestLength != 8U)

  624.     {

  625.         ModbusSlaveStatistics.illegalValueCount++;

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

  627.                   

  628.                    

  629.     }

  630. 

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

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

  633. 

  634.     if (address >= MODBUS_MAP_ITEM_COUNT)

  635.     {

  636.         ModbusSlaveStatistics.illegalAddressCount++;

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

  638.                                   

  639.                                          

  640.     }

  641. 

  642.     (void)ModbusDataWriteWord(MODBUS_DATA_DEVICE_D, address, value);

  643. 

  644.     if (isBroadcast != 0U)

  645.     {

  646.         return 0U;

  647.     }

  648. 

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

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

  651.     ModbusAppendCrc(ModbusTxFrame, 6U);

  652.     return 8U;

  653. }

  654. 

  655. /**

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

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

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

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

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

  661.  */

  662. static uint16_t ModbusProcessWriteSingleCoil(const uint8_t *request,

  663.                                              uint16_t requestLength,

  664.                                              uint8_t isBroadcast)

  665. {

  666.     uint16_t address;

  667.     uint16_t value;

  668. 

  669.     if (requestLength != 8U)

  670.     {

  671.         ModbusSlaveStatistics.illegalValueCount++;

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

  673.                    

  674.                   

  675.     }

  676. 

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

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

  679. 

  680.     /*

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

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

  683.      */

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

  685.     {

  686.         ModbusSlaveStatistics.illegalValueCount++;

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

  688.                    

  689.                   

  690.     }

  691. 

  692.     if (address >= MODBUS_MAP_ITEM_COUNT)

  693.     {

  694.         ModbusSlaveStatistics.illegalAddressCount++;

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

  696.                                    

  697.                                          

  698.     }

  699. 

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

  701. 

  702.     if (isBroadcast != 0U)

  703.     {

  704.         return 0U;

  705.     }

  706. 

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

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

  709.     ModbusAppendCrc(ModbusTxFrame, 6U);

  710.     return 8U;

  711. }

  712. 

  713. /**

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

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

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

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

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

  719.  */

  720. static uint16_t ModbusProcessWriteMultipleCoils(const uint8_t *request,

  721.                                                 uint16_t requestLength,

  722.                                                 uint8_t isBroadcast)

  723. {

  724.     uint16_t start;

  725.     uint16_t quantity;

  726.     uint16_t index;

  727.     uint8_t byteCount;

  728.     uint8_t expectedByteCount;

  729. 

  730.     if (requestLength < 9U)

  731.     {

  732.         ModbusSlaveStatistics.illegalValueCount++;

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

  734.                   

  735.                    

  736.     }

  737. 

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

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

  740.     byteCount = request[6];

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

  742. 

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

  744.         || (byteCount != expectedByteCount)

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

  746.     {

  747.         ModbusSlaveStatistics.illegalValueCount++;

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

  749.                    

  750.                   

  751.     }

  752. 

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

  754.     {

  755.         ModbusSlaveStatistics.illegalAddressCount++;

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

  757.                                    

  758.                                          

  759.     }

  760. 

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

  762.     {

  763.         uint8_t state;

  764. 

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

  766.                          

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

  768.     }

  769. 

  770.     if (isBroadcast != 0U)

  771.     {

  772.         return 0U;

  773.     }

  774. 

  775.     ModbusTxFrame[0] = ModbusSlaveAddress;

  776.     ModbusTxFrame[1] = 0X0F;

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

  778.     ModbusAppendCrc(ModbusTxFrame, 6U);

  779.     return 8U;

  780. }

  781. 

  782. /**

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

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

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

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

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

  788.  */

  789. static uint16_t ModbusProcessWriteMultipleRegisters(const uint8_t *request,

  790.                                                     uint16_t requestLength,

  791.                                                     uint8_t isBroadcast)

  792. {

  793.     uint16_t start;

  794.     uint16_t quantity;

  795.     uint16_t index;

  796.     uint8_t byteCount;

  797. 

  798.     if (requestLength < 9U)

  799.     {

  800.         ModbusSlaveStatistics.illegalValueCount++;

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

  802.                   

  803.                   

  804.     }

  805. 

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

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

  808.     byteCount = request[6];

  809. 

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

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

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

  813.     {

  814.         ModbusSlaveStatistics.illegalValueCount++;

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

  816.                  

  817.                   

  818.     }

  819. 

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

  821.     {

  822.         ModbusSlaveStatistics.illegalAddressCount++;

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

  824.                                   

  825.                                          

  826.     }

  827. 

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

  829.     {

  830.         ModbusWriteRegisterScratch[index] =

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

  832.     }

  833.     (void)ModbusDataWriteWords(MODBUS_DATA_DEVICE_D,

  834.                                start,

  835.                                ModbusWriteRegisterScratch,

  836.                                quantity);

  837. 

  838.     if (isBroadcast != 0U)

  839.     {

  840.         return 0U;

  841.     }

  842. 

  843.     ModbusTxFrame[0] = ModbusSlaveAddress;

  844.     ModbusTxFrame[1] = 0X10;

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

  846.     ModbusAppendCrc(ModbusTxFrame, 6U);

  847.     return 8U;

  848. }

  849. 

  850. /**

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

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

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

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

  855.  */

  856. static uint16_t ModbusProcessReadBigHolding(const uint8_t *request,

  857.                                             uint16_t requestLength)

  858. {

  859.     uint32_t start;

  860.     uint32_t currentAddress;

  861.     uint16_t quantity;

  862.     uint16_t index;

  863.     uint16_t value;

  864. 

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

  866.     if (requestLength != 9U)

  867.     {

  868.         ModbusSlaveStatistics.illegalValueCount++;

  869. 

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

  871.     }

  872. 

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

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

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

  876. 

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

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

  879.     {

  880.         ModbusSlaveStatistics.illegalValueCount++;

  881. 

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

  883.     }

  884. 

  885.     /* Function 0x48 retains the existing sparse range: SRAM 0..19999 and

  886.      * CCMRAM 40000..69998.  The unallocated 20000..39999 gap is rejected. */

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

  888.         || ((start < 40000UL)

  889.             && ((start >= 20000UL)

  890.                 || ((start + quantity) > 20000UL))))

  891. 

  892.     {

  893.         ModbusSlaveStatistics.illegalAddressCount++;

  894. 

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

  896.     }

  897. 

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

  899.     ModbusTxFrame[0] = ModbusSlaveAddress;

  900.     ModbusTxFrame[1] = 0x48U;

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

  902. 

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

  904.     {

  905.         currentAddress = start + (uint32_t)index;

  906. 

  907.         /* The data-store layer validates the sparse physical range. */

  908.         if (ModbusDataReadLinear(currentAddress, &value) == 0U)

  909.         {

  910.             ModbusSlaveStatistics.illegalAddressCount++;

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

  912.         }

  913. 

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

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

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

  917.     }

  918.     /* 添加CRC */

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

  920. 

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

  922. }

  923. 

  924. /**

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

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

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

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

  929.  */

  930. static uint16_t ModbusProcessRequest(const uint8_t *request,

  931.                                      uint16_t requestLength)

  932. {

  933.     uint16_t calculatedCrc;

  934.     uint16_t receivedCrc;

  935.     uint8_t isBroadcast;

  936. 

  937.     if (requestLength < 4U)

  938.     {

  939.         return 0U;

  940.     }

  941. 

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

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

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

  945. 

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

  947.     {

  948.         ModbusSlaveStatistics.crcErrorCount++;

  949.         return 0U;

  950.     }

  951. 

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

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

  954.     {

  955.         ModbusSlaveStatistics.ignoredAddressCount++;

  956.         return 0U;

  957.     }

  958. 

  959.     isBroadcast =

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

  961.     ModbusSlaveStatistics.validFrameCount++;

  962.     ModbusLastValidFrameTick = HAL_GetTick();

  963.     ModbusHasReceivedValidFrame = 1U;

  964. 

  965.     switch (request[1])

  966.     {

  967.         case 0X01U: // 读线圈

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

  969.             return (isBroadcast != 0U)

  970.                        ? 0U

  971.                        : ModbusProcessReadBits(request,

  972.                                                requestLength,

  973.                                                0X01U,

  974.                                                MODBUS_BIT_DEVICE_M);

  975. 

  976.         case 0X02U: /* Read discrete inputs: protocol view of PLC X. */

  977.             return (isBroadcast != 0U)

  978.                        ? 0U

  979.                        : ModbusProcessReadBits(request,

  980.                                                requestLength,

  981.                                                0X02U,

  982.                                                MODBUS_BIT_DEVICE_X);

  983. 

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

  985.             return (isBroadcast != 0U)

  986.                        ? 0U

  987.                        : ModbusProcessReadHolding(request, requestLength);

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

  989.             return ModbusProcessWriteSingleCoil(request, requestLength,

  990.                                                 isBroadcast);

  991. 

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

  993.             return ModbusProcessWriteSingleRegister(request, requestLength,

  994.                                                     isBroadcast);

  995. 

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

  997.             return ModbusProcessWriteMultipleCoils(request, requestLength,

  998.                                                    isBroadcast);

  999. 

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

  1001.             return ModbusProcessWriteMultipleRegisters(request, requestLength,

  1002.                                                        isBroadcast);

  1003. 

  1004.         case MODBUS_RUNTIME_DIAGNOSTICS_FUNCTION:

  1005.             return (isBroadcast != 0U)

  1006.                        ? 0U

  1007.                        : ModbusProcessRuntimeDiagnostics(request,

  1008.                                                          requestLength);

  1009. 

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

  1011.             return (isBroadcast != 0U)

  1012.                        ? 0U

  1013.                        : ModbusProcessReadBigHolding(request, requestLength);

  1014. 

  1015.         default: // 未知功能码

  1016.             ModbusSlaveStatistics.illegalFunctionCount++;

  1017.             return (isBroadcast != 0U)

  1018.                        ? 0U

  1019.                        : ModbusBuildException(request[1],

  1020.                                               MODBUS_EX_ILLEGAL_FUNCTION);

  1021.     }

  1022. }

  1023. 

  1024. HAL_StatusTypeDef ModbusSlaveInit(UART_HandleTypeDef *huart,

  1025.                                   uint8_t slaveAddress)

  1026. 

  1027. {

  1028.     if ((huart == NULL) || (slaveAddress == 0U) || (slaveAddress > 247U))

  1029.     {

  1030.         return HAL_ERROR;

  1031.     }

  1032. 

  1033.     ModbusUart = huart;

  1034.     ModbusSlaveAddress = slaveAddress;

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

  1036.     ModbusRxAssemblyLength = 0U;

  1037.     ModbusRxAssemblyInvalid = 0U;

  1038.     ModbusRxFrameReady = 0U;

  1039.     ModbusTxBusy = 0U;

  1040.     ModbusNextReceiveRetryTick = 0UL;

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

  1042. 

  1043.     return ModbusStartReceive();

  1044. }

  1045. 

  1046. void ModbusSlavePoll(void)

  1047. {

  1048.     uint16_t responseLength;

  1049. 

  1050.     /* Recover from a failed DMA rearm even when no later UART callback occurs.

  1051.      * Limit retries to 100 Hz so a persistent HAL fault cannot monopolize the

  1052.      * 1 ms application task. */

  1053.     if ((ModbusUart != NULL) && (ModbusTxBusy == 0U)

  1054.         && (ModbusRxFrameReady == 0U)

  1055.         && ((ModbusUart->RxState != HAL_UART_STATE_BUSY_RX)

  1056.             || ((ModbusUart->Instance->CR3 & USART_CR3_DMAR) == 0U))

  1057.         && ((ModbusNextReceiveRetryTick == 0UL)

  1058.             || ((int32_t)(HAL_GetTick() - ModbusNextReceiveRetryTick) >= 0)))

  1059.     {

  1060.         (void)ModbusStartReceive();

  1061.     }

  1062. 

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

  1064.     ModbusTryFinalizeReceive();

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

  1066.     {

  1067.         return;

  1068.     }

  1069. 

  1070.     responseLength = ModbusProcessRequest(ModbusRxFrame, ModbusRxFrameLength);

  1071.     if (responseLength > 0U)

  1072.     {

  1073.         ModbusTxBusy = 1U;

  1074. 

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

  1076.             == HAL_OK)

  1077.         {

  1078.             ModbusSlaveStatistics.txFrameCount++;

  1079.         }

  1080.         else

  1081.         {

  1082.             ModbusTxBusy = 0U;

  1083.             ModbusSlaveStatistics.uartErrorCount++;

  1084.             ModbusLastUartErrorCode = ModbusUart->ErrorCode;

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

  1086.         }

  1087.     }

  1088.     else

  1089.     {

  1090.         (void)ModbusStartReceive();

  1091.     }

  1092. 

  1093.     /*

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

  1095.      */

  1096.     ModbusRxFrameReady = 0U;

  1097. }

  1098. 

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

  1100. {

  1101.     HAL_UART_RxEventTypeTypeDef eventType;

  1102.     uint32_t now;

  1103.     uint32_t lastByteCycle;

  1104.     uint32_t firstByteCycle;

  1105.     uint32_t chunkCycles;

  1106.     uint32_t interFrameGap;

  1107. 

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

  1109. 

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

  1111.     {

  1112.         return;

  1113.     }

  1114. 

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

  1116.     {

  1117.         now = DWT->CYCCNT;

  1118.         eventType = HAL_UARTEx_GetRxEventType(huart);

  1119. 

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

  1121.         lastByteCycle = now;

  1122.         if (eventType == HAL_UART_RXEVENT_IDLE)

  1123.         {

  1124.             lastByteCycle -= ModbusRtuCharCycles;

  1125.         }

  1126. 

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

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

  1129.         firstByteCycle = lastByteCycle - chunkCycles;

  1130. 

  1131.         if (ModbusRxAssemblyLength > 0U)

  1132.         {

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

  1134.             ModbusLastInterFrameGapCycles = interFrameGap;

  1135.             if (interFrameGap >= ModbusRtuT35Cycles)

  1136.             {

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

  1138.                 ModbusRxAssemblyFinalize();

  1139.             }

  1140.             else if (interFrameGap > ModbusRtuT15Cycles)

  1141.             {

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

  1143.                 ModbusRxAssemblyInvalid = 1U;

  1144.             }

  1145.             else

  1146.             {

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

  1148.             }

  1149.         }

  1150. 

  1151.         if (size

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

  1153.         {

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

  1155.                          ModbusRxDmaBuffer, size);

  1156.             ModbusRxAssemblyLength += size;

  1157.         }

  1158.         else

  1159.         {

  1160.             ModbusRxAssemblyInvalid = 1U;

  1161.         }

  1162. 

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

  1164.         ModbusRxLastByteCycle = lastByteCycle;

  1165.         (void)ModbusStartReceive();

  1166.     }

  1167.     else

  1168.     {

  1169.         // 长度异常帧

  1170.         ModbusSlaveStatistics.droppedFrameCount++;

  1171.         ModbusRxAssemblyLength = 0U;

  1172.         ModbusRxAssemblyInvalid = 0U;

  1173.         (void)ModbusStartReceive();

  1174.     }

  1175. }

  1176. 

  1177. void ModbusSlaveOnTxComplete(UART_HandleTypeDef *huart)

  1178. {

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

  1180.     {

  1181.         return;

  1182.     }

  1183. 

  1184.     ModbusTxBusy = 0U;

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

  1186. }

  1187. 

  1188. void ModbusSlaveOnUartError(UART_HandleTypeDef *huart)

  1189. {

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

  1191.     {

  1192.         return;

  1193.     }

  1194. 

  1195.     ModbusSlaveStatistics.uartErrorCount++;

  1196.     ModbusLastUartErrorCode = huart->ErrorCode;

  1197.     ModbusTxBusy = 0U;

  1198.     ModbusRxAssemblyLength = 0U;

  1199.     ModbusRxAssemblyInvalid = 0U;

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

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

  1202. }

  1203. 

  1204. uint8_t ModbusSlaveSetHoldingRegister(uint16_t address, uint16_t value)

  1205. {

  1206.     if (address >= MODBUS_MAP_ITEM_COUNT)

  1207.     {

  1208.         return 0U;

  1209.     }

  1210. 

  1211.     return ModbusDataWriteWord(MODBUS_DATA_DEVICE_D, address, value);

  1212. }

  1213. 

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

  1215. {

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

  1217.     {

  1218.         return 0U;

  1219.     }

  1220. 

  1221.     return ModbusDataReadWord(MODBUS_DATA_DEVICE_D, address, value);

  1222. }

  1223. 

  1224. uint8_t ModbusSlaveSetCoil(uint16_t address, uint8_t state)

  1225. {

  1226.     if (address >= MODBUS_MAP_ITEM_COUNT)

  1227.     {

  1228.         return 0U;

  1229.     }

  1230. 

  1231.     ModbusCoilSetUnchecked(address, state);

  1232.     return 1U;

  1233. }

  1234. 

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

  1236. {

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

  1238.     {

  1239.         return 0U;

  1240.     }

  1241. 

  1242.     *state = ModbusCoilGetUnchecked(address);

  1243.     return 1U;

  1244. }

  1245. 

  1246. uint8_t ModbusSlaveIsConnected(uint32_t timeoutMs)

  1247. {

  1248.     if (ModbusHasReceivedValidFrame == 0U)

  1249.     {

  1250.         return 0U;

  1251.     }

  1252. 

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

  1254. }

  1255. 

  1256. uint8_t ModbusSlaveGetRuntimeDiagnostics(

  1257.     uint32_t timeoutMs,

  1258.     MODBUS_SLAVE_RUNTIME_DIAGNOSTICS *diagnostics)

  1259. {

  1260.     if (diagnostics == NULL)

  1261.     {

  1262.         return 0U;

  1263.     }

  1264. 

  1265.     /* Every source field is naturally aligned and 32-bit-or-smaller on the

  1266.      * Cortex-M4.  A diagnostic snapshot may span adjacent frame events, but

  1267.      * must never mask the 100 kHz motion/AB fast-gate interrupts. */

  1268.     __DMB();

  1269.     diagnostics->statistics.rxEventCount =

  1270.         ModbusSlaveStatistics.rxEventCount;

  1271.     diagnostics->statistics.validFrameCount =

  1272.         ModbusSlaveStatistics.validFrameCount;

  1273.     diagnostics->statistics.txFrameCount =

  1274.         ModbusSlaveStatistics.txFrameCount;

  1275.     diagnostics->statistics.crcErrorCount =

  1276.         ModbusSlaveStatistics.crcErrorCount;

  1277.     diagnostics->statistics.ignoredAddressCount =

  1278.         ModbusSlaveStatistics.ignoredAddressCount;

  1279.     diagnostics->statistics.illegalFunctionCount =

  1280.         ModbusSlaveStatistics.illegalFunctionCount;

  1281.     diagnostics->statistics.illegalAddressCount =

  1282.         ModbusSlaveStatistics.illegalAddressCount;

  1283.     diagnostics->statistics.illegalValueCount =

  1284.         ModbusSlaveStatistics.illegalValueCount;

  1285.     diagnostics->statistics.droppedFrameCount =

  1286.         ModbusSlaveStatistics.droppedFrameCount;

  1287.     diagnostics->statistics.uartErrorCount =

  1288.         ModbusSlaveStatistics.uartErrorCount;

  1289.     diagnostics->currentTick = HAL_GetTick();

  1290.     diagnostics->lastValidFrameTick = ModbusLastValidFrameTick;

  1291.     diagnostics->lastInterFrameGapCycles = ModbusLastInterFrameGapCycles;

  1292.     diagnostics->receiveRestartAttemptCount =

  1293.         ModbusReceiveRestartAttemptCount;

  1294.     diagnostics->receiveRestartFailureCount =

  1295.         ModbusReceiveRestartFailureCount;

  1296.     diagnostics->lastUartErrorCode = ModbusLastUartErrorCode;

  1297.     diagnostics->rxAssemblyLength = ModbusRxAssemblyLength;

  1298.     diagnostics->rxFrameLength = ModbusRxFrameLength;

  1299.     diagnostics->lastReceiveStartStatus = ModbusLastReceiveStartStatus;

  1300.     diagnostics->initialized = (ModbusUart != NULL) ? 1U : 0U;

  1301.     diagnostics->hasReceivedValidFrame = ModbusHasReceivedValidFrame;

  1302.     diagnostics->connected =

  1303.         ((ModbusHasReceivedValidFrame != 0U)

  1304.          && ((diagnostics->currentTick - ModbusLastValidFrameTick)

  1305.              <= timeoutMs))

  1306.             ? 1U

  1307.             : 0U;

  1308.     diagnostics->txBusy = ModbusTxBusy;

  1309.     diagnostics->rxFrameReady = ModbusRxFrameReady;

  1310.     diagnostics->rxAssemblyInvalid = ModbusRxAssemblyInvalid;

  1311.     __DMB();

  1312.     return 1U;

  1313. }

  1314. 

  1315. // 上电恢复函数

  1316. void ModbusRetainedRegistersLoad(void)

  1317. {

  1318.     uint16_t index;

  1319. 

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

  1321.     {

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

  1323.         {

  1324.             (void)ModbusDataWriteWord(

  1325.                 MODBUS_DATA_DEVICE_D,

  1326.                 MODBUS_RETAINED_D_START + index,

  1327.                 ModbusBackupData->retainedD[index]);

  1328.         }

  1329.     }

  1330.     else

  1331.     {

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

  1333.         {

  1334.             (void)ModbusDataWriteWord(MODBUS_DATA_DEVICE_D,

  1335.                                       MODBUS_RETAINED_D_START + index,

  1336.                                       0U);

  1337. 

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

  1339.         }

  1340. 

  1341.         /*

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

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

  1344.          */

  1345.         ModbusBackupData->magic = MODBUS_BACKUP_MAGIC;

  1346.     }

  1347. }

  1348. void ModbusRetainedRegistersPoll(void)

  1349. {

  1350.     uint16_t index;

  1351.     uint16_t value;

  1352. 

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

  1354.     {

  1355.         (void)ModbusDataReadWord(MODBUS_DATA_DEVICE_D,

  1356.                                  MODBUS_RETAINED_D_START + index,

  1357.                                  &value);

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

  1359.         {

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

  1361.         }

  1362. 

  1363.         ModbusRetainedSnapshot[index] = value;

  1364.     }

  1365. }