yuwenhao
/
Modbus-rtu
1
0
Forkuj 0
Kod Zgłoszenia 0 Oczekujące zmiany 0 Wydania 0 Wiki Aktywność
Nie możesz wybrać więcej, niż 25 tematów Tematy muszą się zaczynać od litery lub cyfry, mogą zawierać myślniki ('-') i mogą mieć do 35 znaków.
18 Commity
3 Gałęzie
138 MiB
 
 
 
 
 
 
Drzewo: 0267178819
Gałęzie Tagi
${ item.name }
Utwórz gałąź ${ searchTerm }
z '0267178819'
${ noResults }
Modbus-rtu/Modbus/Src/modbus_rtu_slave.c

1103 wiersze
30 KiB
Czysty Wina Historia 

  1. #include "modbus_rtu_slave.h"

  2. #include "ucos_ii.h"

  3. #include <string.h>

  4. 

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

  6. 

  7. 

  8. #define MODBUS_RTU_FRAME_GAP_MS          (2U)

  9. 

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

  11. 

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

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

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

  15. 

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

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

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

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

  20. 

  21. #define MODBUS_COIL_VALUE_ON             (0xFF00U)

  22. #define MODBUS_COIL_VALUE_OFF            (0x0000U)

  23. 

  24. static UART_HandleTypeDef *ModbusUart;

  25. static uint8_t ModbusSlaveAddress;

  26. 

  27. static MODBUS_HISTORY_ITEM ModbusHistory[16];

  28. static uint16_t ModbusHistoryWriteIndex;

  29. /**

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

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

  32.  */

  33. static uint8_t ModbusRxDmaBuffer[MODBUS_RTU_ADU_SIZE_MAX];

  34. static uint8_t ModbusRxFrame[MODBUS_RTU_ADU_SIZE_MAX];

  35. static uint8_t ModbusTxFrame[MODBUS_RTU_ADU_SIZE_MAX];

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

  37. static uint16_t ModbusRetainedSnapshot[MODBUS_RETAINED_D_COUNT];

  38. static volatile uint16_t ModbusRxFrameLength;

  39. static volatile uint8_t ModbusRxFrameReady;

  40. static volatile uint8_t ModbusTxBusy;

  41. static volatile uint32_t ModbusRxEventTick;

  42. static volatile uint32_t ModbusLastValidFrameTick;

  43. static volatile uint8_t ModbusHasReceivedValidFrame;

  44. 

  45. /**

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

  47.  * 占用 1250 字节

  48.  */

  49. static uint16_t ModbusHoldingRegisters[40000];

  50. 

  51. 

  52. #pragma location = ".ccmram"

  53. #pragma data_alignment = 4

  54. __root static uint16_t ModbusRegistersCcm[29999];

  55. 

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

  57. 

  58. volatile MODBUS_SLAVE_STATS ModbusSlaveStatistics;

  59. 

  60. /**

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

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

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

  64.  * @return CRC16 校验值

  65.  */

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

  67. {

  68.     uint16_t crc = 0xFFFFU;

  69.     uint16_t index;

  70.     uint8_t bit;

  71. 

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

  73.     {

  74.         crc ^= data[index];

  75. 

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

  77.         {

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

  79.             {

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

  81.             }

  82.             else

  83.             {

  84.                 crc >>= 1U;

  85.             }

  86.         }

  87.     }

  88. 

  89.     return crc;

  90. }

  91. 

  92. /**

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

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

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

  96.  */

  97. static uint16_t ModbusGetU16Be(const uint8_t *data)

  98. {

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

  100. }

  101. 

  102. /**

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

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

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

  106.  */

  107. static uint32_t ModbusGetU24Be(const uint8_t *data)

  108. {

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

  110. }

  111. 

  112. /**

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

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

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

  116.  */

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

  118. {

  119.     if (start >= MODBUS_MAP_ITEM_COUNT)

  120.     {

  121.         return 0U;

  122.     }

  123. 

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

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

  126. }

  127. 

  128. /**

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

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

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

  132.  */

  133. static uint8_t ModbusCoilGetUnchecked(uint16_t address)

  134. {

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

  136. 

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

  138. }

  139. 

  140. /**

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

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

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

  144.  */

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

  146. {

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

  148. 

  149.     if (state != 0U)

  150.     {

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

  152.     }

  153.     else

  154.     {

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

  156.     }

  157. }

  158. 

  159. /**

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

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

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

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

  164.  */

  165. static HAL_StatusTypeDef ModbusStartReceive(void)

  166. {

  167.     HAL_StatusTypeDef status;

  168. 

  169.     if (ModbusTxBusy != 0U)

  170.     {

  171.         return HAL_BUSY;

  172.     }

  173. 

  174.     status = HAL_UARTEx_ReceiveToIdle_DMA(ModbusUart,

  175.                                           ModbusRxDmaBuffer,

  176.                                           sizeof(ModbusRxDmaBuffer));

  177. 

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

  179.     {

  180.         /*

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

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

  183.          */

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

  185.     }

  186. 

  187.     return status;

  188. }

  189. 

  190. 

  191. 

  192. /**

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

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

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

  196.  */

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

  198. {

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

  200. 

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

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

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

  204. }

  205. 

  206. /**

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

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

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

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

  211.  */

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

  213. {

  214.     ModbusTxFrame[0] = ModbusSlaveAddress;

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

  216.     ModbusTxFrame[2] = exception;

  217.     ModbusAppendCrc(ModbusTxFrame, 3U);

  218. 

  219.     return 5U;

  220. }

  221. 

  222. /**

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

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

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

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

  227.  */

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

  229. {

  230.    

  231.     uint16_t start;

  232.     uint16_t quantity;

  233.     uint16_t index;

  234.     uint8_t byteCount;

  235. 

  236.     if (requestLength != 8U)

  237.     {

  238.         ModbusSlaveStatistics.illegalValueCount++;

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

  240.     }

  241. 

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

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

  244. 

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

  246.     {

  247.         ModbusSlaveStatistics.illegalValueCount++;

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

  249.     }

  250. 

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

  252.     {

  253.         ModbusSlaveStatistics.illegalAddressCount++;

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

  255.     }

  256. 

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

  258.     ModbusTxFrame[0] = ModbusSlaveAddress;

  259.     ModbusTxFrame[1] = 0X01;

  260.     ModbusTxFrame[2] = byteCount;

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

  262. 

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

  264.     {

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

  266.         {

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

  268.                

  269.         }

  270.     }

  271. 

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

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

  274. }

  275. 

  276. /**

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

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

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

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

  281.  */

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

  283.     

  284. {

  285.     uint16_t start;

  286.     uint16_t quantity;

  287.     uint16_t index;

  288.     uint16_t value;

  289. 

  290.     if (requestLength != 8U)

  291.     {

  292.         ModbusSlaveStatistics.illegalValueCount++;

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

  294.     }

  295. 

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

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

  298. 

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

  300.     {

  301.         ModbusSlaveStatistics.illegalValueCount++;

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

  303.     }

  304.     

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

  306.     {

  307.         if ((start >= 20000U) &&

  308.         (start < 25000U) &&

  309.         (quantity > 0U) &&

  310.         (quantity <= (25000U - start)))goto tx;

  311.         ModbusSlaveStatistics.illegalAddressCount++;

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

  313.     }

  314.     tx:

  315.     ModbusTxFrame[0] = ModbusSlaveAddress;

  316.     ModbusTxFrame[1] = 0X03;

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

  318. 

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

  320.     {

  321.         uint16_t address = start + index;

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

  323.         if (address >= 20000U)

  324.         {

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

  326.         }

  327.         value = ModbusHoldingRegisters[address];

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

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

  330.     }

  331. 

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

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

  334. 

  335. 

  336. 

  337. 

  338. }

  339. 

  340. 

  341. /*

  342. * 返回帧

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

  344. *

  345. *    01          从站地址

  346. *    14          功能码

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

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

  349. *    06          引用类型

  350. *    12 34       第一个寄存器

  351. *    56 78       第二个寄存器

  352. */

  353. static uint16_t ModbusProcessFile(const uint8_t *request,uint16_t requestLength)

  354. {

  355.     uint16_t fileNumber;

  356.     uint16_t recordNumber;

  357.     uint16_t quantity;

  358.     uint16_t index;

  359.     uint16_t value;

  360.     uint16_t*p;

  361.     if (requestLength != 12U)

  362.     {

  363.         ModbusSlaveStatistics.illegalValueCount++;

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

  365.     }

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

  367.     {

  368.         ModbusSlaveStatistics.illegalValueCount++;

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

  370.     }

  371. 

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

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

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

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

  376.     {

  377.         ModbusSlaveStatistics.illegalValueCount++;

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

  379.     }

  380.     if (fileNumber>15||recordNumber>=260||((uint32_t)recordNumber + quantity) > 260UL)//地址检查

  381.     {

  382.         ModbusSlaveStatistics.illegalAddressCount++;

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

  384.     }

  385.     ModbusTxFrame[0] = ModbusSlaveAddress;

  386.     ModbusTxFrame[1] = 0X14;

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

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

  389.     

  390.     ModbusTxFrame[4] = 0X06;

  391.     p = (uint16_t*)ModbusHistory;

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

  393.     {

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

  395. 

  396.         value = *(p+address);

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

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

  399.     }

  400. 

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

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

  403. 

  404. }

  405. 

  406. 

  407. /**

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

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

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

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

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

  413.  */

  414. static uint16_t ModbusProcessWriteSingleRegister(

  415.     const uint8_t *request,

  416.     uint16_t requestLength,

  417.     uint8_t isBroadcast)

  418. {

  419.     uint16_t address;

  420.     uint16_t value;

  421. 

  422.     if (requestLength != 8U)

  423.     {

  424.         ModbusSlaveStatistics.illegalValueCount++;

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

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

  427.     }

  428. 

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

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

  431. 

  432.     if (address >= MODBUS_MAP_ITEM_COUNT)

  433.     {

  434.         ModbusSlaveStatistics.illegalAddressCount++;

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

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

  437.     }

  438. 

  439.     ModbusHoldingRegisters[address] = value;

  440. 

  441.     if (isBroadcast != 0U)

  442.     {

  443.         return 0U;

  444.     }

  445. 

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

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

  448.     ModbusAppendCrc(ModbusTxFrame, 6U);

  449.     return 8U;

  450. }

  451. 

  452. /**

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

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

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

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

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

  458.  */

  459. static uint16_t ModbusProcessWriteSingleCoil(

  460.     const uint8_t *request,

  461.     uint16_t requestLength,

  462.     uint8_t isBroadcast)

  463. {

  464.     uint16_t address;

  465.     uint16_t value;

  466. 

  467.     if (requestLength != 8U)

  468.     {

  469.         ModbusSlaveStatistics.illegalValueCount++;

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

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

  472.     }

  473. 

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

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

  476. 

  477.     /*

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

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

  480.      */

  481.     if ((value != MODBUS_COIL_VALUE_ON)

  482.         && (value != MODBUS_COIL_VALUE_OFF))

  483.     {

  484.         ModbusSlaveStatistics.illegalValueCount++;

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

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

  487.     }

  488. 

  489.     if (address >= MODBUS_MAP_ITEM_COUNT)

  490.     {

  491.         ModbusSlaveStatistics.illegalAddressCount++;

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

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

  494.     }

  495. 

  496.     ModbusCoilSetUnchecked(

  497.         address,

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

  499. 

  500.     if (isBroadcast != 0U)

  501.     {

  502.         return 0U;

  503.     }

  504. 

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

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

  507.     ModbusAppendCrc(ModbusTxFrame, 6U);

  508.     return 8U;

  509. }

  510. 

  511. /**

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

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

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

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

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

  517.  */

  518. static uint16_t ModbusProcessWriteMultipleCoils(

  519.     const uint8_t *request,

  520.     uint16_t requestLength,

  521.     uint8_t isBroadcast)

  522. {

  523.     uint16_t start;

  524.     uint16_t quantity;

  525.     uint16_t index;

  526.     uint8_t byteCount;

  527.     uint8_t expectedByteCount;

  528. 

  529.     if (requestLength < 9U)

  530.     {

  531.         ModbusSlaveStatistics.illegalValueCount++;

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

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

  534.     }

  535. 

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

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

  538.     byteCount = request[6];

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

  540. 

  541.     if ((quantity == 0U)

  542.         || (quantity > MODBUS_WRITE_COILS_MAX)

  543.         || (byteCount != expectedByteCount)

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

  545.     {

  546.         ModbusSlaveStatistics.illegalValueCount++;

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

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

  549.     }

  550. 

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

  552.     {

  553.         ModbusSlaveStatistics.illegalAddressCount++;

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

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

  556.     }

  557. 

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

  559.     {

  560.         uint8_t state;

  561. 

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

  563.             >> (index & 0x0007U))

  564.             & 0x01U);

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

  566.     }

  567. 

  568.     if (isBroadcast != 0U)

  569.     {

  570.         return 0U;

  571.     }

  572. 

  573.     ModbusTxFrame[0] = ModbusSlaveAddress;

  574.     ModbusTxFrame[1] = 0X0F;

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

  576.     ModbusAppendCrc(ModbusTxFrame, 6U);

  577.     return 8U;

  578. }

  579. 

  580. /**

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

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

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

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

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

  586.  */

  587. static uint16_t ModbusProcessWriteMultipleRegisters(

  588.     const uint8_t *request,

  589.     uint16_t requestLength,

  590.     uint8_t isBroadcast)

  591. {

  592.     uint16_t start;

  593.     uint16_t quantity;

  594.     uint16_t index;

  595.     uint8_t byteCount;

  596. 

  597.     if (requestLength < 9U)

  598.     {

  599.         ModbusSlaveStatistics.illegalValueCount++;

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

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

  602.     }

  603. 

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

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

  606.     byteCount = request[6];

  607. 

  608.     if ((quantity == 0U)

  609.         || (quantity > MODBUS_WRITE_REGS_MAX)

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

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

  612.     {

  613.         ModbusSlaveStatistics.illegalValueCount++;

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

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

  616.     }

  617. 

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

  619.     {

  620.         ModbusSlaveStatistics.illegalAddressCount++;

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

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

  623.     }

  624. 

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

  626.     {

  627.         ModbusHoldingRegisters[start + index] =

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

  629.     }

  630. 

  631.     if (isBroadcast != 0U)

  632.     {

  633.         return 0U;

  634.     }

  635. 

  636.     ModbusTxFrame[0] = ModbusSlaveAddress;

  637.     ModbusTxFrame[1] = 0X10;

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

  639.     ModbusAppendCrc(ModbusTxFrame, 6U);

  640.     return 8U;

  641. }

  642. 

  643. 

  644. /**

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

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

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

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

  649.  */

  650. static uint16_t ModbusProcessReadBigHolding(

  651.     const uint8_t *request,

  652.     uint16_t requestLength)

  653. {

  654.     uint32_t start;

  655.     uint32_t currentAddress;

  656.     uint16_t quantity;

  657.     uint16_t index;

  658.     uint16_t value;

  659. 

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

  661.     if (requestLength != 9U)

  662.     {

  663.         ModbusSlaveStatistics.illegalValueCount++;

  664. 

  665.         return ModbusBuildException(

  666.             request[1],

  667.             MODBUS_EX_ILLEGAL_VALUE);

  668.     }

  669. 

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

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

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

  673. 

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

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

  676.         (quantity > MODBUS_READ_REGS_MAX))

  677.     {

  678.         ModbusSlaveStatistics.illegalValueCount++;

  679. 

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

  681.             

  682.             

  683.     }

  684. 

  685.     /*

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

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

  688.      */

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

  690.        

  691.     {

  692.         ModbusSlaveStatistics.illegalAddressCount++;

  693. 

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

  695.           

  696.             

  697.     }

  698. 

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

  700.     ModbusTxFrame[0] = ModbusSlaveAddress;

  701.     ModbusTxFrame[1] = 0x48U;

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

  703. 

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

  705.     {

  706.         currentAddress = start + (uint32_t)index;

  707. 

  708.         /*

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

  710.          * 地址40000～69998位于CCMRAM

  711.          */

  712.         if (currentAddress < 40000UL)

  713.         {

  714.             value = ModbusHoldingRegisters[currentAddress];

  715.         }

  716.         else

  717.         {

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

  719.                 

  720.         }

  721. 

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

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

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

  725.            

  726.     }

  727.     /* 添加CRC */

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

  729.         

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

  731. }

  732. 

  733. /**

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

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

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

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

  738.  */

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

  740. {

  741.     uint16_t calculatedCrc;

  742.     uint16_t receivedCrc;

  743.     uint8_t isBroadcast;

  744. 

  745.     if (requestLength < 4U)

  746.     {

  747.         return 0U;

  748.     }

  749. 

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

  751.     receivedCrc =

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

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

  754. 

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

  756.     {

  757.         ModbusSlaveStatistics.crcErrorCount++;

  758.         return 0U;

  759.     }

  760. 

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

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

  763.     {

  764.         ModbusSlaveStatistics.ignoredAddressCount++;

  765.         return 0U;

  766.     }

  767. 

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

  769.     ModbusSlaveStatistics.validFrameCount++;

  770.     ModbusLastValidFrameTick = HAL_GetTick();

  771.     ModbusHasReceivedValidFrame = 1U;

  772. 

  773.     switch (request[1])

  774.     {

  775.         case 0X01U://读线圈

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

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

  778.                 ModbusProcessReadCoils(request, requestLength);

  779. 

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

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

  782.                 ModbusProcessReadHolding(request, requestLength);

  783.         case 0x14U:

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

  785.              ModbusProcessFile(request,requestLength);

  786. 

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

  788.             return ModbusProcessWriteSingleCoil(request,

  789.                                                 requestLength,

  790.                                                 isBroadcast);

  791. 

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

  793.             return ModbusProcessWriteSingleRegister(request,

  794.                                                     requestLength,

  795.                                                     isBroadcast);

  796. 

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

  798.             return ModbusProcessWriteMultipleCoils(request,

  799.                 requestLength,

  800.                 isBroadcast);

  801. 

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

  803.             return ModbusProcessWriteMultipleRegisters(request,

  804.                 requestLength,

  805.                 isBroadcast);

  806. 

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

  808.                return   ModbusProcessReadBigHolding(request, requestLength);

  809.         

  810.         default://未知功能码

  811.             ModbusSlaveStatistics.illegalFunctionCount++;

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

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

  814.     }

  815. }

  816. 

  817. HAL_StatusTypeDef ModbusSlaveInit(UART_HandleTypeDef *huart,

  818.     uint8_t slaveAddress)

  819. {

  820. 

  821.     ModbusUart = huart;

  822.     ModbusSlaveAddress = slaveAddress;

  823. 

  824.     ModbusHoldingRegisters[HMI_REG_DEVICE_ID] = 0xF407U;

  825. 

  826.     return ModbusStartReceive();

  827. }

  828. 

  829. void ModbusSlavePoll(void)

  830. {

  831.     uint16_t responseLength;

  832. 

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

  834.     {

  835.         return;

  836.     }

  837. 

  838. 

  839. 

  840.     responseLength = ModbusProcessRequest(ModbusRxFrame, ModbusRxFrameLength);

  841.     ModbusHistorySave(OSTimeGet() / 1000,ModbusRxFrame,

  842.                                     ModbusRxFrameLength,

  843.                                     ModbusTxFrame,

  844.                                     responseLength);    

  845.     

  846.     

  847. 

  848.     if (responseLength > 0U)

  849.     {

  850.         ModbusTxBusy = 1U;

  851. 

  852.         if (HAL_UART_Transmit_DMA(ModbusUart,

  853.                                   ModbusTxFrame,

  854.                                   responseLength) == HAL_OK)                                                               

  855.         {

  856.             ModbusSlaveStatistics.txFrameCount++;

  857.         }

  858.         else

  859.         {

  860.             ModbusTxBusy = 0U;

  861.             ModbusSlaveStatistics.uartErrorCount++;

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

  863.         }

  864.     }

  865.     else 

  866.     {

  867.          (void)ModbusStartReceive();

  868.     }

  869. 

  870.     /*

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

  872.      */

  873.     ModbusRxFrameReady = 0U;

  874. }

  875. 

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

  877. {

  878. 

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

  880. 

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

  882.     {

  883.         if (ModbusRxFrameReady == 0U)

  884.         {

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

  886.             ModbusRxFrameLength = size;

  887.             ModbusRxEventTick = HAL_GetTick();

  888.             ModbusRxFrameReady = 1U;

  889.         }

  890.         else

  891.         {

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

  893.             ModbusSlaveStatistics.droppedFrameCount++;

  894.         }

  895.     }

  896.     else

  897.     {

  898.         //长度异常帧

  899.         ModbusSlaveStatistics.droppedFrameCount++;

  900.         (void)ModbusStartReceive();

  901.     }

  902. }

  903. 

  904. void ModbusSlaveOnTxComplete(UART_HandleTypeDef *huart)

  905. {

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

  907.     {

  908.         return;

  909.     }

  910. 

  911.     ModbusTxBusy = 0U;

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

  913. }

  914. 

  915. void ModbusSlaveOnUartError(UART_HandleTypeDef *huart)

  916. {

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

  918.     {

  919.         return;

  920.     }

  921. 

  922.     ModbusSlaveStatistics.uartErrorCount++;

  923.     ModbusTxBusy = 0U;

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

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

  926. }

  927. 

  928. uint8_t ModbusSlaveSetHoldingRegister(uint16_t address, uint16_t value)

  929. {

  930.     if (address >= MODBUS_MAP_ITEM_COUNT)

  931.     {

  932.         return 0U;

  933.     }

  934. 

  935.     ModbusHoldingRegisters[address] = value;

  936.     return 1U;

  937. }

  938. 

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

  940. {

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

  942.     {

  943.         return 0U;

  944.     }

  945. 

  946.     *value = ModbusHoldingRegisters[address];

  947.     return 1U;

  948. }

  949. 

  950. uint8_t ModbusSlaveSetCoil(uint16_t address, uint8_t state)

  951. {

  952.     if (address >= MODBUS_MAP_ITEM_COUNT)

  953.     {

  954.         return 0U;

  955.     }

  956. 

  957.     ModbusCoilSetUnchecked(address, state);

  958.     return 1U;

  959. }

  960. 

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

  962. {

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

  964.     {

  965.         return 0U;

  966.     }

  967. 

  968.     *state = ModbusCoilGetUnchecked(address);

  969.     return 1U;

  970. }

  971. 

  972. uint8_t ModbusSlaveIsConnected(uint32_t timeoutMs)

  973. {

  974.     if (ModbusHasReceivedValidFrame == 0U)

  975.     {

  976.         return 0U;

  977.     }

  978. 

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

  980.         ? 1U

  981.         : 0U;

  982. }

  983. 

  984. //上电恢复函数

  985. void ModbusRetainedRegistersLoad(void)

  986. {

  987.     uint16_t index;

  988. 

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

  990.     {

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

  992.         {

  993.             ModbusHoldingRegisters[MODBUS_RETAINED_D_START + index] =             

  994.                 backupData->retainedD[index];

  995.         }

  996.     }

  997.     else

  998.     {

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

  1000.         {

  1001.             ModbusHoldingRegisters[

  1002.                 MODBUS_RETAINED_D_START + index] = 0U;

  1003. 

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

  1005.         }

  1006. 

  1007.         /*

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

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

  1010.          */

  1011.         backupData->magic = MODBUS_BACKUP_MAGIC;

  1012.     }

  1013. }

  1014. void ModbusRetainedRegistersPoll(void)

  1015. {

  1016.     uint16_t index;

  1017.    // uint16_t address;

  1018.     uint16_t value;

  1019. 

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

  1021.     {

  1022.         value=ModbusHoldingRegisters[MODBUS_RETAINED_D_START +index];

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

  1024.         {

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

  1026.         }

  1027. 

  1028.         ModbusRetainedSnapshot[index] = value;

  1029.     }

  1030. 

  1031. 

  1032. 

  1033. 

  1034. }

  1035. static void ModbusHistorySave(

  1036.                             uint32_t tick,

  1037.                             const uint8_t *request,

  1038.                             uint16_t requestLength,

  1039.                             const uint8_t *response,

  1040.                             uint16_t responseLength)

  1041. {

  1042.     MODBUS_HISTORY_ITEM *item;

  1043. 

  1044.     if(requestLength > 256U)

  1045.     {

  1046.         requestLength = 256U;

  1047.     }

  1048. 

  1049.     if(responseLength > 256U)

  1050.     {

  1051.         responseLength = 256U;

  1052.     }

  1053. 

  1054.     item = &ModbusHistory[ModbusHistoryWriteIndex];

  1055. 

  1056.     item->tick = tick;

  1057.     item->requestLength = requestLength;

  1058.     item->responseLength = responseLength;

  1059. 

  1060.     (void)memcpy(

  1061.         item->request,

  1062.         request,

  1063.         requestLength);

  1064. 

  1065.     if(responseLength > 0U)

  1066.     {

  1067.         (void)memcpy(

  1068.             item->response,

  1069.             response,

  1070.             responseLength);

  1071.     }

  1072. 

  1073.     ModbusHistoryWriteIndex++;

  1074. 

  1075.     if(ModbusHistoryWriteIndex >= 16U)

  1076.     {

  1077.         ModbusHistoryWriteIndex = 0U;

  1078.     }

  1079. }

  1080. void HistorySaveToRegisters(void)

  1081. {

  1082.     // (void)memcpy(

  1083.     // &ModbusHoldingRegisters[1000],

  1084.     // ModbusHistory,

  1085.     // sizeof(ModbusHistory));

  1086. 

  1087.     uint16_t index;

  1088. 

  1089.     if(ModbusHistoryWriteIndex == 0U)

  1090.     {

  1091.         index = 15U;

  1092.     }

  1093.     else

  1094.     {

  1095.         index = ModbusHistoryWriteIndex - 1U;

  1096.     }

  1097. 

  1098.     (void)memcpy(

  1099.         &ModbusHoldingRegisters[

  1100.             1000U + index * 260U],

  1101.         &ModbusHistory[index],

  1102.         sizeof(ModbusHistory[index]));

  1103. }