yuwenhao
/
Modbus-rtu
1
0
Forka 0
Codice Problemi 0 Pull Requests 0 Rilasci 0 Wiki Attività
Non puoi selezionare più di 25 argomenti Gli argomenti devono iniziare con una lettera o un numero, possono includere trattini ('-') e possono essere lunghi fino a 35 caratteri.
41 Commit
3 Rami (Branch)
138 MiB
 
 
 
 
 
 
Albero (Tree): fdbbe71aea
Rami (Branch) Tag
${ item.name }
Crea branch ${ searchTerm }
da 'fdbbe71aea'
${ noResults }
Modbus-rtu/Modbus/Src/modbus_rtu_slave.c

1113 righe
34 KiB
Originale Blame Cronologia 

  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 MODBUS_BACKUP_DATA *ModbusBackupData =

  55.     (volatile MODBUS_BACKUP_DATA *)BKPSRAM_BASE;

  56. 

  57. /* Word data is owned by modbus_data_store.c.  This file keeps only the

  58.  * protocol-facing coil space and RTU buffers. */

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

  60. 

  61. volatile MODBUS_SLAVE_STATS ModbusSlaveStatistics;

  62. 

  63. /**

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

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

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

  67.  * @return CRC16 校验值

  68.  */

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

  70. {

  71.     uint16_t crc = 0xFFFFU;

  72.     uint16_t index;

  73.     uint8_t bit;

  74. 

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

  76.     {

  77.         crc ^= data[index];

  78. 

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

  80.         {

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

  82.             {

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

  84.             }

  85.             else

  86.             {

  87.                 crc >>= 1U;

  88.             }

  89.         }

  90.     }

  91. 

  92.     return crc;

  93. }

  94. 

  95. /**

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

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

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

  99.  */

  100. static uint16_t ModbusGetU16Be(const uint8_t *data)

  101. {

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

  103. }

  104. 

  105. /**

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

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

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

  109.  */

  110. static uint32_t ModbusGetU24Be(const uint8_t *data)

  111. {

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

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

  114. }

  115. 

  116. /**

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

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

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

  120.  */

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

  122. {

  123.     if (start >= MODBUS_MAP_ITEM_COUNT)

  124.     {

  125.         return 0U;

  126.     }

  127. 

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

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

  130. }

  131. 

  132. /**

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

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

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

  136.  */

  137. static uint8_t ModbusCoilGetUnchecked(uint16_t address)

  138. {

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

  140. 

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

  142. }

  143. 

  144. /**

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

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

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

  148.  */

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

  150. {

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

  152. 

  153.     if (state != 0U)

  154.     {

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

  156.     }

  157.     else

  158.     {

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

  160.     }

  161. }

  162. 

  163. /**

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

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

  166.  */

  167. static void ModbusRtuTimingInit(uint32_t baudRate)

  168. {

  169.     uint64_t coreClock;

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

  171.     CoreDebug->DEMCR |= CoreDebug_DEMCR_TRCENA_Msk;

  172.     DWT->CYCCNT = 0U;

  173.     DWT->CTRL |= DWT_CTRL_CYCCNTENA_Msk;

  174. 

  175.     coreClock = SystemCoreClock;

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

  177.     ModbusRtuCharCycles =

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

  179. 

  180.     if (baudRate > MODBUS_RTU_HIGH_BAUD_LIMIT)

  181.     {

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

  183.         ModbusRtuT15Cycles =

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

  185. 

  186.         ModbusRtuT35Cycles =

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

  188.     }

  189.     else

  190.     {

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

  192.         ModbusRtuT15Cycles =

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

  194.         ModbusRtuT35Cycles =

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

  196.     }

  197. }

  198. 

  199. /**

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

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

  202.  */

  203. static void ModbusRxAssemblyFinalize(void)

  204. {

  205.     if (ModbusRxAssemblyLength == 0U)

  206.     {

  207.         return;

  208.     }

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

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

  211.     {

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

  213.         (void)memcpy(ModbusRxFrame, ModbusRxAssemblyBuffer,

  214.                      ModbusRxAssemblyLength);

  215.         ModbusRxFrameLength = ModbusRxAssemblyLength;

  216.         ModbusRxFrameReady = 1U;

  217.     }

  218.     else

  219.     {

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

  221.         ModbusSlaveStatistics.droppedFrameCount++;

  222.     }

  223. 

  224.     ModbusRxAssemblyLength = 0U;

  225.     ModbusRxAssemblyInvalid = 0U;

  226. }

  227. 

  228. /**

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

  230.  */

  231. static void ModbusTryFinalizeReceive(void)

  232. {

  233.     uint32_t now;

  234. 

  235.     if (ModbusRxAssemblyLength == 0U)

  236.     {

  237.         return;

  238.     }

  239. 

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

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

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

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

  244.             < MODBUS_RTU_ADU_SIZE_MAX))

  245.     {

  246.         return;

  247.     }

  248. 

  249.     now = DWT->CYCCNT;

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

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

  252.     {

  253.         return;

  254.     }

  255. 

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

  257.     (void)HAL_UART_AbortReceive(ModbusUart);

  258. 

  259.     __disable_irq();

  260.     ModbusRxAssemblyFinalize();

  261.     __enable_irq();

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

  263.     if (ModbusRxFrameReady == 0U)

  264.     {

  265.         (void)ModbusStartReceive();

  266.     }

  267. 

  268. 

  269. }

  270. 

  271. /**

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

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

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

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

  276.  */

  277. static HAL_StatusTypeDef ModbusStartReceive(void)

  278. {

  279.     HAL_StatusTypeDef status;

  280. 

  281.     if (ModbusTxBusy != 0U)

  282.     {

  283.         return HAL_BUSY;

  284.     }

  285. 

  286.     status = HAL_UARTEx_ReceiveToIdle_DMA(ModbusUart, ModbusRxDmaBuffer,

  287.                                           sizeof(ModbusRxDmaBuffer));

  288. 

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

  290.     {

  291.         /*

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

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

  294.          */

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

  296.     }

  297. 

  298.     return status;

  299. }

  300. 

  301. /**

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

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

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

  305.  */

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

  307. {

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

  309. 

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

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

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

  313. }

  314. 

  315. /**

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

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

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

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

  320.  */

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

  322. {

  323.     ModbusTxFrame[0] = ModbusSlaveAddress;

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

  325.     ModbusTxFrame[2] = exception;

  326.     ModbusAppendCrc(ModbusTxFrame, 3U);

  327. 

  328.     return 5U;

  329. }

  330. 

  331. /**

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

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

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

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

  336.  */

  337. static uint16_t ModbusProcessReadCoils(const uint8_t *request,

  338.                                        uint16_t requestLength)

  339. {

  340. 

  341.     uint16_t start;

  342.     uint16_t quantity;

  343.     uint16_t index;

  344.     uint8_t byteCount;

  345. 

  346.     if (requestLength != 8U)

  347.     {

  348.         ModbusSlaveStatistics.illegalValueCount++;

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

  350.     }

  351. 

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

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

  354. 

  355.     if ((quantity == 0U)

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

  357.     {

  358.         ModbusSlaveStatistics.illegalValueCount++;

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

  360.     }

  361. 

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

  363.     {

  364.         ModbusSlaveStatistics.illegalAddressCount++;

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

  366.     }

  367. 

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

  369.     ModbusTxFrame[0] = ModbusSlaveAddress;

  370.     ModbusTxFrame[1] = 0X01;

  371.     ModbusTxFrame[2] = byteCount;

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

  373. 

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

  375.     {

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

  377.         {

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

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

  380.         }

  381.     }

  382. 

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

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

  385. }

  386. 

  387. /**

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

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

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

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

  392.  */

  393. static uint16_t ModbusProcessReadHolding(const uint8_t *request,

  394.                                          uint16_t requestLength)

  395. 

  396. {

  397.     uint16_t start;

  398.     uint16_t quantity;

  399.     uint16_t index;

  400.     uint16_t value;

  401. 

  402.     if (requestLength != 8U)

  403.     {

  404.         ModbusSlaveStatistics.illegalValueCount++;

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

  406.     }

  407. 

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

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

  410. 

  411.     if ((quantity == 0U)

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

  413.     {

  414.         ModbusSlaveStatistics.illegalValueCount++;

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

  416.     }

  417. 

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

  419.     {

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

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

  422.             goto tx;

  423.         ModbusSlaveStatistics.illegalAddressCount++;

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

  425.     }

  426. tx:

  427.     ModbusTxFrame[0] = ModbusSlaveAddress;

  428.     ModbusTxFrame[1] = 0X03;

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

  430. 

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

  432.     {

  433.         uint16_t address = start + index;

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

  435.         if (address >= 20000U)

  436.         {

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

  438.         }

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

  440.         {

  441.             ModbusSlaveStatistics.illegalAddressCount++;

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

  443.         }

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

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

  446.     }

  447. 

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

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

  450. }

  451. 

  452. /**

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

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

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

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

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

  458.  */

  459. static uint16_t ModbusProcessWriteSingleRegister(const uint8_t *request,

  460.                                                  uint16_t requestLength,

  461.                                                  uint8_t isBroadcast)

  462. {

  463.     uint16_t address;

  464.     uint16_t value;

  465. 

  466.     if (requestLength != 8U)

  467.     {

  468.         ModbusSlaveStatistics.illegalValueCount++;

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

  470.                   

  471.                    

  472.     }

  473. 

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

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

  476. 

  477.     if (address >= MODBUS_MAP_ITEM_COUNT)

  478.     {

  479.         ModbusSlaveStatistics.illegalAddressCount++;

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

  481.                                   

  482.                                          

  483.     }

  484. 

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

  486. 

  487.     if (isBroadcast != 0U)

  488.     {

  489.         return 0U;

  490.     }

  491. 

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

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

  494.     ModbusAppendCrc(ModbusTxFrame, 6U);

  495.     return 8U;

  496. }

  497. 

  498. /**

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

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

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

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

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

  504.  */

  505. static uint16_t ModbusProcessWriteSingleCoil(const uint8_t *request,

  506.                                              uint16_t requestLength,

  507.                                              uint8_t isBroadcast)

  508. {

  509.     uint16_t address;

  510.     uint16_t value;

  511. 

  512.     if (requestLength != 8U)

  513.     {

  514.         ModbusSlaveStatistics.illegalValueCount++;

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

  516.                    

  517.                   

  518.     }

  519. 

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

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

  522. 

  523.     /*

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

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

  526.      */

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

  528.     {

  529.         ModbusSlaveStatistics.illegalValueCount++;

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

  531.                    

  532.                   

  533.     }

  534. 

  535.     if (address >= MODBUS_MAP_ITEM_COUNT)

  536.     {

  537.         ModbusSlaveStatistics.illegalAddressCount++;

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

  539.                                    

  540.                                          

  541.     }

  542. 

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

  544. 

  545.     if (isBroadcast != 0U)

  546.     {

  547.         return 0U;

  548.     }

  549. 

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

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

  552.     ModbusAppendCrc(ModbusTxFrame, 6U);

  553.     return 8U;

  554. }

  555. 

  556. /**

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

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

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

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

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

  562.  */

  563. static uint16_t ModbusProcessWriteMultipleCoils(const uint8_t *request,

  564.                                                 uint16_t requestLength,

  565.                                                 uint8_t isBroadcast)

  566. {

  567.     uint16_t start;

  568.     uint16_t quantity;

  569.     uint16_t index;

  570.     uint8_t byteCount;

  571.     uint8_t expectedByteCount;

  572. 

  573.     if (requestLength < 9U)

  574.     {

  575.         ModbusSlaveStatistics.illegalValueCount++;

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

  577.                   

  578.                    

  579.     }

  580. 

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

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

  583.     byteCount = request[6];

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

  585. 

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

  587.         || (byteCount != expectedByteCount)

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

  589.     {

  590.         ModbusSlaveStatistics.illegalValueCount++;

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

  592.                    

  593.                   

  594.     }

  595. 

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

  597.     {

  598.         ModbusSlaveStatistics.illegalAddressCount++;

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

  600.                                    

  601.                                          

  602.     }

  603. 

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

  605.     {

  606.         uint8_t state;

  607. 

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

  609.                          

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

  611.     }

  612. 

  613.     if (isBroadcast != 0U)

  614.     {

  615.         return 0U;

  616.     }

  617. 

  618.     ModbusTxFrame[0] = ModbusSlaveAddress;

  619.     ModbusTxFrame[1] = 0X0F;

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

  621.     ModbusAppendCrc(ModbusTxFrame, 6U);

  622.     return 8U;

  623. }

  624. 

  625. /**

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

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

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

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

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

  631.  */

  632. static uint16_t ModbusProcessWriteMultipleRegisters(const uint8_t *request,

  633.                                                     uint16_t requestLength,

  634.                                                     uint8_t isBroadcast)

  635. {

  636.     uint16_t start;

  637.     uint16_t quantity;

  638.     uint16_t index;

  639.     uint8_t byteCount;

  640. 

  641.     if (requestLength < 9U)

  642.     {

  643.         ModbusSlaveStatistics.illegalValueCount++;

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

  645.                   

  646.                   

  647.     }

  648. 

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

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

  651.     byteCount = request[6];

  652. 

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

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

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

  656.     {

  657.         ModbusSlaveStatistics.illegalValueCount++;

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

  659.                  

  660.                   

  661.     }

  662. 

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

  664.     {

  665.         ModbusSlaveStatistics.illegalAddressCount++;

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

  667.                                   

  668.                                          

  669.     }

  670. 

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

  672.     {

  673.         ModbusWriteRegisterScratch[index] =

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

  675.     }

  676.     (void)ModbusDataWriteWords(MODBUS_DATA_DEVICE_D,

  677.                                start,

  678.                                ModbusWriteRegisterScratch,

  679.                                quantity);

  680. 

  681.     if (isBroadcast != 0U)

  682.     {

  683.         return 0U;

  684.     }

  685. 

  686.     ModbusTxFrame[0] = ModbusSlaveAddress;

  687.     ModbusTxFrame[1] = 0X10;

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

  689.     ModbusAppendCrc(ModbusTxFrame, 6U);

  690.     return 8U;

  691. }

  692. 

  693. /**

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

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

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

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

  698.  */

  699. static uint16_t ModbusProcessReadBigHolding(const uint8_t *request,

  700.                                             uint16_t requestLength)

  701. {

  702.     uint32_t start;

  703.     uint32_t currentAddress;

  704.     uint16_t quantity;

  705.     uint16_t index;

  706.     uint16_t value;

  707. 

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

  709.     if (requestLength != 9U)

  710.     {

  711.         ModbusSlaveStatistics.illegalValueCount++;

  712. 

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

  714.     }

  715. 

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

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

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

  719. 

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

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

  722.     {

  723.         ModbusSlaveStatistics.illegalValueCount++;

  724. 

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

  726.     }

  727. 

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

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

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

  731.         || ((start < 40000UL)

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

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

  734. 

  735.     {

  736.         ModbusSlaveStatistics.illegalAddressCount++;

  737. 

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

  739.     }

  740. 

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

  742.     ModbusTxFrame[0] = ModbusSlaveAddress;

  743.     ModbusTxFrame[1] = 0x48U;

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

  745. 

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

  747.     {

  748.         currentAddress = start + (uint32_t)index;

  749. 

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

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

  752.         {

  753.             ModbusSlaveStatistics.illegalAddressCount++;

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

  755.         }

  756. 

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

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

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

  760.     }

  761.     /* 添加CRC */

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

  763. 

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

  765. }

  766. 

  767. /**

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

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

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

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

  772.  */

  773. static uint16_t ModbusProcessRequest(const uint8_t *request,

  774.                                      uint16_t requestLength)

  775. {

  776.     uint16_t calculatedCrc;

  777.     uint16_t receivedCrc;

  778.     uint8_t isBroadcast;

  779. 

  780.     if (requestLength < 4U)

  781.     {

  782.         return 0U;

  783.     }

  784. 

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

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

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

  788. 

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

  790.     {

  791.         ModbusSlaveStatistics.crcErrorCount++;

  792.         return 0U;

  793.     }

  794. 

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

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

  797.     {

  798.         ModbusSlaveStatistics.ignoredAddressCount++;

  799.         return 0U;

  800.     }

  801. 

  802.     isBroadcast =

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

  804.     ModbusSlaveStatistics.validFrameCount++;

  805.     ModbusLastValidFrameTick = HAL_GetTick();

  806.     ModbusHasReceivedValidFrame = 1U;

  807. 

  808.     switch (request[1])

  809.     {

  810.         case 0X01U: // 读线圈

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

  812.             return (isBroadcast != 0U)

  813.                        ? 0U

  814.                        : ModbusProcessReadCoils(request, requestLength);

  815. 

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

  817.             return (isBroadcast != 0U)

  818.                        ? 0U

  819.                        : ModbusProcessReadHolding(request, requestLength);

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

  821.             return ModbusProcessWriteSingleCoil(request, requestLength,

  822.                                                 isBroadcast);

  823. 

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

  825.             return ModbusProcessWriteSingleRegister(request, requestLength,

  826.                                                     isBroadcast);

  827. 

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

  829.             return ModbusProcessWriteMultipleCoils(request, requestLength,

  830.                                                    isBroadcast);

  831. 

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

  833.             return ModbusProcessWriteMultipleRegisters(request, requestLength,

  834.                                                        isBroadcast);

  835. 

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

  837.             return (isBroadcast != 0U)

  838.                        ? 0U

  839.                        : ModbusProcessReadBigHolding(request, requestLength);

  840. 

  841.         default: // 未知功能码

  842.             ModbusSlaveStatistics.illegalFunctionCount++;

  843.             return (isBroadcast != 0U)

  844.                        ? 0U

  845.                        : ModbusBuildException(request[1],

  846.                                               MODBUS_EX_ILLEGAL_FUNCTION);

  847.     }

  848. }

  849. 

  850. HAL_StatusTypeDef ModbusSlaveInit(UART_HandleTypeDef *huart,

  851.                                   uint8_t slaveAddress)

  852. 

  853. {

  854. 

  855.     ModbusUart = huart;

  856.     ModbusSlaveAddress = slaveAddress;

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

  858.     ModbusRxAssemblyLength = 0U;

  859.     ModbusRxAssemblyInvalid = 0U;

  860.     ModbusRxFrameReady = 0U;

  861.     ModbusTxBusy = 0U;

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

  863. 

  864.     return ModbusStartReceive();

  865. }

  866. 

  867. void ModbusSlavePoll(void)

  868. {

  869.     uint16_t responseLength;

  870. 

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

  872.     ModbusTryFinalizeReceive();

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

  874.     {

  875.         return;

  876.     }

  877. 

  878.     responseLength = ModbusProcessRequest(ModbusRxFrame, ModbusRxFrameLength);

  879.     if (responseLength > 0U)

  880.     {

  881.         ModbusTxBusy = 1U;

  882. 

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

  884.             == HAL_OK)

  885.         {

  886.             ModbusSlaveStatistics.txFrameCount++;

  887.         }

  888.         else

  889.         {

  890.             ModbusTxBusy = 0U;

  891.             ModbusSlaveStatistics.uartErrorCount++;

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

  893.         }

  894.     }

  895.     else

  896.     {

  897.         (void)ModbusStartReceive();

  898.     }

  899. 

  900.     /*

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

  902.      */

  903.     ModbusRxFrameReady = 0U;

  904. }

  905. 

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

  907. {

  908.     HAL_UART_RxEventTypeTypeDef eventType;

  909.     uint32_t now;

  910.     uint32_t lastByteCycle;

  911.     uint32_t firstByteCycle;

  912.     uint32_t chunkCycles;

  913.     uint32_t interFrameGap;

  914. 

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

  916. 

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

  918.     {

  919.         return;

  920.     }

  921. 

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

  923.     {

  924.         now = DWT->CYCCNT;

  925.         eventType = HAL_UARTEx_GetRxEventType(huart);

  926. 

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

  928.         lastByteCycle = now;

  929.         if (eventType == HAL_UART_RXEVENT_IDLE)

  930.         {

  931.             lastByteCycle -= ModbusRtuCharCycles;

  932.         }

  933. 

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

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

  936.         firstByteCycle = lastByteCycle - chunkCycles;

  937. 

  938.         if (ModbusRxAssemblyLength > 0U)

  939.         {

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

  941.             ModbusLastInterFrameGapCycles = interFrameGap;

  942.             if (interFrameGap >= ModbusRtuT35Cycles)

  943.             {

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

  945.                 ModbusRxAssemblyFinalize();

  946.             }

  947.             else if (interFrameGap > ModbusRtuT15Cycles)

  948.             {

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

  950.                 ModbusRxAssemblyInvalid = 1U;

  951.             }

  952.             else

  953.             {

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

  955.             }

  956.         }

  957. 

  958.         if (size

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

  960.         {

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

  962.                          ModbusRxDmaBuffer, size);

  963.             ModbusRxAssemblyLength += size;

  964.         }

  965.         else

  966.         {

  967.             ModbusRxAssemblyInvalid = 1U;

  968.         }

  969. 

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

  971.         ModbusRxLastByteCycle = lastByteCycle;

  972.         (void)ModbusStartReceive();

  973.     }

  974.     else

  975.     {

  976.         // 长度异常帧

  977.         ModbusSlaveStatistics.droppedFrameCount++;

  978.         ModbusRxAssemblyLength = 0U;

  979.         ModbusRxAssemblyInvalid = 0U;

  980.         (void)ModbusStartReceive();

  981.     }

  982. }

  983. 

  984. void ModbusSlaveOnTxComplete(UART_HandleTypeDef *huart)

  985. {

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

  987.     {

  988.         return;

  989.     }

  990. 

  991.     ModbusTxBusy = 0U;

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

  993. }

  994. 

  995. void ModbusSlaveOnUartError(UART_HandleTypeDef *huart)

  996. {

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

  998.     {

  999.         return;

  1000.     }

  1001. 

  1002.     ModbusSlaveStatistics.uartErrorCount++;

  1003.     ModbusTxBusy = 0U;

  1004.     ModbusRxAssemblyLength = 0U;

  1005.     ModbusRxAssemblyInvalid = 0U;

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

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

  1008. }

  1009. 

  1010. uint8_t ModbusSlaveSetHoldingRegister(uint16_t address, uint16_t value)

  1011. {

  1012.     if (address >= MODBUS_MAP_ITEM_COUNT)

  1013.     {

  1014.         return 0U;

  1015.     }

  1016. 

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

  1018. }

  1019. 

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

  1021. {

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

  1023.     {

  1024.         return 0U;

  1025.     }

  1026. 

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

  1028. }

  1029. 

  1030. uint8_t ModbusSlaveSetCoil(uint16_t address, uint8_t state)

  1031. {

  1032.     if (address >= MODBUS_MAP_ITEM_COUNT)

  1033.     {

  1034.         return 0U;

  1035.     }

  1036. 

  1037.     ModbusCoilSetUnchecked(address, state);

  1038.     return 1U;

  1039. }

  1040. 

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

  1042. {

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

  1044.     {

  1045.         return 0U;

  1046.     }

  1047. 

  1048.     *state = ModbusCoilGetUnchecked(address);

  1049.     return 1U;

  1050. }

  1051. 

  1052. uint8_t ModbusSlaveIsConnected(uint32_t timeoutMs)

  1053. {

  1054.     if (ModbusHasReceivedValidFrame == 0U)

  1055.     {

  1056.         return 0U;

  1057.     }

  1058. 

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

  1060. }

  1061. 

  1062. // 上电恢复函数

  1063. void ModbusRetainedRegistersLoad(void)

  1064. {

  1065.     uint16_t index;

  1066. 

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

  1068.     {

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

  1070.         {

  1071.             (void)ModbusDataWriteWord(

  1072.                 MODBUS_DATA_DEVICE_D,

  1073.                 MODBUS_RETAINED_D_START + index,

  1074.                 ModbusBackupData->retainedD[index]);

  1075.         }

  1076.     }

  1077.     else

  1078.     {

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

  1080.         {

  1081.             (void)ModbusDataWriteWord(MODBUS_DATA_DEVICE_D,

  1082.                                       MODBUS_RETAINED_D_START + index,

  1083.                                       0U);

  1084. 

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

  1086.         }

  1087. 

  1088.         /*

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

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

  1091.          */

  1092.         ModbusBackupData->magic = MODBUS_BACKUP_MAGIC;

  1093.     }

  1094. }

  1095. void ModbusRetainedRegistersPoll(void)

  1096. {

  1097.     uint16_t index;

  1098.     uint16_t value;

  1099. 

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

  1101.     {

  1102.         (void)ModbusDataReadWord(MODBUS_DATA_DEVICE_D,

  1103.                                  MODBUS_RETAINED_D_START + index,

  1104.                                  &value);

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

  1106.         {

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

  1108.         }

  1109. 

  1110.         ModbusRetainedSnapshot[index] = value;

  1111.     }

  1112. }