zengbingjie
/
Modbus
1
0
Форкнуть 0
Код Задачи 0 Pull Request'ы 0 Релизы 0 Вики Активность
Вы не можете выбрать более 25 тем Темы должны начинаться с буквы или цифры, могут содержать дефисы(-) и должны содержать не более 35 символов.
4 коммитов
1 ветка
45 MiB
 
 
 
 
 
Дерево: b3de7e1cbe
Ветки Теги
${ item.name }
Создать ветку ${ searchTerm }
из 'b3de7e1cbe'
${ noResults }
Modbus/Core/Src/main.c

954 строки
29 KiB
Исходник Вина История 

  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. /* UART 诊断变量保留为全局可见，便于在 IAR Live Watch 中观察断线和重连测试。 */

  32. volatile uint32_t ModbusUartLastErrorCode;

  33. volatile uint32_t ModbusUartLastRxState;

  34. volatile uint32_t ModbusUartRecoveryCount;

  35. volatile uint32_t ModbusUartRecoveryFailureCount;

  36. volatile uint32_t ModbusUartRxArmCount;

  37. volatile uint32_t ModbusUartRxArmFailureCount;

  38. volatile uint8_t ModbusUartLastRxByte;

  39. volatile uint16_t ModbusLastCompleteFrameLength;

  40. 

  41. static MODBUS_SLAVE ModbusSlave;

  42. static OS_EVENT *ModbusFrameSem;

  43. static OS_EVENT *ModbusTxSem;

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

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

  46. static uint8_t ModbusRxBuffer[MODBUS_RX_BUF_SIZE];

  47. static uint8_t ModbusTxBuffer[MODBUS_TX_BUF_SIZE];

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

  49. static volatile uint16_t ModbusRxLength;

  50. static volatile uint16_t ModbusFrameLength;

  51. static volatile uint8_t ModbusFrameReady;

  52. static volatile uint8_t ModbusRxOverflow;

  53. static volatile uint8_t ModbusRtuTimerPhase;

  54. static volatile uint8_t ModbusInterCharacterTimeout;

  55. static volatile uint8_t ModbusRxDiscard;

  56. static volatile uint8_t ModbusReceptionNeedsRecovery;

  57. static uint32_t ModbusLastActivityTick;

  58. static uint8_t ModbusHasActivity;

  59. static MODBUS_STATUS ModbusLastStatus;

  60. 

  61. static GPIO_TypeDef *const

  62.     AppUserOutputPorts[APP_MODBUS_USER_OUTPUT_COIL_COUNT] =

  63. {

  64.     PLC_Q1_PORT,

  65.     PLC_Q2_PORT,

  66.     PLC_Q3_PORT,

  67.     PLC_Q4_PORT,

  68.     PLC_Q5_PORT,

  69.     PLC_Q6_PORT,

  70.     PLC_Q7_PORT

  71. };

  72. 

  73. static const uint16_t

  74.     AppUserOutputPins[APP_MODBUS_USER_OUTPUT_COIL_COUNT] =

  75. {

  76.     PLC_Q1_PIN,

  77.     PLC_Q2_PIN,

  78.     PLC_Q3_PIN,

  79.     PLC_Q4_PIN,

  80.     PLC_Q5_PIN,

  81.     PLC_Q6_PIN,

  82.     PLC_Q7_PIN

  83. };

  84. 

  85. void SystemClock_Config(void);

  86. 

  87. static void AppTaskStart(void *argument);

  88. static void AppTaskModbus(void *argument);

  89. static void AppTaskT35(void *argument);

  90. static void AppInitSystemTick(void);

  91. static void AppInitGpio(void);

  92. static void AppInitUart1(void);

  93. static void AppInitModbusRtuTimer(void);

  94. static INT8U AppCreateTasks(void);

  95. static HAL_StatusTypeDef AppStartUartReception(void);

  96. static HAL_StatusTypeDef AppRecoverUartReception(void);

  97. static HAL_StatusTypeDef AppRecoverPendingUartReception(void);

  98. static HAL_StatusTypeDef AppEnsureUartReception(void);

  99. static HAL_StatusTypeDef AppTransmitResponse(uint16_t txLength);

  100. static void AppStartModbusRtuTimer(void);

  101. static void AppStopModbusRtuTimer(void);

  102. static void AppSetModbusRtuTimer(uint16_t timeoutUs);

  103. static void AppHandleModbusRtuTimer(void);

  104. static uint16_t AppGetReadyFrameLength(void);

  105. static INT8U AppPostModbusFrameSem(void);

  106. static uint8_t AppIsModbusStatusAccepted(MODBUS_STATUS status);

  107. static uint8_t AppIsModbusRetentionWriteFunction(uint8_t functionCode);

  108. static MODBUS_STATUS AppUpdateLinkStatus(void);

  109. static MODBUS_STATUS AppSyncCoilsToGpio(void);

  110. static void AppProcessFrame(uint16_t rxLength);

  111. 

  112. /**

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

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

  115.  */

  116. int main(void)

  117. {

  118.     INT8U osError;

  119. 

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

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

  122.     HAL_Init();

  123.     AppInitSystemTick();

  124.     SystemClock_Config();

  125.     AppInitGpio();

  126.     AppInitUart1();

  127.     AppInitModbusRtuTimer();

  128. 

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

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

  131.     OSInit();

  132.     osError = OSTaskCreateExt(

  133.         AppTaskStart, NULL,

  134.         &AppTaskStartStk[APP_TASK_START_STK_SIZE - 1U],

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

  136.         APP_TASK_START_STK_SIZE, NULL,

  137.         OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);

  138.     if (osError != OS_ERR_NONE) {

  139.         Error_Handler();

  140.     }

  141. 

  142.     OSStart();

  143. 

  144.     while (1) {

  145.     }

  146. }

  147. 

  148. /**

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

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

  151.  */

  152. void SystemClock_Config(void)

  153. {

  154.     RCC_OscInitTypeDef oscillatorConfig = {0};

  155.     RCC_ClkInitTypeDef clockConfig = {0};

  156. 

  157.     __HAL_RCC_PWR_CLK_ENABLE();

  158.     __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);

  159. 

  160.     oscillatorConfig.OscillatorType = RCC_OSCILLATORTYPE_HSE;

  161.     oscillatorConfig.HSEState = RCC_HSE_ON;

  162.     oscillatorConfig.PLL.PLLState = RCC_PLL_ON;

  163.     oscillatorConfig.PLL.PLLSource = RCC_PLLSOURCE_HSE;

  164.     oscillatorConfig.PLL.PLLM = 12U;

  165.     oscillatorConfig.PLL.PLLN = 336U;

  166.     oscillatorConfig.PLL.PLLP = RCC_PLLP_DIV2;

  167.     oscillatorConfig.PLL.PLLQ = 7U;

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

  169.         Error_Handler();

  170.     }

  171. 

  172.     clockConfig.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK

  173.         | RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2;

  174.     clockConfig.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;

  175.     clockConfig.AHBCLKDivider = RCC_SYSCLK_DIV1;

  176.     clockConfig.APB1CLKDivider = RCC_HCLK_DIV4;

  177.     clockConfig.APB2CLKDivider = RCC_HCLK_DIV2;

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

  179.         Error_Handler();

  180.     }

  181. }

  182. 

  183. /**

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

  185.  */

  186. static void AppInitSystemTick(void)

  187. {

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

  189. }

  190. 

  191. /**

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

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

  194.  */

  195. static void AppInitGpio(void)

  196. {

  197.     GPIO_InitTypeDef gpioConfig = {0};

  198. 

  199.     __HAL_RCC_GPIOE_CLK_ENABLE();

  200.     __HAL_RCC_GPIOF_CLK_ENABLE();

  201.     __HAL_RCC_GPIOI_CLK_ENABLE();

  202. 

  203.     gpioConfig.Mode = GPIO_MODE_OUTPUT_PP;

  204.     gpioConfig.Pull = GPIO_PULLUP;

  205.     gpioConfig.Speed = GPIO_SPEED_FREQ_LOW;

  206. 

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

  208.     HAL_GPIO_Init(GPIOF, &gpioConfig);

  209. 

  210.     gpioConfig.Pin = PLC_Q4_PIN;

  211.     HAL_GPIO_Init(GPIOI, &gpioConfig);

  212. 

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

  214.     HAL_GPIO_Init(GPIOE, &gpioConfig);

  215. 

  216.     HAL_GPIO_WritePin(GPIOF, PLC_Q0_PIN | PLC_Q1_PIN | PLC_Q2_PIN

  217.                       | PLC_Q3_PIN, GPIO_PIN_SET);

  218.     HAL_GPIO_WritePin(GPIOI, PLC_Q4_PIN, GPIO_PIN_SET);

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

  220.                       GPIO_PIN_SET);

  221. }

  222. 

  223. /**

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

  225.  */

  226. static void AppInitUart1(void)

  227. {

  228.     Uart1Handle.Instance = USART1;

  229.     Uart1Handle.Init.BaudRate = APP_MODBUS_BAUD_RATE;

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

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

  232.     Uart1Handle.Init.WordLength = UART_WORDLENGTH_9B;

  233.     Uart1Handle.Init.StopBits = UART_STOPBITS_1;

  234.     Uart1Handle.Init.Parity = UART_PARITY_EVEN;

  235.     Uart1Handle.Init.Mode = UART_MODE_TX_RX;

  236.     Uart1Handle.Init.HwFlowCtl = UART_HWCONTROL_NONE;

  237.     Uart1Handle.Init.OverSampling = UART_OVERSAMPLING_16;

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

  239.         Error_Handler();

  240.     }

  241. }

  242. 

  243. /**

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

  245.  */

  246. static void AppInitModbusRtuTimer(void)

  247. {

  248.     __HAL_RCC_TIM5_CLK_ENABLE();

  249. 

  250.     TIM5->CR1 = 0U;

  251.     TIM5->PSC = (APP_MODBUS_RTU_TIMER_CLOCK_HZ

  252.                  / APP_MODBUS_RTU_TIMER_TICK_HZ) - 1U;

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

  254.     TIM5->CNT = 0U;

  255.     TIM5->EGR = TIM_EGR_UG;

  256.     TIM5->SR = 0U;

  257.     TIM5->DIER = TIM_DIER_UIE;

  258. 

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

  260.     HAL_NVIC_EnableIRQ(TIM5_IRQn);

  261. }

  262. 

  263. /**

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

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

  266.  */

  267. static INT8U AppCreateTasks(void)

  268. {

  269.     INT8U osError;

  270. 

  271.     osError = OSTaskCreateExt(

  272.         AppTaskModbus, NULL,

  273.         &AppTaskModbusStk[APP_TASK_MODBUS_STK_SIZE - 1U],

  274.         APP_TASK_MODBUS_PRIO, APP_TASK_MODBUS_PRIO,

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

  276.         OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);

  277.     if (osError != OS_ERR_NONE) {

  278.         return osError;

  279.     }

  280. 

  281.     osError = OSTaskCreateExt(

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

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

  284.         APP_TASK_T35_STK_SIZE, NULL,

  285.         OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);

  286. 

  287.     return osError;

  288. }

  289. 

  290. /**

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

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

  293.  */

  294. static void AppTaskStart(void *argument)

  295. {

  296.     INT8U osError;

  297. 

  298.     (void)argument;

  299.     ModbusFrameSem = OSSemCreate(0U);

  300.     ModbusTxSem = OSSemCreate(0U);

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

  302.         Error_Handler();

  303.     }

  304. 

  305.     osError = AppCreateTasks();

  306.     if (osError != OS_ERR_NONE) {

  307.         Error_Handler();

  308.     }

  309. 

  310.     OSTaskSuspend(OS_PRIO_SELF);

  311.     while (1) {

  312.     }

  313. }

  314. 

  315. /**

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

  317.  * @return HAL 状态码。

  318.  */

  319. static HAL_StatusTypeDef AppStartUartReception(void)

  320. {

  321.     OS_CPU_SR cpu_sr = 0U;

  322.     HAL_StatusTypeDef halStatus;

  323. 

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

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

  326.     OS_ENTER_CRITICAL();

  327.     AppStopModbusRtuTimer();

  328.     ModbusRxLength = 0U;

  329.     ModbusFrameLength = 0U;

  330.     ModbusFrameReady = 0U;

  331.     ModbusRxOverflow = 0U;

  332.     ModbusRtuTimerPhase = APP_MODBUS_RTU_TIMER_PHASE_T15;

  333.     ModbusInterCharacterTimeout = 0U;

  334.     ModbusRxDiscard = 0U;

  335.     OS_EXIT_CRITICAL();

  336. 

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

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

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

  340.     ModbusUartRxArmCount++;

  341.     if (halStatus != HAL_OK) {

  342.         ModbusUartRxArmFailureCount++;

  343.     }

  344.     ModbusUartLastRxState = (uint32_t)Uart1Handle.RxState;

  345. 

  346.     return halStatus;

  347. }

  348. 

  349. /**

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

  351.  * @return HAL 状态码。

  352.  */

  353. static HAL_StatusTypeDef AppRecoverUartReception(void)

  354. {

  355.     HAL_StatusTypeDef halStatus;

  356.     HAL_StatusTypeDef abortStatus;

  357. 

  358.     ModbusUartRecoveryCount++;

  359. 

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

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

  362.     abortStatus = HAL_UART_AbortReceive_IT(&Uart1Handle);

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

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

  365.     __HAL_UART_CLEAR_PEFLAG(&Uart1Handle);

  366.     halStatus = AppStartUartReception();

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

  368.         (void)HAL_UART_AbortReceive_IT(&Uart1Handle);

  369.         __HAL_UART_CLEAR_PEFLAG(&Uart1Handle);

  370.         halStatus = AppStartUartReception();

  371.     }

  372. 

  373.     if (halStatus != HAL_OK) {

  374.         ModbusUartRecoveryFailureCount++;

  375.     }

  376.     ModbusUartLastRxState = (uint32_t)Uart1Handle.RxState;

  377. 

  378.     return halStatus;

  379. }

  380. 

  381. /**

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

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

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

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

  386.  */

  387. static HAL_StatusTypeDef AppRecoverPendingUartReception(void)

  388. {

  389.     HAL_StatusTypeDef halStatus;

  390. 

  391.     halStatus = HAL_OK;

  392.     if (ModbusReceptionNeedsRecovery != 0U) {

  393.         ModbusReceptionNeedsRecovery = 0U;

  394.         halStatus = AppRecoverUartReception();

  395.         if (halStatus != HAL_OK) {

  396.             ModbusReceptionNeedsRecovery = 1U;

  397.         }

  398.     }

  399. 

  400.     return halStatus;

  401. }

  402. 

  403. /**

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

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

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

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

  408.  */

  409. static HAL_StatusTypeDef AppEnsureUartReception(void)

  410. {

  411.     if (ModbusFrameReady != 0U) {

  412.         return HAL_OK;

  413.     }

  414. 

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

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

  417.     if ((ModbusReceptionNeedsRecovery != 0U)

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

  419.         ModbusReceptionNeedsRecovery = 1U;

  420.         return AppRecoverPendingUartReception();

  421.     }

  422. 

  423.     return HAL_OK;

  424. }

  425. 

  426. /**

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

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

  429.  * @return HAL 状态码。

  430.  */

  431. static HAL_StatusTypeDef AppTransmitResponse(uint16_t txLength)

  432. {

  433.     HAL_StatusTypeDef halStatus;

  434.     INT8U osError;

  435. 

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

  437.         return HAL_ERROR;

  438.     }

  439. 

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

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

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

  443.     if (halStatus != HAL_OK) {

  444.         return halStatus;

  445.     }

  446. 

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

  448.     if (osError != OS_ERR_NONE) {

  449.         (void)HAL_UART_AbortTransmit_IT(&Uart1Handle);

  450.         return HAL_TIMEOUT;

  451.     }

  452. 

  453.     return HAL_OK;

  454. }

  455. 

  456. /**

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

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

  459.  */

  460. static void AppSetModbusRtuTimer(uint16_t timeoutUs)

  461. {

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

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

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

  465.     TIM5->CNT = 0U;

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

  467.     TIM5->SR = 0U;

  468.     TIM5->CR1 |= TIM_CR1_CEN;

  469. }

  470. 

  471. /**

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

  473.  */

  474. static void AppStartModbusRtuTimer(void)

  475. {

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

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

  478.     ModbusRtuTimerPhase = APP_MODBUS_RTU_TIMER_PHASE_T15;

  479.     ModbusInterCharacterTimeout = 0U;

  480.     AppSetModbusRtuTimer(APP_MODBUS_RTU_T15_RX_TIMEOUT_US);

  481. }

  482. 

  483. /**

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

  485.  */

  486. static void AppStopModbusRtuTimer(void)

  487. {

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

  489.     TIM5->SR = 0U;

  490. }

  491. 

  492. /**

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

  494.  */

  495. static void AppHandleModbusRtuTimer(void)

  496. {

  497.     if (ModbusRtuTimerPhase == APP_MODBUS_RTU_TIMER_PHASE_T15) {

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

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

  500.         ModbusInterCharacterTimeout = 1U;

  501.         ModbusRtuTimerPhase = APP_MODBUS_RTU_TIMER_PHASE_T35;

  502.         AppSetModbusRtuTimer(APP_MODBUS_RTU_T35_AFTER_T15_US);

  503.         return;

  504.     }

  505. 

  506.     AppStopModbusRtuTimer();

  507.     ModbusInterCharacterTimeout = 0U;

  508.     if (ModbusRxDiscard != 0U) {

  509.         ModbusRxDiscard = 0U;

  510.         ModbusRxLength = 0U;

  511.         return;

  512.     }

  513. 

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

  515.         return;

  516.     }

  517. 

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

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

  520.     ModbusFrameLength = ModbusRxLength;

  521.     ModbusLastCompleteFrameLength = ModbusFrameLength;

  522.     ModbusFrameReady = 1U;

  523.     (void)HAL_UART_AbortReceive_IT(&Uart1Handle);

  524.     (void)AppPostModbusFrameSem();

  525. }

  526. 

  527. /**

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

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

  530.  */

  531. static uint16_t AppGetReadyFrameLength(void)

  532. {

  533.     OS_CPU_SR cpu_sr = 0U;

  534.     uint16_t frameLength;

  535. 

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

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

  538.     frameLength = 0U;

  539.     OS_ENTER_CRITICAL();

  540.     if (ModbusFrameReady != 0U) {

  541.         frameLength = ModbusFrameLength;

  542.     }

  543.     OS_EXIT_CRITICAL();

  544. 

  545.     return frameLength;

  546. }

  547. 

  548. /**

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

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

  551.  */

  552. static INT8U AppPostModbusFrameSem(void)

  553. {

  554.     INT8U osError;

  555. 

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

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

  558.     osError = OSSemPost(ModbusFrameSem);

  559. 

  560.     return osError;

  561. }

  562. 

  563. /**

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

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

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

  567.  */

  568. static uint8_t AppIsModbusStatusAccepted(MODBUS_STATUS status)

  569. {

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

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

  572.         return 1U;

  573.     }

  574. 

  575.     return 0U;

  576. }

  577. 

  578. /**

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

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

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

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

  583.  */

  584. static uint8_t AppIsModbusRetentionWriteFunction(uint8_t functionCode)

  585. {

  586.     switch (functionCode) {

  587.         case MODBUS_FC_WRITE_EXTENDED_HOLDING_REGS:

  588.             return 1U;

  589. 

  590.         default:

  591.             return 0U;

  592.     }

  593. }

  594. 

  595. /**

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

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

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

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

  600.  */

  601. static MODBUS_STATUS AppUpdateLinkStatus(void)

  602. {

  603.     MODBUS_STATUS status;

  604.     uint32_t currentTick;

  605.     uint8_t linkState;

  606.     GPIO_PinState pinState;

  607. 

  608.     currentTick = OSTimeGet();

  609.     linkState = APP_MODBUS_LINK_DISCONNECTED;

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

  611.         ((currentTick - ModbusLastActivityTick)

  612.             < APP_MODBUS_LINK_TIMEOUT_TICKS))

  613.     {

  614.         linkState = APP_MODBUS_LINK_CONNECTED;

  615.     }

  616. 

  617.     status = ModbusSetCoil(&ModbusSlave, APP_MODBUS_LINK_STATE_COIL,

  618.                            linkState);

  619.     if (status != MODBUS_STATUS_OK)

  620.     {

  621.         return status;

  622.     }

  623. 

  624.     if (linkState == APP_MODBUS_LINK_CONNECTED)

  625.     {

  626.         pinState = GPIO_PIN_RESET;

  627.     }

  628.     else

  629.     {

  630.         pinState = GPIO_PIN_SET;

  631.     }

  632. 

  633.     HAL_GPIO_WritePin(PLC_LINK_LED_PORT, PLC_LINK_LED_PIN, pinState);

  634. 

  635.     return MODBUS_STATUS_OK;

  636. }

  637. 

  638. /**

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

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

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

  642.  */

  643. static MODBUS_STATUS AppSyncCoilsToGpio(void)

  644. {

  645.     MODBUS_STATUS status;

  646.     uint16_t coilOffset;

  647.     uint16_t coilAddress;

  648.     uint8_t coilValue;

  649.     GPIO_PinState pinState;

  650. 

  651.     for (coilOffset = 0U;

  652.          coilOffset < APP_MODBUS_USER_OUTPUT_COIL_COUNT;

  653.          coilOffset++)

  654.     {

  655.         coilAddress = coilOffset + APP_MODBUS_FIRST_USER_OUTPUT_COIL;

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

  657.         if (status != MODBUS_STATUS_OK)

  658.         {

  659.             return status;

  660.         }

  661. 

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

  663.         HAL_GPIO_WritePin(AppUserOutputPorts[coilOffset],

  664.                           AppUserOutputPins[coilOffset], pinState);

  665.     }

  666. 

  667.     return MODBUS_STATUS_OK;

  668. }

  669. 

  670. /**

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

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

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

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

  675.  */

  676. static void AppProcessFrame(uint16_t rxLength)

  677. {

  678.     MODBUS_STATUS status;

  679.     uint16_t txLength;

  680.     uint8_t functionCode;

  681.     uint8_t isWriteOperation;

  682. 

  683.     txLength = 0U;

  684.     functionCode = 0U;

  685.     isWriteOperation = 0U;

  686.     if (rxLength > APP_MODBUS_FUNCTION_INDEX) {

  687.         functionCode = ModbusRxBuffer[APP_MODBUS_FUNCTION_INDEX];

  688.     }

  689. 

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

  691.     {

  692.         ModbusLastStatus = MODBUS_STATUS_FRAME_ERROR;

  693.         return;

  694.     }

  695. 

  696.     if (ModbusRxOverflow != 0U)

  697.     {

  698.         ModbusLastStatus = MODBUS_STATUS_FRAME_ERROR;

  699.         return;

  700.     }

  701. 

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

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

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

  705.                                 ModbusTxBuffer, MODBUS_TX_BUF_SIZE,

  706.                                 &txLength);

  707.     ModbusLastStatus = status;

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

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

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

  711.     {

  712.         ModbusLastActivityTick = OSTimeGet();

  713.         ModbusHasActivity = 1U;

  714.         isWriteOperation = AppIsModbusRetentionWriteFunction(functionCode);

  715.         if (((ModbusLastStatus == MODBUS_STATUS_OK)

  716.              || (ModbusLastStatus == MODBUS_STATUS_BROADCAST))

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

  718.         {

  719.             (void)ModbusBackupSave(&ModbusSlave);

  720.         }

  721.     }

  722. 

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

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

  725.     if ((status == MODBUS_STATUS_OK)

  726.         || (status == MODBUS_STATUS_BROADCAST))

  727.     {

  728.         (void)AppSyncCoilsToGpio();

  729.     }

  730. 

  731.     (void)AppUpdateLinkStatus();

  732. 

  733.     if (txLength > 0U)

  734.     {

  735.         (void)AppTransmitResponse(txLength);

  736.     }

  737. }

  738. 

  739. /**

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

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

  742.  */

  743. static void AppTaskModbus(void *argument)

  744. {

  745.     HAL_StatusTypeDef halStatus;

  746.     INT8U osError;

  747.     uint16_t rxLength;

  748. 

  749.     (void)argument;

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

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

  752.     if (ModbusSlaveInit(&ModbusSlave, MODBUS_SLAVE_ADDR_DEFAULT,

  753.                         holdingRegisters, coilStorage)

  754.         != MODBUS_STATUS_OK) {

  755.         Error_Handler();

  756.     }

  757. 

  758.     if (ModbusConfigureExtendedHoldingRegister(&ModbusSlave,

  759.                                                &extendedHoldingRegister)

  760.         != MODBUS_STATUS_OK) {

  761.         Error_Handler();

  762.     }

  763. 

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

  765.         Error_Handler();

  766.     }

  767. 

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

  769.         Error_Handler();

  770.     }

  771. 

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

  773.         Error_Handler();

  774.     }

  775. 

  776.     halStatus = AppRecoverUartReception();

  777.     if (halStatus != HAL_OK) {

  778.         ModbusReceptionNeedsRecovery = 1U;

  779.     }

  780. 

  781.     while (1) {

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

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

  784.         halStatus = AppEnsureUartReception();

  785.         if (halStatus != HAL_OK) {

  786.             OSTimeDly(1U);

  787.             continue;

  788.         }

  789. 

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

  791.         if (osError != OS_ERR_NONE) {

  792.             continue;

  793.         }

  794. 

  795.         rxLength = AppGetReadyFrameLength();

  796.         if (rxLength > 0U) {

  797.             AppProcessFrame(rxLength);

  798. 

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

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

  801.             halStatus = AppStartUartReception();

  802.             if (halStatus != HAL_OK) {

  803.                 ModbusReceptionNeedsRecovery = 1U;

  804.             }

  805.         }

  806.         else {

  807.             (void)AppUpdateLinkStatus();

  808.         }

  809.     }

  810. }

  811. 

  812. /**

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

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

  815.  */

  816. static void AppTaskT35(void *argument)

  817. {

  818.     uint16_t updateElapsedTicks;

  819. 

  820.     (void)argument;

  821.     updateElapsedTicks = 0U;

  822. 

  823.     while (1) {

  824.         /* 这个低频任务不解析帧，只按周期唤醒 Modbus 任务，使空闲线路在达到配置

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

  826.         OSTimeDly(APP_MODBUS_STATUS_CHECK_TICKS);

  827. 

  828.         updateElapsedTicks += APP_MODBUS_STATUS_CHECK_TICKS;

  829.         if (updateElapsedTicks >= APP_MODBUS_STATUS_UPDATE_TICKS) {

  830.             updateElapsedTicks = 0U;

  831.             (void)AppPostModbusFrameSem();

  832.         }

  833.     }

  834. }

  835. 

  836. /**

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

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

  839.  */

  840. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *uartHandle)

  841. {

  842.     HAL_StatusTypeDef halStatus;

  843. 

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

  845.         return;

  846.     }

  847. 

  848.     /* 此回调每次只处理一个字节，不解析功能码，也不写入数据模型；这些操作由

  849.      * AppTaskModbus 任务完成。 */

  850.     if (ModbusFrameReady != 0U) {

  851.         return;

  852.     }

  853. 

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

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

  856.     if ((ModbusRxDiscard != 0U)

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

  858.         ModbusRxDiscard = 1U;

  859.         ModbusRxLength = 0U;

  860.         AppStartModbusRtuTimer();

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

  862.                                          1U);

  863.         if (halStatus != HAL_OK) {

  864.             ModbusReceptionNeedsRecovery = 1U;

  865.             (void)AppPostModbusFrameSem();

  866.         }

  867.         return;

  868.     }

  869. 

  870.     if (ModbusRxLength >= MODBUS_RX_BUF_SIZE) {

  871.         ModbusRxOverflow = 1U;

  872.         return;

  873.     }

  874. 

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

  876.     ModbusRxLength++;

  877.     ModbusUartLastRxByte = ModbusRxBuffer[ModbusRxLength - 1U];

  878.     AppStartModbusRtuTimer();

  879.     if (ModbusRxLength >= MODBUS_RX_BUF_SIZE) {

  880.         ModbusRxOverflow = 1U;

  881.         return;

  882.     }

  883. 

  884.     halStatus = HAL_UART_Receive_IT(&Uart1Handle,

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

  886.     if (halStatus != HAL_OK) {

  887.         ModbusReceptionNeedsRecovery = 1U;

  888.         (void)AppPostModbusFrameSem();

  889.     }

  890. }

  891. 

  892. /**

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

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

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

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

  897.  */

  898. void HAL_UART_ErrorCallback(UART_HandleTypeDef *uartHandle)

  899. {

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

  901.     {

  902.         return;

  903.     }

  904. 

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

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

  907.     AppStopModbusRtuTimer();

  908.     ModbusUartLastErrorCode = uartHandle->ErrorCode;

  909.     ModbusUartLastRxState = (uint32_t)uartHandle->RxState;

  910.     __HAL_UART_CLEAR_PEFLAG(uartHandle);

  911.     ModbusRxOverflow = 1U;

  912.     ModbusReceptionNeedsRecovery = 1U;

  913.     (void)AppPostModbusFrameSem();

  914. }

  915. 

  916. /**

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

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

  919.  */

  920. void AppModbusRtuTimerIrqHandler(void)

  921. {

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

  923.         return;

  924.     }

  925. 

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

  927.     AppHandleModbusRtuTimer();

  928. }

  929. 

  930. /**

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

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

  933.  */

  934. void HAL_UART_TxCpltCallback(UART_HandleTypeDef *uartHandle)

  935. {

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

  937.         return;

  938.     }

  939. 

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

  941.     (void)OSSemPost(ModbusTxSem);

  942. }

  943. 

  944. /**

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

  946.  */

  947. void Error_Handler(void)

  948. {

  949.     __disable_irq();

  950. 

  951.     while (1) {

  952.     }

  953. }