zengbingjie
/
Modbus
1
0
Rozštěpit 0
Zdrojový kód Úkoly 0 Požadavky na natažení 0 Vydání 0 Wiki Aktivita
Nelze vybrat více než 25 témat Téma musí začínat písmenem nebo číslem, může obsahovat pomlčky („-“) a může být dlouhé až 35 znaků.
5 Revize
1 Větev
127 MiB
 
 
 
 
 
Strom: 80b391e8be
Větve Značky
${ item.name }
Vytvořit větev ${ searchTerm }
z „80b391e8be“
${ noResults }
Modbus/Core/Src/main.c

923 řádky
28 KiB
Surový Blame Historie 

  1. /**

  2.  * @file    main.c

  3.  * @brief   基于 uC/OS-II 的 Modbus RTU 从站主程序。

  4.  * @version 2.0

  5.  * @author  zengbingjie

  6.  * @date    2026-07-29

  7.  * @copyright 版权所有信捷科技股份有限公司

  8.  * @note    修改记录：2.0 增加帧隔离、连接状态和可靠收发处理。

  9.  */

  10. 

  11. #include "main.h"

  12. 

  13. #include "modbus.h"

  14. #include "modbus_backup.h"

  15. 

  16. #define APP_MODBUS_FUNCTION_INDEX            (1U)

  17. #define APP_MODBUS_RTU_TIMER_PHASE_T15       (0U)

  18. #define APP_MODBUS_RTU_TIMER_PHASE_T35       (1U)

  19. 

  20. static OS_STK AppTaskStartStk[APP_TASK_START_STK_SIZE];

  21. static OS_STK AppTaskModbusStk[APP_TASK_MODBUS_STK_SIZE];

  22. static OS_STK AppTaskT35Stk[APP_TASK_T35_STK_SIZE];

  23. 

  24. UART_HandleTypeDef Uart1Handle;

  25. 

  26. /* 保留真实数据区供 IAR Live Watch 调试；不维护请求、应答或状态镜像副本。 */

  27. volatile uint16_t holdingRegisters[MODBUS_DATA_POINT_COUNT];

  28. volatile uint8_t coilStorage[MODBUS_COIL_STORAGE_SIZE];

  29. volatile uint16_t extendedHoldingRegister;

  30. 

  31. static MODBUS_SLAVE ModbusSlave;

  32. static OS_EVENT *ModbusFrameSem;

  33. static OS_EVENT *ModbusTxSem;

  34. /* 接收缓冲区由 UART 中断逐字节填充。只有 RTU 定时器置位

  35.  * ModbusFrameReady 后，Modbus 任务才读取它，因此解析器不会读到仍在接收中的帧。 */

  36. static uint8_t ModbusRxBuffer[MODBUS_RX_BUF_SIZE];

  37. static uint8_t ModbusTxBuffer[MODBUS_TX_BUF_SIZE];

  38. /* 以下状态由中断和任务共享；更新应保持简短，读取完整帧快照时使用已有的临界区保护。 */

  39. static volatile uint16_t ModbusRxLength;

  40. static volatile uint16_t ModbusFrameLength;

  41. static volatile uint8_t ModbusFrameReady;

  42. static volatile uint8_t ModbusRxOverflow;

  43. static volatile uint8_t ModbusRtuTimerPhase;

  44. static volatile uint8_t ModbusInterCharacterTimeout;

  45. static volatile uint8_t ModbusRxDiscard;

  46. static volatile uint8_t ModbusReceptionNeedsRecovery;

  47. static uint32_t ModbusLastActivityTick;

  48. static uint8_t ModbusHasActivity;

  49. 

  50. static GPIO_TypeDef *const

  51.     AppUserOutputPorts[APP_MODBUS_USER_OUTPUT_COIL_COUNT] =

  52. {

  53.     PLC_Q1_PORT,

  54.     PLC_Q2_PORT,

  55.     PLC_Q3_PORT,

  56.     PLC_Q4_PORT,

  57.     PLC_Q5_PORT,

  58.     PLC_Q6_PORT,

  59.     PLC_Q7_PORT

  60. };

  61. 

  62. static const uint16_t

  63.     AppUserOutputPins[APP_MODBUS_USER_OUTPUT_COIL_COUNT] =

  64. {

  65.     PLC_Q1_PIN,

  66.     PLC_Q2_PIN,

  67.     PLC_Q3_PIN,

  68.     PLC_Q4_PIN,

  69.     PLC_Q5_PIN,

  70.     PLC_Q6_PIN,

  71.     PLC_Q7_PIN

  72. };

  73. 

  74. void SystemClock_Config(void);

  75. 

  76. static void AppTaskStart(void *argument);

  77. static void AppTaskModbus(void *argument);

  78. static void AppTaskT35(void *argument);

  79. static void AppInitSystemTick(void);

  80. static void AppInitGpio(void);

  81. static void AppInitUart1(void);

  82. static void AppInitModbusRtuTimer(void);

  83. static INT8U AppCreateTasks(void);

  84. static HAL_StatusTypeDef AppStartUartReception(void);

  85. static HAL_StatusTypeDef AppRecoverUartReception(void);

  86. static HAL_StatusTypeDef AppRecoverPendingUartReception(void);

  87. static HAL_StatusTypeDef AppEnsureUartReception(void);

  88. static HAL_StatusTypeDef AppTransmitResponse(uint16_t txLength);

  89. static void AppStartModbusRtuTimer(void);

  90. static void AppStopModbusRtuTimer(void);

  91. static void AppSetModbusRtuTimer(uint16_t timeoutUs);

  92. static void AppHandleModbusRtuTimer(void);

  93. static uint16_t AppGetReadyFrameLength(void);

  94. static INT8U AppPostModbusFrameSem(void);

  95. static uint8_t AppIsModbusStatusAccepted(MODBUS_STATUS status);

  96. static uint8_t AppIsModbusRetentionWriteFunction(uint8_t functionCode);

  97. static MODBUS_STATUS AppUpdateLinkStatus(void);

  98. static MODBUS_STATUS AppSyncCoilsToGpio(void);

  99. static void AppProcessFrame(uint16_t rxLength);

  100. 

  101. /**

  102.  * @brief 应用程序入口。

  103.  * @return 该函数不返回。

  104.  */

  105. int main(void)

  106. {

  107.     INT8U osError;

  108. 

  109.     /* 启动调度器前必须先完成硬件初始化。尤其要先初始化 USART1 和 TIM5，

  110.      * 这样任务才能安全地启动接收和使用 RTU 帧间隔定时器。 */

  111.     HAL_Init();

  112.     AppInitSystemTick();

  113.     SystemClock_Config();

  114.     AppInitGpio();

  115.     AppInitUart1();

  116.     AppInitModbusRtuTimer();

  117. 

  118.     /* OSStart() 之后由 uC/OS-II 负责任务调度；启动任务会创建下面的

  119.      * Modbus 工作任务和定时监测任务。 */

  120.     OSInit();

  121.     osError = OSTaskCreateExt(

  122.         AppTaskStart, NULL,

  123.         &AppTaskStartStk[APP_TASK_START_STK_SIZE - 1U],

  124.         APP_TASK_START_PRIO, APP_TASK_START_PRIO, &AppTaskStartStk[0],

  125.         APP_TASK_START_STK_SIZE, NULL,

  126.         OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);

  127.     if (osError != OS_ERR_NONE) {

  128.         Error_Handler();

  129.     }

  130. 

  131.     OSStart();

  132. 

  133.     while (1) {

  134.     }

  135. }

  136. 

  137. /**

  138.  * @brief 配置 STM32F407 的 168 MHz 系统时钟。

  139.  * @note 使用板载 12 MHz 外部晶振作为 PLL 时钟源。

  140.  */

  141. void SystemClock_Config(void)

  142. {

  143.     RCC_OscInitTypeDef oscillatorConfig = {0};

  144.     RCC_ClkInitTypeDef clockConfig = {0};

  145. 

  146.     __HAL_RCC_PWR_CLK_ENABLE();

  147.     __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);

  148. 

  149.     oscillatorConfig.OscillatorType = RCC_OSCILLATORTYPE_HSE;

  150.     oscillatorConfig.HSEState = RCC_HSE_ON;

  151.     oscillatorConfig.PLL.PLLState = RCC_PLL_ON;

  152.     oscillatorConfig.PLL.PLLSource = RCC_PLLSOURCE_HSE;

  153.     oscillatorConfig.PLL.PLLM = 12U;

  154.     oscillatorConfig.PLL.PLLN = 336U;

  155.     oscillatorConfig.PLL.PLLP = RCC_PLLP_DIV2;

  156.     oscillatorConfig.PLL.PLLQ = 7U;

  157.     if (HAL_RCC_OscConfig(&oscillatorConfig) != HAL_OK) {

  158.         Error_Handler();

  159.     }

  160. 

  161.     clockConfig.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK

  162.         | RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2;

  163.     clockConfig.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;

  164.     clockConfig.AHBCLKDivider = RCC_SYSCLK_DIV1;

  165.     clockConfig.APB1CLKDivider = RCC_HCLK_DIV4;

  166.     clockConfig.APB2CLKDivider = RCC_HCLK_DIV2;

  167.     if (HAL_RCC_ClockConfig(&clockConfig, FLASH_LATENCY_5) != HAL_OK) {

  168.         Error_Handler();

  169.     }

  170. }

  171. 

  172. /**

  173.  * @brief 将 SysTick 配置为可调用 uC/OS-II 的内核感知中断优先级。

  174.  */

  175. static void AppInitSystemTick(void)

  176. {

  177.     HAL_NVIC_SetPriority(SysTick_IRQn, CPU_CFG_KA_IPL_BOUNDARY, 0U);

  178. }

  179. 

  180. /**

  181.  * @brief 初始化 XDM-60T4-E 的连接指示灯和 Q1 至 Q7 输出引脚。

  182.  * @note 板卡输出为低电平有效，初始状态全部关闭。

  183.  */

  184. static void AppInitGpio(void)

  185. {

  186.     GPIO_InitTypeDef gpioConfig = {0};

  187. 

  188.     __HAL_RCC_GPIOE_CLK_ENABLE();

  189.     __HAL_RCC_GPIOF_CLK_ENABLE();

  190.     __HAL_RCC_GPIOI_CLK_ENABLE();

  191. 

  192.     gpioConfig.Mode = GPIO_MODE_OUTPUT_PP;

  193.     gpioConfig.Pull = GPIO_PULLUP;

  194.     gpioConfig.Speed = GPIO_SPEED_FREQ_LOW;

  195. 

  196.     gpioConfig.Pin = PLC_Q0_PIN | PLC_Q1_PIN | PLC_Q2_PIN | PLC_Q3_PIN;

  197.     HAL_GPIO_Init(GPIOF, &gpioConfig);

  198. 

  199.     gpioConfig.Pin = PLC_Q4_PIN;

  200.     HAL_GPIO_Init(GPIOI, &gpioConfig);

  201. 

  202.     gpioConfig.Pin = PLC_Q5_PIN | PLC_Q6_PIN | PLC_Q7_PIN;

  203.     HAL_GPIO_Init(GPIOE, &gpioConfig);

  204. 

  205.     HAL_GPIO_WritePin(GPIOF, PLC_Q0_PIN | PLC_Q1_PIN | PLC_Q2_PIN

  206.                       | PLC_Q3_PIN, GPIO_PIN_SET);

  207.     HAL_GPIO_WritePin(GPIOI, PLC_Q4_PIN, GPIO_PIN_SET);

  208.     HAL_GPIO_WritePin(GPIOE, PLC_Q5_PIN | PLC_Q6_PIN | PLC_Q7_PIN,

  209.                       GPIO_PIN_SET);

  210. }

  211. 

  212. /**

  213.  * @brief 初始化 Modbus RTU 使用的 USART1。

  214.  */

  215. static void AppInitUart1(void)

  216. {

  217.     Uart1Handle.Instance = USART1;

  218.     Uart1Handle.Init.BaudRate = APP_MODBUS_BAUD_RATE;

  219.     /* 串口参数必须与触摸屏/PLC 主站完全一致。当前工程使用 9 位字长和偶校验

  220.      * （HAL 对“8 位数据 + 1 位校验”的配置方式）；不能只修改从站而不修改主站。 */

  221.     Uart1Handle.Init.WordLength = UART_WORDLENGTH_9B;

  222.     Uart1Handle.Init.StopBits = UART_STOPBITS_1;

  223.     Uart1Handle.Init.Parity = UART_PARITY_EVEN;

  224.     Uart1Handle.Init.Mode = UART_MODE_TX_RX;

  225.     Uart1Handle.Init.HwFlowCtl = UART_HWCONTROL_NONE;

  226.     Uart1Handle.Init.OverSampling = UART_OVERSAMPLING_16;

  227.     if (HAL_UART_Init(&Uart1Handle) != HAL_OK) {

  228.         Error_Handler();

  229.     }

  230. }

  231. 

  232. /**

  233.  * @brief 将 TIM5 配置为 Modbus RTU 帧间隔单次定时器。

  234.  */

  235. static void AppInitModbusRtuTimer(void)

  236. {

  237.     __HAL_RCC_TIM5_CLK_ENABLE();

  238. 

  239.     TIM5->CR1 = 0U;

  240.     TIM5->PSC = (APP_MODBUS_RTU_TIMER_CLOCK_HZ

  241.                  / APP_MODBUS_RTU_TIMER_TICK_HZ) - 1U;

  242.     TIM5->ARR = APP_MODBUS_RTU_T35_US - 1U;

  243.     TIM5->CNT = 0U;

  244.     TIM5->EGR = TIM_EGR_UG;

  245.     TIM5->SR = 0U;

  246.     TIM5->DIER = TIM_DIER_UIE;

  247. 

  248.     HAL_NVIC_SetPriority(TIM5_IRQn, 5U, 0U);

  249.     HAL_NVIC_EnableIRQ(TIM5_IRQn);

  250. }

  251. 

  252. /**

  253.  * @brief 创建 Modbus 工作任务与帧间隔检测任务。

  254.  * @return uC/OS-II 错误码。

  255.  */

  256. static INT8U AppCreateTasks(void)

  257. {

  258.     INT8U osError;

  259. 

  260.     osError = OSTaskCreateExt(

  261.         AppTaskModbus, NULL,

  262.         &AppTaskModbusStk[APP_TASK_MODBUS_STK_SIZE - 1U],

  263.         APP_TASK_MODBUS_PRIO, APP_TASK_MODBUS_PRIO,

  264.         &AppTaskModbusStk[0], APP_TASK_MODBUS_STK_SIZE, NULL,

  265.         OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);

  266.     if (osError != OS_ERR_NONE) {

  267.         return osError;

  268.     }

  269. 

  270.     osError = OSTaskCreateExt(

  271.         AppTaskT35, NULL, &AppTaskT35Stk[APP_TASK_T35_STK_SIZE - 1U],

  272.         APP_TASK_T35_PRIO, APP_TASK_T35_PRIO, &AppTaskT35Stk[0],

  273.         APP_TASK_T35_STK_SIZE, NULL,

  274.         OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);

  275. 

  276.     return osError;

  277. }

  278. 

  279. /**

  280.  * @brief 启动任务，创建同步对象并启动应用任务。

  281.  * @param[in] argument 未使用。

  282.  */

  283. static void AppTaskStart(void *argument)

  284. {

  285.     INT8U osError;

  286. 

  287.     (void)argument;

  288.     ModbusFrameSem = OSSemCreate(0U);

  289.     ModbusTxSem = OSSemCreate(0U);

  290.     if ((ModbusFrameSem == NULL) || (ModbusTxSem == NULL)) {

  291.         Error_Handler();

  292.     }

  293. 

  294.     osError = AppCreateTasks();

  295.     if (osError != OS_ERR_NONE) {

  296.         Error_Handler();

  297.     }

  298. 

  299.     OSTaskSuspend(OS_PRIO_SELF);

  300.     while (1) {

  301.     }

  302. }

  303. 

  304. /**

  305.  * @brief 清空接收状态并启动 USART1 单字节中断接收。

  306.  * @return HAL 状态码。

  307.  */

  308. static HAL_StatusTypeDef AppStartUartReception(void)

  309. {

  310.     OS_CPU_SR cpu_sr = 0U;

  311.     HAL_StatusTypeDef halStatus;

  312. 

  313.     /* 新帧必须从干净的软件状态开始。这里使用临界区，避免定时器或 UART 中断

  314.      * 看到只清除了一半的状态字段。 */

  315.     OS_ENTER_CRITICAL();

  316.     AppStopModbusRtuTimer();

  317.     ModbusRxLength = 0U;

  318.     ModbusFrameLength = 0U;

  319.     ModbusFrameReady = 0U;

  320.     ModbusRxOverflow = 0U;

  321.     ModbusRtuTimerPhase = APP_MODBUS_RTU_TIMER_PHASE_T15;

  322.     ModbusInterCharacterTimeout = 0U;

  323.     ModbusRxDiscard = 0U;

  324.     OS_EXIT_CRITICAL();

  325. 

  326.     /* 每次只挂接一个字节的接收。接收完成回调负责推进缓冲区并重新挂接下一个

  327.      * 字节，使组帧完全由中断驱动且不会阻塞 Modbus 任务。 */

  328.     halStatus = HAL_UART_Receive_IT(&Uart1Handle, &ModbusRxBuffer[0], 1U);

  329. 

  330.     return halStatus;

  331. }

  332. 

  333. /**

  334.  * @brief 在 Modbus 任务上下文中恢复 USART1 单字节中断接收。

  335.  * @return HAL 状态码。

  336.  */

  337. static HAL_StatusTypeDef AppRecoverUartReception(void)

  338. {

  339.     HAL_StatusTypeDef halStatus;

  340.     HAL_StatusTypeDef abortStatus;

  341. 

  342.     /* 出错的接收仍由 HAL 持有时，HAL_UART_Receive_IT() 会返回 BUSY。

  343.      * 先终止旧接收并清除外设状态，下一次挂接才能从 READY 状态开始。 */

  344.     abortStatus = HAL_UART_AbortReceive_IT(&Uart1Handle);

  345.     /* STM32 HAL 宏会按外设要求读取 SR 和 DR，以清除奇偶校验、帧格式和溢出错误。

  346.      * 该操作必须在中断之外执行。 */

  347.     __HAL_UART_CLEAR_PEFLAG(&Uart1Handle);

  348.     halStatus = AppStartUartReception();

  349.     if ((abortStatus != HAL_OK) || (halStatus != HAL_OK)) {

  350.         (void)HAL_UART_AbortReceive_IT(&Uart1Handle);

  351.         __HAL_UART_CLEAR_PEFLAG(&Uart1Handle);

  352.         halStatus = AppStartUartReception();

  353.     }

  354. 

  355.     return halStatus;

  356. }

  357. 

  358. /**

  359.  * @brief 处理一个待执行的 UART 接收恢复请求。

  360.  * @return 本次恢复操作返回的 HAL 状态。

  361.  * @note 接收已经挂接时 UART 中断仍可能设置待恢复标志。只能清除本次尝试前

  362.  *       已取出的请求，不能清除恢复过程中并发产生的新请求。

  363.  */

  364. static HAL_StatusTypeDef AppRecoverPendingUartReception(void)

  365. {

  366.     HAL_StatusTypeDef halStatus;

  367. 

  368.     halStatus = HAL_OK;

  369.     if (ModbusReceptionNeedsRecovery != 0U) {

  370.         ModbusReceptionNeedsRecovery = 0U;

  371.         halStatus = AppRecoverUartReception();

  372.         if (halStatus != HAL_OK) {

  373.             ModbusReceptionNeedsRecovery = 1U;

  374.         }

  375.     }

  376. 

  377.     return halStatus;

  378. }

  379. 

  380. /**

  381.  * @brief 即使 HAL 状态丢失，也保持 UART 接收中断处于挂接状态。

  382.  * @return 恢复操作的 HAL 状态；接收已经挂接时返回 HAL_OK。

  383.  * @note RS-485 断线时可能完全没有 UART 中断，因此这里的检查可以补充错误回调，

  384.  *       同时处理接收被打断后 HAL 停留在 READY/BUSY 状态的情况。

  385.  */

  386. static HAL_StatusTypeDef AppEnsureUartReception(void)

  387. {

  388.     if (ModbusFrameReady != 0U) {

  389.         return HAL_OK;

  390.     }

  391. 

  392.     /* 线缆断开可能完全不产生 UART 中断。任务每次唤醒时检查 HAL 状态，可以补充

  393.      * ErrorCallback 的处理，即使硬件没有上报错误标志也能重新挂接接收。 */

  394.     if ((ModbusReceptionNeedsRecovery != 0U)

  395.         || (Uart1Handle.RxState != HAL_UART_STATE_BUSY_RX)) {

  396.         ModbusReceptionNeedsRecovery = 1U;

  397.         return AppRecoverPendingUartReception();

  398.     }

  399. 

  400.     return HAL_OK;

  401. }

  402. 

  403. /**

  404.  * @brief 通过 USART1 发送 Modbus 从站响应帧。

  405.  * @param[in] txLength 响应帧长度。

  406.  * @return HAL 状态码。

  407.  */

  408. static HAL_StatusTypeDef AppTransmitResponse(uint16_t txLength)

  409. {

  410.     HAL_StatusTypeDef halStatus;

  411.     INT8U osError;

  412. 

  413.     if ((txLength == 0U) || (txLength > MODBUS_TX_BUF_SIZE)) {

  414.         return HAL_ERROR;

  415.     }

  416. 

  417.     /* 发送是异步进行的。任务等待 ModbusTxSem，确保 USART1 发出最后一个字节前

  418.      * 不会复用同一个发送缓冲区。 */

  419.     halStatus = HAL_UART_Transmit_IT(&Uart1Handle, ModbusTxBuffer, txLength);

  420.     if (halStatus != HAL_OK) {

  421.         return halStatus;

  422.     }

  423. 

  424.     OSSemPend(ModbusTxSem, APP_MODBUS_TX_TIMEOUT_TICKS, &osError);

  425.     if (osError != OS_ERR_NONE) {

  426.         (void)HAL_UART_AbortTransmit_IT(&Uart1Handle);

  427.         return HAL_TIMEOUT;

  428.     }

  429. 

  430.     return HAL_OK;

  431. }

  432. 

  433. /**

  434.  * @brief 设置正在运行的 RTU 定时器单次超时时间，单位为微秒。

  435.  * @param[in] timeoutUs 单次超时时间，单位为微秒。

  436.  */

  437. static void AppSetModbusRtuTimer(uint16_t timeoutUs)

  438. {

  439.     /* TIM5 作为单次定时器使用。装载新间隔前先停止、清零并确认状态，

  440.      * 否则残留的更新标志可能立即产生错误的帧边界。 */

  441.     TIM5->CR1 &= (uint32_t)(~TIM_CR1_CEN);

  442.     TIM5->CNT = 0U;

  443.     TIM5->ARR = (uint32_t)timeoutUs - 1U;

  444.     TIM5->SR = 0U;

  445.     TIM5->CR1 |= TIM_CR1_CEN;

  446. }

  447. 

  448. /**

  449.  * @brief 启动 Modbus RTU T1.5/T3.5 定时器的第一阶段。

  450.  */

  451. static void AppStartModbusRtuTimer(void)

  452. {

  453.     /* 每收到一个字节就重新开始 T1.5。如果线路静默超过 T1.5，当前帧会被标记为

  454.      * 无效，随后第二阶段继续等待 T3.5，再决定丢弃帧还是交给任务处理。 */

  455.     ModbusRtuTimerPhase = APP_MODBUS_RTU_TIMER_PHASE_T15;

  456.     ModbusInterCharacterTimeout = 0U;

  457.     AppSetModbusRtuTimer(APP_MODBUS_RTU_T15_RX_TIMEOUT_US);

  458. }

  459. 

  460. /**

  461.  * @brief 停止并确认 Modbus RTU 帧间隔定时器。

  462.  */

  463. static void AppStopModbusRtuTimer(void)

  464. {

  465.     TIM5->CR1 &= (uint32_t)(~TIM_CR1_CEN);

  466.     TIM5->SR = 0U;

  467. }

  468. 

  469. /**

  470.  * @brief 在中断上下文中处理 T1.5 和 T3.5 单次定时到期事件。

  471.  */

  472. static void AppHandleModbusRtuTimer(void)

  473. {

  474.     if (ModbusRtuTimerPhase == APP_MODBUS_RTU_TIMER_PHASE_T15) {

  475.         /* T1.5 表示帧内出现了字符间隔，此时不能立即解析；还要等待后续 T3.5，

  476.          * 用它把这条不完整帧与下一条合法 RTU 帧分隔开。 */

  477.         ModbusInterCharacterTimeout = 1U;

  478.         ModbusRtuTimerPhase = APP_MODBUS_RTU_TIMER_PHASE_T35;

  479.         AppSetModbusRtuTimer(APP_MODBUS_RTU_T35_AFTER_T15_US);

  480.         return;

  481.     }

  482. 

  483.     AppStopModbusRtuTimer();

  484.     ModbusInterCharacterTimeout = 0U;

  485.     if (ModbusRxDiscard != 0U) {

  486.         ModbusRxDiscard = 0U;

  487.         ModbusRxLength = 0U;

  488.         return;

  489.     }

  490. 

  491.     if ((ModbusRxLength == 0U) || (ModbusFrameReady != 0U)) {

  492.         return;

  493.     }

  494. 

  495.     /* T3.5 表示帧结束。通知任务前先保存帧长度，任务随后解析稳定的缓冲区，

  496.      * 完成后再重置接收状态。 */

  497.     ModbusFrameLength = ModbusRxLength;

  498.     ModbusFrameReady = 1U;

  499.     (void)HAL_UART_AbortReceive_IT(&Uart1Handle);

  500.     (void)AppPostModbusFrameSem();

  501. }

  502. 

  503. /**

  504.  * @brief 原子读取已封存 Modbus 帧的长度。

  505.  * @return 完整帧长度；无完整帧时返回 0。

  506.  */

  507. static uint16_t AppGetReadyFrameLength(void)

  508. {

  509.     OS_CPU_SR cpu_sr = 0U;

  510.     uint16_t frameLength;

  511. 

  512.     /* 定时器中断将 ModbusFrameLength 和 ModbusFrameReady 作为一个逻辑事件发布。

  513.      * 这里原子地读取快照，避免任务拿到属于另一种缓冲区状态的长度。 */

  514.     frameLength = 0U;

  515.     OS_ENTER_CRITICAL();

  516.     if (ModbusFrameReady != 0U) {

  517.         frameLength = ModbusFrameLength;

  518.     }

  519.     OS_EXIT_CRITICAL();

  520. 

  521.     return frameLength;

  522. }

  523. 

  524. /**

  525.  * @brief 通知 Modbus 任务处理完整帧或刷新通信状态。

  526.  * @return uC/OS-II 错误码。

  527.  */

  528. static INT8U AppPostModbusFrameSem(void)

  529. {

  530.     INT8U osError;

  531. 

  532.     /* RTU 定时器、UART 错误路径和周期链路检查等多个来源共用一个信号量。

  533.      * 任务会再次检查帧长度，因此没有完整帧的唤醒也是安全的，并能刷新链路指示。 */

  534.     osError = OSSemPost(ModbusFrameSem);

  535. 

  536.     return osError;

  537. }

  538. 

  539. /**

  540.  * @brief 判断协议处理结果是否代表已寻址的有效通信。

  541.  * @param[in] status Modbus 协议处理结果。

  542.  * @return 1 表示有效通信；0 表示无效通信。

  543.  */

  544. static uint8_t AppIsModbusStatusAccepted(MODBUS_STATUS status)

  545. {

  546.     if ((status == MODBUS_STATUS_OK) || (status == MODBUS_STATUS_BROADCAST)

  547.         || (status == MODBUS_STATUS_EXCEPTION)) {

  548.         return 1U;

  549.     }

  550. 

  551.     return 0U;

  552. }

  553. 

  554. /**

  555.  * @brief 判断功能码是否为需要保存到 RTC 的写操作。

  556.  * @param[in] functionCode Modbus 功能码。

  557.  * @return 写操作返回 1，否则返回 0。

  558.  * @note 仅 0x42 修改 0x00010000；标准寄存器和线圈写入不具备掉电保持承诺。

  559.  */

  560. static uint8_t AppIsModbusRetentionWriteFunction(uint8_t functionCode)

  561. {

  562.     switch (functionCode) {

  563.         case MODBUS_FC_WRITE_EXTENDED_HOLDING_REGS:

  564.             return 1U;

  565. 

  566.         default:

  567.             return 0U;

  568.     }

  569. }

  570. 

  571. /**

  572.  * @brief 更新连接线圈和 PLC 连接指示灯。

  573.  * @return 成功返回 MODBUS_STATUS_OK；失败返回错误状态。

  574.  * @note 仅已寻址的正常响应、广播写或异常响应刷新活动时间；CRC 错误和

  575.  *       非本机帧不会误报链路在线。

  576.  */

  577. static MODBUS_STATUS AppUpdateLinkStatus(void)

  578. {

  579.     MODBUS_STATUS status;

  580.     uint32_t currentTick;

  581.     uint8_t linkState;

  582.     GPIO_PinState pinState;

  583. 

  584.     currentTick = OSTimeGet();

  585.     linkState = APP_MODBUS_LINK_DISCONNECTED;

  586.     if ((ModbusHasActivity != 0U) &&

  587.         ((currentTick - ModbusLastActivityTick)

  588.             < APP_MODBUS_LINK_TIMEOUT_TICKS))

  589.     {

  590.         linkState = APP_MODBUS_LINK_CONNECTED;

  591.     }

  592. 

  593.     status = ModbusSetCoil(&ModbusSlave, APP_MODBUS_LINK_STATE_COIL,

  594.                            linkState);

  595.     if (status != MODBUS_STATUS_OK)

  596.     {

  597.         return status;

  598.     }

  599. 

  600.     if (linkState == APP_MODBUS_LINK_CONNECTED)

  601.     {

  602.         pinState = GPIO_PIN_RESET;

  603.     }

  604.     else

  605.     {

  606.         pinState = GPIO_PIN_SET;

  607.     }

  608. 

  609.     HAL_GPIO_WritePin(PLC_LINK_LED_PORT, PLC_LINK_LED_PIN, pinState);

  610. 

  611.     return MODBUS_STATUS_OK;

  612. }

  613. 

  614. /**

  615.  * @brief 将线圈 1 至 7 的状态同步到 PLC Q1 至 Q7 输出。

  616.  * @return 成功返回 MODBUS_STATUS_OK；失败返回错误状态。

  617.  * @note 板级输出为低有效，因此逻辑线圈置 1 时向 GPIO 写入 GPIO_PIN_RESET。

  618.  */

  619. static MODBUS_STATUS AppSyncCoilsToGpio(void)

  620. {

  621.     MODBUS_STATUS status;

  622.     uint16_t coilOffset;

  623.     uint16_t coilAddress;

  624.     uint8_t coilValue;

  625.     GPIO_PinState pinState;

  626. 

  627.     for (coilOffset = 0U;

  628.          coilOffset < APP_MODBUS_USER_OUTPUT_COIL_COUNT;

  629.          coilOffset++)

  630.     {

  631.         coilAddress = coilOffset + APP_MODBUS_FIRST_USER_OUTPUT_COIL;

  632.         status = ModbusGetCoil(&ModbusSlave, coilAddress, &coilValue);

  633.         if (status != MODBUS_STATUS_OK)

  634.         {

  635.             return status;

  636.         }

  637. 

  638.         pinState = (coilValue != 0U) ? GPIO_PIN_RESET : GPIO_PIN_SET;

  639.         HAL_GPIO_WritePin(AppUserOutputPorts[coilOffset],

  640.                           AppUserOutputPins[coilOffset], pinState);

  641.     }

  642. 

  643.     return MODBUS_STATUS_OK;

  644. }

  645. 

  646. /**

  647.  * @brief 处理已封存的 Modbus RTU 请求帧。

  648.  * @param[in] rxLength 请求帧长度。

  649.  * @note 此函数在 Modbus 任务上下文执行。它负责协议分发、链路活动刷新、

  650.  *       线圈 GPIO 同步、0x42 成功后的 RTC 保存和异步 UART 应答启动。

  651.  */

  652. static void AppProcessFrame(uint16_t rxLength)

  653. {

  654.     MODBUS_STATUS status;

  655.     uint16_t txLength;

  656.     uint8_t functionCode;

  657.     uint8_t isWriteOperation;

  658. 

  659.     txLength = 0U;

  660.     functionCode = 0U;

  661.     isWriteOperation = 0U;

  662.     if (rxLength > APP_MODBUS_FUNCTION_INDEX) {

  663.         functionCode = ModbusRxBuffer[APP_MODBUS_FUNCTION_INDEX];

  664.     }

  665. 

  666.     if ((rxLength == 0U) || (rxLength > MODBUS_RX_BUF_SIZE))

  667.     {

  668.         return;

  669.     }

  670. 

  671.     if (ModbusRxOverflow != 0U)

  672.     {

  673.         return;

  674.     }

  675. 

  676.     /* 协议解析固定放在任务上下文中执行。这样解析器可以更新线圈/寄存器并构造

  677.      * 响应，而不必在 UART 或定时器中断中执行较长的处理。 */

  678.     status = ModbusProcessFrame(&ModbusSlave, ModbusRxBuffer, rxLength,

  679.                                 ModbusTxBuffer, MODBUS_TX_BUF_SIZE,

  680.                                 &txLength);

  681.     /* 只有 CRC 正确且寻址到本站的帧（包括合法广播写入或已生成的异常响应）才算

  682.      * 有效链路活动，线路上的随机干扰不能错误点亮连接指示灯。 */

  683.     if (AppIsModbusStatusAccepted(status) != 0U)

  684.     {

  685.         ModbusLastActivityTick = OSTimeGet();

  686.         ModbusHasActivity = 1U;

  687.         isWriteOperation = AppIsModbusRetentionWriteFunction(functionCode);

  688.         if (((status == MODBUS_STATUS_OK)

  689.              || (status == MODBUS_STATUS_BROADCAST))

  690.             && (isWriteOperation != 0U))

  691.         {

  692.             (void)ModbusBackupSave(&ModbusSlave);

  693.         }

  694.     }

  695. 

  696.     /* 线圈值是协议数据模型；这里是唯一的同步桥，将用户线圈 1..7 映射到板卡

  697.      * 低电平有效的 Q1..Q7 输出。 */

  698.     if ((status == MODBUS_STATUS_OK)

  699.         || (status == MODBUS_STATUS_BROADCAST))

  700.     {

  701.         (void)AppSyncCoilsToGpio();

  702.     }

  703. 

  704.     (void)AppUpdateLinkStatus();

  705. 

  706.     if (txLength > 0U)

  707.     {

  708.         (void)AppTransmitResponse(txLength);

  709.     }

  710. }

  711. 

  712. /**

  713.  * @brief Modbus 协议处理任务。

  714.  * @param[in] argument 未使用。

  715.  */

  716. static void AppTaskModbus(void *argument)

  717. {

  718.     HAL_StatusTypeDef halStatus;

  719.     INT8U osError;

  720.     uint16_t rxLength;

  721. 

  722.     (void)argument;

  723.     /* 先将协议模型绑定到 RAM 数据区，再恢复由 RTC 备份的扩展寄存器，确保第一条

  724.      * 请求到达前数据已经准备好。 */

  725.     if (ModbusSlaveInit(&ModbusSlave, MODBUS_SLAVE_ADDR_DEFAULT,

  726.                         holdingRegisters, coilStorage)

  727.         != MODBUS_STATUS_OK) {

  728.         Error_Handler();

  729.     }

  730. 

  731.     if (ModbusConfigureExtendedHoldingRegister(&ModbusSlave,

  732.                                                &extendedHoldingRegister)

  733.         != MODBUS_STATUS_OK) {

  734.         Error_Handler();

  735.     }

  736. 

  737.     if (ModbusBackupRestore(&ModbusSlave) != MODBUS_STATUS_OK) {

  738.         Error_Handler();

  739.     }

  740. 

  741.     if (AppSyncCoilsToGpio() != MODBUS_STATUS_OK) {

  742.         Error_Handler();

  743.     }

  744. 

  745.     if (AppUpdateLinkStatus() != MODBUS_STATUS_OK) {

  746.         Error_Handler();

  747.     }

  748. 

  749.     halStatus = AppRecoverUartReception();

  750.     if (halStatus != HAL_OK) {

  751.         ModbusReceptionNeedsRecovery = 1U;

  752.     }

  753. 

  754.     while (1) {

  755.         /* 完整帧解析和 UART 恢复由本任务负责。中断回调只收集字节、标记帧边界或

  756.          * 错误，并投递此信号量。 */

  757.         halStatus = AppEnsureUartReception();

  758.         if (halStatus != HAL_OK) {

  759.             OSTimeDly(1U);

  760.             continue;

  761.         }

  762. 

  763.         OSSemPend(ModbusFrameSem, 0U, &osError);

  764.         if (osError != OS_ERR_NONE) {

  765.             continue;

  766.         }

  767. 

  768.         rxLength = AppGetReadyFrameLength();

  769.         if (rxLength > 0U) {

  770.             AppProcessFrame(rxLength);

  771. 

  772.             /* 帧定时器已经终止了本次完整帧的接收。正常挂接下一帧时不能再次清除

  773.              * SR/DR，因为主站可能在 T3.5 后已经开始发送下一条请求。 */

  774.             halStatus = AppStartUartReception();

  775.             if (halStatus != HAL_OK) {

  776.                 ModbusReceptionNeedsRecovery = 1U;

  777.             }

  778.         }

  779.         else {

  780.             (void)AppUpdateLinkStatus();

  781.         }

  782.     }

  783. }

  784. 

  785. /**

  786.  * @brief 定期检测接收静默时间并判断 Modbus RTU 帧结束。

  787.  * @param[in] argument 未使用。

  788.  */

  789. static void AppTaskT35(void *argument)

  790. {

  791.     uint16_t updateElapsedTicks;

  792. 

  793.     (void)argument;

  794.     updateElapsedTicks = 0U;

  795. 

  796.     while (1) {

  797.         /* 周期唤醒 Modbus 任务，使空闲线路在达到配置

  798.           的超时时间后将连接指示灯恢复为断开状态。 */

  799.         OSTimeDly(1U);

  800. 

  801.         updateElapsedTicks += 1U;

  802.         if (updateElapsedTicks >= 100U) {

  803.             updateElapsedTicks = 0U;

  804.             (void)AppPostModbusFrameSem();

  805.         }

  806.     }

  807. }

  808. 

  809. /**

  810.  * @brief USART1 单字节接收完成回调。

  811.  * @param[in] uartHandle 触发回调的串口句柄。

  812.  */

  813. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *uartHandle)

  814. {

  815.     HAL_StatusTypeDef halStatus;

  816. 

  817.     if ((uartHandle == NULL) || (uartHandle->Instance != USART1)) {

  818.         return;

  819.     }

  820. 

  821.     /* 此回调每次只处理一个字节 */

  822.     if (ModbusFrameReady != 0U) {

  823.         return;

  824.     }

  825. 

  826.     /* T1.5 间隔会使当前不完整帧失效。继续接收并丢弃字节直到后续 T3.5 边界，

  827.      * 防止迟到的字节被误认为新帧的首字节。 */

  828.     if ((ModbusRxDiscard != 0U)

  829.         || (ModbusInterCharacterTimeout != 0U)) {

  830.         ModbusRxDiscard = 1U;

  831.         ModbusRxLength = 0U;

  832.         AppStartModbusRtuTimer();

  833.         halStatus = HAL_UART_Receive_IT(&Uart1Handle, &ModbusRxBuffer[0],

  834.                                          1U);

  835.         if (halStatus != HAL_OK) {

  836.             ModbusReceptionNeedsRecovery = 1U;

  837.             (void)AppPostModbusFrameSem();

  838.         }

  839.         return;

  840.     }

  841. 

  842.     if (ModbusRxLength >= MODBUS_RX_BUF_SIZE) {

  843.         ModbusRxOverflow = 1U;

  844.         return;

  845.     }

  846. 

  847.     /* HAL 已经将当前字节放入 ModbusRxBuffer[ModbusRxLength]。 */

  848.     ModbusRxLength++;

  849.     AppStartModbusRtuTimer();

  850.     if (ModbusRxLength >= MODBUS_RX_BUF_SIZE) {

  851.         ModbusRxOverflow = 1U;

  852.         return;

  853.     }

  854. 

  855.     halStatus = HAL_UART_Receive_IT(&Uart1Handle,

  856.                                     &ModbusRxBuffer[ModbusRxLength], 1U);

  857.     if (halStatus != HAL_OK) {

  858.         ModbusReceptionNeedsRecovery = 1U;

  859.         (void)AppPostModbusFrameSem();

  860.     }

  861. }

  862. 

  863. /**

  864.  * @brief USART1 通信错误回调。

  865.  * @param[in] uartHandle 触发回调的串口句柄。

  866.  * @note 中断仅停止计时、标记当前帧无效并通知任务；接收重挂接由

  867.  *       AppRecoverPendingUartReception 在任务上下文执行。

  868.  */

  869. void HAL_UART_ErrorCallback(UART_HandleTypeDef *uartHandle)

  870. {

  871.     if ((uartHandle == NULL) || (uartHandle->Instance != USART1))

  872.     {

  873.         return;

  874.     }

  875. 

  876.     /* UART 错误会使当前整帧失效。中断只记录错误并唤醒任务，不在这里终止或重新

  877.      * 进入 HAL 接收流程，从而避免 HAL 重入，并让恢复操作集中在一个上下文中。 */

  878.     AppStopModbusRtuTimer();

  879.     __HAL_UART_CLEAR_PEFLAG(uartHandle);

  880.     ModbusRxOverflow = 1U;

  881.     ModbusReceptionNeedsRecovery = 1U;

  882.     (void)AppPostModbusFrameSem();

  883. }

  884. 

  885. /**

  886.  * @brief 处理 TIM5 的 Modbus RTU T1.5/T3.5 单次定时到期事件。

  887.  * @note 本函数只更新接收状态和投递信号量，不解析帧内容。

  888.  */

  889. void AppModbusRtuTimerIrqHandler(void)

  890. {

  891.     if ((TIM5->SR & TIM_SR_UIF) == 0U) {

  892.         return;

  893.     }

  894. 

  895.     TIM5->SR &= (uint32_t)(~TIM_SR_UIF);

  896.     AppHandleModbusRtuTimer();

  897. }

  898. 

  899. /**

  900.  * @brief USART1 中断发送完成回调。

  901.  * @param[in] uartHandle 触发回调的串口句柄。

  902.  */

  903. void HAL_UART_TxCpltCallback(UART_HandleTypeDef *uartHandle)

  904. {

  905.     if ((uartHandle == NULL) || (uartHandle->Instance != USART1)) {

  906.         return;

  907.     }

  908. 

  909.     /* 只有最后一个字节已经移出串口后，才唤醒发送任务。 */

  910.     (void)OSSemPost(ModbusTxSem);

  911. }

  912. 

  913. /**

  914.  * @brief 进入不可恢复错误状态。

  915.  */

  916. void Error_Handler(void)

  917. {

  918.     __disable_irq();

  919. 

  920.     while (1) {

  921.     }

  922. }