yuwenhao
/
Modbus-rtu
1
0
Çatalla 0
Kod Konular 0 Değişiklik İstekleri 0 Sürümler 0 Wiki Aktivite
25'ten fazla konu seçemezsiniz Konular bir harf veya rakamla başlamalı, kısa çizgiler ('-') içerebilir ve en fazla 35 karakter uzunluğunda olabilir.
26 İşleme
3 Dallar
138 MiB
 
 
 
 
 
 
Ağaç: 1fa91b403e
Dallar Biçim İmleri
${ item.name }
${ searchTerm } dalı oluştur
'1fa91b403e'den
${ noResults }
Modbus-rtu/Modbus/Src/modbus_rtu_slave.c

1114 satır
33 KiB
Ham Suçlama Geçmiş 

  1. #include "modbus_rtu_slave.h"

  2. #include <string.h>

  3. 

  4. #define MODBUS_RTU_ADU_SIZE_MAX (256U) // Modbus RTU 最大 ADU 长度，单位为字节

  5. 

  6. #define MODBUS_RTU_T15_US (750UL)       // 高波特率下固定T1.5时间，单位us 

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

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

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

  10. 

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

  12. 

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

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

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

  16. 

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

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

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

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

  21. 

  22. #define MODBUS_COIL_VALUE_ON (0xFF00U)

  23. #define MODBUS_COIL_VALUE_OFF (0x0000U)

  24. 

  25. static UART_HandleTypeDef *ModbusUart;

  26. static uint8_t ModbusSlaveAddress;

  27. static HAL_StatusTypeDef ModbusStartReceive(void);

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

  29. static volatile uint32_t ModbusLastInterFrameGapCycles;

  30. /**

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

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

  33.  */

  34. static uint8_t ModbusRxDmaBuffer[MODBUS_RTU_ADU_SIZE_MAX];

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

  36. static uint8_t ModbusRxAssemblyBuffer[MODBUS_RTU_ADU_SIZE_MAX];

  37. static uint8_t ModbusRxFrame[MODBUS_RTU_ADU_SIZE_MAX];

  38. static uint8_t ModbusTxFrame[MODBUS_RTU_ADU_SIZE_MAX];

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

  40. static uint16_t ModbusRetainedSnapshot[MODBUS_RETAINED_D_COUNT];

  41. static volatile uint16_t ModbusRxFrameLength;

  42. static volatile uint8_t ModbusRxFrameReady;

  43. static volatile uint8_t ModbusTxBusy;

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

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

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

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

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

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

  50. static volatile uint32_t ModbusLastValidFrameTick;

  51. static volatile uint8_t ModbusHasReceivedValidFrame;

  52. static volatile MODBUS_BACKUP_DATA *ModbusBackupData =

  53.     (volatile MODBUS_BACKUP_DATA *)BKPSRAM_BASE;

  54. 

  55. /**

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

  57.  * 占用 1250 字节

  58.  */

  59. static uint16_t ModbusHoldingRegisters[20000];

  60. 

  61. #pragma location = ".ccmram"

  62. #pragma data_alignment = 4

  63. __root static uint16_t ModbusRegistersCcm[29999];

  64. 

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

  66. 

  67. volatile MODBUS_SLAVE_STATS ModbusSlaveStatistics;

  68. 

  69. /**

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

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

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

  73.  * @return CRC16 校验值

  74.  */

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

  76. {

  77.     uint16_t crc = 0xFFFFU;

  78.     uint16_t index;

  79.     uint8_t bit;

  80. 

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

  82.     {

  83.         crc ^= data[index];

  84. 

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

  86.         {

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

  88.             {

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

  90.             }

  91.             else

  92.             {

  93.                 crc >>= 1U;

  94.             }

  95.         }

  96.     }

  97. 

  98.     return crc;

  99. }

  100. 

  101. /**

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

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

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

  105.  */

  106. static uint16_t ModbusGetU16Be(const uint8_t *data)

  107. {

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

  109. }

  110. 

  111. /**

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

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

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

  115.  */

  116. static uint32_t ModbusGetU24Be(const uint8_t *data)

  117. {

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

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

  120. }

  121. 

  122. /**

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

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

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

  126.  */

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

  128. {

  129.     if (start >= MODBUS_MAP_ITEM_COUNT)

  130.     {

  131.         return 0U;

  132.     }

  133. 

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

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

  136. }

  137. 

  138. /**

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

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

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

  142.  */

  143. static uint8_t ModbusCoilGetUnchecked(uint16_t address)

  144. {

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

  146. 

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

  148. }

  149. 

  150. /**

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

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

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

  154.  */

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

  156. {

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

  158. 

  159.     if (state != 0U)

  160.     {

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

  162.     }

  163.     else

  164.     {

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

  166.     }

  167. }

  168. 

  169. /**

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

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

  172.  */

  173. static void ModbusRtuTimingInit(uint32_t baudRate)

  174. {

  175.     uint64_t coreClock;

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

  177.     CoreDebug->DEMCR |= CoreDebug_DEMCR_TRCENA_Msk;

  178.     DWT->CYCCNT = 0U;

  179.     DWT->CTRL |= DWT_CTRL_CYCCNTENA_Msk;

  180. 

  181.     coreClock = SystemCoreClock;

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

  183.     ModbusRtuCharCycles =

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

  185. 

  186.     if (baudRate > MODBUS_RTU_HIGH_BAUD_LIMIT)

  187.     {

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

  189.         ModbusRtuT15Cycles =

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

  191. 

  192.         ModbusRtuT35Cycles =

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

  194.     }

  195.     else

  196.     {

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

  198.         ModbusRtuT15Cycles =

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

  200.         ModbusRtuT35Cycles =

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

  202.     }

  203. }

  204. 

  205. /**

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

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

  208.  */

  209. static void ModbusRxAssemblyFinalize(void)

  210. {

  211.     if (ModbusRxAssemblyLength == 0U)

  212.     {

  213.         return;

  214.     }

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

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

  217.     {

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

  219.         (void)memcpy(ModbusRxFrame, ModbusRxAssemblyBuffer,

  220.                      ModbusRxAssemblyLength);

  221.         ModbusRxFrameLength = ModbusRxAssemblyLength;

  222.         ModbusRxFrameReady = 1U;

  223.     }

  224.     else

  225.     {

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

  227.         ModbusSlaveStatistics.droppedFrameCount++;

  228.     }

  229. 

  230.     ModbusRxAssemblyLength = 0U;

  231.     ModbusRxAssemblyInvalid = 0U;

  232. }

  233. 

  234. /**

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

  236.  */

  237. static void ModbusTryFinalizeReceive(void)

  238. {

  239.     uint32_t now;

  240. 

  241.     if (ModbusRxAssemblyLength == 0U)

  242.     {

  243.         return;

  244.     }

  245. 

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

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

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

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

  250.             < MODBUS_RTU_ADU_SIZE_MAX))

  251.     {

  252.         return;

  253.     }

  254. 

  255.     now = DWT->CYCCNT;

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

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

  258.     {

  259.         return;

  260.     }

  261. 

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

  263.     (void)HAL_UART_AbortReceive(ModbusUart);

  264. 

  265.     __disable_irq();

  266.     ModbusRxAssemblyFinalize();

  267.     __enable_irq();

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

  269.     if (ModbusRxFrameReady == 0U)

  270.     {

  271.         (void)ModbusStartReceive();

  272.     }

  273. 

  274. 

  275. }

  276. 

  277. /**

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

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

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

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

  282.  */

  283. static HAL_StatusTypeDef ModbusStartReceive(void)

  284. {

  285.     HAL_StatusTypeDef status;

  286. 

  287.     if (ModbusTxBusy != 0U)

  288.     {

  289.         return HAL_BUSY;

  290.     }

  291. 

  292.     status = HAL_UARTEx_ReceiveToIdle_DMA(ModbusUart, ModbusRxDmaBuffer,

  293.                                           sizeof(ModbusRxDmaBuffer));

  294. 

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

  296.     {

  297.         /*

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

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

  300.          */

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

  302.     }

  303. 

  304.     return status;

  305. }

  306. 

  307. /**

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

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

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

  311.  */

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

  313. {

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

  315. 

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

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

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

  319. }

  320. 

  321. /**

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

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

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

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

  326.  */

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

  328. {

  329.     ModbusTxFrame[0] = ModbusSlaveAddress;

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

  331.     ModbusTxFrame[2] = exception;

  332.     ModbusAppendCrc(ModbusTxFrame, 3U);

  333. 

  334.     return 5U;

  335. }

  336. 

  337. /**

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

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

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

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

  342.  */

  343. static uint16_t ModbusProcessReadCoils(const uint8_t *request,

  344.                                        uint16_t requestLength)

  345. {

  346. 

  347.     uint16_t start;

  348.     uint16_t quantity;

  349.     uint16_t index;

  350.     uint8_t byteCount;

  351. 

  352.     if (requestLength != 8U)

  353.     {

  354.         ModbusSlaveStatistics.illegalValueCount++;

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

  356.     }

  357. 

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

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

  360. 

  361.     if ((quantity == 0U)

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

  363.     {

  364.         ModbusSlaveStatistics.illegalValueCount++;

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

  366.     }

  367. 

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

  369.     {

  370.         ModbusSlaveStatistics.illegalAddressCount++;

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

  372.     }

  373. 

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

  375.     ModbusTxFrame[0] = ModbusSlaveAddress;

  376.     ModbusTxFrame[1] = 0X01;

  377.     ModbusTxFrame[2] = byteCount;

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

  379. 

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

  381.     {

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

  383.         {

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

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

  386.         }

  387.     }

  388. 

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

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

  391. }

  392. 

  393. /**

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

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

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

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

  398.  */

  399. static uint16_t ModbusProcessReadHolding(const uint8_t *request,

  400.                                          uint16_t requestLength)

  401. 

  402. {

  403.     uint16_t start;

  404.     uint16_t quantity;

  405.     uint16_t index;

  406.     uint16_t value;

  407. 

  408.     if (requestLength != 8U)

  409.     {

  410.         ModbusSlaveStatistics.illegalValueCount++;

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

  412.     }

  413. 

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

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

  416. 

  417.     if ((quantity == 0U)

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

  419.     {

  420.         ModbusSlaveStatistics.illegalValueCount++;

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

  422.     }

  423. 

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

  425.     {

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

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

  428.             goto tx;

  429.         ModbusSlaveStatistics.illegalAddressCount++;

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

  431.     }

  432. tx:

  433.     ModbusTxFrame[0] = ModbusSlaveAddress;

  434.     ModbusTxFrame[1] = 0X03;

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

  436. 

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

  438.     {

  439.         uint16_t address = start + index;

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

  441.         if (address >= 20000U)

  442.         {

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

  444.         }

  445.         value = ModbusHoldingRegisters[address];

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

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

  448.     }

  449. 

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

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

  452. }

  453. 

  454. /**

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

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

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

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

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

  460.  */

  461. static uint16_t ModbusProcessWriteSingleRegister(const uint8_t *request,

  462.                                                  uint16_t requestLength,

  463.                                                  uint8_t isBroadcast)

  464. {

  465.     uint16_t address;

  466.     uint16_t value;

  467. 

  468.     if (requestLength != 8U)

  469.     {

  470.         ModbusSlaveStatistics.illegalValueCount++;

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

  472.                   

  473.                    

  474.     }

  475. 

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

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

  478. 

  479.     if (address >= MODBUS_MAP_ITEM_COUNT)

  480.     {

  481.         ModbusSlaveStatistics.illegalAddressCount++;

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

  483.                                   

  484.                                          

  485.     }

  486. 

  487.     ModbusHoldingRegisters[address] = value;

  488. 

  489.     if (isBroadcast != 0U)

  490.     {

  491.         return 0U;

  492.     }

  493. 

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

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

  496.     ModbusAppendCrc(ModbusTxFrame, 6U);

  497.     return 8U;

  498. }

  499. 

  500. /**

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

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

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

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

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

  506.  */

  507. static uint16_t ModbusProcessWriteSingleCoil(const uint8_t *request,

  508.                                              uint16_t requestLength,

  509.                                              uint8_t isBroadcast)

  510. {

  511.     uint16_t address;

  512.     uint16_t value;

  513. 

  514.     if (requestLength != 8U)

  515.     {

  516.         ModbusSlaveStatistics.illegalValueCount++;

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

  518.                    

  519.                   

  520.     }

  521. 

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

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

  524. 

  525.     /*

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

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

  528.      */

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

  530.     {

  531.         ModbusSlaveStatistics.illegalValueCount++;

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

  533.                    

  534.                   

  535.     }

  536. 

  537.     if (address >= MODBUS_MAP_ITEM_COUNT)

  538.     {

  539.         ModbusSlaveStatistics.illegalAddressCount++;

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

  541.                                    

  542.                                          

  543.     }

  544. 

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

  546. 

  547.     if (isBroadcast != 0U)

  548.     {

  549.         return 0U;

  550.     }

  551. 

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

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

  554.     ModbusAppendCrc(ModbusTxFrame, 6U);

  555.     return 8U;

  556. }

  557. 

  558. /**

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

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

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

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

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

  564.  */

  565. static uint16_t ModbusProcessWriteMultipleCoils(const uint8_t *request,

  566.                                                 uint16_t requestLength,

  567.                                                 uint8_t isBroadcast)

  568. {

  569.     uint16_t start;

  570.     uint16_t quantity;

  571.     uint16_t index;

  572.     uint8_t byteCount;

  573.     uint8_t expectedByteCount;

  574. 

  575.     if (requestLength < 9U)

  576.     {

  577.         ModbusSlaveStatistics.illegalValueCount++;

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

  579.                   

  580.                    

  581.     }

  582. 

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

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

  585.     byteCount = request[6];

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

  587. 

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

  589.         || (byteCount != expectedByteCount)

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

  591.     {

  592.         ModbusSlaveStatistics.illegalValueCount++;

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

  594.                    

  595.                   

  596.     }

  597. 

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

  599.     {

  600.         ModbusSlaveStatistics.illegalAddressCount++;

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

  602.                                    

  603.                                          

  604.     }

  605. 

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

  607.     {

  608.         uint8_t state;

  609. 

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

  611.                          

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

  613.     }

  614. 

  615.     if (isBroadcast != 0U)

  616.     {

  617.         return 0U;

  618.     }

  619. 

  620.     ModbusTxFrame[0] = ModbusSlaveAddress;

  621.     ModbusTxFrame[1] = 0X0F;

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

  623.     ModbusAppendCrc(ModbusTxFrame, 6U);

  624.     return 8U;

  625. }

  626. 

  627. /**

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

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

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

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

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

  633.  */

  634. static uint16_t ModbusProcessWriteMultipleRegisters(const uint8_t *request,

  635.                                                     uint16_t requestLength,

  636.                                                     uint8_t isBroadcast)

  637. {

  638.     uint16_t start;

  639.     uint16_t quantity;

  640.     uint16_t index;

  641.     uint8_t byteCount;

  642. 

  643.     if (requestLength < 9U)

  644.     {

  645.         ModbusSlaveStatistics.illegalValueCount++;

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

  647.                   

  648.                   

  649.     }

  650. 

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

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

  653.     byteCount = request[6];

  654. 

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

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

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

  658.     {

  659.         ModbusSlaveStatistics.illegalValueCount++;

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

  661.                  

  662.                   

  663.     }

  664. 

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

  666.     {

  667.         ModbusSlaveStatistics.illegalAddressCount++;

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

  669.                                   

  670.                                          

  671.     }

  672. 

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

  674.     {

  675.         ModbusHoldingRegisters[start + index] =

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

  677.     }

  678. 

  679.     if (isBroadcast != 0U)

  680.     {

  681.         return 0U;

  682.     }

  683. 

  684.     ModbusTxFrame[0] = ModbusSlaveAddress;

  685.     ModbusTxFrame[1] = 0X10;

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

  687.     ModbusAppendCrc(ModbusTxFrame, 6U);

  688.     return 8U;

  689. }

  690. 

  691. /**

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

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

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

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

  696.  */

  697. static uint16_t ModbusProcessReadBigHolding(const uint8_t *request,

  698.                                             uint16_t requestLength)

  699. {

  700.     uint32_t start;

  701.     uint32_t currentAddress;

  702.     uint16_t quantity;

  703.     uint16_t index;

  704.     uint16_t value;

  705. 

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

  707.     if (requestLength != 9U)

  708.     {

  709.         ModbusSlaveStatistics.illegalValueCount++;

  710. 

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

  712.     }

  713. 

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

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

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

  717. 

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

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

  720.     {

  721.         ModbusSlaveStatistics.illegalValueCount++;

  722. 

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

  724.     }

  725. 

  726.     /*

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

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

  729.      */

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

  731. 

  732.     {

  733.         ModbusSlaveStatistics.illegalAddressCount++;

  734. 

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

  736.     }

  737. 

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

  739.     ModbusTxFrame[0] = ModbusSlaveAddress;

  740.     ModbusTxFrame[1] = 0x48U;

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

  742. 

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

  744.     {

  745.         currentAddress = start + (uint32_t)index;

  746. 

  747.         /*

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

  749.          * 地址40000～69998位于CCMRAM

  750.          */

  751.         if (currentAddress < 40000UL)

  752.         {

  753.             value = ModbusHoldingRegisters[currentAddress];

  754.         }

  755.         else

  756.         {

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

  758.         }

  759. 

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

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

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

  763.     }

  764.     /* 添加CRC */

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

  766. 

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

  768. }

  769. 

  770. /**

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

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

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

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

  775.  */

  776. static uint16_t ModbusProcessRequest(const uint8_t *request,

  777.                                      uint16_t requestLength)

  778. {

  779.     uint16_t calculatedCrc;

  780.     uint16_t receivedCrc;

  781.     uint8_t isBroadcast;

  782. 

  783.     if (requestLength < 4U)

  784.     {

  785.         return 0U;

  786.     }

  787. 

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

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

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

  791. 

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

  793.     {

  794.         ModbusSlaveStatistics.crcErrorCount++;

  795.         return 0U;

  796.     }

  797. 

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

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

  800.     {

  801.         ModbusSlaveStatistics.ignoredAddressCount++;

  802.         return 0U;

  803.     }

  804. 

  805.     isBroadcast =

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

  807.     ModbusSlaveStatistics.validFrameCount++;

  808.     ModbusLastValidFrameTick = HAL_GetTick();

  809.     ModbusHasReceivedValidFrame = 1U;

  810. 

  811.     switch (request[1])

  812.     {

  813.         case 0X01U: // 读线圈

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

  815.             return (isBroadcast != 0U)

  816.                        ? 0U

  817.                        : ModbusProcessReadCoils(request, requestLength);

  818. 

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

  820.             return (isBroadcast != 0U)

  821.                        ? 0U

  822.                        : ModbusProcessReadHolding(request, requestLength);

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

  824.             return ModbusProcessWriteSingleCoil(request, requestLength,

  825.                                                 isBroadcast);

  826. 

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

  828.             return ModbusProcessWriteSingleRegister(request, requestLength,

  829.                                                     isBroadcast);

  830. 

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

  832.             return ModbusProcessWriteMultipleCoils(request, requestLength,

  833.                                                    isBroadcast);

  834. 

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

  836.             return ModbusProcessWriteMultipleRegisters(request, requestLength,

  837.                                                        isBroadcast);

  838. 

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

  840.             return (isBroadcast != 0U)

  841.                        ? 0U

  842.                        : ModbusProcessReadBigHolding(request, requestLength);

  843. 

  844.         default: // 未知功能码

  845.             ModbusSlaveStatistics.illegalFunctionCount++;

  846.             return (isBroadcast != 0U)

  847.                        ? 0U

  848.                        : ModbusBuildException(request[1],

  849.                                               MODBUS_EX_ILLEGAL_FUNCTION);

  850.     }

  851. }

  852. 

  853. HAL_StatusTypeDef ModbusSlaveInit(UART_HandleTypeDef *huart,

  854.                                   uint8_t slaveAddress)

  855. 

  856. {

  857. 

  858.     ModbusUart = huart;

  859.     ModbusSlaveAddress = slaveAddress;

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

  861.     ModbusRxAssemblyLength = 0U;

  862.     ModbusRxAssemblyInvalid = 0U;

  863.     ModbusRxFrameReady = 0U;

  864.     ModbusTxBusy = 0U;

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

  866. 

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

  868. 

  869.     return ModbusStartReceive();

  870. }

  871. 

  872. void ModbusSlavePoll(void)

  873. {

  874.     uint16_t responseLength;

  875. 

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

  877.     ModbusTryFinalizeReceive();

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

  879.     {

  880.         return;

  881.     }

  882. 

  883.     responseLength = ModbusProcessRequest(ModbusRxFrame, ModbusRxFrameLength);

  884.     if (responseLength > 0U)

  885.     {

  886.         ModbusTxBusy = 1U;

  887. 

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

  889.             == HAL_OK)

  890.         {

  891.             ModbusSlaveStatistics.txFrameCount++;

  892.         }

  893.         else

  894.         {

  895.             ModbusTxBusy = 0U;

  896.             ModbusSlaveStatistics.uartErrorCount++;

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

  898.         }

  899.     }

  900.     else

  901.     {

  902.         (void)ModbusStartReceive();

  903.     }

  904. 

  905.     /*

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

  907.      */

  908.     ModbusRxFrameReady = 0U;

  909. }

  910. 

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

  912. {

  913.     HAL_UART_RxEventTypeTypeDef eventType;

  914.     uint32_t now;

  915.     uint32_t lastByteCycle;

  916.     uint32_t firstByteCycle;

  917.     uint32_t chunkCycles;

  918.     uint32_t interFrameGap;

  919. 

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

  921. 

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

  923.     {

  924.         return;

  925.     }

  926. 

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

  928.     {

  929.         now = DWT->CYCCNT;

  930.         eventType = HAL_UARTEx_GetRxEventType(huart);

  931. 

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

  933.         lastByteCycle = now;

  934.         if (eventType == HAL_UART_RXEVENT_IDLE)

  935.         {

  936.             lastByteCycle -= ModbusRtuCharCycles;

  937.         }

  938. 

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

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

  941.         firstByteCycle = lastByteCycle - chunkCycles;

  942. 

  943.         if (ModbusRxAssemblyLength > 0U)

  944.         {

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

  946.             ModbusLastInterFrameGapCycles = interFrameGap;

  947.             if (interFrameGap >= ModbusRtuT35Cycles)

  948.             {

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

  950.                 ModbusRxAssemblyFinalize();

  951.             }

  952.             else if (interFrameGap > ModbusRtuT15Cycles)

  953.             {

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

  955.                 ModbusRxAssemblyInvalid = 1U;

  956.             }

  957.             else

  958.             {

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

  960.             }

  961.         }

  962. 

  963.         if (size

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

  965.         {

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

  967.                          ModbusRxDmaBuffer, size);

  968.             ModbusRxAssemblyLength += size;

  969.         }

  970.         else

  971.         {

  972.             ModbusRxAssemblyInvalid = 1U;

  973.         }

  974. 

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

  976.         ModbusRxLastByteCycle = lastByteCycle;

  977.         (void)ModbusStartReceive();

  978.     }

  979.     else

  980.     {

  981.         // 长度异常帧

  982.         ModbusSlaveStatistics.droppedFrameCount++;

  983.         ModbusRxAssemblyLength = 0U;

  984.         ModbusRxAssemblyInvalid = 0U;

  985.         (void)ModbusStartReceive();

  986.     }

  987. }

  988. 

  989. void ModbusSlaveOnTxComplete(UART_HandleTypeDef *huart)

  990. {

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

  992.     {

  993.         return;

  994.     }

  995. 

  996.     ModbusTxBusy = 0U;

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

  998. }

  999. 

  1000. void ModbusSlaveOnUartError(UART_HandleTypeDef *huart)

  1001. {

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

  1003.     {

  1004.         return;

  1005.     }

  1006. 

  1007.     ModbusSlaveStatistics.uartErrorCount++;

  1008.     ModbusTxBusy = 0U;

  1009.     ModbusRxAssemblyLength = 0U;

  1010.     ModbusRxAssemblyInvalid = 0U;

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

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

  1013. }

  1014. 

  1015. uint8_t ModbusSlaveSetHoldingRegister(uint16_t address, uint16_t value)

  1016. {

  1017.     if (address >= MODBUS_MAP_ITEM_COUNT)

  1018.     {

  1019.         return 0U;

  1020.     }

  1021. 

  1022.     ModbusHoldingRegisters[address] = value;

  1023.     return 1U;

  1024. }

  1025. 

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

  1027. {

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

  1029.     {

  1030.         return 0U;

  1031.     }

  1032. 

  1033.     *value = ModbusHoldingRegisters[address];

  1034.     return 1U;

  1035. }

  1036. 

  1037. uint8_t ModbusSlaveSetCoil(uint16_t address, uint8_t state)

  1038. {

  1039.     if (address >= MODBUS_MAP_ITEM_COUNT)

  1040.     {

  1041.         return 0U;

  1042.     }

  1043. 

  1044.     ModbusCoilSetUnchecked(address, state);

  1045.     return 1U;

  1046. }

  1047. 

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

  1049. {

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

  1051.     {

  1052.         return 0U;

  1053.     }

  1054. 

  1055.     *state = ModbusCoilGetUnchecked(address);

  1056.     return 1U;

  1057. }

  1058. 

  1059. uint8_t ModbusSlaveIsConnected(uint32_t timeoutMs)

  1060. {

  1061.     if (ModbusHasReceivedValidFrame == 0U)

  1062.     {

  1063.         return 0U;

  1064.     }

  1065. 

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

  1067. }

  1068. 

  1069. // 上电恢复函数

  1070. void ModbusRetainedRegistersLoad(void)

  1071. {

  1072.     uint16_t index;

  1073. 

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

  1075.     {

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

  1077.         {

  1078.             ModbusHoldingRegisters[MODBUS_RETAINED_D_START + index] =

  1079.                 ModbusBackupData->retainedD[index];

  1080.         }

  1081.     }

  1082.     else

  1083.     {

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

  1085.         {

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

  1087. 

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

  1089.         }

  1090. 

  1091.         /*

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

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

  1094.          */

  1095.         ModbusBackupData->magic = MODBUS_BACKUP_MAGIC;

  1096.     }

  1097. }

  1098. void ModbusRetainedRegistersPoll(void)

  1099. {

  1100.     uint16_t index;

  1101.     uint16_t value;

  1102. 

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

  1104.     {

  1105.         value = ModbusHoldingRegisters[MODBUS_RETAINED_D_START + index];

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

  1107.         {

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

  1109.         }

  1110. 

  1111.         ModbusRetainedSnapshot[index] = value;

  1112.     }

  1113. }